[Java] 자바 기초

본 글은 자바를 학습하면서, 타 언어에서 알고 있던 내용 이외에 추가로 기억할 사항을 정리하여 작성한 글이다. 즉, 모든 내용을 포함하고 있지는 않다.

 

변수와 타입

명명 관례

코드를 작성할 때, 여러 단어를 혼합하여 명명하는 경우, camel case를 사용하는 것을 기본으로 다음 상황에 따라 추가한다.

자바 소스 파일명(클래스명)은 대문자로 시작하는 것이 관례이다. ex) Member.java, Item.java

변수명은 소문자로 시작하는 것이 관례이다. ex) mathScore, uploadFile

 

변수 선언

변수는 메모리 번지에 붙여진 이름이다. 변수를 선언한다고 해서 메모리에 할당되는 것은 아니다. 변수에 값을 대입해야 메모리가 할당된다. 

int x = 3;
int y = 7;
int temp = x;

x = y;
y = temp;

System.out.println(x + " " + y);	// 7 3

등호 오른쪽의 값을 왼쪽의 변수에 저장한다.

 

자동 타입 변환

원래 값을 보존하는 것을 우선으로 하여 타입 변환이 일어난다. 즉, 허용 범위가 작은 타입이 허용 범위가 큰 타입으로 대입될 때, 발생한다. byte < short, char < int < long < float < double 에서 부등호의 왼쪽에 있는 변수의 값이 오른쪽에 있는 변수의 값에 대입될 때 발생한다.

 

강제 타입 변환

허용 범위가 큰 타입을 허용 범위가 작은 타입에 대입할 경우, 오류가 발생한다.

int a = 3;
double b = 2.7;
a = b;	// 오류 발생

 

이 때는 강제 타입 변환이 필요하다. 다만, 아래의 경우처럼 8Byte 크기를 4Byte에 넣어야 하므로, 원래 값이 보존되지 않을 수 있다.

int a = 3;
double b = 2.7;
a = (int)b;

 

연산식에서 자동 타입 변환

int 타입보다 작은 byte, short 타입의 경우, 연산 시 int로 자동 타입 변환되어 연산된다. 따라서, 결과값도 int에 저장해야 한다. 특별한 이유가 없다면, 정수 연산에서 int 변수로 선언하고 연산하는 것이 타입 변환이 일어나지 않기 때문에 실행 성능에 도움이 된다.

 

정수의 경우에는 최소가 int, 실수인 경우에는 최소가 double이며, 이외에는 큰 범위의 타입으로 자동 변환되어 연산된다.

 

연산이 먼저 이루어지고, 대입이 이루어진다는 것에 유의해야 한다.

int a = 1;
int b = 2;
double c = a / b;
System.out.println("c = " + c);	// 0.0

 

+ 연산자는 두 가지 기능을 가지고 있다. 피연산자가 모두 숫자인 경우에는 덧셈 연산을 수행하지만, 둘 중 하나가 문자열인 경우에는 나머지 피연산자가 문자열로 변환되어 결합 연산을 수행한다. 먼저 수행된 연산이 덧셈 연산이라면, 그 결과를 가지고 + 연산을 한다는 것에 유의해야 한다.

String a = 1 + 2 + "3";
System.out.println("a = " + a);	// 33

 

문자열을 기본 타입으로 변환

문자열을 기본 타입으로 변환하고 싶은 경우, TYPE.parseTYPE(str)을 이용한다.

String str = "1234";
int value = Integer.parseInt(str);

 

기본 타입을 문자열로 바꾸고 싶은 경우, String.valueOf()를 이용한다.

int value = 1234;
String str = String.valueOf(value);

 

참조 타입

데이터 타입 분류

자바의 데이터 타입은 크게 기본 타입(primitive type)과 참조 타입(reference type)으로 분류된다.

기본 타입으로 선언된 변수는 값 자체를 저장하지만, 참조 타입으로 선언된 변수는 객체가 생성된 메모리의 번지를 저장한다.

 

변수들은 모두 스택이라는 메모리 영역에 생성되고, 참조 타입 변수는 힙 메모리 영역의 객체 번지를 저장하여 참조한다.

 

참조 타입 변수의 ==, != 연산

==, != 연산자는 변수에 저장된 값이 같은지, 아닌지를 조사한다. 참조 타입 변수의 값은 참조하는 객체의 번지이므로, 번지를 비교하게 된다. 번지가 같다면, 같은 객체를 참조하는 것이고, 다르다면 다른 객체를 참조하는 것이다.

int[] arr1 = new int[]{1,2,3};
int[] arr2 = new int[]{1,2,3};
int[] arr3 = arr1;

System.out.println(arr1==arr2);	// false
System.out.println(arr1==arr3);	// true

 

null과 NullPointerException

참조 타입 변수가 아직 번지를 저장하고 있지 않다는 뜻으로 null을 저장할 수 있다. 힙 메모리 영역의 변수를 가르키지 않고, 스택에 저장된 상태로 있다.

 

번지를 저장하고 있지 않고, null이 저장된 참조 변수를 사용하면, NullPointerException이 발생한다. 오류가 발생한다면, 의도한 값을 대입해주어야 한다.

 

번지를 참조했던 변수가 null이 대입되어 힙 메모리 영역에 있는 객체가 더 이상 사용되고 있는 곳이 없으면, 자바는 이런 객체를 쓰레기 취급하고, 자동 제거한다.

String hobby = "여행";
hobby = "수면";	// "여행" 객체는 쓰레기 객체가 되어 제거된다.

 

문자열 타입

문자열 비교

자바는 문자열 리터럴이 동일하다면, 같은 String 객체를 공유하도록 설계되어 있다.

String name1 = "신짱구";
String name2 = "신짱구";
System.out.println(name1 == name2);	// true

 

new 연산자로 새로운 String 객체를 생성하여 대입할 수도 있다. 이 때는 같은 참조를 공유하지 않는다.

String name1 = new String("신짱구");
String name2 = new String("신짱구");
System.out.println(name1 == name2);	// false

 

참조와 상관없이 내부 문자열만 비교하려고 할 때는 equals() 메소드를 이용한다.

String name1 = new String("신짱구");
String name2 = new String("신짱구");
System.out.println(name1.equals(name2));	// true

 

문자 추출

문자열에서 특정 위치의 문자를 얻고 싶을 때는 charAt() 메소드를 사용한다.

String str = "안녕하세요~";
char charValue = str.charAt(2);
System.out.println("charValue = " + charValue);

 

문자열 대체

기존 문자열에는 변함없이 대체가 적용된 새로운 문자열을 반환한다.

String oldStr = "자바자바자바";
String newStr = oldStr.replace("자바", "JAVA");
System.out.println("newStr = " + newStr);	// JAVAJAVAJAVA

 

문자열 찾기

문자열에서 특정 문자열의 위치를 찾고자 할 때, indexOf() 메소드를 이용한다. 특정 문자열이 존재하지 않는 경우, -1을 반환한다.

String str = "안녕하세요. 모두 반갑습니다.";
int index = str.indexOf("모두");
System.out.println("index = " + index);	// 7

 

문자열 분리

특정 구분자를 이용하여 분리하고 싶을 경우, split() 메소드를 이용한다.

String str = "안녕,내일,보자";
String[] arr = str.split(",");
for (String s : arr) {
    System.out.println(s);	// 안녕\n내일\n보자
}

 

배열 타입

배열은 관례 상 타입[] 변수; 형태로 선언한다.

 

값이 있는 배열로 초기화하고 싶을 때는 다음과 같이 생성한다. 배열 변수를 미리 선언한 후에 대입하는 것은 불가능하다.

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

 

배열을 선언한 시점과 값 목록이 대입되는 시점이 다르다면, new를 사용한다.

int[] arr = new int[] { 1, 2, 3, 4 };

 

배열 복사

반복문을 이용할 수도 있지만, System.arraycopy(원본 배열, 원본 배열에서 어느 인덱스부터, 새 배열, 새 배열에서 어느 인덱스부터, 개수)를 이용할 수 있다.

String[] oldStrArray = {"java", "array", "copy"};

String[] newStrArray = new String[5];

System.arraycopy(oldStrArray, 0, newStrArray, 0, oldStrArray.length);

for (String s : newStrArray) {
    System.out.println(s);
}

 

반복문 단순화

for (int i=0; i<newStrArray.length; i++){
	System.out.println(newStrArray[i]);
}

