🧮연산자

연산자 : 연산을 수행하는 기호 ( + / - / && / || 등)
피연산자 : 연산자의 연산 수행 대상

종류	연산자	설명
산술 연산자	+	덧셈
	-	뺄셈
	*	곱셈
	/	나눗셈
	%	나머지
	<<	왼쪽 시프트(비트연산자)
	>>	오른쪽 시프트(비트연산자)
비교 연산자	>	초과
	<	미만
	>=	이상
	<=	이하
	!=	같지 않음
논리 연산자	&&	그리고 (AND)
	||	또는 (OR)
	!	부정 (NOT)
대입 연산자	=	대입
	++	증가 (단항)
	--	감소 (단항)
기타 연산자	(type)	형 변환 (Type Cast)
	? :	조건부(삼항) 연산자
	instanceof	객체의 형식 비교 (Java 등에서 사용)

---

산술 연산자 ( +, -, *, /, %)

//사칙연산 : +, - , * , /, %
System.out.println(4 + 2); // 6
System.out.println(4 - 2); // 2
System.out.println(4 * 2); // 8
System.out.println(4 / 2); // 2
System.out.println(5 / 2); // 2 int / int = int 의 결과를 반환한다. 따라서, 몫 부분만 반환해 준다.
System.out.println(5 / 2.0); // 2.5 int / double = double 의 결과 반환
System.out.println(2 / 4); // 0
System.out.println(4 % 2); // 0 : % -> 나머지 연산자는 나누고 난 후 몫이 아닌 나머지 값을 반환 해준다.
System.out.println(5 % 2); // 1

// 우선순위 연산 (연산의 우선순위 : () > *,/,%  >  +,- )
System.out.println(2 + 2 * 2); // 6
System.out.println((2 + 2) * 2); // 8
System.out.println(2 + (2 * 2)); // 6

나누기 연산자 / : 위 예시에서 int / int 의 경우 int의 결과값을 반환하기 때문에 몫 부분만 반환해준다.
나머지 연산자 - % : 나머지 연산자는 나누고 난 후 나머지 값을 반환해 준다.
연산자 우선순위 : () > *, /, % > +, - 와 같이 우선적으로 계산 된다.

---

비교 연산자 ( >, <, >=, <=, ==, !=)

비교연산자 : 두 피연산자를 비교해서 true(참) 또는 false(거짓)을 반환

// 대소 비교 연산자  예제
System.out.println(10 > 9); // true
System.out.println(10 >= 9); // true
System.out.println(10 < 9); // false
System.out.println(10 <= 9); // false

대소비교연산자	연산결과
>	좌변 값이 크면 true 아니면 false
<	좌면 값이 작으면 true 아니면 false
>= (기호순서주의! =>는 xxx)	좌변 값이 크거나 같으면 true 아니면 false
<= (기호순서주의!)	좌변값이 작거나 같으면 true 아니면 false

등가비교 연산자 : ==, !=

// 등가 비교 연산자  예제
System.out.println(10 == 10); // true
System.out.println(10 == 9); // false
System.out.println(10 != 10); // false
System.out.println(10 != 9); // true

등가비교연산자	연산결과
==	두 값이 같으면 true 아니면 false
!= (기호순서 주의!)	두 값이 다르면 true 아니면 false

---

논리 연산자 ( &&, ||, !)

논리연산자 : &&, ||

• 조건식을 연결할 때 사용하는 연산자
• || (OR 결합) : 피연산자 중 한 쪽이 true 이면 true
• && (AND 결합) : 피연산자 양 쪽 모두 true 이여야만 true

boolean flag1 = true;
boolean flag2 = true;
boolean flag3 = false;

//피 연산자 중 하나라도 true 이면 true -> or 조건
System.out.println(flag1 || flag2); // true || true -> true
System.out.println(flag1 || flag2 || flag3); // true || true || false -> true
System.out.println((5 > 3) || (3 > 1)); // true || true -> true
System.out.println((5 > 3) || (3 < 1)); // true || false -> true
System.out.println((5 < 3) || (3 < 1)); // false || false -> false
        
// 피 연산자 모두 true 이면 true -> and 조건
System.out.println(flag1 && flag2); // true || true -> true
System.out.println(flag1 && flag2 && flag3); // true || true || false -> false
System.out.println((5 > 3) && (3 > 1)); // true && true -> true
System.out.println((5 > 3) && (3 < 1)); // true && false -> false

x	y	x || y	x && y
true	true	true	true
true	false	true	false
false	true	true	false
false	false	false	false

논리 부정 연산자 : ! (NOT)

• true를 false로, false는 true로 바꾼다.
• 단항연산자. (연산 진행방향 오→왼)

