개발옹

📌인터페이스와 추상클래스의 차이

자바에는 비슷한 듯 다른 인터페이스와 추상 클래스가 있다. 이 둘의 차이점을 정리해보려 한다. 

먼저, 인터페이스와 추상 클래스가 무엇인지 먼저 알아보자.

인터페이스(Interface)

인터페이스는 모든 메서드가 추상 메서드로 구성되어있고, 클래스가 구현해야할 메서드의 집합을 정의한다.

간단하게 무언가 구현해야할 내용을 정의해놓은 것이라고 생각하면 된다.

'구현해야할' 것들을 정의해놓은 것이므로 일반 클래스와 달리 메서드에 코드 블럭이 없다. 즉, 어떤 메서드의 기능을 구현해놓은 내용인 코드 블럭이 없다.

interface 인터페이스명() {
    public static final 상수명 = 값;
    public abstract void 메서드명();
}

인터페이스를 선언할 때는 접근 제어자와 함께 ① interface 키워드를 사용한다.

그리고 ② 인터페이스의 모든 메서드는 암묵적으로 public 이며, 필드(변수)는 public static final 이다.

*인터페이스 필드에 int COUNT = 3;은 public static final을 생략해도 자동으로 public static final이 적용된다.

메서드에 기능을 구현해놓지 않기 때문에, 인터페이스는 혼자서 무언갈 할 수는 없다. 인터페이스를 상속한 클래스(구현체)에서 메서드를 Override 해서 구현해야한다.

interface Computer { }
Computer C = new Computer(); // Error: Cannot instantiate the type Computer

위처럼 인터페이스가 있다고 할때, Computer 객체를 생성하려하면 에러가 발생한다. 

그리고 인터페이스는 ③ 다중 상속이 가능해서, 아래와 같이 한 클래스가 여러 인터페이스를 상속받아 구현할 수 있다.

class 클래스명 implements 인터페이스1, 인터페이스2

④ Java8 부터 인터페이스는 default 메서드와 static 메서드를 사용할 수 있다.

인터페이스의 메서드는 구현체를 가질 수 없지만, default 메서드를 사용하면 실제 구현된 형태의 메서드를 가질 수 있다. 

그리고 인터페이스에 static 메서드를 구현하면 인터페이스명.스태틱메서드명과 같이 사용하여 일반 클래스의 static 메서드를 사용하는 것과 동일하게 사용할 수 있다.

interface TestInterface {
    // default 메서드
    default void printSomething() {
    	System.out.println("default method in interface");
    }
    // static 메서드
    static int getNum() {
    	return 10;
    }
}

아래와 같이 인터페이스명.스태틱메서드명으로 사용할 수 있다.

TestInterface.printSomething();

인터페이스(Interface)를 사용하는 이유?

그렇다면 인터페이스를 왜 사용해야 하는걸까?

보통 중요 클래스를 작성하는 시점에서 클래스의 구현체가 몇 개가 될지 알 수 없으므로 인터페이스를 정의해서 인터페이스를 기준으로 메서드를 만드는 것이 효율적이기 때문이다.

당장 이 문장을 읽었을때는 무슨 소린가 싶다.

예시로 한번 다시 정리해보자.

Animal 클래스를 상속하는 Tiger, Bear 클래스가 있고, 이들을 관리하고 먹이를 주는 ZooKeeper 클래스가 있다고 해보자.

class Animal {
	String name;
	void setName(String name) {
		this.name = name;
	}
}

class Tiger extends Animal { }
class Bear extends Animal { }
class ZooKeeper {
	void feed(Tiger tiger) {
		System.out.println("feed apple to Tiger");
	}
	void feed(Bear bear) {
		System.out.println("feed banana to Bear");
	}
}

ZooKeeper는 feed() 메서드 호출시 인자의 타입에 따라 Tiger나 Bear에게 먹이를 준다.

public static void main(String[] args) {
    ZooKeeper zooKeeper = new ZooKeeper();
    Tiger tiger = new Tiger();
    Bear bear = new Bear();

    zooKeeper.feed(tiger); // feed apple to Tiger
    zooKeeper.feed(bear); // feed banana to Bear
}