for (String s : newStrArray) {
    System.out.println(s);
}

 

열거(ENUM) 타입

열거 상수들은 모두 대문자로 쓰는 것이 관례이다.

 

클래스

객체지향 프로그래밍의 특징

캡슐화

캡슐화란 객체의 데이터(필드), 동작(메소드)을 하나로 묶고, 실제 구현 내용은 외부에 감추는 것을 말한다. 외부에서는 객체 내부의 구조를 알지 못하고, 객체가 노출해서 제공하는 필드와 메소드만 사용할 수 있다. ex) member1.setName("신짱구");

 

상속

객체지향 프로그래밍에서는 부모 역할의 상위 객체와 자식 역할의 하위 객체가 있다. 부모 객체는 자기가 가지고 있는 필드와 메소드를 자식 객체에게 물려주어 자식 객체가 사용할 수 있도록 하는데 이를 상속이라고 한다.

 

상속을 하면, 부모 객체의 필드와 메소드를 자식 객체가 그대로 사용할 수 있어 중복 코딩을 하지 않아도 된다. 또한, 부모 객체의 필드와 메소드를 수정하면, 모든 자식 객체들의 필드와 메소드도 수정되므로 유지 보수 측면에서 좋다.

 

다형성

사용 방법은 동일하지만, 실행 결과가 다르게 나오는 성질을 말한다.

 

객체와 클래스

클래스는 짱구는 못말려 삼바 극장판에서 나왔던 곤약 인간 틀이고, 객체는 그 틀로부터 생성된 곤약 인간이다.

 

클래스 선언

클래스를 위한 소스 파일을 생성하면, 공개 클래스가 생성된다. 공개 클래스는 어느 위치에 있든지 패키지와 상관없이 사용할 수 있는 클래스이다. 하나의 클래스 파일에는 복수 개의 클래스가 있지만, 소스 파일과 이름이 같은 클래스만 공개 클래스로 선언할 수 있다. 

public class SportsCar {
}

class Tire {
    
}

별다른 이유가 없다면, 소스 파일 하나 당 클래스를 하나만 선언하는 것이 좋다.

 

객체 생성과 클래스 변수

클래스 변수 = new 클래스();

 

생성자 선언과 호출

기본 생성자

클래스에 생성자 선언이 없으면, 매개변수를 필요로 하지 않는 기본 생성자를 자동으로 생성한다. 

 

생성자 오버로딩

public class Car {

    String company = "Hyundai";
    String model;
    String color;
    int maxSpeed;

    Car() {}

    Car(String model) {
        this.model = model;
        this.color = "silver";
        this.maxSpeed = 250;
    }

    Car(String model, String color) {
        this.model = model;
        this.color = color;
        this.maxSpeed = 250;
    }

    Car(String model, String color, int maxSpeed) {
        this.model = model;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }
}

매개변수의 타입이나 개수가 다른 경우, 생성자 오버로딩이라고 한다. 전달된 매개변수와 일치하는 생성자를 이용하여 생성한다. 하지만, 위의 경우 중복 코드가 많다. 이를 아래와 같이 고칠 수 있다.

 

public class Car {

    String company = "Hyundai";
    String model;
    String color;
    int maxSpeed;

    Car() {}

    Car(String model) {
        this(model, "silver", 250);
    }

    Car(String model, String color) {
        this(model, color, 250);
    }

    Car(String model, String color, int maxSpeed) {
        this.model = model;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }
}

 

메소드 선언과 호출

메소드 명명

메소드명은 첫 문자를 소문자로 시작하고, camel case로 작성하는 것이 관례이다.

 

가변길이 매개변수

int sum(int ... values){
    int sum = 0;

    for (int value : values){
        sum += value;
    }

    return sum;
}

타입 ... 변수명으로 매개변수를 전달하면, 변수명을 가진 배열로 자동 변환되어 메소드에서 사용할 수 있다.

 

인스턴스 멤버

필드와 메소드는 선언 방법에 따라 인스턴스 멤버와 정적 멤버로 구분할 수 있다. 인스턴스 멤버는 객체를 생성한 후에 사용할 수 있고, 정적 멤버는 객체 생성 없이도 사용할 수 있다.

public class Car {

    int gas;

    public void setGas(int gas) {
        this.gas = gas;
    }
    
}

위 클래스에서 gas 필드는 객체마다 따로 존재하지만, setGas 메소드는 메소드 영역이라는 곳에 저장되고 공유된다.

 

정적 멤버

자바는 클래스 로더를 이용해서 클래스를 메소드 영역에 저장하고 사용한다. 정적 멤버란 메소드 영역의 클래스에 고정적으로 위치하는 멤버를 말한다. 그렇기 때문에 객체를 생성할 필요없이 클래스를 통해 바로 사용 가능하다.

 

정적 멤버를 사용하면 좋은 경우는 다음과 같다.

 

객체마다 가지고 있을 필요성이 없는 공용적인 필드는 정적 필드로 선언하는 것이 좋다. 정적 필드는 초깃값을 주는 것이 일반적이다.

public class Calculator {
    String price;
    static double pi = 3.141592;
}

게산기마다 가격은 다를 수 있기에 인스턴스 멤버로 선언하고, 계산기가 사용하는 pi는 객체마다 가지고 있을 필요가 없기 때문에 정적 멤버로 선언한다.

 

인스턴스 필드를 이용하지 않는 메소드는 정적 메소드로 선언하는 것이 좋다.

public class Calculator {
    int price;

    public void setPrice(int price) {
        this.price = price;
    }
    
    static int plus(int x, int y){ return x + y; }
    static int minus(int x, int y){ return x - y; }
}

setPrice() 메소드는 인스턴스 필드를 이용하므로 인스턴스 메소드로 선언하고, 인스턴스 필드를 사용하지 않는 plus(), minus() 메소드는 정적 메소드로 선언한다.

 

정적 멤버 사용

정적 멤버는 클래스 이름으로 접근하는 것이 정석이다.

int result1 = Calculator.plus(2, 3);
int result2 = Calculator.minus(10, 2);

 

인스턴스 멤버 사용 불가

정적 메소드와 정적 블록은 객체가 없어도 실행된다는 특징 때문에 내부에 인스턴스 필드나 인스턴스 메소드를 사용할 수 없다. 또한, 객체 자신의 참조인 this도 사용할 수 없다.

 

final 필드와 상수

인스턴스 필드와 정적 필드는 언제든지 값을 변경할 수 있다. 하지만, 값을 변경하는 것을 막고 읽기만 허용해야 할 때가 있다. 이 때, final 필드와 상수를 선언해서 사용한다.

 

final 필드에 초기값을 줄 수 있는 방법은 필드를 선언할 때 초기값을 대입하거나 생성자에서 초기값을 대입하는 경우 밖에 없다.

 

상수는 보통 다음과 같이 선언한다.

static final double PI = 3.141592;

 

Getter와 Setter

외부에서 직접적으로 필드에 접근하는 것을 막고, 그 대신 메소드를 통해 필드에 접근하는 것을 선호한다. Setter를 통해서 값을 변경할 때, 데이터를 검증해서 유효한 값을 필드에 저장할 수 있다.

 

접근 제한자

접근 제한자	제한 대상	제한 범위
public	클래스, 필드, 생성자, 메소드	없음
protected	필드, 생성자, 메소드	같은 패키지이거나 자식 객체만 사용 가능
(default)	클래스, 필드, 생성자, 메소드	같은 패키지
private	필드, 생성자, 메소드	객체 내부

 

싱글톤 패턴

애플리케이션 전체에서 단 한 개의 객체만 생성해서 사용하고 싶다면, 싱글톤 패턴을 적용할 수 있다. 싱글톤 패턴을 사용할 때는 생성자를 private로 접근 제한하여 외부에서 생성되지 못하게 해야 한다.

public class Calculator {
    private static Calculator calculator = new Calculator();

    private Calculator() {};

    public static Calculator getInstance() {
        return calculator;
    }
}

Calculator cal1 = Calculator.getInstance();
Calculator cal2 = Calculator.getInstance();
System.out.println(cal1 == cal2);	// true

 

상속

상속 개념

객체지향 프로그램에서도 부모 클래스의 필드와 메소드를 자식 클래스에게 물려주는 행위를 말한다.

 

클래스 상속

프로그래밍에서는 자식 클래스가 어떤 부모로부터 상속받을 것인지를 다음과 같이 결정한다.

