JAVA(2)

📖Java(2)

🔍에러와 예외

어떤 원인에 의해 오동작하거나 비정상적으로 종료되는 경우

Error

프로그램을 잘못 작성한 경우

Exception

• Checked Exception: 예외에 대한 대처코드 유무를 확인(예외에 대한 대처코드가 없다면 컴파일을 진행하지 않는다, 대처코드 O)
• Unchecked Exception: 예외에 대한 대처코드 유무를 확인(예외에 대한 대처코드가 없어도 컴파일을 진행한다. 런타임 오류, 대처코드 X)

 

✔️try~catch 구문

try{
}
catch(XXException c){ //던진 예외를 받음
	//예외가 발생했을 때 처리할 코드
}

public class SimpleException {
    public static void main(String[] args) {
	//java.lang.ArrayIndexOutOfBoundsException : unchecked exception
        int[] intArray = { 10 };

        try {
            System.out.println(intArray[2]);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("예외 처리 완료");
        }
        
        System.out.println("프로그램 종료합니다.");     
    }
}

Exception 객체의 정보 활용

Throwable의 주요 메서드

• getMessage(): 발생한 예외에 대한 구체적인 메시지 반환
• getCause(): 예외의 원인이 되는 Throwable 객체 또는 null 반환
• printStackTrace(): 예외가 발생된 메서드가 호출되기까지의 메서드 호출스택 출력, 디버깅의 수단으로 주로 사용됨

 

Q. catch에서 아무것도 기록하지 않으면?

오류의 발생 여부를 알 수가 없다. 따라서 어떤 에러가 발생했는지 그 정보를 잘 출력해야 한다.

 

 

try~catch문에서의 흐름

• try 블록에서 예외가 발생하면
  • JVM이 해당 Exception 클래스의 객체를 생성 후에 던진다.(Throw)
    • throw new XXException()
  • 던져진 exception을 처리할 수 있는 catch 블록에서 받은 후 처리
    • 적당한 catch 블록을 만나지 못하면 예외처리는 실패
  • 정상적으로 처리되면 try~catch블록을 벗어나 다음 문장 실행
• try 블록에서 예외가 발생하지 않으면
  • catch 문을 거치지 않고 try~catch 블록의 다음 흐름 문장을 실행

 

Q.

int num = new Random().nextInt(2);

try{
	System.out.println("code 1, num: "+num);
	int i = 1/num;
	System.out.println("code 2, 예외 없음");
}catch(ArithmeticException e){
	System.out.println("code 3, 예외 처리 완료");
}

System.out.println("code 4");

num=0일 때,

code 1, num: 1
code 3, 예외 처리 완료
code 4

num=1일 때

code 1, num: 1
code 2, 예외 없음
code 4

 

✔️Unchecked Exception과 Checked Exception

Exception 설명 종류

ArrayIndexOutOfBoundsException	배열의 접근 범위를 벗어난 경우	UnCheckedException
NegativeArraySizeException	배열의 크기를 음수로 지정한 경우	UnCheckedException
NullPointerException	객체를 선언만 하고 생성하지 않은 상태에서 접근한 경우	UnCheckedException
ClassCastException	Reference 타입의 잘못된 형변환시 발생	UnCheckedException
NumberFormatException	문자열로된 데이터를 Primitive로 변환시 잘못 변경하면 발생	UnCheckedException
IndexOutOfBoundsException	List에서 잘못된 index에 데이터를 추가한 경우	UnCheckedException
ArithmeticException	0으로 나눈 경우	UnCheckedException
IllegalArgumentException	메서드에 잘못된 인자를 전달한 경우	UnCheckedException
InterruptedException	쓰레드 수행중 중단 명려에 따른 오류	UnCheckedException
FileNotFoundException	지정한 경로에 파일이 없는 경우	CheckedException
IOException	데이터를 IO하는 중 발생하는 오류	CheckedException
SQLException	DB서버에서 데이터 처리 중 발생하는 오류	CheckedException

 