근데 이때 동물들이 계속해서 늘어난다면, ZooKeeper에 해당 동물들의 타입을 매개변수로 한 feed() 메서드를 계속 계속 추가해주어야한다. 이렇게 계속 추가하게 되면 ZooKeeper 가 굉장히 복잡해질 것이다.

이럴때 인터페이스를 구현하면 훨씬 효율적으로 코드를 구성할 수 있다.

먹이를 주는 메서드 기능을 가진 인터페이스 Work를 생성해보자.

interface Work {	} // 인터페이스
class Animal { // 부모(상위) 클래스
    String name;
    void setName(String name) {
    	this.name = name;
    }
}
class Tiger extends Animal implements Work { }
class Bear extends Animal implements Work { }

그리고 Tiger, Bear 클래스에서  인터페이스 Work를 상속한다. 

*인터페이스 상속시 키워드는 implements

이렇게하면 ZooKeeper 클래스에 인터페이스 Work 타입을 매개변수로 받아서 먹이를 주는 기능인 feed() 메서드를 구현할 수 있다. 

class ZooKeeper {
    void feed(Work work) {
        System.out.println("feed apple to Animal");
    }
}

원래는 Tiger, Bear 타입에 대해 각각 feed() 메서드를 구현해야했지만, 인터페이스인 Work 타입의하나의 메서드만으로도 feed() 메서드 구현이 가능하다.

실제로 Tiger, Bear 인스턴스를 feed(Work work) 메서드의 인자로 넣어서 호출하면 아래와 같은 결과가 나온다.

public static void main(String[] args) {
    ZooKeeper zooKeeper = new ZooKeeper();
    Tiger tiger = new Tiger();
    Bear bear = new Bear();

    zooKeeper.feed(tiger); // feed apple to Animal
    zooKeeper.feed(bear); // feed apple to Animal
}

이제 어떤 동물 클래스를 추가하든 ZooKeeper 클래스에 feed() 메서드를 추가할 필요가 없다.

다시 위에서 얘기했던 이유를 가져오면,

"중요 클래스를 작성하는 시점에서 클래스의 구현체가 몇 개가 될지 알 수 없으므로 인터페이스를 정의해서 인터페이스를 기준으로 메서드를 만드는 것이 효율적"

이라는 말이 조금은 이해가 될 것이다.

다만, 위 예시는 인터페이스가 왜 필요한가에 대한 부분에 대한 설명을 위한 예시로, Work 인터페이스를 상속하는 모든 클래스에서 같은 출력이 나온다. 이건 Work 인터페이스를 상속받는 하위 클래스, 즉 자식 클래스에서 별도로 메서드를 구현해서 각 동물 클래스마다 다른 결과를 나오게 할 수 있다.

*어떻게 하는건지는 이 포스팅에서는 다루지 않겠다. 추상 클래스랑 비교가 목적이므로..

추상 클래스(Abstract Class)

추상 클래스는 ① 하나 이상의 추상 메서드를 포함하며, 인터페이스의 역할도 하면서 클래스의 기능도 가지고 있는 클래스이다. 

하나 이상의 추상 메서드를 포함한다는 것은, 일반 메서드를 가질 수 있다는 의미도 내포한다.

인터페이스의 경우, 모든 메서드가 추상 메서드인 반면 추상 클래스는 미리 구현된 메서드를 가질 수 있다는 차이가 있다.

abstract class 클래스명() { // 추상 클래스
    abstract 반환타입 메서드명(); // 추상 메서드
}

추상 메서드는 인터페이스의 메서드와 마찬가지로 구현체가 없다.

즉, 추상 클래스를 상속하는 자식 클래스에서 반드시 해당 추상 메서드를 오바라이딩을해야 사용할 수 있다.

추상 메서드는 코드 블럭이 있는 구현체로 작성되지 않고, 선언부만 존재한다. 이 메서드를 자식 클래스에서 오버라이딩하여 구현해서 사용하는 것이다.

다시말해, 추상 클래스는 "내가 이 기능을 정해두지 않을테니, 나를 상속한 자식 클래스들아, 내가 정의한 기능을 구현해봐!" 라고 이야기 하는 것이다. 여기에 추가로, "단 일부는 만들어주고, 일부는 안만들어줄게" 라고 한다고 생각하면 기억하기 쉽다.