// 논리 부정  연산자(! : not)
System.out.println(!flag1); //!ture -> false
System.out.println(!flag3); //!false -> true
System.out.println(!(5 == 5)); //!true -> false
System.out.println(!(5 == 3)); //!false -> true

---

대입 연산자 ( = , op=)

대입연산자(=) : 오른쪽 피연산자의 값을 왼쪽 피연산자(저장공간)에 저장 후 저장된 값을 반환

number = number + 2; // 10 +2 -> 12
System.out.println(number); // 12

number = number - 2; // 12 - 2 -> 10
System.out.println(number); // 10

number = number * 2; // 10 * 2 -> 20
System.out.println(number); // 20

number = number / 2; // 20 / 2 -> 10
System.out.println(number); // 10

number = number % 2; // 20 % 2 -> 몫 : 10, 나머지 : 0
System.out.println(number); // 0

System.out.println("===========================");

복합 대입 연산자( op= ) : 대입 연산자와 다른 연산자를 하나로 축약한 형태. ex) +=, -=, *= ....

//복합 대입 연산자 : 대입연산자와 다른 연산자를 하나로 축약
number = 10;

number += 2; // number = number + 2 -> 10 +2 -> 12
System.out.println(number); // 12

number -= 2; // number = number - 2 -> 12 - 2 -> 10
System.out.println(number); // 10

number *= 2; // number = number * 2 -> 10 * 2 -> 20
System.out.println(number); // 20

number /= 2; // number = number / 2 -> 20 / 2 -> 10
System.out.println(number); // 10

number %= 2; // number = number % 2 -> 10 % 2 -> 몫 : 5, 나머지 : 0
System.out.println(number); // 0

---

증감 연산자 ( ++, --)

증가 연산자(++) : 피연산자의 값을 1 증가시킨다.
감소 연산자(--) : 피연산자의 값을 1 감소시킨다.

//증가 연산자
// number = number +1 ;
// number += 1;
number++; // 1, 위 형태가 축약 된 것

// number = number - 1;
// number -= 1;
number--;

// 증감 연산자, 주의사항!
int a = 10;
int b = 10;
// int val = ++a + b--; // a:11, b : 9 = 20 -> 기대값
// System.out.println(val); // val : 21
// 증가연산자(++), 감소연산자(--)가 전위에 있을때 : 증감 or 증가 후 식에 대입하여 계산
int val = ++a + b--; // a:11(증가 후 대입), b : 10(대입 후 감소) = 21

System.out.println("a :"+ a + ", b: "+b+", val: "+val); //a :11, b: 9, val: 21

타입	설명	사용예
전위형	값이 참조되기 전에 증가	j = ++i;
후위형	값이 참조된 후에 증가	j = i ++;

---

기타연산자

조건 연산자 : 조건식 ? 식1 : 식2 (삼항연산자)

• 조건식이 true -> 식1 대입, 조건식 false -> 식2 대입
  result = (x > y) ? x : y ; // 'x > y'의 결과가 true 이면 result=x, false 이면 result=y

// 삼항 연산자 -> 비교연산자와 항상 함께 쓰인다
// 비교연산자의 결과 : true or false -> 결과에 따라 결정되는 무언가
// 조건 ? 참 : 거짓
int x = 1;
int y = 9;

boolean b = (x == y) ? true : false;
System.out.println(b);// false

String s = (x != y) ? "정답" : "오답";
System.out.println(s); // 정답

int max = (x > y) ? x : y;
System.out.println(max); //9

int min = (x > y) ? y : x;
System.out.println(min); //1

형변환 연산자

// 형변환 연산자
int intNumber = 93 + (int) 98.8;//93+98 -> 191
System.out.println(intNumber);

double doubleNumber = (double) 93 + 98.8; //93.0 + 98.8 -> 191.8
System.out.println(doubleNumber);

---

산술 변환

산술 변환

• 두 피연산자의 타입을 같게 일치시킨다 (큰 타입으로 일치)
  • long + int → long + long → long (int<long)
  • float + int → float + float → float (int<float)
  • double + float → double + double → double (float<double)
• 피연산자의 타입이 int 보다 작은 타입이면 int로 변환
  • byte + short → int + int → int (byte,short < int)
  • char + short → int + int → int (char,short < int)

---

연산자 우선순위

• 산술 > 비교 > 논리 > 대입
• 괄호 연산이 최우선으로 계산
  

---

비트 연산자

• 피연산자를 비트단위로 논리연산
• 피연산자를 이진수로 표현하여 연산 수행
• 피연산자는 정수(문자포함)만 허용
  << : 왼쪽으로 자리수 옮기기 / 옮기는 횟수만큼 2의 배수로 곱셈이 연산
  >> : 오른쪽으로 자리수 옮기기 / 옮기는 횟수만큼 2의 배수로 나눗셈이 연산