Unchecked Exception

public class UncheckedTest{
	public static void main(String[] args){
			int[] list = {1,2,3,4,5};
			System.out.println(list[0]);
	}
}

다음과 같은 상황에서 에러 체크를 강제해야 했다면(ArrayIndexOutOfBoundsException 등) try~catch문을 반드시 사용해야 했을 것이다.

 

Checked Exception

예외에 대한 처리 코드가 있는 경우

public class CheckedExceptionHandling {
    public static void main(String[] args) {
        // TODO: 다음에서 발생하는 예외를 처리해보자.
        try {
            Class.forName("abc.Def");
        }catch(ClassNotFoundException e) {
            e.printStackTrace();
        }
        // END
        System.out.println("프로그램 정상 종료");
    }

}

 

 

즉, Checked exception과 Unchecked exception의 차이는 예외 발생 여부가 아니라 예외 발생시 어떻게 할 것인가?이다.

checked→대처코드가 없으면 컴파일 진행X, unchecked→대처코드가 없어도 컴파일 진행

 

 

✔️다중 exception handling

• try 블록에서 여러 종류의 예외가 발생할 경우
• 하나의 try 블록에 여러 개의 catch 블록 추가 가능
  • 예외 종류별로 catch 블록 구성

try{
}catch(XXException e){
	//XXException 발생시 처리 코드
}catch(XXException e){
	//XXException 발생시 처리 코드
}catch(XXException e){
	//XXException 발생시 처리 코드
}

 

• 다중 catch 문장 작성 순서 유의 사항
  • JVM이 던진 예외는 catch문장을 찾을 때는 다형성이 적용된다
  • 상위 타입의 예외가 먼저 실행되는 경우 뒤에 등장하는 catch 블록은 동작할 기회가 없다
  • 상속 관계가 없는 경우는 무관
  • 상속 관계에서는 작은 범위(자식)에서 큰 범위(조상)순으로 정의

 

다중 예외 처리를 이용한 checked exception 처리

• 처리하지 않으면 컴파일 불가: Checked Exception⇒컴파일조차 이루어지지 않는다.(checked exception이므로)

public static void main(String[] args){
	Class.forName("abc.Def"); // ClassNotFoundException
	new FileInputStream("Hello.java"); // FileNotFoundException
  DriverManager.getConnection("Hello"); // SQLException
}

• 예외 처리는 가능한 구체적으로 진행한다.

public class MultiExceptionHandling {
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        // TODO: 다음에서 발생하는 예외를 처리해보자.
	try {
	    Class.forName("abc.Def"); // ClassNotFoundException
	    new FileInputStream("Hello.java"); // FileNotFoundException
	    DriverManager.getConnection("Hello"); // SQLException
	}catch(ClassNotFoundException e) {
	    System.out.printf("클래스를 찾을 수 없습니다: %s\n", e.getMessage());;
	}catch(FileNotFoundException e) {
	    System.out.printf("파일을 찾을 수 없습니다: %s\n", e.getMessage());;
	}catch(SQLException e) {
	    System.out.printf("DB 접속 실패: %s\n", e.getMessage());;
	}
        // END
        System.out.println("프로그램 정상 종료");

    }
}

• 하지만 심각하지 않는 예외를 굳이 세분화해서 처리하는 것도 낭비이므로 ‘|’(or)를 이용해 하나의 catch 구문에서 상속관계가 없는 여러 개의 exception 처리하는 것도 좋다.

public class MultiExceptionHandling {
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        // TODO: 다음에서 발생하는 예외를 처리해보자.
	try {
	    Class.forName("abc.Def"); // ClassNotFoundException
	    new FileInputStream("Hello.java"); // FileNotFoundException
	    DriverManager.getConnection("Hello"); // SQLException
	}catch(ClassNotFoundException | FileNotFoundException e) {
	    System.out.printf("자원을 찾을 수 없습니다: %s\n", e.getMessage());;
	}catch(SQLException e) {
	    System.out.printf("DB 접속 실패: %s\n", e.getMessage());;
	}
        // END
        System.out.println("프로그램 정상 종료");
    }
}