추상 클래스는 인터페이스와 마찬가지로 구현부가 없는 추상 메서드가 있기 때문에 일반 클래스와 달리  ② 단독으로 객체, 즉 인스턴스를 생성할 수 없다.

반드시 추상 클래스를 상속한 실제 클래스를 통해서만 객체를 생성할 수 있다.

(추상 클래스를 상속한 자식 클래스에서 해당 추상 클래스의 추상 메서드를 오버라이딩 해야, 자식 클래스의 인스턴스 생성 가능)

abstract class Teacher { }
Teacher t = new Teacher();  // Error: Cannot instantiate the type Teacher

그리고 추상 클래스는 인터페이스와 달리 일반 클래스처럼 ③ 인스턴스 변수, 생성자, private 메서드 등을 가질 수 있다.

즉, 추상 메서드와 일반 메서드, 객체 변수, 생성자까지 가질 수 있는 것이다.

abstract class Teacher {
	private String name; // 멤버 변수
	Teacher() {} // 생성자
    
	abstract void hello(); // 추상 메서드
	void hi() { System.out.println("안녕!"); } // 일반 메서드
}

그리고 Java에서는 클래스의 다중 상속을 막기 때문에 ④ 추상 클래스는 다중 상속을 할 수 없다.

class 클래스명 extends 추상클래스

추상 클래스(Abstract Class)를 사용하는 이유?

추상 메서드도 인터페이스와 비슷하게, 중복되거나 공통되는 부분에 대해 미리 만들어진 것을 사용하고, 이를 사용하는 쪽에서 자신에게 필요한 부분만 재정의해서 사용함으로써 생산성과 효율성이 향상되기 때문에 사용한다.

또한 추상 메서드가 포함된 클래스를 상속받는 하위(자식)클래스가 반드시 그 추상 메서드를 구현하게끔 하기 위함이다.

일반 메서드는 해당 메서드를 구현하지 않을수도 있지만, 추상 메서드가 포함된 추상 클래스를 상속받은 모든 하위(자식)클래스는 추상 메서드를 구현해야만 인스턴스를 생성할 수 있기 때문에 반드시 구현하게 된다.

인터페이스(Interface) vs 추상 클래스(Abstract Class)

그럼 이 둘의 차이가 어디에 있는지 정리해보자.

1. 사용 목적

• 인터페이스는 모든 메서드가 추상 메서드로, 인터페이스를 상속받는 클래스가 구현해야 할 메서드의 집합을 정의한다. 
• 추상 클래스는 1개 이상의 추상 메서드가 있고, 일반 메서드도 포함할 수 있기 때문에, 추상 메서드의 기능을 구현하게 하기 위해서도 있지만, 상속을 통한 공통 기능 공유하도록 하는 것에도 목적이 있다.

2. 구현

• 인터페이스는 모든 메서드가 추상 메서드이다.
• 추상 클래스는 추상 메서드와 일반 메서드를 모두 가질 수 있다.

3. 멤버 변수

• 인터페이스의 멤버 변수는 public static final이다. 즉, 인스턴스 변수를 가질 수 없다.
• 추상 클래스는 인스턴스 변수를 가질 수 있다.

4. 생성자 가능 여부

• 인터페이스는 생성자를 가질 수 없다.
• 추상 클래스는 생성자를 가질 수 있다.

5. 다중 상속 여부

• 인터페이스(키워드: implements)는 다중 상속이 가능하다.
• 추상 클래스(키워드: extends) 는 다중 상속이 불가능하다. 

마치며,

Java의 인터페이스와 추상 클래스에 대해 알아보았다.

알아보면서도 더 알아봐야할 개념들이 많아서, 이후에 하나씩 차근히 정리해보아야겠다. 

참고 포스팅 및 서적

• Do it! 점프 투 자바
• TCP School

단축 평가(Short-circuit Evaluation)란?

단축 평가는 표현식의 결과를 결정하는데에 필요한 최소한의 연산만 수행하는 것을 의미한다.

다르게 말하면, 표현식의 결과를 결정하는 도중에 결과가 확정된 경우, 나머지 연산을 수행하지 않고 생략하는 것을 말한다.