System.out.println(3 << 2); //12
System.out.println(3 << 1); //6

---

🔁조건문과 반복문

조건문 - if, switch

• 조건식과 문장을 포함하는 블럭{ }으로 구성
• 조건을 만족할 때만 { }을 수행(0~1번)

---

if 문

• 조건식이 참(true)일 때, 괄호{ }안의 문장들을 수행한다.
• 조건식이 거짓일 경우 if문을 실행하지 않고 다음 문장으로 넘어간다.
• if문에 사용되는 조건식은 일반적으로 비교연산자와 논리연산자로 구성
• 조건식의 결과는 반드시 true 또는 false이어야 한다

if-esle 문

• 둘 중의 하나의 조건 처리를 할 때 사용.
• 조건식이 참일 때와 거짓일 때로 나눠서 처리

if (조건식) { 
	// 조건식이 참(true)일 때 수행될 문장
} else {
	// 조건식이 거짓(false)일 때 수행될 문장
}

if-else if문

• 여러 개 중의 하나 - 여러 개의 조건식을 포함한 조건식

if (조건식1) {
	// 조건식1 연산결과가 참일때 수행될 문장
} else if (조건식2) {
	// 조건식2 연산결과가 참일 때 수행될 문장
} else if (조건식3) {
	// 조건식2 연산결과가 참일 때 수행될 문장
} else { // 어느 조건도 만족하지 않을 때 수행될 문장.
} // 마지막은 보통 else 블럭으로 끝남, else 블럭은 생략 가능.

1. 결과가 참이 조건식을 만날 때까지 첫 번쩨 조건식부터 순서대로 평가
2. 참인 조건식을 만나면 해당 블럭의 문장을 수행
3. if-else if문 전체를 빠져나온다

중첩 if문 - if문 안의 if문

• if문 블럭 내에 또 다른 if문을 포함시키는 것.
• 중첩의 횟수에는 거의 제한이 없다.

if (조건식1) {
	// 조건식1이 true일 때 수행될 문장.
	if (조건식2) {
		// 조건식1과 2과 모두 true일 때 수행될 문장.
	} else { 
		// 조건식1이 true이고, 조건식2가 false일 때 수행되는 문장
	}
} else { 
	// 조건식1이 false일 때 수행되는 문장
}

//중첩if 예제_가위바위보

// A에게 값 입력받기
        System.out.println("A 입력 : ");
        String aHand = sc.nextLine();

        // B에게 값 입력받기
        System.out.println("B 입력 : ");
        String bHand = sc.nextLine();

        // 두 개의 값을 비교하는 메서드 -> Objects.equals(좌,우) : 좌,우가 같은경우 true, 다른경우 false 반환
        if (Objects.equals(aHand, "가위")) {
            if (Objects.equals(bHand, "가위")) {
                System.out.println("비겼습니다.");
            } else if (Objects.equals(bHand, "바위")) {
                System.out.println("b가 이겼습니다.");
            } else if (Objects.equals(bHand, "보")) {
                System.out.println("A가 이겼습니다.");
            } else {
                System.out.println("B가 이상한 값을 입력했습니다.");
            }
        } else if (Objects.equals(aHand, "바위")) {
            if (Objects.equals(bHand, "가위")) {
                System.out.println("A가 이겼습니다.");
            } else if (Objects.equals(bHand, "바위")) {
                System.out.println("비겼습니다.");
            } else if (Objects.equals(bHand, "보")) {
                System.out.println("B가 이겼습니다.");
            } else {
                System.out.println("B가 이상한 값을 입력했습니다.");
            }
        } else if (Objects.equals(aHand, "보")) {
            if (Objects.equals(bHand, "가위")) {
                System.out.println("B가 이겼습니다.");
            } else if (Objects.equals(bHand, "바위")) {
                System.out.println("A가 이겼습니다.");
            } else if (Objects.equals(bHand, "보")) {
                System.out.println("비겼습니다.");
            } else {
                System.out.println("B가 이상한 값을 입력했습니다.");
            }
        } else {
            System.out.println("A가 이상한 값을 입력했습니다.");
        }

---

switch 문

• 처리해야 하는 경우의 수가 많을 때 유용한 조건문
• break문 빼먹지 않도록 주의
• default문 : if문의 else블럭과 같은 역할. 생략가능. 보통 가장 마지막에 위치.

1. 조건식을 먼저 계산
2. 조건식의 결과와 일치하는 case문으로 이동
3. 이후의 문장들을 수행
4. break문이나 switch문의 끝을 만나면 switch문 전체를 빠져나간다.

if-else if 문 vs switch문

	if-else if 문	switch문