public class 자식클래스 extends 부모클래스 {
}

 

다른 언어와 다르게 자바는 다중 상속을 허용하지 않는다. extends 뒤에는 단 하나의 부모 클래스만이 올 수 있다.

 

부모 생성자 호출

자식 객체를 생성하면, 자식 생성자가 실행되는데, 맨 앞에 숨어 있는 부모 클래스의 기본 생성자가 super()에 의해서 먼저 실행된다.

자식클래스 변수 = new 자식클래스();

public 자식클래스() {
	super();	// 생략 가능
    ...
}

 

만약, 부모 클래스에서 기본 생성자가 없다면, 에러가 발생한다. 이 때는 부모 클래스에 있는 생성자에 맞게 super에 매개변수를 넣어 직접 명시해주어야 한다.

public 자식클래스() {
	super(매개변수1, 매개변수2);
    ...
}

 

메소드 재정의

부모 클래스에서 정의한 모든 메소드가 자식 클래스에 맞게 설계되어 있다면 가장 이상적인 상속이지만, 어떤 메소드는 자식 클래스가 사용하기에 적합하지 않다. 이러한 메소드는 자식 클래스에서 재정의해서 사용해야 한다. 이것을 메소드 오버라이딩이라고 한다.

 

메소드 오버라이딩

메소드 오버라이딩은 상속된 메소드를 자식 클래스에서 재정의하는 것을 말한다. 메소드가 오버라이딩되었다면, 해당 부모 메소드는 숨겨지고, 자식 메소드가 우선적으로 사용된다.

 

메소드를 오버라이딩할 때는 다음 규칙들에 주의해서 작성해야 한다.

• 부모 메소드의 선언부(리턴 타입, 메소드 이름, 매개변수)와 동일해야 한다.
• 접근 제한을 더 강하게 할 수 없다.(public을 private로 변경 불가)
• 새로운 예외를 throws할 수 없다.

public class Calculator {
    
    public double areaCircle(double r){
        return 3.14 * r * r;
    }
    
}

public class Computer extends Calculator {

    @Override
    public double areaCircle(double r){
        return Math.PI * r * r;
    }
}

Calculartor에서의 원의 넓이 계산의 정확도가 부족하여 Computer에서 정확도를 높인 메소드를 오바라이딩하여 구현하였다. @Override는 컴파일 시 정확히 오버라이딩이 되었는지 체크해주는 역할을 하며 생략 가능하다.

 

부모 메소드 호출

메소드를 정의하면, 부모 메소드는 숨겨지고 자식 메소드만 사용되기 때문에 비록 부모 메소드에서 일부만 추가할 것이라도 자식 메소드가 부모 메소드를 모두 가지고 있어야 한다. 이렇게 했을 때, 중복 코드가 매우 많아지는 문제가 발생한다. 이 문제는 자식 메소드 내에서 부모 메소를 호출하는 방식으로 해결할 수 있다.

public class Airplane {
    public void takeOff(){
        System.out.println("이륙");
    }

    public void fly(){
        System.out.println("일반 비행");
    }

    public void land(){
        System.out.println("착륙");
    }
}

public class SupersonicAirplane extends Airplane{
    public static final int NORMAL = 1;
    public static final int SUPERSONIC = 2;

    public int flyMode = NORMAL;

    @Override
    public void fly() {
        if (flyMode == NORMAL){
            super.fly();
        }
        else if (flyMode == SUPERSONIC){
            System.out.println("초음속 비행");
        }
    }
}

 

final 클래스

부모 클래스의 class 앞에 final을 붙이면, 자식 클래스를 만들 수 없다.

 

final 메소드

부모 클래스의 메소드 앞에 final을 붙이면, 자식 클래스에서 메소드를 오버라이딩할 수 없다. 

 

타입 변환

자동 타입 변환

부모타입 변수 = 자식타입객체;

자식 객체는 부모의 특징과 기능을 상속받았기 때문에 부모와 동일하게 취급될 수 있다.

 

Cat cat = new Cat();
Animal animal = cat;

cat과 animal 모두 같은 객체를 참조한다.

 

다만, 부모 타입으로 자동 타입 변환된 후에는 부모 클래스에 선언된 필드와 메소드만 접근이 가능하다. 즉, 자식 객체를 참조하긴 하지만, 사용이 제한된다. 

 

그러나 자식 클래스에서 오버라이딩된 메소드가 있다면 부모 메소드 대신 오버라이딩된 메소드가 호출된다.

 

강제 타입 변환

부모 변수에 자식 객체를 대입했을 때, 자식 타입은 부모 타입으로 자동 변환되지만, 반대로 부모 타입은 자식 타입으로 자동 변환되지 않는다. 캐스팅 연산자로 강제 타입 변환을 해야 한다. 단, 자식 객체가 부모 타입으로 자동 변환된 후 다시 자식 타입으로 변환할 때, 강제 타입 변환을 사용할 수 있다. 즉, 원래 자식 타입이었어야 한다.

Parent parent = new Child();
Child child = (Child) parnet;

 

다형성

다형성이란 사용 방법은 동일하지만 실행 결과가 다양하게 나오는 성질을 말한다. 사용 방법이 동일하다는 것은 동일한 메소드를 가지고 있다는 의미이다.

 

필드 다형성

필드 다형성은 필드 타입은 동일하지만, 대입되는 객체가 달라져서 실행결과가 다양하게 나올 수 있는 것을 말한다.

 

매개변수 다형성

매개변수 다형성은 메소드가 클래스 타입의 매개변수를 가지고 있을 경우, 호출할 때, 매개변수 타입에 맞는 객체를 제공하는 것이 정석이지만, 자식 객체를 제공하여 발생한다. 이 경우, 자식 객체에서 오버라이딩된 메소드가 실행된다.

public class Driver {

    public void drive(Vehicle vehicle){
        vehicle.run();
    }
    
}

public class Vehicle {

    public void run(){
        System.out.println("차량이 달린다.");
    }
    
}

public class Bus extends Vehicle {

    @Override
    public void run() {
        System.out.println("버스가 달린다.");
    }

}

public class Taxi extends Vehicle {

    @Override
    public void run() {
        System.out.println("택시가 달린다.");
    }
    
}

public class Main {
    public static void main(String[] args) {
        Driver driver = new Driver();

        Bus bus = new Bus();
        driver.drive(bus);	// 버스가 달린다.

        Taxi taxi = new Taxi();
        driver.drive(taxi);	// 택시가 달린다.
    }
}

 

객체 타입 확인

변수가 참조하는 객체의 타입을 확인하고자 할 때, instanceof 연산자를 이용할 수 있다.

boolean result = 객체 instance of 타입

instanceof 연산자의 좌항에는 객체가 오고 우항에는 타입이 오는데, 좌항의 객체가 우항의 타입이면 true, 그렇지 않으면, false를 반환한다.

 

public void method(Parent parent){
	if (parent instanceof Child) {
    	Child child = (Child) parent;
    }
}

매개변수 parent에 Child를 참조하는지 확인하고, 참조한다면, 강제 타입 변환을 한다.

 

Java 12부터는 instanceof 연산의 결과가 true인 경우, 우측 타입 변수를 사용할 수 있기 때문에 강제 타입 변환이 필요없다.

if (parent instanceof Child child){
	// 바로 child 사용 가능
}

 

추상 클래스

추상 클래스란?

객체를 생성할 수 있는 클래스를 실체 클래스라고 한다면, 이 클래스들의 공통적인 필드나 메소드를 추출해서 선언한 클래스를 추상 클래스라고 한다. 추상 클래스는 실체 클래스의 부모 역할을 한다. 따라서 실체 클래스는 추상 클래스를 상속해서 공통적인 필드나 메소드를 물려받을 수 있다.

 

예를 들어, Bird, Insect, Fish와 같은 실체 클래스에서 공통되는 필드와 메소드를 따로 선언한 Animal 클래스를 만들 수 있고, 이것을 상속해서 실체 클래스를 만들 수 있다. 즉, Animal은 실제로 생성해서 사용하지 않고, 상속을 위한 부모 클래스 역할만 하기 때문에 추상 클래스로 선언한다. 따라서, 추상 클래스는 extends 뒤에만 올 수 있다.

 

추상 클래스 선언

클래스 선언에 abstract 키워드를 붙이면 추상 클래스 선언이 된다. 추상 클래스는 new 연산자를 이용해서 객체를 만들지 못하고, 상속을 통해 자식 클래스를 생성하는 데만 이용된다.