그리고 단축 평가는 논리 연산에서 효율성을 높이는 중요한 개념이다.

💡 표현식(Expression)

표현식은 값을 계산하기 위해 사용하는 코드의 한 조각으로, 결과적으로 하나의 값을 만들어낸다.

예를 들어 10 + 3 은 13이라는 값을 만들어내는 표현식이다.

단축 평가의 적용

논리 연산자인 AND(&&)와 OR(||) 연산은 단축 평가를 수행한다.

논리곱(&&) 연산

논리곱(&&) 연산자는 두 피연산자가 모두 true 일 때, true를 반환한다.

그리고 좌항에서 우항으로 평가가 진행된다. 

(피연산자 1) && (피연산자 2) 가 있으면 피연산자 1이 먼저 평가되고, 피연산자 2가 평가되는 것이다.

피연산자 1이 true라고 해서 표현식 전체를 true로 평가할 수는 없고, 피연산자 2까지 평가를 해보아야한다.

즉, 두번째 피연산자인 피연산자 2가 논리곱 연산의 결과를 결정한다고 볼 수 있다. 

그런데 이때 피연산자 1이 false 라면, 피연산자 2의 결과와는 관계없이 논리곱 연산의 결과가 false가 된다.

논리곱(&&) 연산은 두 피연산자가 모두 true이여야하기 때문이다.

논리합(||) 연산

논리합(||) 연산자는 두 피연산자 중 하나라도 true 일 때, true를 반환한다.

논리곱 연산자와 마찬가지로 좌항에서 우항으로 평가된다.

(피연산자 1) || (피연산자 2) 가 있다고 할 때, 피연산자 1이 true라면 두번째 피연산자인 피연산자 2를 평가하지 않아도 이 표현식이 true라고 평가할 수 있다.

그런데 이때 피연산자 1이 false 라면, 피연산자 2를 평가해야지만 이 표현식의 결과를 확정할 수 있다. 

논리합 연산자는 둘 중 하나라도 true면 true를 반환하기 때문이다.

논리곱(&&) 연산자와 논리합(||) 연산자의 단축 평가

그럼 논리곱, 논리합 연산자의 단축 평가가 어떻게 이뤄지는지 알아보자.

결론을 말하자면,

논리곱(&&) 연산자는 첫번째 피연산자가 false 면, 이후 피연산자에 대해서는 평가를 하지 않고,

논리합(||) 연산자는 첫번째 피연산자가 true 면, 이후 피연산자에 대해서는 평가를 하지 않는다.

다음 예제로 자세히 알아보자.

1 == 0 : false
1 / 0 == 0 : Error

조건이 위와 같이 있다할때, 각 결과는 1 == 0 은 false, 1 / 0 == 0 은 에러가 발생한다.

그럼 두개의 피연산자로 표현식을 구성해서 논리곱 연산을 하면 어떻게 될까?

1 == 0 && 1 / 0 == 0

위 표현식에서 두번째 피연산자에 1 / 0 은 에러가 발생하므로, 에러가 발생하지 않을까하지만, 결과는 false 이다!

논리곱(&&) 연산자는 좌항부터 연산을 하고, 단축 평가를 하기 때문에 첫번째 피연산자가 false 라면, 두번째 피연산자에 대해서는 평가를 하지 않고 (결과가 확정되었기 때문) false 를 반환한다. 

두번째 피연산자에 관련된 코드는 실행하지 않으므로 Dead Code가 된다.

*Dead Code: 실행되지 않는 코드

논리합(||) 연산자도 마찬가지로 다음 예제로 살펴보자.

1 == 0 || 1 / 0 == 0

이때는 첫번째 피연산자가 false 이고, 결과가 확정되지 않았으므로 1 / 0 == 0 까지 연산을 수행하게 되어서 에러가 발생한다.

1 == 1 || 1 / 0 == 0

만약 첫번째 피연산자가 1 == 1로, 결과가 true 라면, 두번째 피연산자를 평가하지 않으므로 결과로 true가 반환된다.

논리합(||) 연산자도 좌항부터 연산을 수행하고 단축 평가를 하기 때문에 앞선 연산이 true 라면 결과가 확정되어 이후 연산을 수행하지 않는다.

