IT 블로그

Java Version History and Features

Java Version History and Features - HowToDoInJava

버전별 변경사항(eng)

Java Versions and Features

Java Versions and Features

java 버전별 차이 & 특징 (****한글판)

java 버전별 차이 & 특징

java 8

• Lambda
  Java 8 이전 익명 클래스의 사용을 람다를 이용하여 더욱 간결하고 직관적으로 구현 가능
• Stream
  자바 8은 스트림 API를 통해 컬렉션을 처리하면서 발생하는 모호함과 반복적인 코드 문제와 멀티코어 활용 어려움이라는 두 가지 문제를 모두 해결

Java 9

     모듈시스템 등장(jigsaw)

Java 10

• var 키워드
• 병렬 처리 가비지 컬렉션 도입으로 인한 성능 향상
• JVM 힙 영역을 시스템 메모리가 아닌 다른 종류의 메모리에도 할당 가능

자바 버전별 역사 및 특징

위와 비슷함( Java12 까지 정리됨)
Java SE 10
2018년 3월 20일 발표 일반 지원은 2018년 9월에 종료되었다. var 키워드를 이용한 지역 변수 타입 추론

병렬 처리 가비지 컬렉션, 개별 쓰레드로 분리된 Stop-The-World 등이 추가 되었다.

• 기존에는 Stop-The-World 가 발생하면 GC 를 실행하는 쓰레드를 제외한 나머지 쓰레드는 모두 작업을 멈춘다. GC 작업을 완료한 이후에야 중단했던 작업을 다시 시작한다. 근데 이게 개별 쓰레드로 분리되어서 Stop-The-World 시간이 개선된것 같다.
  JVM 힙 영역을 시스템 메모리가 아닌 다른 종류의 메모리에도 할당할 수 있게 되었다.

JDK에서 루트 인증 기관(CA) 인증서의 기본 세트를 제공하게 되었다. Enhanced for Loop 를 위한 바이트코드 생성

• Enhanced for Loop 에 대한 바이트코드 생성이 개선되어 해당 루프에 대한 컴파일 접근 방식이 개선되었다.

Java 11로 전환해야 하는 이유 - Azure

MS 문서?

(8과 11 비교 중)

G1GC
Java 11의 기본 가비지 수집기는 G1GC(G1 가비지 수집기)입니다. G1GC의 목표는 대기 시간과 처리량 간의 균형을 유지하는 것입니다. G1 가비지 수집기는 높은 확률의 일시 중지 시간 목표를 충족하여 높은 처리량을 달성하려고 시도합니다. G1GC는 전체 컬렉션을 방지하도록 설계되었지만 동시 컬렉션이 메모리를 충분히 빨리 회수할 수 없는 경우 전체 GC 대체가 발생합니다. 전체 GC는 젊고 혼합된 컬렉션과 동일한 수의 병렬 작업자 스레드를 사용합니다.

병렬 GC
병렬 수집기는 Java 8의 기본 수집기입니다. 병렬 GC는 여러 스레드를 사용하여 가비지 수집 속도를 높이는 처리량 수집기입니다.

엡실론
엡실론 가비지 수집기는 할당을 처리하지만 메모리를 회수하지는 않습니다. 힙이 소진되면 JVM이 종료됩니다. 엡실론은 수명이 짧은 서비스와 가비지를 사용하지 않는 것으로 알려진 애플리케이션에 유용합니다.

JAVA 버전별 특징

JAVA 버전별 특징 (tistory.com)

JAVA 8

• 기본 GC > Parallel GC
• Lambda Expression
• Repeating Annotation
• 새로운 날짜와 시간 API(LocalDate, LocalTIme, LocalDateTime)
• Interface Default Method
• Stream API

JAVA 9

• Java를 인터프리터 언어 셸처럼 사용할 수 있는 JShell이 추가
• private 인터페이스 메소드
• immutable collection
• 64비트 버전만 출시
• 프로퍼티 파일에 UTF-8 지원

JAVA 10

• var 키워드를 이용한 지역 변수 타입 추론
• 병렬 처리 가비지 컬렉션
• 개별 쓰레드로 분리된 Stop-The-World
• 루트 CA 목록