값	true, false만 가능	정수, 문자열 가능
	여러개의 조건식	조건식 한번만 계산
	{ } 계속 추가해줘야함	case문만 추가

switch문의 제약조건

• switch문의 조건식 결과는 정수 또는 문자열이어야 한다.
• case문의 값은 정수 상수(문자 포함). 문자열만 가능하면, 중복되지 않아야 한다.

//switch 예제

System.out.print("현재 월을 입력하세요.>");
		
Scanner scanner = new Scanner(System.in);
int month = scanner.nextInt();
		
switch(month) {
  case 3:
  case 4:	
  case 5:
    System.out.println("현재의 계절은 봄입니다.");
    break;
    
  case 6: 
  case 7: 
  case 8:
    System.out.println("현재의 계절은 여름입니다.");
    break;
			
  case 9: 
  case 10: 
  case 11:
    System.out.println("현재의 계절은 가을입니다.");
    break;
    
  default: // 앞에서 3~11까지의 값을 제외한 나머지 12,1,2가 default 값이 됨.
    System.out.println("현재의 계절은 겨울입니다.");
}

---

반복문 - for, while, do-while

• 조건을 만족하는 동안 { }를 수행(0~n번)

---

for문

• 조건을 만족하는 동안 블럭{ }을 반복 - 반복횟수를 알 때 적합
• for(초기값; 조건문; 증가연산){(연산)} 형태로 사용

 //for
for (int i = 0; i < 4; i++) {
	System.out.println(i + " 번째 출력");
}
/*
실행결과
0 번째 출력
1 번째 출력
2 번째 출력
3 번째 출력
*/

향상된 for 문

• 향상된 for 문은 연속된 변수목록을 출력할때 쓰입니다.
• for (변수 타입 변수 명 : 목록변수) { (연산) } 형태로 사용
• 변수 타입 과 변수 명 은 for 문안에서 연산을 수행할 변수를 정의

//향상된 for 문
int[] numbers = {3, 6, 9, 12, 15};
for (int number : numbers) { // number 가 numbers 만큼을 돌면서 for문을 짆애
	System.out.print(number + " "); // 3 6 9 12 15 
}
// for문으로 변경하면 동일한 값 출력
for (int i = 0; i < numbers.length; i++) {
	System.out.print(numbers[i] + " "); //3 6 9 12 15 
}

---

while문

