날짜 표현 (LocalDateTime)

package ch10;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class S01 {
    public static void main(String[] args) {
        // 현재 시간을 가져온다
        // 실행한 컴퓨터의 시간대(Local)을 가져옴
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        // plus minus / 예약 등의 기능 만들 때 사용
        LocalDateTime plusDays = now.plusDays(2);
        System.out.println(plusDays);
        
        // parse
        // 다른 타입의 데이터나 미가공 데이터를 사용 가능하게 바꾸는 작업
        // 문자열 데이터를 date 타입으로 파싱
        LocalDateTime parse = LocalDateTime.parse("2020-07-06T14:20:02.886353900");
        System.out.println(parse);

        DateTimeFormatter ofPattern = DateTimeFormatter.ofPattern("yyyy년 MM월 dd일 HH시 mm분 ss초");
        LocalDateTime parse2 = LocalDateTime.parse("2000년 11월 24일 00시 00분 01초", ofPattern);
        System.out.println(parse2);

        System.out.println(LocalDate.now());
        System.out.println(LocalTime.now());
    }
}

컬렉션 프레임워크

여러 객체를 모아 놓은 것 (컬렉션) + 표준, 정형화된 체계적 프로그래밍 방식 (프레임워크)

-> 다수의 객체를 다루기 위한 표준화된 프로그래밍 방식

컬렉션 프레임워크 종류

package ch11;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;

public class S01 {
    public static void main(String[] args) {
        // List - 순서가 있고 데이터 중복이 가능
        List list = new ArrayList<>();

        // Set - 순서가 없고 데이터 중복 불가능
        // key만으로 이루어져 있다
        Set set = new HashSet<>();

        // Map - 순서가 없고 key, value로 이루어져 있다
        // key는 중복 불가능, value는 중복 가능
        Map map = new HashMap<>();

        // Stack - 나중에 들어온 값이 먼저 나감
        Stack stack = new Stack<>();

        // Queue - 먼저 들어온 값이 먼저 나감
        Queue queue = new LinkedList<>();
    }
}

List 기초

순서가 있고 데이터 중복이 가능

package ch11;

import java.util.ArrayList;
import java.util.List;

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

        // 리스트 선언
        List<String> list = new ArrayList<String>();
        System.out.println("list.size() : " + list.size());
        System.out.println();

        // 추가 메소드. 불린 반환, 리스트 반환이 아니니 내부적으로 실행됨
        list.add("바나나");
        System.out.println("list.size() : " + list.size());
        System.out.println("list : " + list);
        System.out.println();

        list.add("사과");
        list.add("바나나");
        // add한 순서대로 정렬이 되어있다
        System.out.println("list : " + list);
        System.out.println("list.get(1) : " + list.get(1));
        System.out.println();

        // 변경 메소드. 바뀌기 전 객체(?) 반환
        System.out.println("list.set(1, \"멜론\") : " + list.set(1, "멜론")); 
        System.out.println("list : " + list);
        System.out.println();

        // 삭제 메소드. 삭제한 객체 반환
        System.out.println("list.remove(0) : " + list.remove(0));
        System.out.println("list : " + list);

        // 콜렉션 모든 요소 추가
        System.out.println("list.addAll(1, list) : " + list.addAll(1, list));
        // 콜렉션 모든 요소 포함 여부
        System.out.println("list.containsAll(list) : " + list.containsAll(list));
    }
}

결과

list.size() : 0

list.size() : 1
list : [바나나]

list : [바나나, 사과, 바나나]
list.get(1) : 사과

list.set(1, "멜론") : 사과
list : [바나나, 멜론, 바나나]

list.remove(0) : 바나나
list : [멜론, 바나나]
list.addAll(1, list) : true
list.containsAll(list) : true

Set 기초

Set - 순서가 없고 데이터 중복 불가능
key만으로 이루어져 있다

package ch11;

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

public class S03 {
    public static void main(String[] args) {
        // 싸이버거 세트
        Set<String> set = new HashSet<String>();

        set.add("바나나");
        set.add("사과");
        set.add("바나나");
        set.add("멜론");
        set.add("망고");
        set.add("딸기");
        // 중복 불가 [사과, 바나나]
        System.out.println("set : " + set);

        // set은 순서가 없기 때문에 인덱스 값으로 값을 가져올 수 없다
        // set.get();

        // set는 리스트 안의 값 유무 파악할 때 사용
        System.out.println("set.contains(\"파인애플\") : " + set.contains("파인애플"));
    }
}

결과

set : [멜론, 망고, 사과, 바나나, 딸기]
set.contains("파인애플") : false

Map 기초

순서가 없고 key, value로 이루어져 있다
key는 중복 불가능, value는 중복 가능

package ch11;

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

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

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

        // 추가할 땐 put
        map.put("사과", "3개");
        map.put("바나나", "1개");
        map.put("멜론", "2개");
        System.out.println("map : " + map);

        // 값 찾을 떈 key 값으로 찾아오기
        System.out.println("map.get(\"사과\") : " + map.get("사과"));

        // 삭제도 key값
        map.remove("멜론");
        
        // 이름과 값 둘 다 중요할 때 사용
        System.out.println("map : " + map);

    }
}

결과

map : {멜론=2개, 사과=3개, 바나나=1개}
map.get("사과") : 3개
map : {사과=3개, 바나나=1개}