JAVA 11

• 기본 GC > G1 GC
• 람다 파라미터에 대한 지역 변수 문법
• 엡실론 가비지 컬렉터

엡실론 가비지 수집기는 할당을 처리하지만 메모리를 회수하지는 않는고 힙이 소진되면 JVM이 종료된다. 엡실론은 수명이 짧은 서비스와 가비지를 사용하지 않는 것으로 알려진 애플리케이션에 유용하다.

Epsilon GC를 사용할 경우 우리가 작성한 어플리케이션이 외부 환경으로부터 고립된 채로 실행되기 때문에 실제 내 어플리케이션이 얼마나 메모리를 사용하는 지에 대한 임계치나 어플리케이션 퍼포먼스 등을 보다 정확하게 측정할 수 있다.

• HTTP 클라이언트 표준화(HttpClient 추가)

JAVA 12

• Shenandoah GC 추가. Shenandoah는 ZGC와 비슷하게 대량의 메모리 처리에 우수한 퍼포먼스를 내지만 좀 더 많은 옵션을 제공한다는 장점이 있다. Shenandoah는 레드 햇에서 개발한 GC인데, 실제로는 ZGC보다 앞선 Java 8부터 개발하기 시작해서 12가 나올 때 release를 하였다

…

[9 부터 G1GC 가 default]

나만 모르고 있던 - Java 9 (Java9 빠르게 훑어 보기)

나만 모르고 있던 - Java 9 (Java9 빠르게 훑어 보기) | Popit

gc

Java 가비지 컬렉터(GC) 이해하기

Java 가비지 컬렉터(GC) 이해하기

우선 Java 11에서는 Epsilon과 Z Garbage Collector(ZGC)가 추가되었습니다. 엡실론이라니 이름이 멋있어서 무슨 뜻이 있나 하고 검색해보니 그리스어로 숫자 5라는 의미도 있고, 엡실론 델타 논법이라 해서 수학적 용어로도 쓰인다고 합니다.(그래서 왜 GC 이름이 엡실론인건데..)

Epsilon은 메모리 할당은 처리하지만 사용되지 않는 영역에 대해 재활용하지 않습니다. 그리고 기존에 다른 알고리즘의 GC들은 Java Heap 영역이 가득 찼을 경우 OS에 요청하여 추가적으로 Heap 영역을 할당 받았는데, Epsilon의 경우 Java Heap 영역을 모두 소진하게 되면 JVM이 Shut down 됩니다. Epsilon의 목적은 제한된 영역의 메모리 할당을 허용함으로써 최대한 latency overhead를 줄이는 데에 있습니다. Epsilon GC를 사용할 경우 우리가 작성한 어플리케이션이 외부 환경으로부터 고립된 채로 실행되기 때문에 실제 내 어플리케이션이 얼마나 메모리를 사용하는 지에 대한 임계치나 어플리케이션 퍼포먼스 등을 보다 정확하게 측정할 수 있습니다.

ZGC는 대량의 메모리를 low-latency로 잘 처리하기 위해 디자인 된 GC 입니다. Oracle에 따르면 multi-tera bytes 크기의 Heap도 관리할 수 있다고 합니다. ZGC는 어플리케이션과 Concurrently하게 동작하는데, Heap Reference를 위해 Load barrier를 사용합니다. 이 Load barrier는 이전 버전에서 사용하던 G1(Garbage First) GC보다 딜레이가 낮습니다. Java 12를 기준으로 했을 때 ZGC의 경우 64bit 운영체제에서만 동작한다고 하는데, 이는 ZGC가 64비트 크기의 Color Point 방식으로 Heap 영역에 있는 객체들을 관리하기 때문입니다. ZGC가 내세우는 최대 장점 중 하나는 'stop-the-world'의 시간이 절대 10ms를 넘지 않는다는 것인데, 구체적인 숫자로 자신있게 얘기하는 것 보니 신뢰해도 좋을 것 같습니다.