마찬가지로 두번째 피연산자에 관련된 코드는 실행하지 않으므로 Dead Code가 된다.

단축 평가 규칙

단축 평가의 규칙은 아래 표와 같다.

단축 평가의 이점

단축 평가의 이점은 효율성 향상에 따른 성능 향상에 있다.

논리 연산 수행시 결과가 이미 결정된 경우 나머지 부분을 수행하지 않기 때문에 불필요한 계산을 생략하여 효율성을 높인다. 이는 특히 연산을 많이 수행하는 메서드나 I/O 작업이 포함된 경우에 이점이 커진다.

boolean result = (condition1 && condition2); // condition1이 false라면 condition2는 평가되지 않음

그리고 단축 평가는 특정 조건에서만 메서드를 호출하거나 연산을 수행하고자 할 때 유용하게 쓰인다.

if (obj != null && obj.someMethod()) {
	// obj가 null이 아닌 경우에만 obj.someMethod()가 호출	
}

또한 특정 연산을 실제로 필요한 경우에만 수행하게끔 한다.

if (condition && someMethod()) {
	// someMethod()는 condition이 true인 경우에만 호출
}

이는 배열이나 리스트 같은 자료 구조를 접근할 때 범위 체크시에도 유용하다.

if (idx < array.length && array[idx] == target) {
	// array[idx]에 안전한 접근 가능
}

마치며,

단축 평가를 모른다면 코드 구현시 의도한대로 결과가 나오지 않거나, 런타임 에러가 발생하는 등의 문제가 발생할 수 있겠다.

이번 기회를 통해 단축 평가를 잘 정리한 것 같다.

그리고 Java 카테고리로 분류하긴 했지만, 단축 평가는 대부분의 주요 프로그래밍 언어에서 지원한다고 한다.

참고 포스팅

📌요약

main 메서드는 자바 프로그램의 진입점(entry point), 즉 시작점이다.

JVM은 자바 프로그램 실행시 main 메서드를 찾아서 시작하므로 main 메서드는 필수적인 메서드이다.

• public: 접근제어자로, JVM이 main 메서드를 접근할 수, 찾을 수 있다.
• static: 인스턴스 생성 없이 클래스가 로드되면 바로 실행되어야하고 프로그램 실행시 main 메서드는 메모리에 할당되어 있어야하기 때문에 가비지 컬렉터의 정리 대상이 아니여야 한다. 
• void: main 메서드가 종료되었다는 것은 프로그램이 종료되었다는 것을 의미하므로 반환할 리턴값도 없다.
• String[] args: 프로그램 실행시 main 메서드에 넘기는 파라미터이다.

main 메서드란?

먼저 이 main 메서드가 무엇인지 알아보자.

main 메서드는 Java 프로그램의 진입점(entry point)로, 프로그램이 실행될 때 가장 먼저 호출된다.

그리고 모든 자바 어플리케이션은 main 메서드를 필수로 포함해야한다.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

💡 진입점(entry point)

진입점이란 프로그램이 시작되는 시작점으로, main 메서드가 이에 해당한다.

컴퓨터가 프로그램을 실행할 때 가장 먼저 main 메서드를 찾아서 그 안에 있는 코드를 실행한다.

즉, 프로그램을 시작할 때 컴퓨터가 어디서부터 실행해야할지를 알려주는 역할을 하는 것이다.

모든 자바 프로그램은 main 메서드를 포함해야하는 이유가 이에 있다. main 메서드가 없으면 프로그램이 어디서 시작해야할지를 몰라서 실행되지 않는다.

*관례적으로 프로그램의 시작점을 main으로 한다고 한다!

main 메서드가 자바 프로그램을 실행하려면 필수적으로 있어야하고, 가장 먼저 실행된다는 것을 알아보았으니 이제 하나씩 뜯어보자!

public

public은 접근 제어자(access modifier)중 하나로, 어디서든 해당 객체를 참조할 수 있는 접근 제어자이다.

main 메서드는 진입점(entry point)이기 때문에 JVM에서 이 main 메서드를 어느곳에서든 접근하기 위해 public 이여야한다.