public abstract class 클래스명 {
	//필드
    //생성자
    //메소드
}

 

public class Phone {

    String owner;

    Phone(String owner){
        this.owner = owner;
    }

    public void turnOn(){
        System.out.println("전원이 켜집니다.");
    }

    public void turnOff(){
        System.out.println("전원이 꺼집니다.");
    }
    
}

public class SmartPhone extends Phone {
    public SmartPhone(String owner) {
        super(owner);
    }

    public void internetSearch(){
        System.out.println("인터넷 검색을 합니다.");
    }
}

 

추상 메소드와 재정의

자식 클래스들이 가지고 있는 공통 메소드를 뽑아내어 추상 클래스로 작성할 때, 메소드 선언부(리턴타입, 메소드명, 매개변수)만 동일하고 실행 내용은 자식 클래스마다 달라야 하는 경우가 있다. 예를 들어, Animal 부모 클래스를 상속받은 자식 클래스들의 울음소리 메소드와 같은 경우이다. 이런 경우를 위해서 추상 클래스는 다음과 같은 추상 메소드를 선언할 수 있다.

abstract 리턴타입 메소드명(매개변수, );

추상 메소드는 자식 클래스에서 반드시 재정의해서 실행 내용을 채워야 한다.

 

public abstract class Animal {
    public void breathe(){
        System.out.println("숨을 쉰다.");
    }

    public abstract void sound();
}

public class Dog extends Animal{

    @Override
    public void sound() {
        System.out.println("멍멍");
    }

}

public class Cat extends Animal {

    @Override
    public void sound() {
        System.out.println("야옹");
    }

}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();

        Cat cat = new Cat();
        cat.sound();

        animalSound(dog);
        animalSound(cat);
    }

    public static void animalSound(Animal animal){
        animal.sound();
    }
}

 

인터페이스

인터페이스의 역할

인터페이스는 두 객체를 연결하는 역할을 한다.

개발 코드를 객체A라고 할 때, 객체A가 인터페이스의 메소드를 호출하면, 인터페이스가 객체의 메소드를 호출하고 리턴값을 받아 객체A에 전달한다.

 

인터페이스를 사용하는 이유는 객체A는 인터페이스의 메소드만 사용하므로, 인터페이스가 호출하는 객체를 변경해도 객체A에 대해서는 변함이 없다. 만약, 객체A가 객체를 직접 사용한다면, 객체A의 코드를 변경해야 할 것이다.

 

이 특징으로 인해 인터페이스는 다형성 구현에 주로 이용한다. 상속을 이용해서 다형성을 구현할 수도 있지만, 인터페이스를 통해서 다형성을 구현하는 경우가 더 많다.

 

인터페이스와 구현 클래스 선언

위에서 객체A가 인터페이스의 추상 메소드를 호출하면, 인터페이스는 객체의 메소드를 실행한다. 그러기 위해서는 객체가 인터페이스에 선언된 추상 메소드를 재정의한 매소드를 가지고 있어야 한다.

public interface RemoteControl {
    public void turnOn();
}

public class Television implements RemoteControl{
    @Override
    public void turnOn() {
        System.out.println("TV를 켭니다.");
    }
}

public class Audio implements RemoteControl{
    @Override
    public void turnOn() {
        System.out.println("Audio를 켭니다.");
    }
}

변수 선언과 구현 객체 대입

인터페이스도 하나의 타입이므로 변수의 타입으로 사용할 수 있다. 인터페이스는 참조 타입에 속하므로 인터페이스 변수에는 번지를 저장할 수 있는데, 객체를 참조하고 있지 않다는 뜻으로 null을 대입할 수 있다.

 

인터페이스를 통해 구현 객체를 사용하려면, 인터페이스 변수에 구현 객체를 대입해야 한다. 

public class RemoteControlExample {
    public static void main(String[] args) {
        RemoteControl rc = new Television();
        rc.turnOn();

        rc = new Audio();
        rc.turnOn();
    }
}

 

상수 필드

인터페이스에 선언된 필드는 모두 public static final 특성을 갖기 때문에 생략하더라도 컴파일 과정에서 붙게 된다. 상수명은 대문자로 작성하되, 서로 다른 단어로 구성되어 있을 경우에는 언더바로 연결하는 것이 관례이다.

public interface RemoteControl {
    int MAX_VOLUME = 100;
    int MIN_VOLUME = 0;
}

public class RemoteControlExample {
    public static void main(String[] args) {
        System.out.println("리모콘 최대 볼륨 " + RemoteControl.MAX_VOLUME);
        System.out.println("리모콘 최소 볼륨 " + RemoteControl.MIN_VOLUME);
    }
}

 

추상 메소드

인터페이스에서 추상 메소드는 리턴 타입, 메소드명, 매개변수만 기술되고, 중괄호를 붙이지 않는 메소드를 말한다. 구현 클래스에서 반드시 재정의해야 한다. public abstract를 생략하더라도 컴파일 과정에서 자동으로 붙게 된다.

public interface RemoteControl {
    int MAX_VOLUME = 100;
    int MIN_VOLUME = 0;

    void turnOn();
    void turnOff();
    void setVolume(int volume);
}

public class Television implements RemoteControl{
    private int volume;

    @Override
    public void turnOn() {
        System.out.println("TV를 켭니다.");
    }

    @Override
    public void turnOff() {
        System.out.println("TV를 끕니다.");
    }

    @Override
    public void setVolume(int volume) {
        if (volume > RemoteControl.MAX_VOLUME){
            this.volume = RemoteControl.MAX_VOLUME;
        }
        else if (volume < RemoteControl.MIN_VOLUME){
            this.volume = RemoteControl.MIN_VOLUME;
        }
        else{
            this.volume = volume;
        }
        System.out.println("현재 TV의 볼륨은 " + this.volume);
    }
}

public class Audio implements RemoteControl{
    private int volume;

    @Override
    public void turnOn() {
        System.out.println("Audio를 켭니다.");
    }

    @Override
    public void turnOff() {
        System.out.println("Audio를 끕니다.");
    }

    @Override
    public void setVolume(int volume) {
        if (volume > RemoteControl.MAX_VOLUME){
            this.volume = RemoteControl.MAX_VOLUME;
        }
        else if (volume < RemoteControl.MIN_VOLUME){
            this.volume = RemoteControl.MIN_VOLUME;
        }
        else{
            this.volume = volume;
        }
        System.out.println("현재 Audio의 볼륨은 " + this.volume);
    }
}

 

디폴트 메소드

인터페이스에는 완전한 실행 코드를 가진 디폴트 메소드를 선언할 수 있다. 추상 메소드는 실행부가 없지만, 디폴트 메소드는 실행부가 있다. 앞에 default를 붙여야 한다. 디폴트 메소드 인터페이스의 상수 필드를 읽거나 추상 메소드를 호출하는 코드를 작성할 수 있다. 

public interface RemoteControl {
    int MAX_VOLUME = 100;
    int MIN_VOLUME = 0;

    void turnOn();
    void turnOff();
    void setVolume(int volume);

    default void setMute(boolean mute){
        if (mute){
            System.out.println("무음 처리");
            setVolume(0);
        }
        else{
            System.out.println("무음 해제");
        }
    }
}

디폴트 메소드가 추상 메소드를 이용하기 때문에, 구현 객체를 인터페이스 변수에 대입하고 나서 호출해야 한다.

 

구현 클래스는 디폴트 메소드를 재정의해서 자신에게 맞게 수정할 수도 있다.

public class Audio implements RemoteControl{
    private int volume;

    @Override
    public void turnOn() {
        System.out.println("Audio를 켭니다.");
    }

    @Override
    public void turnOff() {
        System.out.println("Audio를 끕니다.");
    }

    @Override
    public void setVolume(int volume) {
        if (volume > RemoteControl.MAX_VOLUME){
            this.volume = RemoteControl.MAX_VOLUME;
        }
        else if (volume < RemoteControl.MIN_VOLUME){
            this.volume = RemoteControl.MIN_VOLUME;
        }
        else{
            this.volume = volume;
        }
        System.out.println("현재 Audio의 볼륨은 " + this.volume);
    }

    private int memoryVolume;

