[TIL] 2022-11-15(12day)

JAVA 기초문법(4)

---

👉 날짜와 시간 다루기

-1) 기본 시간 다루기

public class Main {
    public static void main(String[] args) {
        System.out.println("now()를 활용하여 생성");
        LocalDate date = LocalDate.now();
        LocalTime time = LocalTime.now();
        LocalDateTime dateTime = LocalDateTime.now();

        System.out.println(date);
        System.out.println(time);
        System.out.println(dateTime);

        System.out.println("of()를 활용하여 생성");
        LocalDate newDate = LocalDate.of(2021, 03, 29);
        LocalTime newTime = LocalTime.of(22, 50, 55);

        System.out.println(newDate);
        System.out.println(newTime);
    }
}

 

-2) 날짜와 시간 형식 수정

DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");	//원하고자 하는 날짜형식
String myDate = newFormatter.format(LocalDate.now());
System.out.println(myDate);

 

-3) 날짜와 시간 차이 계산

LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(2021, 8, 9);
Period period = Period.between(today, birthday);
System.out.println(period.getMonths());
System.out.println(period.getDays());

 

-4) 오늘의 날짜와 시간을 [연도/월/일 시간/일자]로 출력하기

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

public class Main {
    public static void main(String[] args) {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd h/mm");
        String now = dateTimeFormatter.format(LocalDateTime.now());
        System.out.println("현재시간: " + now);
    }
}

---

👉 컬렉션 Collection 정의

- 다수의 데이터를 다루기 위한 자료구조를 표현하고 사용하는 클래스의 집합

- 컬렉션 프레임워크의 모든 클래스는 Collection interface를 구현(implement)하는 클래스 또는 인터페이스

 

-1)컬렉션을 위한 자바 인터페이스와 클래스 

 

# List : 순서가 있는 데이터의 집합이며 데이터의 중복을 허용.
→ ArrayList, LinkedList, Stack 등
# Set : 순서를 유지하지 않는 데이터의 집합이며 데이터의 중복을 허용X.
→ HashSet, TreeSet 등
# Map : 키(key)와 값(value)의 쌍으로 이루어진 데이터의 집합. 순서는 유지되지 않으며 키는 중복을 허용x 값은 중복 허용
→ HashMap, TreeMap 등
# Stack : 마지막에 넣은 데이터를 먼저 꺼내는 자료구조. LIFO(Last In First Out)
→ Stack, ArrayDeque 등
# Queue : 먼저 넣은 데이터를 먼저 꺼내는 자료구조. FIFO(First In First Out)
→ Queue, ArrayDeque 등
- 컬렉션 인터페이스**에는 컬렉션 클래스에 저장된 데이터를 읽고, 추가하고 삭제하는 등 데이터를 다루는데 기본적인 메소드들을 정의.

 

 

👉 컬렉션 Collection - List, Set, Map

-1) List

# 순서가 있는 나열된 데이터를 표현.

# ArrayList는 배열을 이용하여 데이터를 저장하는 List 인터페이스

public class Main {
    public static void main(String[] args) {
        List list = new ArrayList(10);
        list.add(1);
        list.add(5);
        list.add(4);
        list.add(11);
        list.add(10); // ArrayList에 값 한개씩 입력
        System.out.println(list); // [1,5,4,11,10]

        Collections.sort(list); // list 정렬
        System.out.println(list); // [1,4,5,10,11]

        System.out.println(list.size()); // arrayList의 크기 출력

        arrayList.remove(4); // 인덱스를 활용하여 해당하는 값 제거
        System.out.println(list);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i)); // get을 이용하여 값 1개씩 출력
        }
				for (int current : list) {
						System.out.println(current);
        }

    }
}

 

-2) Set

# 순서를 유지하지 않는 데이터의 집합이며 데이터의 중복을 허용X