• 하지만 계층 관계가 존재할 경우 “상속 관계에서는 작은 범위(자식)에서 큰 범위(조상)순으로 정의”해야 한다.

public class HierachyException {
    @SuppressWarnings("resource")
    public static void main(String[] args) {
        String src = "./.project";
        // TODO: 상속 관계를 고려하여 다음에서 예외를 처리해보자.
        try {
             FileInputStream input = new FileInputStream(src);
             int readData = -1;
             while ((readData = input.read()) != -1) {
              System.out.print((char) readData);
             }
        }catch(FileNotFoundException e) {
            System.out.printf("읽으려는 파일이 없습니다.: %s\n", e.getMessage());
        }catch(IOException e) {
            System.out.printf("파일 읽기에 실패했습니다.: %s\n", e.getMessage());;
        }

        // END
        System.out.println("파일 읽음 완료!");
    }

}

 

 

 

✔️try ~ catch ~ finally

finally는 예외 발생 여부와 상관 없이 언제나 실행

• 중간에 return을 만나는 경우도 finally 블록을 먼저 수행 후 리턴 실행

public class tryCatchFinallyTest{
	public static void main(String[] args){
		int num = new Random().nextInt(2);
		try{
			System.out.println("1");
			int i = 1/num;
			System.out.println("2");
		}catch(ArithmeticException e){
			System.out.println("3");
		}finally{
			System.out.println("4");
		}
	}
	System.out.println("5");
}

//num=0일 때
1
3
4
5
//num=1일 때
1
2
4 //finaly는 중간에 return을 만나는 경우에도 finally 블록을 먼저 수행 후에 리턴을 실행한다.

finally는 주로 자원을 정리할 때 사용한다. 또한 try-catch-finally를 통해 동작이 묶여 움직이도록함으로써 유지보수를 용이하게 할 수 있다는 장점도 존재한다.

public class UseInstaller {
    public static void main(String[] args) {
        // TODO: InstallApp을 이용하면서 자원이 확실히 정리되도록 해보자.
	InstallApp app = new InstallApp();
	try {
	    app.copy();
	    app.install();
	}catch(Exception e) {
	    e.printStackTrace();
	}finally {
	    app.delete();
	}
	    // END
      System.out.println("설치 종료");
    }
}

 

 

*try 구문이 수행된다면 항상 수행되는 문장

1. try 문에서 오류가 발생하지 않아도
2. try 문에서 오류가 발생한 경우에도
3. try 문에서 오류가 발생했지만 예외 처리가 안된 경우에도
4. try 문이나 catch 문에서 return 된 경우에도

단, System.exit(~)에 의해 JVM이 종료되면 finally 문은 수행되지 않는다.

 

 

✔️try-with-resource

• JDK 1.7 이상에서 리소스의 자동 close 처리

try(리소스_타입1 res1 = 초기화; 리소스_타입2 res2 = 초기화; ...){
	//예외 발생 코드
}catch(Exception e){
	//exception handling 코드
}

• try 선언문에 선언된 객체들에 대해 자동 close 호출(finalliy 역할)
  • 단, 해당 객체들이 AutoCloseable interface를 구현할 것
    • 각종 I/O stream, socket, connection, …
  • 해당 객체는 try 블록에서 다시 할당할 수 없음

 

 

✔️throws 활용

Declare Exception (선언적 예외 처리)

오류가 발생한 곳에서 예외 처리를 직접 하지 않고 메서드 호출한 곳으로

예외를 던져서 메소드 호출한 곳에서 처리하도록 위임.

 

목적

• 오류가 발생한 곳에서 직접 처리하면 처리 방법이 고정되므로 메서드 호출한 곳에 맞게 처리가 되지 않는다.
  • 메서드 호출한 곳에 맞게 처리하도록 위임
  • 예외 처리의 다양성을 제공