    @Override
    public void setMute(boolean mute) {
        if (mute){
            this.memoryVolume = this.volume;
            System.out.println("무음 처리");
            setVolume(RemoteControl.MIN_VOLUME);
        }
        else{
            System.out.println("무음 해제");
            setVolume(this.memoryVolume);
        }
    }
}

 

정적 메소드

구현 객체를 요구하는 추상 메소드와 디폴트 메소드와는 달리, 정적 메소드는 인터페이스만으로 호출할 수 있다. 선언 방법은 클래스의 정적 메소드와 동일하지만, public을 생략하더라도 자동으로 컴파일 과정에서 붙는다.

 

다중 인터페이스 구현

구현 객체는 여러 개의 인터페이스를 implements 할 수 있다. 구현 객체가 인터페이스A, 인터페이스B를 구현하고 있다면, 각각의 인터페이스를 통해 구현 객체를 사용할 수 있다. 단, 인터페이스에 선언된 부분만 호출할 수 있다.

 

인터페이스 상속

인터페이스도 다른 인터페이스를 상속할 수 있으며, 클래스와는 달리 다중 상속을 허용한다.

public interface 자식인터페이스 extends 부모인터페이스1, 부모인터페이스2 {}

 

자식 인터페이스의 구현 클래스는 자식 인터페이스의 메소드 뿐만 아니라 부모 인터페이스의 모든 추상 메소드를 재정의해야 한다. 그리고, 구현 클래스는 자식 및 부모 인터페이스의 변수에 대입될 수 있다. 물론 해당 인터페이스에서 호출 가능한 부분만 호출할 수 있다.

 

타입 변환

인터페이스의 타입 변환은 인터페이스와 구현 클래스 간에 발생한다. 인터페이스 변수에 구현 객체를 대입하면, 구현 객체는 인터페이스 타입으로 자동으로 타입 변환된다. 반대로 인터페이스 타입을 구현 클래스 타입으로 변화시킬 때는 강제 타입 변환이 필요하다.

 

자동 타입 변환

구현 객체가 인터페이스 타입으로 자동 변환되면, 인터페이스에 선언된 메소드만 사용 가능하다.

인터페이스 변수 = 구현 객체;

 

강제 타입 변환

원래 구현 객체였던 것을 자동 타입 변환한 결과를 다시 구현 객체로 되돌리기 위해 사용한다. 

구현클래스 변수 = (구현클래스) 인터페이스변수;

 

다형성

상속의 다형성 부분과 같다.

 

객체 타입 확인

상속과 마찬가지로 instanceof를 사용한다.

 

예외 처리

예외와 예외 클래스

예외에는 두 가지가 있는데, 컴파일러가 검사하는 Exception과 컴파일러가 컴사하지 않는 Runtime Exception이 있다.

 

자바는 예외가 발생하면 예외 클래스로부터 객체를 생성하고, 이 객체는 예외 처리 시에 사용된다.

 

자바의 모든 에러와 예외 클래스는 Throwable을 상속받아 만들어지고, 추가적으로 예외 클래스는 java.lang.Exception 클래스를 상속받는다. 실행 예외는 RuntimeException과 그 자식 클래스에 해당한다. 그 밖의 예외 클래스는 모두 일반 예외이다.

예외 처리 코드

예외 처리 코드는 try-catch-finally 블록으로 구성되고, 생성자 내부 또는 메소드 내부에서 작성된다. try 블록에서 다양한 종류의 예외가 발생할 수 있기 때문에, 다중 catch를 사용하여, 발생하는 예외에 따라 예외 처리 코드를 다르게 작성할 수 있다.

try {
    예외 발생 코드
}
catch (예외클래스1 e1) {
    예외 처리
}
catch (예외클래스2 e2) {
    예외 처리
}
finally {
    항상 실행 코드
}

catch 블록이 여러 개라 할지라도 가장 먼저 발생한 에러에 대한  catch 블록 코드 단 하나만 실행된다. 처리해야할 예외 클래스들이 상속 관계에 있을 때는 하위 클래스 catch 블록을 작성하고 상위 클래스 catch 블록을 나중에 작성해야 한다. 예외가 발생하면, catch 블록은 위에서부터 차례대로 검사하는데, 하위 클래스 예외도 상위 클래스 예외가 되므로 주의해야 한다.

 

두 개 이상의 예외를 하나의 catch 블록으로 동일하게 예외 처리하고 싶을 때는 |를 이용한다.

try {
    예외 발생 코드
}
catch (예외클래스1 | 예외 클래스2 e) {
    예외 처리
}
finally {
    항상 실행 코드
}

 

예외 떠넘기기

메소드 내부에서 예외가 발생할 때, try-catch 블록으로 예외를 처리하는 것이 기본이지만, throws를 통해 메소드를 호출한 곳으로 예외를 떠넘길 수도 있다.

public static void main(String[] args) {
    try{
        findClass();
    }
    catch (ClassNotFoundException e){
        System.out.println(e.toString());
    }
}

public static void findClass() throws ClassNotFoundException{
    Class.forName("java.lang.String2");
}

findClass() 메소드에서 오류가 발생하지만, findClass() 메소드 내부에서 처리하지 않고, 호출한 main에서 처리하도록 한다.

 

나열해야할 예외 클래스가 많은 경우에는 throws Exception이나 throws Throwable 만으로 모든 예외를 간단히 떠넘길 수도 있다.

 

사용자 정의 예외

사용자 정의 예외란?

은행 프로그램에서 잔고보다 더 많은 출금 요청이 들어온 경우, 잔고 부족 예외를 발생시켜야 한다. 하지만, 잔고 부족 예외는 표준 라이브러리에는 존재하지 않기 때문에 직접 예외 클래스를 정의해서 사용해야 한다. 이를 사용자 정의 예외라고 한다.

 

사용자 정의 예외는 컴파일러가 체크하는 일반 예외로 선언할 수도 있고, 컴파일러가 체크하지 않는 실행 예외로 선언할 수도 있다. 통상적으로 일반 예외는 Exception 클래스의 자식 클래스로 선언하고, 실행 예외는 RuntimeException 클래스의 자식 클래스로 선언한다.

public class XXXException extends [Exception | RuntimeException] {
	public XXXException() {}
    
    public XXXException(String message) {
    	super(message);
    }
}

사용자 정의 예외 클래스에는 기본 생성자와 예외 메세지를 입력받는 생성자를 선언해 준다. 예외 메세지는 부모 생성자의 매개값으로 넘겨주는데, 그 이유는 예외 객체의 공통 메소드인 getMessage()의 리턴값으로 사용하기 위해서이다.

 

예외 발생시키기

자바에서 제공하는 예외 뿐만 아니라 사용자 정의 예외를 직접 코드에서 발생시키려면 throw 키워드와 함께 예외 객체를 제공하면 된다. 예외의 원인에 해당하는 메세지를 직접 제공하고 싶다면, 생성자 매개값으로 전달한다.

public class Account {
    private long balance;

    public long getBalance() {
        return balance;
    }

    public void deposit(int money){
        this.balance += money;
    }

    public void withdraw(int money) throws InsufficentException {
        if (balance < money){
            throw new InsufficentException("잔고가 부족합니다. 부족한 금액은 "+(money-balance)+"입니다.");
        }
        this.balance -= money;
    }
}

public class InsufficentException extends Exception {
    public InsufficentException(){};

    public InsufficentException(String message){
        super(message);
    };
}

public class AccountExample {
    public static void main(String[] args) {
        Account account = new Account();
        account.deposit(5000);
        System.out.println("현재 잔고에 " + account.getBalance() + "원이 있습니다.");

        try{
            account.withdraw(10000);
        }
        catch (InsufficentException e) {
            System.out.println(e.getMessage());
        }

    }
}

 

java.base 모듈

Object 클래스

클래스를 선언할 때, extends 키워드로 다른 클래스를 상속하지 않으면, 암시적으로 java.lang.Object 클래스를 상속하게 된다. 자바의 모든 클래스는 Object의 자식이나 자손 클래스이다. 그렇기 때문에 모든 객체에서 Object 메소드를 사용할 수 있다. Object 메소드는 다음과 같다.

 

객체 동등 비교

Object의 equals() 메소드는 객체의 번지를 비교하고, boolean 값을 리턴한다. equals() 메소드는 비교 연산자인 ==과 동일한 결과를 리턴한다. 즉, ==도 객체의 번지를 비교한다는 뜻이다.

boolean result = obj1.equals(obj2);
boolean result = (obj1 == obj2);

 