• 조건을 만족시키는 동안 { }을 반복 - 반복횟수 모를 때
• while문과 for문은 항상 상호간 변경이 가능
• 조건식 생략 불가능
• while(조건식) {// 조건식이 참인동안 반복될 문장}

//for문 초기화, 조건식, 증감식
for(int i=1;i<=10;i++{
	System.out.pritln(i);
}

//while문
int i=1; //초기화

while (i<=10) { //조건식
	System.out.println(i);
	i++ //증감식
}

//결국 위 두개 for문과 while문은 같음

do-while문

• { }을 최소한 한 번 이상 반복(do구문) - 사용자 입력받을 때 유용(1~n번 반복)
• { }을 먼저 수행한 후에 조건식을 평가.
• do{//조건식이 참일때 수행될 문장} while();

int number = 4;
do {
	System.out.println(number + "출력");
} while (number < 3);
/*
실행결과 : 4출력
*/

---

break문

• 자신이 포함된 하나의 반목문을 벗어난다.

//break : 가장 가까운 블록의 for문 또는 while, switch 문을 중단
int number = 0;
while(number<3){
	number++;
	if(number==2){ // number ==2 가 되면 반복문을 탈출
		break;
	}
	System.out.println(number + "출력");
}
/*
실행결과
1출력
*/

continue 문

• 자신이 포함된 반복문의 끝으로 이동 - 다음 반복으로 넘어감
• 전체 반복 중에서 특정 조건시 반복을 건너뛸 때 유용

//continue : 건너뛰고 다음 반복을 수행
int number = 0;
while(number<3){
	number++;
	if(number==2){
		continue;
	}
	System.out.println(number + "출력");
}
/*
실행결과
1출력
3출력
*/

---

🗂️배열

• 같은 타입의 변수를 하나의 묶음으로 다루는 것(연속적이어야한다!!!)
• 한번에 많은 양의 데이터를 다루거나 계산할 때 사용

배열의 선언

//선언방법1 - 타입[] 변수이름;_JAVA에서 선호
//선언예
int[] score;
String[] name;

//선언방법2 - 타입[] 변수이름[];_주로 C언어에서 많이 사용
//선언예
int score[];
String name[];

배열의 생성

• 값을 저장할 수 있는 실제 저장공간을 생성
• 참조형 변수와 같이 new 명령을 통해 생성, 대괄호 안에 크기를 지정
• 배열은 생성 시 각 타입별 초기값으로 초기화 되어 채워진다.

//배열의 선언과 생성

타입[] 변수이름; // 배열을 선언(배열을 다루기 위한 참조변수 선언)
변수이름 = new 타입[길이]; // 배열을 생성(실제 저장공간을 생성)

int[] score; // int 타입의 배열을 다루기 위한 참조변수 score 선언
score = new int[5]; // int 타입의 값 5개를 저장할 수 있는 배열 생성

//인덱스 넘버 0 부터임!!!!!!!!! 인덱스 범위 0~4(0,1,2,3,4)

배열의 길이

• array.length : 배열의 길이 반환(int 형 상수)

배열의 초기화

• 배열의 각 요소에 처음으로 값을 저장하는 것

int[] score = new int[5]; //길이가 5인 배열을 생성
//각 요소에 직접 값을 저장
score[0]=50; 
score[1]=60;
score[2]=70;
score[3]=80;
score[4]=90;

//위 초기화를, for문을 이용해 초기화
for(int i=0; i< score.length; i++) // 일정한 규칙이 있는경우 가능
	score[i] = i*10+50;

//많이 쓰는 방법
int[] score=new int[]{50,60,70,80,90}; //배열의 생성과 초기화를 동시에
int[] score={50,60,70,80,90}; //new int[] 생략도 가능하며, 보통 많이 사용 하는 방법


// Arrays 클래스 이용
// 배열의 주소를 모두 같은 값으로 초기화
int[] intArr = {1, 2, 3, 4, 5};

Arrays.fill(intArr, 1); // 출력결과 : 1,1,1,1,1 모두 같은 값으로 초기화

for(int item: intArr){
	System.out.println(item);
}

배열의 출력/조회

1. for문을 사용하여 출력.
2. ‘Arrays.toString(배열이름)’ 메서드 사용하여 출력

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

// for문을 통해 출력
for(int i=0; i<intArr.length; i++){
    System.out.println(intArr[i]);
}

// 향샹된 for 문을 통한 출력
for(int item : intArr){
    System.out.println(item);
}

// Arrays 클래스 메서드 : 실행결과 [1, 1, 1, 1, 1] 배열 전체 출력해준다
System.out.println(Arrays.toString(intArr));

/*
for, 향상 for 실행결과 : 동일한 값 출력
1
2
3
4
5
*/

---

배열의 복사

얕은 복사 : 주소값만 복사되고 실제값은 1개로 유지되는 것(변수명은 다르지만 같은 값을 보고있다)

int[] a= {1,2,3,4};
int[] b = a; //얕은 복사

b[0] = 3; // 배열 b의 0번째 순번값을 3으로 수정(1->3)

System.out.println("a주소 : "+ a+" / b주소 : "+ b); //a주소 : [I@16b98e56 / b주소 : [I@16b98e56 주소값 동일한 것 알 수 있음
System.out.println(a[0]);// 출력 3 -> 배열 a의 0번째 순번값도 3으로 변경됨

깊은 복사 : 배열의 실제 값을 꺼내 복사해주는 것
1. for 문을 통한 복사
2. 메서드르 사용한 복사

// 1. for문을 이용한 복사
int[] arr = {1,2,3,4,5};
int[] tmp = new int[arr.length]; //복사할 배열의 길이와 같은 길이의 배열 생성

//배열 arr의 모든 요소에 저장된 값을 배열 tmp에 복사
for(int i=0; i<arr.length; i++) {
	tmp[i]=arr[i]; //깊은 복사
	}
    
b[0] = 3;

System.out.println(a[0]); // 출력 1 -> 깊은 복사 했기 때문에 a 배열 값 그대로 유지

// 2. 메서드를 사용한 배열의 복사
// Arrays.copyOf() 메서드를 통한 배열 복사
int[] a = {1,2,3,4};
int[] b = Arrays.copyOf(a, a.length); //배열과 함께 length값도 같이 넣어준다

a[3] = 0;
// 복사한 b 배열에 영향이 없는 것 확인, 깊은 복사가 되었다. 서로의 주소가 다르다.
System.out.println(a[3]); //0
System.out.println(b[3]); //4

---

String 배열과 메서드

String = char[] : 문자열은 문자의 배열!
**charAt(int index) : 해당 인덱스 char 타입 문자로 반환
length() : 문자열의 길이를 반환
substring(int from, int to) : 문자열의 해당 범위(from~to)의 문자열 반환(to 포함x)
equals(” ”) : (” ”)내용과 같은지 문자열의 비교
toCharArray() : 문자열을 char[] 으로 변환하여 반환

//String 기능 활용 예시
String str = "ABCD";

 //length -> string의 길이 반환
int strLength = str.length();
System.out.println(strLength);

//charAt(int index) -> 출력하고 싶은 글자 인덱스 char 로 반환
char strChar = str.charAt(1);
System.out.println(strChar);

//subString(int fromIdx, int toIdx) :  subString(시작인덱스, 끝인덱스(출력하고싶은글자뒤인덱스))
String strSub = str.substring(0,3);
System.out.println(strSub); // ABC

//equals(String str) -> true, false 반환
String newStr = "ABCD";
boolean strEqual = newStr.equals(str);
System.out.println(strEqual);

// toCharArray(0 : String -> char[]
char[] strCharArray = str.toCharArray();

// char[] -> String
char[] charArray = {'a', 'b','c'};
String charArrayString = new String(charArray);
System.out.println(charArrayString); // 문자열 abc 반환

---

//배열을 활용하여 최대,최소 구하기
int[] arr = {3, 2, 1, 5, 0};

// 최대값 초기화 세팅
int max = arr[0];
int min = arr[0];

// 최대값 구하기 로직
for(int num: arr){
	if(num>max){
		max = num;
	}else if(num < min){
		min = num;
		}
	}
System.out.println("최대값 : " + max+ " / 최소값 : "+ min); //최대값 : 5 / 최소값 : 0

---

다차원 배열

이차원 배열

• 테이블 형태의 데이터를 저장하기 위한 배열 (행x열 형태)

//2차원 배열의 초기화
int[][] arr=new int[][]{{1,2,3},{4,5,6}};
int[][] arr={{1,2,3},{4,5,6}}; // new int[][] 생략 가능. ->

int[][] arr = {
				{1,2,3},
				{4,5,6}
			}; // <- 보기 좋게 이렇게 많이 써줌 

int[][] score = {
				{100,100,100},
				{20,20,20},
				{30,30,30},
				{40,40,40}
				}; //이차원 배열 score의 선언과 초기화 동시

• 2차원배열 score 모습

score[0][0] = 100;	score[0][1] = 100;	score[0][2]=100;
score[1][0] = 20;	score[1][1] = 20;	score[1][2] = 20;
score[2][0] = 30;	score[1][1] = 30;	score[2][2] = 30;
score[3][0] = 40;	score[3][1] = 40;	score[3][2] = 40;

이차원 배열 예제

//가변 배열의 선언 
//int[][] score=new int[4][]; // 앞에 행 길이만 정해주고 뒤에 열 길이 안정해줘도 됨

int[][] score = { //각 행마다 열길이 달라도 됨
				{100,100,100,80}, // score[0]=new int[4];
				{20,20}, // score[1]=new int[2];
				{30}, // score[2]=new int[1];
				{40,40,40} // score[3]=new int[3];
				}; 

//이차원 배열의 합
int sum=0;

for (int i=0; i < score.length; i++){ //score.length = 행의 길이
	for(int j=0; j < score[i].lingth; j++){
		sum += socre[i][j]; // score[i]각 행의 열 요소들을 더해줌 그럼 이차원배열 score의 모든 요소 더하기 가능
		}
}
System.out.println("sum=" + sum);

---

Collection

컬렉션 기능 : 크기 자동조정 / 추가 / 수정 / 삭제/ 반복 / 순회 / 필터/ 포함확인 등...
컬렉션 종류 : List, Set, Queue, Map

• List : 순서가 있는 데이터의 집합 (데이터 중복을 허용) - 배열과 비슷

• Queue : 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합

  • FIFO구조(First In First Out : 먼저 들어간 순서대로 값 조회 할 수 있다)

• Set : 순서가 없는 데이터의 집합 (데이터 중복 허용 x) - 순서 x, 중복 x 인 배열 (집합으로생각)

• Map : 순서가 없는 (Key,Value) 쌍으로 이루어진 데이터의 집합 (Key값 중복 x)

Collection은 참조형 변수를 저장한다! (Wrapper class 변수~)

---

List

add(int index, Object element) : 인덱스에 객체 추가
set(int index, Object element) : 인덱스에 객체 저장.
get(int index) : 인덱스에 대한 객체 출력
remove(int index) : 인덱스에 저장된 객체 삭제
clear() : 리스트 전체 객체 삭제

ArrayList

• 데이터를 순차적으로 추가하거나 삭제하는 경우
• 데이터를 읽어들이는 경우 효율적이다

// List
        // 순서가 있는 데이터의 집합
        // 처음에 길이를 몰라도 만들 수 있다 (<-> array 최초의 길이를 알아야 한다)
        // array : 정적 배열
        // List(ArrayList) -> 동적배열(크기가 가변적으로 늘어난다)
        // - 생성 시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓는다.
        // - 값이 추가될 때 더 큰 공간이 필요하면 더 큰 공간을 받아서 저장하기때문에 상관 x

        // List 선언과 생성 동시에
        ArrayList<Integer> intList = new ArrayList<Integer>();

        // List에 값 추가 list.add(value); -> 추가한 순서대로 index에 저장된다
        intList.add(99);
        intList.add(15);
        intList.add(3);

        // List 값 가져오기 list.get(index);
        System.out.println(intList.get(0));

        // 2번째 있는 값을 변경, list.set(변경할index, 변경할value);
        System.out.println(intList.get(1));
        intList.set(1,50);
        System.out.println(intList.get(1));

        // list의 값 삭제, list.remove(index) -> index번째 값 삭제
        System.out.println(intList); //[99, 50, 3]
        intList.remove(1); // 50 삭제
        System.out.println(intList.get(1)); // 3 -> 50이 삭제 되어 3이 앞으로 당겨져서 index 1이 된 것 알 수 있음

        // 리스트 전체 값 삭제 : list.clear();
        System.out.println(intList);
        intList.clear();
        // ArrayList  클래스가 AbstractCollection 클래스를 상속하였기 때문에 toString() 메서드를 기본적으로 구현한다.
        System.out.println(intList.toString());

LinkedList

• 메모리에 남는 공간을 요청해서 여기저기 나누어서 실제 값을 담아둔다
• 기본 기능은 ArrayList와 동일
• 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조
• 조회 속도는 느리지만, 값의 추가 or 삭제 속도는 빠르다(데이터의 변경이 있을 때 사용하면 좋다)

LinkedList<Integer> linkedList = new LinkedList<Integer>();

        linkedList.add(5);
        linkedList.add(10);
        linkedList.add(3);

        System.out.println(linkedList.get(0));
        System.out.println(linkedList.get(1));
        System.out.println(linkedList.get(2));

        System.out.println(linkedList); // 조회속도는 현저히 느리다 -> 퍼저있는걸 가져와야 해서

        linkedList.add(200);
        System.out.println(linkedList);

        linkedList.add(2, 4);
        System.out.println(linkedList);

        linkedList.set(1,30);
        System.out.println(linkedList);

        linkedList.remove(1);
        System.out.println(linkedList);

        linkedList.clear();
        System.out.println(linkedList);

---

Stack

• 수직으로 값을 쌓아두고 넣었다가 뺀다. LIFO 구조(List In Fist Out)
• 상자에 물건을 쌓아 올리듯이 데이터를 쌓는 자료 구조
• 최근 저장된 데이터를 나열할 때, 데이터의 중복 처리를 막고 싶을 때 사용
  

Stack 주요 메서드

boolean empty() : Stack이 비어있는지 알려줍니다.

Object peek() : Stack의 맨 위에 저장된 객체를 반환합니다. (pop과 달리 Stack에서 객체를 꺼내지는 않습니다. 비어있을 경우 EmptyStackException이 발생합니다.)

Object pop() : Stack의 맨 위에 저장된 객체를 꺼냅니다. (비어있을 경우 EmptyStackException이 발생합니다.)

Object push(Object item) : Stack에 객체(item)를 저장합니다.

int search(Object o) : Stack에서 주어진 객체(o)를 찾아서 그 위치를 반환합니다. (못 찾을 경우 -1을 반환하며, 배열과 달리 위치는 0이 아닌 1부터 시작합니다.)

        //선언 및 생성
        Stack<Integer> intStack = new Stack<>();

        //.push(); -> 값을 밀어 넣는다
        intStack.push(10);
        intStack.push(15);
        intStack.push(1);

        //다 지워질 때 까지 출력한다
        while(!intStack.isEmpty()){
            //.pop() -> 데이터를 하나씩 뺀다
            System.out.println(intStack.pop()); //1 , 15, 10 순으로 출력 ( 최신 데이터 부터 출력 됨)
        }

        //다시 추가
        //.push(); -> 값을 밀어 넣는다
        intStack.push(10);
        intStack.push(15);
        intStack.push(1);

        // .peek
        System.out.println(intStack.peek()); // 1 출력 -> 가장 위에 있는 데이터 출력(가장 나중에 넣은)
        System.out.println(intStack.size()); // 3 출력 stack 의 길이 출력

---

Queue

• 선입선출 FIFO(First-In-First-Out) 구조
• 처음 들어온 원소가 가장 먼저 나간다
• 생성자가 없는 인터페이스이다.

boolean add(Object o) : 지정된 객체를 Queue에 추가하고 저장공간이 부족할 경우 IllegalStateException을 발생시킵니다.

Object remove() : Queue에서 객체를 꺼내 반환하며, 비어있을 경우 NoSuchElementException을 발생시킵니다.

Object element() : 삭제 없이 Queue의 요소를 읽어옵니다. 비어있을 경우 NoSuchElementException이 발생합니다.

boolean offer(Object o) : Queue에 객체를 저장합니다.

Object poll() : Queue에서 객체를 꺼내 반환하며, 비어있을 경우 null을 반환합니다.

Object peek() : 삭제 없이 Queue의 요소를 읽어옵니다. 비어있을 경우 null을 반환합니다.

        //Queue 선언, 생성
        Queue<Integer> intQueue = new LinkedList<>();

        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);

        while(!intQueue.isEmpty()){
            System.out.println(intQueue.poll()); //FIFO -> 1,5,9 순으로 출력 (처음 추가한 것 먼저 출력)
        }

        //다시 추가
        intQueue.add(1);
        intQueue.add(5);
        intQueue.add(9);
        intQueue.add(10);

        System.out.println(intQueue.peek()); // 1 출력 , -> 가장먼저 추가된 것 조회
        System.out.println(intQueue.size()); // 4 출력, -> queue의 길이 출력

---

Set

• 데이터 중복 x, 순서 x
• 순서가 없기 대문에 get() 메서드 미존재
  

Set 주요 메서드
boolean add(E e) : 주어진 객체를 저장

boolean contains(Object o) : 주어진 객체가 저장되어 있는지 여부를 확인.

Iterator<E> iterator() : 저장된 객체를 한 번씩 가져오는 반복자(Iterator)를 반환.

boolean isEmpty() : 컬렉션이 비어있는지 여부를 조사

int size() : 저장되어 있는 전체 객체 수를 반환합니다.

void clear() : 저장된 모든 객체를 삭제합니다.

boolean remove(Object o) : 주어진 객체를 삭제

        Set<Integer> intSet = new HashSet<>();

        intSet.add(1);
        intSet.add(12);
        intSet.add(5);
        intSet.add(9);
        intSet.add(1);
        intSet.add(12);

        for (Integer value: intSet){
            // 출력 : 1,5,9,12 -> set은 중복을 허용하지 않기 때문에 중복값이 존재하지 않는다.
            System.out.println(value);
        }

        // contains(value) -> return true or false 
        //(set 이 가지고 있는 요소들 중 () 안의 값이 있는지 확인하여 true or false 반환)
        System.out.println(intSet.contains(2)); // false
        System.out.println(intSet.contains(5)); // true

---

Map

• 키(Key)와 값(value)의 쌍으로 연관지어 이루어진 데이터의 집합
• 값(value)은 중복되서 저장될수 있지만, 키(key)는 해당 Map에서 고유해야만 한다.
• 만일 기존에 저장된 데이터와 중복된 키에 값을 저장하면 기존의 값은 없어지고 마지막에 저장된 값이 남게 된다.
• 저장 순서가 유지 되지 않는다

메서드	설명	구분
void clear()	Map의 모든 객체 삭제
boolean containsKey(Object Key)	지정된 Key 객체와 일치하는 Map의 Key 객체가 있는지 확인	검색
boolean containsValue(Object value)	지정된 value 객체와 일치하는 Map의 value 객체가 있는지 확인	검색
Set entrySet()	Map에 저장되어 있는 key-value 쌍을 Map.Entry 타입의 객체로 저장한 Set으로 반환한다.	읽기
boolean equals(Object o)	동일한 Map인지 비교
Object get(Object key)	지정한 key 객체에 대응하는 value 객체를 찾아서 반환	검색
int hashCode()	해시코드 반환
boolean isEmpty()	Map이 비어있는지 확인
Set keySet()	Map에 저장도니 모든 Key 객체 반환	읽기
Object put(Object key, Object value)	Map에 value객체를 key객체에 연결하여 저장	추가
void putAll(Map t)	지정된 Map의 모든 key-value 쌍 추가	추가
Object remove(Object key)	지정한 key 객체와 일치하는 key-value 객체를 삭제	삭제
int size()	Map에 저장된 key-value 쌍의 개수를 반환
Collection values()	Map에 저장도니 모든 value 객체를 반환	읽기

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

       //키 값
       intMap.put("일", 11);
       intMap.put("이", 12);
       intMap.put("삼", 13); //중복 key
       intMap.put("삼", 14); //중복 key
       intMap.put("오", 15);

       // key 값 전체 출력(향상된 for 문)
       for (String key: intMap.keySet()){
           System.out.println(key);
       }
       // value 값 전체 출력(향상된 for 문)
       for (Integer value: intMap.values()){
           System.out.println(value);
       }
       
       // key 로 value 찾아오기
       System.out.println(intMap.get("삼"));

---

흠...자료구조에 대해서 더 공부해야겠다.

(https://docs.oracle.com/javase/8/docs/api/java/util/Set.html)