• 다양한 함수에서 여러 오류가 발생하지만 프로그램 내에서 처리하는 방법이 한 가지인 경우 각각의 함수에서 똑같은 예외 처리를 하면 코드 재사용이 안되고, 수정이 용이하지 않으므로 오류를 한 곳(이벤트 처리하는 곳, 클라이언트의 요청을 받는 곳)으로 던져서 한번에 처리한다.
• 메서드가 정상적으로 처리된 경우 결과를 return을 통해서 전달하고 메서드에 문제가 발생한 경우 예외를 통해 메서드 호출한 곳으로 전달된다.

 

형식

[modifiers] 리턴타입 메서드이름([인자들, ...]) [throws 예외들, ...]{
//오류가 발생된 코드
}

• 예외가 없어지는 것이 아니라 단순히 전달됨
• 예외를 전달받은 메서드는 다시 예외 처리의 책임 발생

 

checked exception과 throws

• checked exception은 반드시 try~catch 또는 throws가 필요하다.
• 필요한 곳에서 try~catch 처리
• runtime exception은 throws 하지 않아도 전달되지만
• 하지만 결국은 try~catch로 처리해야 한다.

package chapter07;

/**
 * 사용자 정의 Exception
 * 
 * UncheckedException
 * - 예외 처리 하지 않아도 컴파일 error가 발생하지 않음
 * 	=>실행시에 오류가 발생할 수 있다.
 * - 종류
 * 	RuntimeException과 RuntimeException을 상속 받은 sub들
 * 
 * - 사용자 정의 UncheckedException
 * 	RuntimeException과 RuntimeException을 상속받은 sub들을 상속받는다.
 * 
 * CheckedException
 * - 예외 처리 하지 않으면 컴파일 error가 발생한다.
 * 	=> 반드시 예외 처리 해야 한다.
 * - 종류
 * 	RuntimeException과 RuntimeException을 상속 받은 sub들을 제외한 나머지 예외들
 *	ex) Exception, IOException
 * - 사용자 정의 CheckedException
 * 	RuntimeException과 RuntimeException을 상속받은 sub들을 상속받는다.
 * 	ex) Exception
 */

class MyChecked extends Exception{
    public MyChecked(String msg) {
	super(msg); //getMessage()를 통해 메세지를 전달 받을 수 있다.
    }
}

class MyUnChecked extends RuntimeException{
    public MyUnChecked(String msg) {
	super(msg); //getMessage()를 통해 메세지를 전달 받을 수 있다.
    }
}

class ExceptionUse{
    public static int mod(int i, int j) {
	//MyUnChecked RuntimeException을 상속받아서 예외 처리 하지 않아도 컴파일 오류가 발생하지 않는다.
	if(j==0) throw new MyUnChecked("0으로 나눌 수 없습니다.");
	return i/j;
    }
    
    public static int div(int i, int j) throws MyChecked{
	//MyChecked는 Exception을 상속 받은 CheckedException이므로 반드시 예외 처리를 해야 한다.
	if(j==0) throw new MyChecked("0으로 나눌 수 없습니다.");
	return i/j;
    }    
}

public class ExceptionTest5 {
    public static void main(String[] args) {
	//UnCheckedException을 던지는 mod 메서드는 필요시 예외 처리한다.
	ExceptionUse.mod(256,8);
	try {
	    //CheckException을 던지는 div 메서드는 호출시 반드시 예외처리해야 한다.
	    ExceptionUse.div(256,8);
	}catch(MyChecked e){
	    e.printStackTrace();
	}
    }
}

 

 

 

✔️로그 분석과 예외의 추적

• Throwable의 printStackTrace는 메서드 호출 스택 정보 조회 가능
  • 최초 호출 메서드에서부터 예외 발생 메서드까지이 스택 정보 출력