마지막으로 Java 12에서 도입된 GC는 Shenandoah GC 입니다. Shenandoah는 ZGC와 비슷하게 대량의 메모리 처리에 우수한 퍼포먼스를 내지만 좀 더 많은 옵션을 제공한다는 장점이 있습니다. Shenandoah는 레드 햇에서 개발한 GC인데, 실제로는 ZGC보다 앞선 Java 8부터 개발하기 시작해서 12가 나올 때 release를 한거라고 합니다. 그 때문인지 Java 8, 10 버전에서도 호환이 가능합니다.

리액티브 프로그래밍

[RxJava] RxJava 프로그래밍(1) - 리액티브 프로그래밍

[RxJava] RxJava 프로그래밍(1) - 리액티브 프로그래밍

리액티브 프로그래밍은 데이터 흐름과 전달에 관한 프로그래밍 패러다임이다. 기존의 명령형(imperative) 프로그래밍은 주로 컴퓨터 하드웨어를 대상으로 프로그래머가 작성한 코드가 정해진 절차에 따라 순서대로 실행된다. 그러나 리액티브 프로그래밍은 데이터 흐름을 먼저 정의하고 데이터가 변경되었을때 연관되는 함수나 수식이 업데이트되는 방식이다.

Reactive 프로그래밍이란?

1. Reactive 프로그래밍이란?

데이터와 데이터 스트림에 영향을 미치는 모든 변경 사항을 관련된 모든 당사자들에게 전파하는 모든 프로그램을 리액티브 프로그램이라고 할 수 있습니다. 리액티브 프로그래밍을 하면 다음과 같은 이점을 얻을 수 있습니다.

• 간결해진 Thread 사용
• 간단한 비동기 연산
• 콜백 지옥의 제거

Reactive Programming 101 : 리액티브 프로그래밍이 뭔가요

Reactive Programming 101 : 리액티브 프로그래밍이 뭔가요 | juneyr.dev

private int getMaxValue_2(int[][] inputData, int endValue) {

int maximumValue = 0; // rtn 값
int inputSize = inputData.length; // 배열 size
int cur_x_st = 0;
int cur_x_end = endValue;
int cur_y_st = 0;
int cur_y_end = endValue;
int tmp_max = 0; // ? Integer.MIN_VALUE;

while (cur_x_end <= inputSize) { // N x N 배열의 사이즈를 넘지 않아야 ...
tmp_max = 0;
for (int i=cur_x_st; i< cur_x_end ; i++) {
for (int j=cur_y_st; j< cur_y_end ; j++) {
tmp_max += inputData[i][j];
}
}
cur_y_st++;
cur_y_end++; // 일단 열이 증가하도록

if (cur_y_end > inputSize) { // 열이 증가하다가 배열의 사이즈 보더 커지면

cur_x_st++;
cur_x_end++;
cur_y_st = 0;
cur_y_end = endValue;
}

if (maximumValue < tmp_max) {
maximumValue = tmp_max;
}

}

return maximumValue;
}

시저 암호

문제 설명

어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 AB는 1만큼 밀면 BC가 되고, 3만큼 밀면 DE가 됩니다. z는 1만큼 밀면 a가 됩니다. 문자열 s와 거리 n을 입력받아 s를 n만큼 민 암호문을 만드는 함수, solution을 완성해 보세요.

제한 조건

- 공백은 아무리 밀어도 공백입니다.
- s는 알파벳 소문자, 대문자, 공백으로만 이루어져 있습니다.
- s의 길이는 8000이하입니다.
- n은 1 이상, 25이하인 자연수입니다.

입출력 예
s        n   result
AB      1   BC
z        1   a
a B z   4   e F d

소수 찾기

문제 설명
1부터 입력받은 숫자 n 사이에 있는 소수의 개수를 반환하는 함수, solution을 만들어 보세요.

소수는 1과 자기 자신으로만 나누어지는 수를 의미합니다.
(1은 소수가 아닙니다.)

제한 조건
n은 2이상 1000000이하의 자연수입니다.

입출력 예
n      result
10    4
5      3

입출력 예 설명
입출력 예 #1
1부터 10 사이의 소수는 [2,3,5,7] 4개가 존재하므로 4를 반환

입출력 예 #2
1부터 5 사이의 소수는 [2,3,5] 3개가 존재하므로 3를 반환