일반적으로, Object의 equals() 메소드는 재정의해서 동등 비교용으로 사용한다. 동등 비교란 객체가 달라도 내부의 데이터가 같은지 비교하는 것을 말한다. 예를 들어, String은 equals() 메소드를 재정의하여 내부 문자열이 같은지를 비교한다.

public class Member {
    public String id;

    public Member(String id){
        this.id = id;
    }

    @Override
    public boolean equals(Object object) {
        if (object instanceof Member target){
            if (id.equals(target.id)){
                return true;
            }
        }
        return false;
    }
}

 

객체 해시코드

객체 해시코드란 객체를 식별하는 정수를 말한다. Object의 hashCode() 매소드는 객체의 메모리 번지를 이용해서 해시코드를 생성하기 때문에 객체마다 다른 정수값을 리턴한다. hashCode() 또한 eqauls()와 비슷하게 두 객체가 동등한지 비교할 때 주로 사용한다.

 

자바에서 두 객체가 동등함을 비교할 때, hashCode()와 equals() 메소드를 같이 사용하는 경우가 많다. 우선 hashCode()가 리턴하는 정수값이 같은지를 확인하고, 그 다음 eqauls() 메소드가 true임을 확인하여 동등 객체임을 판단한다.

public class Student {
    private int no;
    private String name;

    public Student(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public int getNo() {
        return no;
    }

    public String getName() {
        return name;
    }

    @Override
    public boolean equals(Object object) {
        if (object instanceof Student target){
            if (no == target.getNo() && name.equals(target.getName())){
                return true;
            }
        }
        return false;
    }

    @Override
    public int hashCode() {
        int hashCode = no + name.hashCode();
        return hashCode;
    }
}

public class HashCodeExample {
    public static void main(String[] args) {
        Student student1 = new Student(1, "신짱구");
        Student student2 = new Student(1, "신짱구");

        if (student1.hashCode() == student2.hashCode()){
            if (student1.equals(student2)){
                System.out.println("동일한 객체입니다.");
            }
            else{
                System.out.println("데이터가 다르므로 동등 객체가 아닙니다.");
            }
        }
        else{
            System.out.println("해시코드가 다르므로 동등 객체가 아닙니다.");
        }
    }
}

 

객체 문자 정보

Object의 toString() 메소드는 객체의 문자 정보를 리턴한다. 객체의 문자 정보란 객체를 문자열로 표현한 값을 말한다. 기본적으로  Object의 toString() 메소드는 클래스명@16진수해시코드로 구성된 문자열을 리턴한다. 이 또한 제정의해서 간결하고 유익한 정보를 리턴하도록 해야 한다.

 

String 클래스

String 클래스는 문자열을 저장하고 조작할 때 사용한다. 문자열 리터럴은 자동으로 String 객체로 생성된다.

 

포장 클래스

자바는 기본 타입(byte, char, short, int, long, float, double, boolean)의 값을 갖는 객체를 생성할 수 있다. 이런 객체를 값을 포장하고 있다고 해서 포장 객체라고 한다. 

 

포장 객체는 포장하고 있는 기본 타입의 값을 변경할 수 없고, 단지 객체로 생성하는 데 목적이 있다. 이런 객체가 필요한 이유는 컬렉션 객체 때문이다. 컬렉션 객체는 기본 타입의 값은 저장할 수 없고, 객체만 저장할 수 있다.

 

박싱과 언박싱

기본 타입의 값을 포장 객체로 만드는 과정을 박싱이라고 하고, 반대로 포장 객체에서 기본 타입의 값을 얻어내는 과정을 언박싱이라고 한다. 박싱은 포장 클래스의 변수에 기본 타입 값이 대입될 때 발생한다. 반대로 언박싱은 기본 타입 변수에 포장 객체가 대입될 때, 기본 타입과의 연산 과정에서 발생한다.

public class BoxingUnBoxingExample {
    public static void main(String[] args) {

        Integer obj = 100;
        System.out.println("value = " + obj.intValue());

        int value = obj;
        System.out.println("value = " + value);

        int result = obj + 200;
        System.out.println("result = " + result);

    }
}

ㅈ

포장 값 비교

포장 클래스의 equals() 메소드는 내부의 값을 비교하도록 재정의되어 있다.

 

제네릭

제네릭이란?

결정되지 않은 타입을 파라미터로 처리하고, 실제 사용할 때 파라미터를 구체적인 타입으로 대체시키는 기능을 말한다.

public class Box<T> {
	public T content;
}

Box<String> stringBox = new Box<String>();
stringBox.content = "안녕하세요.";

Box<Integer> integerBox = new Box<>();
integerBox.content = 1000;

T는 단지 이름이기 때문에 다른 알파벳을 사용해도 좋다. 일반적으로 대문자 알파벳 한 글자로 표현한다. 하지만, 주의할 점은 타입 파라미터를 대체하는 타입은 클래스 및 인터페이스이어야 한다. 기본 타입은 대체 타입이 될 수 없다. 제네릭 타입을 지정하지 않으면, 암묵적으로 Object 타입이 사용된다.

 

변수 선언과 동일하게 하고 싶으면, <> 안을 생략해도 된다.

 

제네릭 타입

위에서 설명한 대로 제네릭+클래스 또는 인터페이스가 제네릭 타입이다.

 

제네릭 메소드

제네릭 메소드는 타입 파라미터를 가지고 있는 메소드를 말한다. 타입 파라미터가 메소드 선언부에 정의된다는 점에서 제네릭 타입과 차이가 있다. 

public 타입파라미터정의 리턴타입 메소드명(매개변수.. ) { ... }

public class Box<T>{
    public T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class GenericExample {
    public static void main(String[] args) {
        Box<Integer> box1 = boxing(100);
        int intValue = box1.getT();
        System.out.println(intValue);

        Box<String> box2 = boxing("신짱구");
        String stringValue = box2.getT();
        System.out.println(stringValue);
    }

    public static <T> Box<T> boxing(T t){
        Box<T> box = new Box<>();
        box.setT(t);
        return box;
    }
}

 

컬렉션 자료구조

컬렉션 프레임워크

자바는 널리 알려져 있는 자료구조를 바탕으로 객체들을 효율적으로 추가, 삭제, 검색할 수 있도록 관련된 인터페이스와 클래스들을 java.util 패키지에 포함시켜 놓았는데, 이것을 총칭해서 컬렉션 프레임워크라고 부른다. 컬렉션 프레임워크는 몇 가지 인터페이스를 통해서 다양한 컬렉션 클래스를 사용할 수 있도록 설계되어 있다. 주요 인터페이스로는 List, Set, Map이 있다.

List, Set은 객체를 추가, 삭제하는 방법에 있어서 공통점이 있기 때문에 공통된 메소드만 따로 모아 Collection 인터페이스로 정의해두고, 이를 상속하고 있다. Map은 키와 값을 하나의 쌍으로 묶어서 관리하는 구조로 되어 있어 이들과는 다르다.

인터페이스 분류	특징
List	- 순서를 유지하고 저장 - 중복 저장 가능
Set	- 순서를 유지하지 않고 저장 - 중복 저장 안됨
Map	- 키와 값으로 구성된 엔트리 저장 - 키는 중복 저장 안됨

 

List 컬렉션

List 컬렉션은 객체를 인덱스로 관리하기 때문에 객체를 저장하면 인덱스가 부여되고 인덱스로 객체를 검색, 삭제할 수 있는 기능을 제공한다.

 

List 컬렉션은 객체 자체를 저장하는 것이 아니라 객체의 번지를 저장한다. 또한 동일한 객체를 중복해서 저장할 수 있는데, 이 경우에는 동일한 번지가 저장된다. null 또한 저장이 가능하다.

ArrayList

ArrayList는 List 컬렉션에서 가장 많이 사용하는 컬렉션이다. ArrayList에 객체를 추가하면 내부 배열에 객체가 저장되며, 일반 배열과의 차이점은 제한 없이 객체를 추가할 수 있다는 것이다.

List<T> list = new ArrayList<>();

 

중간에 객체를 삽입하면, 뒤로 하나씩 밀리고, 중간에 있는 객체를 삭제하면, 앞으로 하나씩 당겨진다. 따라서 빈번한 객체 삽입과 삭제가 일어나는 곳에서는 ArrayList 대신 LinkedList를 사용하는 것이 좋다.

Vector

Vector는 ArrayList와 동일한 내부 구조를 가지고 있다. 차이점은 Vector는 동기화된 메소드로 구성되어 있기 때문에 멀티 스레드가 동시에 Vector 메소드를 실행할 수 없어서 안전하게 객체를 추가 또는 삭제할 수 있다.

 

LinkedList

LinkedList는 ArrayList와 사용 방법은 동일하지만 내부 구조는 완전히 다르다. ArrayList는 내부 배열에 객체를 저장하지만, LinkedList는 인접 객체를 체인처럼 연결해서 관리한다.

 

Set 컬렉션

Set 컬렉션은 저장 순서가 유지되지 않고, 중복해서 저장할 수 없다.

 

HashSet

Set 컬렉션 중에서 가장 많이 사용되는 것이 HashSet이다.

Set<E> set = new HashSet<>();

 

HashSet은 동일한 객체는 중복 저장하지 않는다. 여기서 동일한 객체는 동등 객체를 말한다. hashCode() 메소드의 리턴값이 같은지 비교하고, equals() 메소드가 true를 리턴하면 동일한 객체라고 판단하고 중복 저장하지 않는다.

 

문자열을 HashSet에 저장할 경우, 같은 문자열을 갖는 String 객체는 중복 저장되지 않는다. 같은 문자열을 가지는 String 객체는 hashCode()의 리턴값이 같고, equals()의 리턴값이 true이기 때문이다.

 

String이 아닌 다른 타입이라면, hashCode()와 eqauls() 메소드를 재정의하여 사용하면 된다.

 

Set 컬렉션은 순서가 없으므로, 인덱스로 객체를 가져올 수 없다. 따라서 하나씩 반복해서 가져와야 하는데 iterator를 사용하는 방법과 반복문을 사용하는 방법이 있다.

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set= new HashSet<>();