• 꼭 확인해야할 정보
  • 어떤 예외인가? - 예외 종류
  • 예외 객체의 메시지는 무엇인가? - 예외 원인
  • 어디서 발생했는가? - 디버깅 출발점
    • 직접 작성한 코드를 디버깅 대상으로 삼을 것
    • 참조하는 라이브러리(java.xx 등)는 과감히 건너뛰기

 

매서드 재정의와 throws

매서드 재정의시 조상 클래스 메서드가 던지는 예외보다 큰 예외를 던질 수 없다.(부모가 치지 않은 사고를 자식이 칠 수 없다.)

 

예외 변환

하위 계층에서 발생한 예외는 상위 계층에 맞는 예외로 바꿔서 던져야 한다.

 

Exception Chaining

하위 계층에서 발생한 예외 정보가 상위 계층의 예외를 디버깅하는데 유용할 경우 사용

• 하위 계층의 예외를 원인으로 상위 계층에서 예외를 발생시킴

 

 

 

🔍Collection

배열

배열은 가장 기본적인 자료 구조로, 동일한 데이터 타입만 관리 가능하다.

⇒타입이 다른 객체를 관리하기 위해서는 매번 다른 배열을 필요로 한다.

 

 

Collection Framework

• java.util 패키지
  • 다수의 데이터를 쉽게 처리하는 방법 제공 → DB처럼 CRUD 기능 중요
• List, Set, Map(3대 주요 interface)
  • List: 입력 순서가 있는 데이터의 집합, 순서가 있으니까 데이터의 중복을 허락
  • ArrayList, LinkedList
  • Set: 입력 순서를 유지하지 않는 데이터의 집합, 순서가 없어서 같은 데이터를 구별할 수 없음 → 중복 허락하지 않음
  • HashSet, TreeSet
  • Map: key와 value의 쌍으로 데이터를 관리하는 집합. 순서는 없고 key의 중복 불가, value는 중복 가능
  • HashMap, TreeMap

 

 

✔️List

입력 순서 O, 데이터의 중복 O

특정 위치 O(index O)

• add(int index, E element)
• get(int index)
• indexOf(Object o)
• lastIndexOf(Object o)
• 데이터를 저장한 순서대로 저장해 준다.
• 데이터의 index는 0부터 size()-1까지
• 중간 삽입할 수 있는 index는 0부터 size()

⇒범위를 벗어나면 IndexOutOfBoundsException이 발생한다.

• 데이터를 중복해서 저장할 수 있다.
• IndexOf(Object o), lastIndexOf(Object o), contains(Object o), remove(Object o)은 해당 기능을 수행하기 위해서 **equals(Object o)**를 호출해서 객체가 같은지 비교 후 처리한다.

 

배열과 ArrayList

배열은 간단하고 사용이 쉬우며 접근 속도가 빠르지만, 크기를 변경할 수 없어 추가 데이터를 위해 새로운 배열을 만들고 복사해야 한다. 또한 비순차적인 데이터의 추가 및 삭제에 많은 시간이 걸린다.

⇒배열을 사용하는 ArrayList도 태생적으로 배열의 장-단점을 그대로 가져간다.

 

LinkedList

각 요소를 Node로 저장하고 Node는 다음 요소의 참조값과 데이터로 구성됨

• 각 요소가 다음 요소의 링크 정보를 가지며 연속적으로 구성될 필요가 없다.

public class ListTest {
    public static void main(String[] args) {
			//ArrayList는 저장할 데이터의 개수를 알고 사용하는 것이 좋다.
			ArrayList<String> list = new ArrayList<>(10);
			list.add("hello");
			
			//데이터를 추가할 때마다 node를 추가해서 연결하므로 기본 생성자로 생성한다.
			LinkedList<String> list2 = new LinkedList<>();
			
			Queue<Integer> queue = new LinkedList<>();
			Queue<Integer> queue2 = new ArrayDeque<>(); //list를 상속받지 않음
    }
}

 

 

결론

• 소량의 데이터를 가지고 사용하는 경우 ArrayList와 LinkedList는 큰 차이가 없음
• 정적인 데이터의 활용, 단순한 데이터 조회용: ArrayList
• 동적인 데이터 추가, 삭제가 많은 작업: LinkedList

 

 