Stack 기초

나중에 들어온 값이 먼저 나감(LIFO)

package ch11;

import java.util.Stack;

public interface S05 {
public static void main(String[] args) {
Stack stack = new Stack();

    // 값 입력 push
    stack.push("사과");
    stack.push("바나나");
    stack.push("멜론");

    System.out.println(stack);

    // 값 뺄 때는 pop (무조건 마지막)
    stack.pop();
    System.out.println(stack);
}

}

### Queue 기초
>먼저 들어온 값이 먼저 나감(FIFO)
```java
package ch11;

import java.util.LinkedList;
import java.util.Queue;

public class S06 {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>();
        // 값 넣기
        queue.add("사과");
        queue.add("바나나");
        queue.add("멜론");
        System.out.println(queue);
        // 값 빼기 (처음 들어온 것)
        // FIFO, 음식점, 은행 번호표
        // 롤 큐
        queue.poll();
        System.out.println(queue);
    }
}

롬복

설명
https://jiurinie.tistory.com/20

---

설치
https://mvnrepository.com/artifact/org.projectlombok/lombok/1.18.28

기본 어노테이션 예제

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

// 어노테이션 읽어서 롬복에서 생성자 자동 생성
@AllArgsConstructor
@NoArgsConstructor
// getter와 setter 자동 생성
@Getter
@Setter
// toString을 인스턴스 정보 정리 출력으로 오버라이딩
@ToString
class Cat {
    private String name;
    private boolean male;

    // lombok 사용 시에도 덮어쓰기 가능
    public String getName() {
        return this.name + " 입니다";
    }
}

public class Study07 {
    public static void main(String[] args) {
        // 고양이 생성
        Cat cat = new Cat("야옹이", true);

        // 고양이 이름
        // 어노테이션으로 getter, setter 자동 생성
        System.out.println(cat.getName());

        // 수컷?
        System.out.println(cat.isMale());

        // 이름 변경
        cat.setName("냐옹이");

        // cat.toString()과 같음
        System.out.println(cat);
    }

}

업 / 다운 캐스팅

자손 클래스 -> 조상 클래스
조상 클래스 -> 자손 클래스 (업)

package ch00;

import lombok.Getter;
import lombok.ToString;

class Animal {
    // 상속이나 같은 종류만 접근 가능
    // protected
    protected String name;
}

@ToString
@Getter
class Cat extends Animal {
    public Cat(String name) {
        this.name = name;
    }

    public void cry(){
        System.out.println("야옹");
    }
}

public class Study08 {
    public static void main(String[] args) {
        Cat cat = new Cat("dd");

        cat.cry();

        // 조상 클래스로 캐스팅 하는 것 = 업캐스팅
        Animal animal = (Animal) cat;

        // 자손이 cry를 가지고 있더라도
        // 업캐스팅 시 사용할 수 없다
        // animal.cry();

        // 자손 클래스로 캐스팅 하는 것 = 다운캐스팅
        Cat cat1 = (Cat) animal;
        cat1.cry();
        System.out.println(cat1);


        // Cat -> Animal -> Cat은 가능 하지만
        // 원래 Animal 에서 Cat은 불가능
        Animal animal2 = new Animal();        
        Cat cat2 = (Cat) animal2;

        cat2.cry();
    }
}

Wrapper Type

기본형 타입들을 객체처럼 사용 가능함

예제

package ch00;

public class Study09 {
    public static void main(String[] args) {
        int num1 = 1;
        // 기본형 타입을 객체처럼 사용 가능
        // 랩퍼 타입(Wrapper)
        Integer num2 = 1;
        System.out.println(num2);
        
        // num1 = null;
        num2 = null;
        System.out.println(num2);
    }
}

결과

1
null

Optional

만약 String 객체에 null값이 들어올 때를 대비해 null값에 대한 대비가 필요
-> Optional을 이용해 null 처리를 강제함

예제

package ch00;

import java.util.Optional;

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

        String str = null;
        
        // null 값이 들어올 수 있으니 처리 필요
        if(str == null){
            System.out.println("데이터가 null");
        } else {
            System.out.println(str.length());
        }
        

        // null 값이 들어올 수 있는 변수를 컨트롤 할 때 사용
        // null 처리 강제
        Optional<String> optionalStr = Optional.of("asdf");
        if(optionalStr.isEmpty()){
            System.out.println("데이터가 null");
        } else { 
            System.out.println("optionalStr.get().length() : " + optionalStr.get().length());
        }
        System.out.println(optionalStr.orElse("값이 없습니다"));
    }
}

결과

optionalStr.get().length() : 4
asdf

enum

데이터를 고정적으로 제한할 때 사용

예제

package ch00;

import lombok.Getter;
import lombok.ToString;

// 데이터를 고정적으로 제한할 때 사용한다
enum Gender{
    MALE, FEMALE
}

@Getter
@ToString
class Person{
    private String name;
    private String gender;

    public Person(String name, Gender gender){
        this.name = name;
        this.gender = gender.name();
    }
}

public class Study11 {
    public static void main(String[] args) {
        // 생성자에 의해 생성될 때 Gender안의 속성으로만 설정 가능
        Person person = new Person("홍길동", Gender.MALE);
        System.out.println(person);
    }
}

결과

Person(name=홍길동, gender=MALE)