        set.add("신짱구");
        set.add("김철수");
        set.add("이훈이");
        set.add("맹구");

        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            String element = iterator.next();
            System.out.println(element);
        }

        for (String element : set){
            System.out.println(element);
        }
    }
}

 

Map 컬렉션

Map 컬렉션은 키와 값으로 구성된 엔트리 객체를 저장한다. 여기서 키와 값은 모두 객체이다. 키는 중복 저장할 수 없고, 값은 중복 저장할 수 있다. 기존에 저장된 키와 동일한 키로 값을 저장하면 기존의 값은 없어지고 새로운 값으로 대체된다.

 

HashMap

Map<String, Integer> map = new HashMap<>();

 

HashMap도 HashSet처럼 동일한 객체는 중복 저장하지 않는다. 여기서 동일한 객체는 동등 객체를 말한다. hashCode() 메소드의 리턴값이 같은지 비교하고, equals() 메소드가 true를 리턴하면 동일한 객체라고 판단하고 중복 저장하지 않는다.

 

Hashtable

Hashtable은 HashMap과 동일한 내부 구조를 가지고 있다. 차이점은 Hashtable은 동기화된 메소드로 구성되어 있기 때문에 멀티 스레드가 동시에 Hashtable  메소드를 실행할 수 없어서 안전하게 객체를 추가 또는 삭제할 수 있다.

 

LIFO와 FIFO 컬렉션

Stack

Stack<String> stack = new Stack<>();

 

Queue

Queue<String> queue = new LinkedList<>();

 

동기화된 컬렉션

컬렉션 프레임워크의 대부분의 클래스들은 싱글 스레드 환경에서 사용할 수 있도록 설계되었다. 그렇기 때문에 여러 스레드가 동시에 컬렉션에 접근한다면 의도치 않게 요소가 변경될 수 있는 불안전한 상태가 된다.

 

Vector와 Hashtable은 동기화된 메소드로 구성되어 있어 멀티 스레드 환경에서 안전하게 요소를 처리할 수 있지만, 나머지는 그렇지 않다. 이런 경우를 대비해서 컬렉션 프레임워크는 비동기화된 메소드를 동기화된 메소드로 래핑하는 Collections의 synchronizedXXX() 메소드를 제공한다.

List<T> list = Collections.synchronizedList(new ArrayList<>());

 

람다식

함수형 프로그래밍이란 함수를 정의하고, 이 함수를 데이터 처리부로 보내 데이터를 처리하는 기법을 말한다. 데이터 처리부에서는 데이터만 가지고 있을 뿐, 처리 방법이 정해져 있지 않아 외부에서 제공된 함수에 의존한다.

 

람다식은 다음과 같은 형태이다.

(매개변수, ...) -> { 처리 내용 }

 

자바는 람다식을 메소드를 가지는 익명 구현 객체로 반환한다. 익명 구현 객체란 이름이 없이 인터페이스를 구현한 객체를 말한다.

@FunctionalInterface
public interface Calculable {
    void calculate(int x, int y);
}

new Calculable() {
	@Override
    public void calculate(int x, int y) { 처리내용 } 
}

// 위 코드를 람다식으로 표현하면 아래와 같다.

(x, y) -> { 처리내용 }

 

람다식은 인터페이스의 익명 구현 객체이므로 인터페이스 타입의 매개변수에 대입될 수 있다. 

public class CalculableExample {
    public static void main(String[] args) {
        action((x, y) -> {
            int result = x+y;
            System.out.println(result);
        });

        action((x, y) -> {
            int result = x-y;
            System.out.println(result);
        });
    }

    public static void action(Calculable calculable){
        int x = 10;
        int y = 5;
        calculable.calculate(x, y);
    }
}

 

인터페이스의 익명 구현 객체를 람다식으로 표현하려면 인터페이스가 단 하나의 추상 메소드만 가져야 한다.

@FunctionalInterface
public interface Workable {
    void work();
}

public class Person {
    public void action(Workable workable){
        workable.work();
    }
}

public class LambdaExample {
    public static void main(String[] args) {
        Person person = new Person();
        
        person.action(() -> {
            System.out.println("출근");
            System.out.println("열일");
            System.out.println("퇴근");
        });

        person.action(() -> {
            System.out.println("오늘은 쉬는 날");
        });
    }
}

 

매개변수가 있는 람다식

@FunctionalInterface
public interface Workable {
    void work(String name, String job);
}

@FunctionalInterface
public interface Speakable {
    void speak(String content);
}

public class Person {
    public void action1(Workable workable){
        workable.work("신짱구", "요리");
    }

    public void action2(Speakable speakable){
        speakable.speak("맹구야 놀자");
    }
}

public class Person {
    public void action1(Workable workable){
        workable.work("신짱구", "요리");
    }

    public void action2(Speakable speakable){
        speakable.speak("맹구야 놀자");
    }
}

 

리턴값이 있는 람다식

@FunctionalInterface
public interface Calculable {
    int calculate(int x, int y);
}

public class Person {
    public void action(Calculable calculable){
        int result = calculable.calculate(10, 5);
        System.out.println(result);
    }
}

public class LambdaExample {
    public static void main(String[] args) {
        Person person = new Person();

        person.action((x, y) -> {
            return x+y;
        });

    }
}

 

스트림

지금까지 컬렉션 및 배열에 저장된 요소를 반복 처리하기 위해서는 for 문을 이용하거나 iterator를 사용했다. Java 8부터는 스트림을 사용할 수 있다.

public class StreamExample {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("신짱구");
        list.add("김철수");
        list.add("맹구");

        Stream<String> stream = list.stream();
        stream.forEach(item -> System.out.println(item));

    }
}

 

Stream과 Iterator의 차이

내부 반복자

for 문과 iterator는 컬렉션의 요소를 컬렉션 바깥쪽으로 반복해서 가져와 처리하는데, 이것을 외부 반복자라고 한다. 반면 스트림은 컬렉션 내부에서 반복 처리하는데 이를 내부 반복자라고 한다.

 

내부 반복자는 멀티 코어 CPU를 활용하기 위해 요소들을 분배시켜 병렬 작업을 할 수 있다. 하나씩 처리하는 순차적 외부 반복자보다는 효율적으로 요소를 반복시킬 수 있다는 장점이 있다.

public class LambdaExample {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("신짱구");
        list.add("김철수");
        list.add("맹구");

        Stream<String> parallelStream = list.parallelStream();
        parallelStream.forEach(item -> System.out.println(item + " : " + Thread.currentThread().getName()));

    }
}

 

중간 처리와 최종 처리