✔️Set

입력 순서 X, 데이터의 중복 X

• 입력 순서를 관리하지 않고 주머니에 구슬(데이터)를 넣는 형태
• 데이터를 구별할 순서(index)가 없어 중복이 허용되지 않는다.
  • 효율적인 중복 데이터 제거 수단

  import java.util.*;
  
  public class ListToSetToListTest {
      public static void main(String[] args){
          List<Integer> numList = Arrays.asList(1,2,2,3,3,3,4,5);
          System.out.println("중복이 존재하는 numList: "+numList);
  
          Set<Integer> uniqueSet = new HashSet<>(numList);
          System.out.println("Set을 통한 중복제거 uniqueSet: "+uniqueSet);
  
          numList = new ArrayList<>(uniqueSet);
          System.out.println("다시 List로 uniqueList: "+numList);
      }
  }
  

  중복이 존재하는 numList: [1, 2, 2, 3, 3, 3, 4, 5] Set을 통한 중복제거 uniqueSet: [1, 2, 3, 4, 5] 다시 List로 uniqueList: [1, 2, 3, 4, 5]

import java.util.HashSet;
import java.util.Set;

public class SetTest {
    Set<Object> hset = new HashSet<Object>();

    private void addMethod() {
        hset.add(Integer.valueOf(1));
        hset.add("Hello");
        hset.add("Hi");
        hset.add("There");
        hset.add("Hello"); // 동일한 데이터 추가 확인
        hset.add(1); // 기본형은 wrapper를 통해 추가
        // TODO: SmartPhone 타입의 객체를 추가해보자.
        SmartPhone sp1 = new SmartPhone("010");
        SmartPhone sp2 = new SmartPhone("010");
        System.out.println("equals: "+sp1.equals(sp2));
        hset.add(sp1);
        hset.add(sp2);
        // END
        System.out.println("데이터 추가 결과: " + hset);
    }

    private void retrieveMethod() {
        System.out.println("데이터 개수: " + hset.size());

        for (Object sobj : hset) {
            System.out.println("데이터 조회: " + sobj);
        }
    }

    private void removeMethod() {
        hset.remove("Hello");
        System.out.println("데이터 삭제 결과: " + hset);
    }

    public static void main(String[] args) {
        SetTest test = new SetTest();
        test.addMethod();
        test.retrieveMethod();
        test.removeMethod();
    }
}

• index가 없기때문에 특정 요소를 수정할 수 없다. (수정 X)
• 동일한 데이터의 기준

// TODO: SmartPhone 타입의 객체를 추가해보자.
hset.add(new SmartPhone("010"));
hset.add(new SmartPhone("010"));

객체의 입장에서는 서로 다른 객체로 인식

// TODO: 동일한 번호의 SmartPhone이면 하나만 추가될 수 있도록 처리하시오.
    @Override
    public boolean equals(Object obj) {
			if(obj!=null && obj instanceof SmartPhone phone) {
			    return this.number.equals(phone.number);
			}
			return false;
    }
    
    @Override
    public int hashCode() {
			return this.number.hashCode();
    }

동일한 데이터의 기준은 객체의 equals()가 true를 리턴하고 hashcode값이 같아야 한다.

따라서 equals()뿐만 아니라 hashCode도 override해야한다.

 

 

✔️Map

• key와 value를 하나의 Entry로 묶어서 데이터를 관리
  • key: Object형태로 데이터 중복을 허락하지 않음
  • value: Object형태로 데이터 중복이 허락 됨