JVM이 자바 프로그램을 시작하고 main 메서드를 실행하려는 시점은 아직 아무런 클래스도 로드되어있지 않은 상태이다.

가장 먼저 main 메서드가 어떤 클래스에 있는지를 찾고, 그 클래스에서 불러오는 과정이 필요하다.

그래서 이 main 메서드에 접근 제약이 생긴다면 JVM은 main 메서드를 찾지 못해서 프로그램을 실행시킬 수 없는 것이다.

이렇게 되면 자바 프로그램 실행이 안되므로, main 메서드에는 아무런 제약이 없도록 public을 써주어야 한다.

접근제어자로 public 이 아니라 private로 실행하면 아래와 같은 에러가 발생한다.  

오류: javafx.application.Application 클래스에서 기본 메소드가 Main3이(가) 아닙니다. 다음 형식으로 기본 메소드를 정의하십시오.
   public static void main(String[] args)

static

static 은 인스턴스 생성없이 메서드를 호출할 수 있게하는 키워드로, 정적 함수임을 의미한다.

static으로 선언한 속성과 메서드는 인스턴스와 관계없이 항상 일정한 값을 가지므로 굳이 인스턴스를 생성하지 않아도 사용할 수 있게끔 만들어진 것이다.

JVM이 main 메서드를 발견하면 main 메서드가 들어있는 클래스를 로드한다.

그 후 별도로 인스턴스를 생성하는 과정을 거치지 않고 클래스가 로드되면 바로 main 메서드를 사용할 수 있도록 해야하기 때문에 static 키워드를 붙여주어야 한다.

그리고 static으로 선언한 속성과 메서드는 프로그램이 실행되는 순간 메모리가 할당되고, 가비지 컬렉터의 메모리 정리대상이 아니다.

즉, static으로 선언한 속성과 메서드는 메모리에 항상 할당되어 있다는 것이다. 

main 메서드는 가비지 컬렉터에 의해 정리되어서는 안되는 기본 함수이므로 static을 붙여야한다.

void

void 는 메서드의 리턴 값이 없음을 의미한다. 자바는 메서드의 실행이 종료되면 리턴 타입을 명시해야하는 언어이기 때문에 main 메서드에도 명시되어있어야 한다.

main 메서드가 종료되었다는 것은 프로그램이 종료되었다는 것을 의미하므로 반환할 리턴값도 없다.

그렇기 때문에 void를 붙여준다.

String[] args

String[] args는 커맨드 라인의 argument들로, 커맨드 라인을 통해 main 메서드 내부에서 사용할 수 있는 String 타입의 데이터를 전달할 수 있다.

*String[]는 String 타입의 여러 값을 저장할 수 있는 저장구조이다.

JVM이 main 메서드의 변수명은 강제하지 않기에 변수명은 임의로 변경해도 잘 동작한다.

하지만 String[]  args 구문 자체를 빼면 안된다. 일반 메서드는 main 메서드 내부에서 호출하기 때문에 입력값을 main 메서드에서 정할 수 있지만, main 메서드는 프로그램 실행시 처음으로 수행되기 때문에 외부로부터 값을 받을 수 있어야하기 때문이다.

즉, main 메서드는 프로그램 내부에서 값을 호출할 수 없기 때문에 문자열 인자를 받을 수 있도록 해야한다는 것이다.

하지만 IntelliJ나 Eclipse 같은 IDE로 Java 프로그램을 구현하고 실행하는 요즘에는 main 메서드에 문자열을 전달할 일이 거의 없다. 위에 기재했듯이 커맨드라인의 인자값으로, Java가 DOS 환경에서 실행되던 때에 사용하던 것이다. 

명령 프롬프트(cmd)등의 터미널을 통해서 자바를 실행할 때 인자값이라고 생각하면 된다. 

예를들어 아래와 같은 자바 파일을 컴파일하고 실행시 인자값을 넣어서 확인해보겠다.

package project01;

import java.util.Arrays;

public class Solution01 {
	public static void main(String[] args) {
		System.out.println(Arrays.toString(args));
	}
}

윈도우의 경우 명령 프롬프트(cmd)에서 실행해보면 아래와 같이 인자값을 잘 받아서 출력해준다는 것을 알 수 있다.