스트림은 하나 이상 연결될 수 있다. 오리지널 스트림에서 다른 스트림으로 변화할 수 있다는 의미이다. 오리지널 스트림 뒤에 필터링 중간 스트림이 연결될 수 있고, 그 뒤에 매핑 중간 스트림이 연결될 수 있다. 이와 같이 스트림이 연결되어 있는 것을 스트림 파이프라인이라고 한다.

public class Student {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }
}

public class StreamPipeLineExample {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("신짱구", 100));
        list.add(new Student("김철수", 50));
        list.add(new Student("이훈이", 0));

        double avg = list.stream()
                .mapToInt(student -> student.getScore())
                .average()
                .getAsDouble();

        System.out.println("avg = " + avg);
    }
}

 

스트림 파이프라인으로 구성할 때 주의할 점은 파이프라인의 맨 끝에는 반드시 최종 처리 부분이 있어야 한다. 최종 처리가 없다면 오리지널 및 중간 처리 스트림은 동작하지 않는다.

다양한 리소스로부터 스트림 얻기

참고하여 해결하자.

 

요소 걸러내기(필터링)

필터링은 요소를 걸러내는 중간 처리 기능이다. 필터링 메소드에는 중복을 제거하는 distinct()와 람다식으로 조건 필터링이 가능한 filter()가 있다.

public class FilteringExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("신짱구");
        list.add("맹구");
        list.add("이훈이");
        list.add("이훈이");
        list.add("한유리");
        list.add("김철수");

        list.stream().distinct().forEach(name -> System.out.println(name));

        System.out.println();
        
        list.stream().filter(name -> name.startsWith("신")).forEach(name -> System.out.println(name));
    }
}

 

요소 변환(매핑)

매핑은 스트림의 요소를 다른 요소로 변환하는 중간 처리 기능이다.

 

요소를 다른 요소로 변환

mapXxx() 메소드는 요소를 다른 요소로 변환한 새로운 스트림을 리턴한다. 

public class MapExample {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("신짱구", 100));
        list.add(new Student("김철수", 50));
        list.add(new Student("이훈이", 0));

         list.stream()
                .mapToInt(student -> student.getScore())
                 .forEach(score -> System.out.println(score));
         
    }
}

public class MapExample {
    public static void main(String[] args) {
        int[] intArray = { 1, 2, 3, 4, 5 };

        IntStream intStream = Arrays.stream(intArray);
        intStream.asDoubleStream()
                .forEach(value -> System.out.println(value));

        intStream = Arrays.stream(intArray);
        Stream<Integer> boxedStream = intStream.boxed();
        boxedStream.forEach(obj -> System.out.println(obj.intValue()));
    }
}

 

요소를 복수 개의 요소로 변환

flatMapXxx() 메소드는 하나의 요소를 복수 개의 요소들로 변환한 새로운 스트림을 리턴한다. 

public class FlatMappingExample {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("i am sherlock");
        list1.add("my friend is watson");
        list1.stream().
                flatMap(data -> Arrays.stream(data.split(" ")))
                .forEach(word -> System.out.println(word));
    }
}

 

요소 정렬

스트림의 요소가 객체일 경우, 객체가 Comparable을 구현하고 있어야만 stream에서 sorted() 메소드를 사용하여 정렬할 수 있다. 내림차순으로 정렬하고 싶으면, sorted() 메소드 내부에 Comparator.reverseOrder()를 추가한다.

public class Student implements Comparable<Student> {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }

    @Override
    public int compareTo(Student o) {
        return Integer.compare(score, o.score);
    }
}

public class SortingExample {
    public static void main(String[] args) {
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("신짱구", 100));
        studentList.add(new Student("김철수", 50));
        studentList.add(new Student("이훈이", 0));

        studentList.stream().sorted().forEach(student -> System.out.println(student.getName()));

        System.out.println();

        studentList.stream().sorted(Comparator.reverseOrder()).forEach(student -> System.out.println(student.getName()));
    }
}

 

객체가 Comparable을 구현하고 있지 않다면, 비교자를 제공하여 람다식으로 작성하여 해결할 수도 있다.

public class SortingExample {
    public static void main(String[] args) {
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("신짱구", 100));
        studentList.add(new Student("김철수", 50));
        studentList.add(new Student("이훈이", 0));

        studentList.stream()
                .sorted((s1, s2)->Integer.compare(s1.getScore(), s2.getScore()))
                .forEach(student -> System.out.println(student.getName()));

        System.out.println();

        studentList.stream()
                .sorted((s1, s2)->Integer.compare(s2.getScore(), s1.getScore()))
                .forEach(student -> System.out.println(student.getName()));
    }
}

 

요소 조건 만족 여부(매칭)

매칭은 요소들이 특정 조건에 만족하는지 여부를 조사하는 최종 처리 기능이다. 매칭과 관련된 메소드는 다음과 같다.

리턴 타입	메소드	조사 내용
boolean	allMatch	모든 요소가 만족하는지 여부
boolean	anyMatch	최소한 하나의 요소가 만족하는지 여부
boolean	noneMatch	모든 요소가 만족하지 않는지 여부

public class MatchingExample {
    public static void main(String[] args) {
        int[] intArr = { 2, 4, 6 };

        boolean result = Arrays.stream(intArr)
                .allMatch(a->a%2==0);

        System.out.println("모두 짝수인가? : " + result);
    }
}

 

요소 기본 집계

집계는 최종 처리 기능으로 요소들을 처리해서 카운팅(개수 세기), 합계, 평균값, 최댓값, 최솟값 등과 같이 하나의 값으로 산출하는 것을 말한다. 즉, 대량의 데이터를 가공해서 하나의 값으로 축소하는 리덕션이라고 볼 수 있다.

 

리턴 타입	메소드(매개변수)	설명
long	count()	요소 개수
OptionalXXX	findFirst()	첫 번째 요소
Optional<T> OptionalXXX	max(Comparator<T>) max()	최대 요소
Optional OptionalXXX	min(Comparator<T>) min()	최소 요소
OptionalDouble	average()	요소 평균
int, long, double	sum()	요소 총합

public class AggregateExample {
    public static void main(String[] args) {
        int[] intArr = { 1, 2, 3, 4, 5 };

        long count = Arrays.stream(intArr).count();
        System.out.println("count = " + count);

        int sum = Arrays.stream(intArr).sum();
        System.out.println("sum = " + sum);

        double avg = Arrays.stream(intArr).average().getAsDouble();
        System.out.println("avg = " + avg);

    }
}

 

Optional 클래스

Optional, OptionalDouble, OptionalInt, OptionalLong 클래스는 단순히 집계값만 저장하는 것이 아니라 집계값이 존재하지 않을 경우, 디폴트 값을 설정하거나 집계값을 처리하는 Consumer를 등록할 수 있다. 다음은 Optional 클래스가 제공하는 메소드이다.

리턴 타입	메소드	설명
boolean	isPresent()	집계값이 있는지 여부
T double int long	orElse(T) orElse(double) orElse(int) orElse(long)	집계값이 없을 경우, 디폴트 값 설정
void	ifPresent(람다식)	집계값이 있을 경우, 람다식 실행

public class OptionalExample {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        OptionalDouble optional = list.stream().mapToInt(Integer::intValue).average();

        if (optional.isPresent()){
            System.out.println(optional.getAsDouble());
        }
        else{
            System.out.println(0.0);
        }
        
        list.stream().mapToInt(Integer::intValue).average().ifPresent(avg-> System.out.println(avg));

        list.stream().mapToInt(Integer::intValue).average().orElse(0.0);
    }
}

 

요소 수집

스트림은 요소들을 필터링 또는 매핑한 후 요소들을 수집하는 최종 처리 메소드인 collect()를 제공한다. 이 메소드를 이용하면 필요한 요소만 컬렉션에 담을 수 있고, 요소들을 그룹핑한 후에 집계도 할 수 있다.

public class CollectExample {
    public static void main(String[] args) {
        List<Student> totalList = new ArrayList<>();
        totalList.add(new Student("신짱구", "남",100));
        totalList.add(new Student("김철수", "남",54));
        totalList.add(new Student("한유리", "여",80));

        List<Student> maleList = totalList.stream().filter(s -> s.getSex().equals("남")).toList();
        maleList.stream().forEach(s-> System.out.println(s.getName()));

        System.out.println();

        Map<String, Integer> map = totalList.stream().collect(
                Collectors.toMap(
                        s -> s.getName(),
                        s -> s.getScore()
                )
        );
        System.out.println(map);
    }
}