• put(K key, V Value)
• Java의 Map에서 put 메서드를 사용하여 요소를 수정하면 해당 키에 대한 이전 값이 반환됩니다. 만약 이전에 해당 키에 연결된 값이 없었다면 **null**이 반환된다.
• containsKey(Object key)
• get(Object key)
• keySet()

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class MapTest {
    public static void main(String[] args){
        Map<String, Integer> ageMap = new HashMap<>();
        ageMap.put("John", 25);
        ageMap.put("Stormy", 5);
        ageMap.put("Stonsy", 23);
        System.out.println(ageMap);

        for(Entry<String, Integer> entry : ageMap.entrySet()){
            String name = entry.getKey();
            int age = entry.getValue();
            System.out.println(name+"의 현재 나이는 "+age+"입니다.");
        }

        ageMap.remove("Stormy");
        System.out.println("stormy 삭제후");

        for(Entry<String, Integer> entry : ageMap.entrySet()){
            String name = entry.getKey();
            int age = entry.getValue();
            System.out.println(name+"의 현재 나이는 "+age+"입니다.");
        }
    }
}

 

 

 

✔️정렬

순서를 가지는 Collection들만 정렬이 가능하다.

• List 계열
• Set에서는 SortedSet의 자식 객체
• Map에서는 SortedMap의 자식 객체(key 기준)

 

Comparator의 활용

• 객체가 Comparable을 구현하고 있지 않거나 사용자 정의 알고리즘으로 정렬하려는 경우
  • String을 알파벳 순이 아닌 글자 수 별로 정렬하려면?

 

Comparable: 내가 정렬되는 것

Comparator: 무엇을 정렬하는 것

 

import java.util.*;

public class SortTest {
    static class StringLengthComparable implements Comparator<String> {
        @Override
        public int compare(String s1, String s2){
            int len1 = s1.length();
            int len2 = s2.length();

            return Integer.compare(len1, len2);
        }
    }

    public static void main(String[] args){
        //1. 배열의 정렬(오름차순 정렬)
        Integer[] numArr = {2,1,4,3,5};
        Arrays.sort(numArr);
        System.out.println("숫자 배열 오름차순 정렬: "+Arrays.toString(numArr));

        //2. 배열의 정렬(내림차순 정렬)
        Arrays.sort(numArr, (n1,n2)->n2-n1);
        Arrays.sort(numArr, (n1,n2)->{return n2-n1;});
        System.out.println("숫자 배열 내림차순 정렬: "+Arrays.toString(numArr));

        //3. List의 정렬
        List<Integer> numList = new ArrayList<>();
        //List<Integer> numList = Arrays.asList(5,1,2,4,3);
        numList.add(5);
        numList.add(1);
        numList.add(2);
        numList.add(4);
        numList.add(3);
        Collections.sort(numList); // 오름차순정렬
        System.out.println("Integer List 오름차순 정렬: "+numList);
        Collections.sort(numList,(n1,n2)->(n2-n1));
        System.out.println("Integer List 내림차순 정렬: "+numList); // 내림차순정렬

        //4. String의 정렬
        List<String> strList = Arrays.asList("011", "010", "111");
        System.out.println("String List: "+strList);
        Collections.sort(strList);
        System.out.println("String List 오름차순 정렬: "+strList);

        //5. String 글자길이순 정렬
        List<String> strList2 = Arrays.asList("Stormy", "Stonesy", "John");
        Collections.sort(strList2, new StringLengthComparable());
        System.out.println("String List 글자길이순 정렬: "+strList2);
    }
}

숫자 배열 오름차순 정렬: [1, 2, 3, 4, 5]

숫자 배열 내림차순 정렬: [5, 4, 3, 2, 1]

Integer List 오름차순 정렬: [1, 2, 3, 4, 5]

Integer List 내림차순 정렬: [5, 4, 3, 2, 1]

String List: [011, 010, 111]

String List 오름차순 정렬: [010, 011, 111]

String List 글자길이순 정렬: [John, Stormy, Stonesy]

 

 

Anonymous Nested Class

• 클래스의 이름이 없이 객체 생성과 동시에 구현하는 클래스
• 부모의 이름을 빌려서 객체를 생성 => 상속이 기본

 

형식