해당 자바 파일이 있는 디렉토리에서 명령어를 입력해서 수행한다.

• java Solution01.java : java 파일 컴파일
• java project01.Solution01 test string HelloWorld : 컴파일한 자바 파일을 실행
  • projext01.Solution01: 패키지명.클래스명
  • test string HelloWorld 가 main 메서드의 인자값으로 들어가는 String[] args에 해당하는 부분이다.

*중간에 cd .. 를 하는 이유는 상위 폴더로 이동하기 위해서!

물론 IDE 에서도 설정을 하면 main 메서드에 String 배열 인자를 전달할 수 있다고 한다.

참고 포스팅

✏️ 코딩테스트를 풀면서 int[] 를 List로 변환하다가 마주한 문제와 알게된 문법에 대한 포스팅

int[ ] to List<Integer>

int 배열을 List로 변환하는 방법, 즉 int 배열에 담긴 요소를 그대로 List<Integer> (=ArrayList<Integer>)타입으로 변환하는 방법을 아래와 같이 시도했었다.

❌ Fail : Arrays.asList()로 변환

Arrays.asList()에 int 배열(int[])을 매개변수로 그대로 담으면 List<int[]>형으로 변환된다.

// int 배열
int[] arr = {1,2,3,4};

// 리스트로 변환
List<int[]> list = Arrays.asList(arr);

// 결과
System.out.println(list.size());                    // 1
System.out.println(list.get(0));                    // [I@36baf30c
System.out.println(Arrays.toString(list.get(0)));   // [1, 2, 3, 4]

int 배열인 arr을 asList로 변환했을때 기대한 건 arr의 요소(1,2,3,4)를 가진 List<Integer> 타입이지만, List<int[]>로 반환된다.

내가 원하는 List<Integer> 타입이 아니다!

결론부터 말하자면,

Arrays.asList()는 primitive 타입을 Wrapper 클래스로 형변환해주지 않는다.

즉, int 타입을 Integer로 형변환해주지 않기때문에,
primitive 타입의 배열은 Arrays.asList()를 사용해서 List로 변환할 수 없다.

따라서 int 타입의 배열은 다른 방식으로 배열에서 List로 변환해야한다.

1) 반복문을 사용하거나 2) Stream을 사용해서 변환하는 방식이 있다.

✅ Success : 반복문 or Stream 사용해서 변환

1. 반복문

// int 배열
int[] arr = {1,2,3,4};

// 리스트로 변환
List<Integer> list = new ArrayList<>();
for (int el: arr) {
    list.add(el);
}

// 결과
System.out.println(list.size());    // 4
System.out.println(list);           // [1, 2, 3, 4]

위처럼 반복문을 통해 int 배열을 순회하면서 list에 값을 하나씩 추가해주면 된다.

결과를 확인해보면 List에 Integer 요소 4개가 그대로 들어가 있는것을 확인할 수 있다.

2. Stream 

Stream은 람다와 함께 사용되어 간결하게 표현 가능한 기능으로, Java 8부터 지원된다.

// int 배열
int[] arr = {1,2,3,4};

// 리스트로 변환
List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());

// 결과
System.out.println(list.size());    // 4
System.out.println(list);           // [1, 2, 3, 4]

• Arrays.stream(arr) : int[] → IntStream
• boxed() : IntStream → Stream<Integer>
• collect(Collectors.toList()) : Stream<Integer> → ArrayList<Integer>
  • Stream의 데이터를 변형 등의 처리를 하고 원하는 자료형으로 변환
  • collect: 스트림의 최종연산으로, 매개변수로는 Collector를 필요로 함
  • Collectors.toList(): Collectors를 이용하여 스트림의 요소들을 List 객체로 변환
    *Collectors: 미리 작성된 다양한 Collector를 반환하는 static 메서드를 가지고 있다.

이렇게 int[]를 List<Integer>로 변환하는데 성공했는데,

다음에는 배열을 리스트로 변환하는 방법을 더 알아보고,

Arrays.asList()와 new ArrayList<>()로 생성된 List의 차이점도 포스팅 해야겠다.

참고 포스팅

자바 프로그래머가 자주 실수 하는 10가지 - 1

[JAVA] For과 Stream은 어떤 차이가 있는걸까?