----------------------------------------
(인터넷 검색/펌 포함)

        int answer = 0;
        
        int not_prime = 0;
        int numOfPrime;

        int n2 = (int)(Math.sqrt((double)n));

        for(int i=2; i<=n; i++){
            for(int j=2; j<=n2; j++){
                if(i%j == 0 && i!=j) {
                    not_prime++;
                    break;
                }
            }
        }
        
        numOfPrime = n - not_prime - 1;
        System.out.println("소수의 개수 : " + numOfPrime);
        
        answer = numOfPrime;
        return answer;

// => 값은 맞음. 시간 초과

int answer = 0;
int tot = 0;

boolean[] marked = new boolean[n + 1];

int nSqrt = (int) Math.sqrt(n);

for (int i = 2; i <= nSqrt; i++) {
    if (!marked[i]) {

        for (int j = i*i ; j < n + 1; j += i) {
            marked[j] = true;
        }
    }
}
        
for (int i = 2; i < n + 1; i++) {
    if (!marked[i] ) {
        System.out.print(i + "  ");
        tot++;
    }
}
System.out.println( );
answer = tot;
return answer;

// => 통과

문자열 내 마음대로 정렬하기

문제 설명

문자열로 구성된 리스트 strings와, 정수 n이 주어졌을 때, 각 문자열의 인덱스 n번째 글자를 기준으로 오름차순 정렬하려 합니다. 예를 들어 strings가 [sun, bed, car]이고 n이 1이면 각 단어의 인덱스 1의 문자 u, e, a로 strings를 정렬합니다.

제한 조건

• strings는 길이 1 이상, 50이하인 배열입니다.
• strings의 원소는 소문자 알파벳으로 이루어져 있습니다.
• strings의 원소는 길이 1 이상, 100이하인 문자열입니다.
• 모든 strings의 원소의 길이는 n보다 큽니다.
• 인덱스 1의 문자가 같은 문자열이 여럿 일 경우, 사전순으로 앞선 문자열이 앞쪽에 위치합니다.

입출력 예

strings                n   return
[sun, bed, car]      1   [car, bed, sun]
[abce, abcd, cdx]   2   [abcd, abce, cdx]

입출력 예 설명

입출력 예 1
sun, bed, car의 1번째 인덱스 값은 각각 u, e, a 입니다. 이를 기준으로 strings를 정렬하면 [car, bed, sun] 입니다.

입출력 예 2
abce와 abcd, cdx의 2번째 인덱스 값은 c, c, x입니다. 따라서 정렬 후에는 cdx가 가장 뒤에 위치합니다. abce와 abcd는 사전순으로 정렬하면 abcd가 우선하므로, 답은 [abcd, abce, cdx] 입니다.

----------------------------------------
(인터넷 검색/펌 포함)

특정 자리수 기준으로 정렬

-> 특정 자리수를 잘라와 맨 앞에 붙임

-> 맨 앞 자리 기준으로 정렬

-> 맨 앞 제거

List list = new LinkedList<>();

// 정수 n 기준 1글자 뽑기
// 뽑은 글자와 strings 결합
for (int i =0; i<strings.length; i++) {
  System.out.println(strings[i].charAt(n) + strings[i]); //?
  list.add(strings[i].charAt(n) + strings[i]);
}

// 정수 n 기준 정렬
Collections.sort(list);

String[]  answer = new String[list.size()];

// strings[i].charAt(n)를 자르고 완전한 단어로 출력
for (int i=0; i< list.size(); i++) {
  answer[i] = list.get(i).substring(1, list.get(i).length());
}
return answer;

K번째수 

문제 설명

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면
1.array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
2.1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
3.2에서 나온 배열의 3번째 숫자는 5입니다.

배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항
•array의 길이는 1 이상 100 이하입니다.
•array의 각 원소는 1 이상 100 이하입니다.
•commands의 길이는 1 이상 50 이하입니다.
•commands의 각 원소는 길이가 3입니다.

입출력 예

array                         commands                         return

[1, 5, 2, 6, 3, 7, 4]     [[2, 5, 3], [4, 4, 1], [1, 7, 3]]     [5, 6, 3] 