new 부모(){ //구현하기 }

 

 

Lamda

• 함수의 축약형
• Anonymous Nested Class와 같은 역할

 

형식

( )->{ }

 

public class SortTest {
    public static void main(String[] args){
        //1. 배열의 정렬(오름차순 정렬)
        Integer[] numArr = {2,1,4,3,5};
        Arrays.sort(numArr);
        System.out.println(Arrays.toString(numArr));

        //2. 배열의 정렬(내림차순 정렬)
        Arrays.sort(numArr, (n1,n2)->n2-n1);
        Arrays.sort(numArr, (n1,n2)->{return n2-n1;});
        System.out.println(Arrays.toString(numArr));
    }
}

 

 

 

🔍Java 스트림(Stream)

Java 스트림 Stream (1) 총정리

Java 스트림 Stream (1) 총정리

 

Stream을 통해 배열 또는 컬렌션 인스턴스에 함수 여러 개를 조합해서 원하는 결과를 필터링하고 가공된 결과를 얻을 수 있다.

Stream의 또 하나의 장점은 간단하게 병렬처리(multi-threading)이 가능하다는 것이다.

 

 

※예제

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class StreamTest {
    public static class Person{
        String name;
        int age;
        String address;

        Person(){}

        Person(String name, int age, String address){
            this.name = name;
            this.age = age;
            this.address = address;
        }

        @Override
        public String toString(){
            return "name: "+name+", age:"+age+", address: "+address;
        }
    }

    public static void main(String[] args){
        //1. Stream의 생성
        System.out.println("1. Stream 생성");
        String[] arr = {"John", "John","APC", "AcneStudio", "Stormy", "Stonesy"};
        Stream<String> stream = Arrays.stream(arr);
        stream.forEach(System.out::println);

        //2. distinct()를 통한 중복 제거
        System.out.println("\\n2. distinct()를 통한 중복 제거");
        //중복 제거 후 새로운 스트림 생성
        Stream<String> uniqueStream = Arrays.stream(arr).distinct();
        uniqueStream.forEach(System.out::println);

        //3-1. filter를 통해 원하는 요소 추출 - A 포함 문자열 필터링
        System.out.println("\\n3. filter()를 통한 원하는 요소 추출-A 포함 문자열 filtering");
        Arrays.stream(arr).filter(word->word.contains("A")).forEach(System.out::println);

        //3-2. filter를 통해 원하는 요소 추출 - 문자열 길이
        System.out.println("\\n4. filter()를 통한 원하는 요소 추출-문자열 길이 filtering");
        Arrays.stream(arr).filter(word->word.length()>=5).forEach(System.out::println);

        //4. Stream.iterate: 주어진 초깃값부터 시작해 주어진 연산자를 반복적용하여 무한한 요소 생성
        System.out.println("\\n5. Stream.iterate()를 통한 요소 생성");
        Stream<Integer> numStream = Stream.iterate(3, n->n+1).limit(10);
        numStream.forEach(n->System.out.print(n+" "));
        System.out.println();

        //5. skip()
        System.out.println("\\n6. skip(), before: "+Arrays.toString(arr));
        Arrays.stream(arr).skip(2).forEach(s->System.out.print(s+" "));
        System.out.println();

        //6. 정렬
        System.out.println("\\n7-1. Stream 오름차순 정렬");
        Integer[] numArr = {4,1,2,5,3};
        Arrays.stream(numArr).sorted().forEach(n-> System.out.print(n+" "));
        System.out.println("\\n7-2. Stream 내림차순 정렬");
        Arrays.stream(numArr).sorted((n1,n2)->n2-n1).forEach(n-> System.out.print(n+" "));
        System.out.println();

        //7. 객체와 Stream
        System.out.println("\\n8. 객체Stream 필터링");
        Person[] persons = {new Person("John", 25, "서울"),
                new Person("Stormy", 5, "LA"),
                new Person("Stonesy", 23, "서울"),};
        Stream<Person> personStream = Arrays.stream(persons);
        personStream.filter(p->p.age>=20).forEach(p-> System.out.println(p));
    }
}