# HashSet은 Set 인터페이스를 구현한 대표적인 컬렉션

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> integerSet = new HashSet<>(); // Collection의 자료형에는 primitive 타입은 올 수 없음.
        integerSet.add(1);
        integerSet.add(3);
        integerSet.add(2);
        integerSet.add(9);// 하나씩 값을 삽입.
        System.out.println(integerSet); // 
        Set<String> stringSet = new HashSet<>();
        stringSet.add("LA");
        stringSet.add("New York");
        stringSet.add("LasVegas");
        stringSet.add("San Francisco");
        stringSet.add("Seoul");
        System.out.println(stringSet);

        stringSet.remove("Seoul"); //Seoul을 HashSet에서 제거.
        System.out.println(stringSet);

        ArrayList<String> target = new ArrayList<String>();
        target.add("New York");
        target.add("LasVegas");//제거할 항목을 ArrayList에 삽입.
        stringSet.removeAll(target);//제거항목에 삽입된 도시들을 삭제.
        System.out.println(stringSet);

        System.out.println("LA가 포함되어있나요? " + stringSet.contains("LA"));
        System.out.println("LA가 포함되어있나요? " + stringSet.contains("LasVegas"));
        //LA가 HashSet에 포함되어있으면 true를, 그렇지 않으면 false를 반환.

        System.out.println("현재 HashSet의 크기는 : " + stringSet.size() + "입니다.");
        //HashSet의 크기를 반환.

        stringSet.clear();//HashSet의 모든 아이템들을 삭제.
        System.out.println(stringSet);
    }
}

 

-3) Map

# 키(key)와 값(value)을 하나의 데이터로 저장

# 해싱(hashing)을 가능하게 하여 데이터를 검색하는데 유용

public class Main {
    public static void main(String[] args) {
				Map<Integer, String> map = new HashMap<>();
        map.put(1, "apple");
        map.put(2, "berry");
        map.put(3, "cherry");

        System.out.println(map);

        System.out.println("1st in map: " + map.get(1));

        map.remove(2);
        System.out.println(map);
        System.out.println(map.containsKey(2));
        System.out.println(map.containsValue("cherry"));
        
        map.clear();
        System.out.println(map);
    }
}

 

👉 컬렉션 Collection - 스택, 큐, ArrayDeque

-1) 스택 Stack

# 마지막에 저장한 데이터를 가장 먼저 꺼내는 자료구조 (LIFO)

 ex) 웹브라우저의 앞페이지 이동 뒤페이지 이동 / 그릇 쌓기

public class Main {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(3);
        stack.push(5);
        stack.push(7);
        System.out.println(stack); // Stack을 출력합니다

        System.out.println(stack.peek()); // Stack의 가장 상단 값을 출력.(삭제는 안함.)
        stack.pop(); // Stack의 가장 상단 값을 제거합니다.
        System.out.println(stack);
        System.out.println(stack.size()); // Stack의 크기를 반환.
        System.out.println(stack.contains(1)); // Stack에 1이라는 값이 있으면 true를, 그렇지 않으면 false를 반환.
        System.out.println(stack.empty()); // STack이 비어있으면 true를, 그렇지 않으면 false를 반환.
        System.out.println(stack);
    }
}

 

-2) 큐 Queue

# 처음에 저장한 데이터를 가장 먼저 꺼내는 자료구조 (FIFO)

 ex) 은행 창구 줄서기 / 인쇄작업 대기목록

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(3);
        queue.add(5);//Queue에 값 삽입합니다.
        System.out.println(queue);//Queue 출력합니다.
        System.out.println(queue.poll()); // Queue에서 객체를 꺼내서 반환합니다.
        queue.add(7);
        queue.add(11);
        queue.add(9);
        System.out.println(queue);
        System.out.println(queue.peek()); //Queue에서 삭제 없이 요소를 반환합니다.
        System.out.println(queue);
    }
}

 

-3) ArrayDeque

# 기본 Stack, Queue의 기능을 모두 포함하면서도 성능이 더 좋다.

# 양 끝에서 삽입과 반환 가능

public class Main {
    public static void main(String[] args) {
        ArrayDeque<Integer> arrayDeque = new ArrayDeque<>(); // ArrayDeque를 이용한 선언(제네릭스 이용)
        arrayDeque.addFirst(1);
        arrayDeque.addFirst(2);
        arrayDeque.addFirst(3);
        arrayDeque.addFirst(4); // arrayDeque의 앞에 값을 삽입
        System.out.println(arrayDeque);

        arrayDeque.addLast(0); // arrayDeque의 끝에 값을 삽입
        System.out.println(arrayDeque);

        arrayDeque.offerFirst(10); // addFirst와 비슷하지만 큐의 크기 문제가 생길 때, offerFirst는 false를,
        // addFrist는 exception을 반환합니다.
        System.out.println(arrayDeque);

        arrayDeque.offerLast(-1); // arrayDeque의 끝에 값을 삽입
        System.out.println(arrayDeque);
        System.out.println(arrayDeque.size()); // 7


        System.out.println(arrayDeque.removeFirst()); // 첫번째 값을 제거하면서 그 값을 리턴
        System.out.println(arrayDeque.removeLast()); // 마지막 값을 제거하면서 그 값을 리턴
		    System.out.println(arrayDeque);
				System.out.println(arrayDeque.size()); // 5

        System.out.println(arrayDeque.pollFirst()); // 첫번째 값을 반환 및 제거하면서 그 값을 리턴
        System.out.println(arrayDeque);
				System.out.println(arrayDeque.size()); // 4

        System.out.println(arrayDeque.pollLast()); // 마지막 값을 반환 및 제거하면서 그 값을 리턴
        System.out.println(arrayDeque);
				System.out.println(arrayDeque.size()); // 3

        System.out.println(arrayDeque.peekFirst()); // 첫번째 값을 반환, 제거하지 않음
        System.out.println(arrayDeque.peekLast()); // 마지막 값을 반환, 제거하지 않음
				System.out.println(arrayDeque.size()); // 3
    }
}