입출력 예 설명

 [1, 5, 2, 6, 3, 7, 4]를 2번째부터 5번째까지 자른 후 정렬합니다. [2, 3, 5, 6]의 세 번째 숫자는 5입니다.
 [1, 5, 2, 6, 3, 7, 4]를 4번째부터 4번째까지 자른 후 정렬합니다. [6]의 첫 번째 숫자는 6입니다.
 [1, 5, 2, 6, 3, 7, 4]를 1번째부터 7번째까지 자릅니다. [1, 2, 3, 4, 5, 6, 7]의 세 번째 숫자는 3입니다.

----------------------------------------
(인터넷 검색/펌 포함)

         int[] tmp = Arrays.copyOfRange(array, from-1, to);
        
         Arrays.sort(tmp);
        
         answer[i] = tmp[ord-1];

체육복 

문제 설명

점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.

전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.

제한사항
- 전체 학생의 수는 2명 이상 30명 이하입니다.
- 체육복을 도난당한 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
- 여벌의 체육복을 가져온 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
- 여벌 체육복이 있는 학생만 다른 학생에게 체육복을 빌려줄 수 있습니다.
- 여벌 체육복을 가져온 학생이 체육복을 도난당했을 수 있습니다. 이때 이 학생은 체육복을 하나만 도난당했다고 가정하며, 남은 체육복이 하나이기에 다른 학생에게는 체육복을 빌려줄 수 없습니다.

입출력 예

n     lost     reserve     return

5     [2, 4]   [1, 3, 5]   5 
5     [2, 4]   [3]         4 
3     [3]      [1]         2 

입출력 예 설명

예제 #1
 1번 학생이 2번 학생에게 체육복을 빌려주고, 3번 학생이나 5번 학생이 4번 학생에게 체육복을 빌려주면 학생 5명이 체육수업을 들을 수 있습니다.

예제 #2
 3번 학생이 2번 학생이나 4번 학생에게 체육복을 빌려주면 학생 4명이 체육수업을 들을 수 있습니다.

--------------------------------------------------

(인터넷 검색/펌 포함)

[1]

체육복을 도난당하고
도난 arr
여벌 체육복 arr

바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다

도난 arr loop

  앞, 뒤 번호를 구하고
  
  여벌 체육복 arr loop (값이 0 이상인 것만)
  
    번호가 동일하거나
      (해당 사항 있으면 값을 0 으로 셋팅 )     
    앞번호 같거나
      (해당 사항 있으면 값을 0 으로 셋팅 ) 
    뒷 번호 같은지
      (해당 사항 있으면 값을 0 으로 셋팅 ) 

=> sort 가 되어 있지 않은 arr 들어오면 답 틀려짐
    (예)
int n3 = 5;
int[] lost3 = {2, 3};
int[] reserve3 = {5, 3, 1}; // 3번은 빌려줄 수가 없음

lost 2 일 때 reserve 3 을 빌려 줌

--------------------------------------------------
[2]

ArrayList 만들고