---

👉 제네릭스 Generics

public class 클래스명<T> {...}
public interface 인터페이스명<T> {...}

- 다양한 타입의 객체들을 다루는 메소드나 컬렉션 클래스에 컴파일 시의 타입 체크를 해주는 기능을 의미

 

- <T> == Type

- <E> == Element

- <K> == Key

- <V> == Value

- <N> == Number

- <R> == Result

 

-1) Collection.java 중 일부

public interface Collection<E> extends Iterable<E> {
	int size();
	boolean isEmpty();
	Iterator<E> iterator();
	boolean add(E e);
	<T> T[] toArray(T[] a);
	boolean containsAll(Collection<?> c);
	boolean addAll(Collection<? extends E> c);
}

 

-2) List.java 중 일부

public interface List<E> extends Collection<E> {
  // Collection 에 있는 메소드들 모두 포함 
  // + List 에만 있는 메소드들
	boolean add(E e);
}

 

-3) ArrayList.java 중 일부

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable 
{
	public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }
    public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
}

---

👉 람다 Lamda

[기존의 메소드 형식]
반환타입 메소드이름(매개변수 선언) {
    수행 코드 블록
}

[람다식의 형식]
반환타입 메소드이름(매개변수 선언) -> {
    수행 코드 블록
}

- 함수의 이름을 따로 정의하지 않아도 곧바로 함수처럼 사용할 수 있는 함수 (식별자가 없다.)

public class Main {
    public static void main(String[] args) {
        ArrayList<String> strList = new ArrayList<>(Arrays.asList("korea", "japan", "china", "france", "england"));
        Stream<String> stream = strList.stream();
        stream.map(str -> str.toUpperCase()).forEach(System.out::println); // :: => 매개변수를 중복해서 사용하고 싶지 않을 때 사용.
    }
}

---

👉 스트림 stream

# 데이터의 흐름

# 컬렉션의 저장 요소를 하나씩 참조해서 람다식으로 처리할 수 있도록 해주는 반복자

# 스트림을 활용해서 필터링,데이터 변경, 다른 타입이나 자료구조로 변환 가능

 

-1) 스트림의 특징

 1. 데이터 소스를 변경하지 않는다.

 2. 작업을 내부적으로 반복 처리한다.

 3. 컬렉션의 요소를 모두 읽고 나면 닫혀서 재사용이 불가능 (필요할 경우 재생성)

 

-2) 스트림의 구조

1. 스트림 생성
- 'Stream<T> Collection.stream()` 을 이용하여 해당하는 컬렉션을 기반으로하는 스트림을 생성
2. 중간 연산
- 중간 단계로써 데이터의 형변환 혹은 필터링, 정렬 등 스트림에 대한 가공.
- map(변환) / sorted(정렬) / skip(스트림 자르기) / limit(스트림 자르기) 등......
3. 최종 연산
- 스트림의 요소를 소모해서 결과를 반환하는 단계. 최종 연산 이후에는 스트림이 닫히게 되고 더 이상 사용불가
- 최종 연산의 결과값은 단일 값일 수도 있으며 배열 혹은 컬렉션일 수도 있음.
- collect()를 이용해서 다른 콜렉션으로 바꾸는 것, reduce를 이용해서 incremental calculation하는 것도 가장 많이 쓰이는 패턴.

 

---

🙋‍♂️ 소감 : 

람다와 ArrayDeque는 처음 예전 강의에서는 배우지 않았던 내용이다,실무에서 많이 쓰이는 방법이라고 하니, 반복해서 연습해야겠다.

😈 아는 내용이라고 그냥 넘어가지 않기! 😈