해당 숫자 있으면 지움
    if (al_reserve.contains(val)) {
        al_reserve.remove( (Integer)val ); // 여분을 사용함
    ...
    앞 번호 포함?
    
    뒷 번호 포함?
 
=> 이 경우도 틀린 케이스 발생

    ----------
    n = 3, lost = [1,2], reserve = [2,3]
    답 : 2

    2번 학생이 1번학생을 빌려주고, 3번 학생이 2번 학생을 빌려주는 방식으로 풀면 3이 나와서 틀립니다.
    lost[1], reserve[3] 이렇게 만들고 푸는게 맞는 것 같습니다.
    ----------

--------------------------------------------------
[3]

// 여벌의 옷을 가지고 있으나 , 도난 당했을 경우 => 빌려줄 수 없다
// 먼저 처리해서 제외 시킴

=> 틀린 케이스 발생
reserve 이면서 도난 당했을 경우
먼저 제거 해주고
나머지 처리

빌려준 사람이 옷을 도난 당했으면 다른사람에게 못빌려줍니당
그 조건을 한번 적용해보세요 예를 들면
solution(5, new int[]{3,4}, new int[]{4,5})
4는 여별의 체육복이 있지만 잃어버려 빌려줄 수 없니다.
5가 아닌 4가 나와야합니당


solution(5, new int[]{4,5}, new int[]{3,4})
이 경우 참고 하시면 되실듯 합니다. 
4번 5번 이 lost 인데, 
3번 4번이 reserve 일 경우 4번은 꼭 자기가 가져온 reserve 를 사용하기에 
3번한테서 받지 않습니다. 그리고 4번의 reserve 는 5번에게 가지 않습니다.   

--------------------------------------------------
[4]

3번에서 틀렸던 이유는
-> reserve 이면서 도난 당했을 경우 
 reserve 에서만 제외 시킴
 lost 에서도 제외 시켜야 cnt 가 맞게 됨(1 차이 발생)

4번에서는 
    // 잃어버린 사람 중 여분의 옷을 가지고 있는 경우 먼저 처리
    // 뒤에서 부터 loop 필요 **
        // 양쪽 쌍으로 지워준다 **
    (sort 해서...)
    // 앞번호 부터 검색 후 처리    

모의고사

문제 설명
수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한 조건
시험은 최대 10,000 문제로 구성되어있습니다.
문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

입출력 예
answers return
[1,2,3,4,5] [1]
[1,3,2,4,2] [1,2,3]

입출력 예 설명
입출력 예 #1

수포자 1은 모든 문제를 맞혔습니다.
수포자 2는 모든 문제를 틀렸습니다.
수포자 3은 모든 문제를 틀렸습니다.
따라서 가장 문제를 많이 맞힌 사람은 수포자 1입니다.

입출력 예 #2

모든 사람이 2문제씩을 맞췄습니다.

--------------------------------------------------

(인터넷 검색/펌 포함)

[1]

정답지가 주어지고
시험보는 사람은 일정한 패턴으로 답을 함

5개 숫자를 반복해서 찍는다면
5개 넘을 때  %5 (나머지연산) 를 해줌
-> if ( answers[i] == p1[i%5] ) ans[0]++; // 5 반복에서 5번을 넘었을 경우

마지막으로 가장 득점이 높은 사람 선정
 

//Map 컬렉션 생성
Map<String, Integer> map = new HashMap<String, Integer>();

//객체 저장
map.put("신용권", 85);
map.put("홍길동", 90);
map.put("동장군", 80);
map.put("홍길동", 95); // "홍길동" 키가 같기 때문에 마지막에 저장한 값으로 대치
System.out.println("총 Entry 수: " + map.size());

//객체 찾기
System.out.println("\t홍길동 : " + map.get("홍길동"));
System.out.println();

//객체를 하나씩 처리
Set keySet = map.keySet(); // Key set 얻기
Iterator keyIterator = keySet.iterator();
while(keyIterator.hasNext()) {
  String key = keyIterator.next();
  Integer value = map.get(key);
  System.out.println("\t" + key + " : " + value);
}
System.out.println();

//객체 삭제
map.remove("홍길동");
System.out.println("총 Entry 수: " + map.size());

//객체를 하나씩 처리
Set<Map.Entry<String, Integer>> entrySet = map.entrySet(); // Entry Set 얻기
Iterator<Map.Entry<String, Integer>> entryIterator = entrySet.iterator();
while(entryIterator.hasNext()) {
  Map.Entry<String, Integer> entry = entryIterator.next();
  String key = entry.getKey();
  Integer value = entry.getValue();
  System.out.println("\t" + key + " : " + value);
}
System.out.println();

//객체 전체 삭제
map.clear();
System.out.println("총 Entry 수: " + map.size());

// List A 에 포함된 요소 B 에서 제거
String[] name1 = {"ABC", "CBB", "KKK"};
String[] name2 = {"ABC", "CBB"};

List listA = Arrays.asList(name1);
List listB = new ArrayList<>(Arrays.asList(name2));

//listA.remove("ABC");  // 이 경우 에러 발생 - java.lang.UnsupportedOperationException
listB.remove("ABC");

// for (String s : listB) {
// listA.remove(s);
// }
System.out.println(">" + listA);
System.out.println(">" + listB);

--------------------------------------------------

>[ABC, CBB, KKK]
>[CBB]