| 핵심 키워드 | ||
| 1. if | 5. for | 9. 배열 |
| 2. if(조건)-else | 6. while | 10. 컬렉션 |
| 3. if(조건)-else if(조건) | 7. do-while | * 래퍼 클래스 |
| 4. switch/case | 8. break, continue | * 비트 연산 |
그 외 내용
| 11. Scanner sc = new Scanner.(System.in) |
어제 6번인 while 문 까지 정리를 했었고, 7번부터 다시 정리해보겠음!
7. do-while
- do-while 문으로 사용하면, 최초 1회 연산수행 후 조건문을 체크하여 더 반복할지를 결정
- 반복하게 된다면, 그 이후에는 한번 반복할 때마다 조건문을 체크해서 불만족(false)이면 반복을 중단
| do-while 구조 |
| do{ (연산) } while (조건문) |
8. break 와 continue
(1) break
- 깨부수다
- 가장 가까운 블록의 for 문 또는 while, switch 문을 중단
- 반복문 안에서 break; 형태로 사용
(2) continue
- for 문 또는 while 문에서 해당 순서를 패스하고 싶을 때 continue 명령을 사용
- 반복문 안에서 continue; 형태로 사용
(3) break 와 continue의 차이점?
9. 배열(Array)
| 타입[ ] 변수 = new 타입 [배열 크기를 지정]; |
- 배열은 분류통, 보따리 같은 것이다.
- 여러 개의 변수를 모아서 저장하고 싶을 때, 배열이라는 변수에 저장(표현)
- 여러 개의 값들을 한꺼번에 넣거나, 하나씩 넣을수도 있고, 꺼낼 때는 하나씩 꺼낼 수 있다.
- 배열은 영어로 Array
| (1) 선언 | (2) 생성 | (3) 순회 | (4) 초기화 | (5) 복사 |
(1) 선언
- int 와 같은 기본형 변수는 1개의 값만 변수에 저장할 수 있다면, int[ ]와 같은 배열형 변수는 여러 개를 변수에 저장할 수 있다.
- 여러 개를 하나의 변수에 넣고 들고 다니거나, 하나씩 꺼내서 쓸 수 있다는 점에서 분류통(보따리)의 개념과 비슷하다.
- 변수의 선언방법 (2가지)
1) 타입 [ ] 변수;
| 정수 배열 | 실수 배열 | 문자 배열 | 문자열 배열 | |
| int[ ] intArray; | long[ ] longArray; | double[ ] doubleArray; | char[ ] charArray; | String[ ] StringArray; |
2) 타입 변수 [ ];
| 정수 배열 | 실수 배열 | 문자 배열 | 문자열 배열 | |
| int intArray[ ] ; | long longArray[ ]; | double doubleArray[ ]; | char charArray[ ]; | String StringArray[ ]; |
(2) 생성
- new ㅁ[ ]; (ㅁ는 선언할 때 type으로 맞춰준다.)
- (좌측) 선언 = (우측) 생성;
- 배열(Array)은 참조형 변수들처럼, new 명령을 통해서 생성하며, 대괄호 [ ] 안에 크기를 지정해줍니다.
- 배열(보따리)을 만들 때, new 명령어로 생성하고, 배열(보따리)에 몇 개를 담을지 미리 정의해준다.
- 순번은 0번부터 시작한다. (8개 사이즈의 배열(보따리)이라면 0번~7번(8개)까지 있다.)
- 배열(보따리)은 생성될 때 각 타입별 초기값으로 초기화되어 채워진다.
( int 는 0 , boolean 은 false , String 은 null 값과 같은 초기값이 미리 정해져 있다. )
- 배열은 참조형 변수이기 때문에 실제 값을 담는 것이 아니라, 실제값의 주소값을 저장하고 있다.
( Stack영역 과 Heap 영역)
(예시) Int Array[ ] = new int[8];
배열의 크기는 8이다. (0번~7번)
타입은 int, 정수형이다.
(3) 순회
- 배열 안에 담겨 있는 변수들을 하나씩 꺼내서 사용하는 것을 순회라고 한다.
- 배열에는 순번이 있고, 순번을 통해 하나의 값을 조회할 수 있다.
- 단건조회와 다건조회
- 배열을 순회하는 방법은 반복문을 사용하는 것이 가장 일반적인 방법이다.
- 배열 순회에서 for 문을 사용하는 예시
| int[ ] intArray = new int[3]; | 선언 = 생성; intArray 라는 배열을 선언 new 를 통해서 배열을 생성 길이가 3인 정수배열 |
| for (int i=0; i<intArray.length; i++) { System.out.println(intArray[i]); } |
for (조건) { 연산 } 조건 = (초기값 ; 조건문 ; 증가연산) 조건문 = i < intArray.length; 변수 i 가 0부터 시작해서 intArray.length 인 3보다 작을 때까지 수행 증가연산 = i가 1씩 증가 연산 = intArray[i] 를 출력 |
| 0 0 0 |
출력 모두 초기값인 0으로 출력되는 것을 확인할 수 있다. |
| .length( ) 메서드 |
| length( ) 메서드는 배열이 지원하는 메서드로써 해당 배열의 값을 응답해준다. 배열의 길이는 처음에 선언한 크기를 가지고 있다. |
(4) 초기화
- 배열 = { ... }
1) 중괄호 { } 를 사용해서 초기화
2) 반복문 for 문을 사용해서 초기화 ( 또는 향상된 for 문을 사용 )
3) Arrays.fill 메서드를 사용해서 초기화
( Arrays 클래스는 Java에서 기본으로 제공하는 메서드가 담긴 클래스이다. )
| import java.util.Arrays; | java.util 이라는 클래스에 있는 Arrays 라는 메서드를 import (가져오다) 하겠다. |
| public class Main { public static void main(String[ ] args) { |
|
| int[ ] intArray = {1, 2, 3, 4, 5}; String[ ] stringArray = {"a", "b", "c", "d", "e"}; |
intArray 배열에 특정값을 대입하며 선언 stringArray 배열에 특정값을 대입하며 선언 |
| for (int i = 0; i < intArray.length; i++) { intArray[i] = i; } |
for (조건) {연산} 조건 = ( 초기값 ; 조건문 ; 증가연산 ) 조건문 = i 가 intArray 의 길이보다 작을 때 까지 for 문을 통해서 값을 대입 |
| for (int i : intArray) { System.out.print(i); } |
향상된 for 문 for ( 변수타입 변수명 : 목록변수 ) { 연산 } 01234 를 출력해준다. |
| System.out.println( ); | 줄바꿈 |
| Arrays.fill(intArray, 1); | 배열의 모든 값을 1로 초기화 |
| for (int i : intArray) { System.out.print(i); } |
향상된 for 문을 이용 11111 을 출력해준다. |
| } } |
| 01234 11111 |
출력 처음에 대입했던 값들을 출력 초기화를 통해 모두 1로 출력 |
| .fill( ) 메서드 |
| 배열의 주소를 모두 같은 값으로 초기화해준다. |
(5) 복사
| 얕은 복사 | 깊은 복사 |
1) 얕은 복사
- 배열은 참조형 변수이며, 실제값이 아닌 주소값을 저장한다.
- 배열 변수 간에 대입 연산자(=)를 이용해서 복사를 하게 되면, 주소값만 복사됨
| 주소값만 복사된다라는 의미란? |
| 주소값만 복사 된다는 것은 변수명은 서로 다르지만, 같은 값을 보고 있다는 것을 의미함 |
| int[ ] a = {1, 2, 3, 4, 5} int[ ] b = a; for (int i = 0; i < a.length; i++) { b[i] = a[i]; } b[0] = 3; System.out.println(a[0]); |
a 라는 배열에 특정값을 대입하여 선언 b 라는 배열을 선언하고, a를 대입 for ( 초기값; 조건문; 증가연산) { 연산 } b배열의 0번째 순번값을 3으로 수정 a배열의 0번째 순번값을 출력 |
| 3 | a 배열의 0번째 순번값도 3으로 조회됨 |
2) 깊은 복사
- 얕은 복사처럼 가짜 복사가 아니라, 진짜 새로운 배열을 만들고 싶을 때 깊은 복사를 한다.
- 깊은 복사는 결국 실제 값을 가지고 있는 배열의 기본형 값을 꺼내서 복사를 해주면 됨
- 반복문(for 문)을 통해서 하나씩 꺼내서 복사해주는 방법과 여러 메서드를 사용하는 방법이 있다.
| int[ ] a = {1, 2, 3, 4}; int[ ] b = new int[a.length]; for (int i = 0; i < a.length; i++) { b[i] = a[i]; } b[0] = 3; System.out.println(a[0]); |
a 라는 배열에 특정 값을 대입하여 선언 b라는 배열을 선언. new 를 통해서 배열의 길이가 a배열 만큼인 배열을 생성 for (초기값; 조건문; 증가연산) { 연산 } 연산 = a배열의 i번째 순번값을 b배열의 i번째 순번값에 대입한다. 3을 b배열의 0번째 순번값에 대입한다. a배열의 0번째 순번값을 출력한다. |
| 1 | 깊은 복사를 했기 때문에 a 배열은 그대로 1입니다. (3이 아님) |
- 깊은 복사 메서드의 2가지 방법
1) clone( ) 메서드
2) Arrays.copyOf( ) 메서드
| 1) clone( ) 메서드 | |
| 가장 간단한 깊은 복사 메서드 2차원 이상의 배열에서는 얕은 복사로 동작한다. |
|
| int[ ] a = {1, 2, 3, 4} int[ ] b = a.clone( ); |
a라는 정수형 배열에 특정값을 대입하여 선언 a배열(정수형)을 clone( ) 메서드를 사용해서 b배열(정수형)에 대입 |
| 2) Arrays.copyOf( ) 메서드 | |
| (ㅁ1,ㅁ2) ㅁ1 에는 배열이름을, ㅁ2 에는 해당 배열이 가지고 있는 길이를 넣어준다. 새로운 배열을 return 해줌 (함수로서 동작하기 때문) |
|
| import java.util.Arrays; public class Main{ public static void main(String[ ] args) { int [ ] a = {1, 2, 3, 4}; int [ ] b = Arrays.copyOf(a, a.length); |
java 라이브러리의 util 클래스에 있는 Arrays 라는 메서드를 import(가져오다)한다. a 라는 정수형 배열을 선언하고 생성 Arrays.CopyOf라는 메서드를 사용 a = 배열 이름 a.length = 배열의 길이 메서드를 사용해서 b라는 정수형 배열에 대입 |
(6) String 배열
- 기본형 변수와 참조형 변수
기본형 변수는 소문자로 시작하고, 참조형 변수는 대문자로 시작한다.
- Wrapper 클래스에서 기본형 변수를 감싸줌 (boxing)
int ⇒ Integer
- 기본형 변수는 값 자체를 저장, 참조형 변수는 별도의 공간에 값을 저장 후 그 주소를 저장한다. (주소형 변수)
| String 배열 선언과 생성 | |
| String[ ] stringArray = new String[3]; |
stringArray 라는 배열(문자열)을 선언 String은 문자열로써 참조형 변수이기 때문에 대문자로 시작한다. new 를 사용해서 String[3] 배열을 생성하고 이를 stringArray에 대입 stringArray = 길이가 3인 문자열 배열 |
- 문자열과 문자배열
~ String 은 문자열이고, char[ ] 은 문자배열이다.
~ String 에는 문자배열이 가지지 못하는 기능들이 존재한다.
- String 기능 활용
~ String 은 char 배열과 같기 때문에 둘다 문자열을 저장할 수 있는 변수이다.
~ 하지만, String 인 참조형 변수가 char 인 기본형 변수보다 더 많은 기능을 가지고 있기 때문에, String 을 더 많이 쓴다.
~ char 배열에는 없는 String 만 가지고 있는 기능을 살펴보자.
| 메서드 | 응답값 타입 | 설명 |
| length( ) | int | 문자열의 길이를 정수형으로 반환(return)해준다. |
| String str = "ABCD"; int strLength = str.length( ); |
str 이라는 문자열을 선언하고, ABCD를 str 변수(문자열)에 대입한다. str 이라는 문자열이 가진 길이를 strLength 라는 값(정수형)으로 반환해준다. |
|
| charAt(int index) | char | 문자열에서 해당 index의 문자를 문자형으로 반환 |
| String str = "ABCD"; char strChar = str.charAt(1); |
str 이라는 문자열의 index에서 1번째의 문자인 B 를 문자형으로 반환 괄호() 안에는 0부터 3까지 들어갈 수 있다. |
|
| substring(int from, int to) | String | 문자열에서 해당 범위 (from~to)에 있는 문자열을 반환한다 to 는 범위에 포함되지 않는다. ( from A to B : A <= ㅁ < B ) |
| String str = "ABCD"; String StrSub = str.substring(0, 3); |
str 이라는 문자열의 0번째부터 3번째 전까지의 문자열을 문자열로 반환해준다. 0,1,2 까지 이므로 ABC만 출력이 된다. |
|
| equals(String str) | boolean | 문자열의 내용이 같은지 확인한다. 같으면 결과는 true, 다르면 결과는 false가 된다. (boolean형) |
| String str = "ABCD"; String newStr = "ABCD"; boolean strEqual = newStr.equals(str) |
str (문자열)의 값과 같은 문자열인 newStr 을 문자열로 선언 및 생성 str (문자열)이 newStr (문자열)과 같기 때문에 true 를 반환 |
|
| String str = "ABCD"; String newStr1 = "ABCDE"; boolean strEqual = newStr1.equals(str) |
배열이 ABCDE 인 문자열인 newStr1 을 문자열로 선언 및 생성 str (문자열)이 newStr1 (문자열)과 다르기 때문에 false 를 반환 |
|
| toCharArray( ) | char[ ] | 문자열을 문자배열( char[ ] )로 반환해서 변환 |
| String str = "ABCD"; char[ ] strCharArray = str.toCharArray( ); |
str (문자열)을 strCharArray 라는 문자형(값)들로 이루어진 문자 배열로 변환해서 반환함 ( 반환한 배열의 이름이 strCharArray 이다. ) |
|
| new String(char[ ] charrArr) | String | 문자배열( char[ ] )을 받아서 String 으로 복사해서 반환 |
| char[ ] charArray = {'A', 'B', 'C'}; String charArrayString = new String(charArray); |
charArray 라는 문자배열(문자형 값들로 구성된 배열)을 선언 및 생성 charArray 라는 문자 배열을 문자열로 복사해서 새롭게 생성하고, 이 문자열을 charArrayString 이라는 변수(문자열)에 대입 |
|
(7) 다차원 배열
1) 2차원 배열 (2열 배열)
[1] 선언 : 1차원 배열에 대괄호[ ] 를 하나 더 추가한다.
~ 행렬 ( [행] [렬] )로 주소값이 저장된다.
| 선언 (3가지 방법) |
int[ ] [ ] array |
| int array[ ] [ ] | |
| int[ ] array [ ] |
[2] 생성 : 2차원 배열을 생성할 때에도 대괄호를 하나 더 추가하면 된다.
| int [ ] [ ] array = new int [ ] [ ]; |
[3] 초기화 :
| 중괄호{ } 를 사용해서 선언과 동시에 초기화 | |
| int [ ] [ ] array = {{1, 2, 3}, {4, 5, 6}}; | |
| 선언 및 생성을 한 이후에 반복문을 통해 초기화 | |
| int [ ] [ ] array = new int [2] [3]; for ( int i = 0; i < array.length; i++ ) { for ( int j = 0; j < array[i].length; j++ ) { arr [i] [j] = 0; } { |
array 라는 2차원 배열(정수형) 배열을 (2행)*(3렬)로 선언 for ( 초기값 ; 조건문 ; 증가연산 ) { 연산 } for 문( i ) 아래에 for 문( j )을 한번 더 사용 i는 행, j는 렬을 의미하며, 인덱스라고 부른다. |
[4] 가변 배열 :
- Java 프로그래밍에서는 2차원 배열을 생성할 때, 열의 길이를 생략하여, 행마다 다른 길이의 배열을 요소로 저장할 수 있다.
- 행마다 다른 길이의 배열을 저장할 수 있는 배열을 가변 배열 이라고 한다.
| 선언과 생성을 한 후에, 배열 원소마다 각기 다른 크기로 지정하여 초기화 | |
| int [ ] [ ] array1 = new int [3] [ ]; array1[0] = new int [2]; array1[1] = new int [4]; array1[2] = new int [1]; |
행의 크기가 3이고, 열을 지정하지 않은 2차원 배열인 array1 을 선언 및 생성 array1 의 0번째 행에 대하여 열의 크기를 2로 지정 array1 의 1번째 행에 대하여 열의 크기를 4로 지정 array1 의 2번째 행에 대하여 열의 크기를 1로 지 |
| 중괄호{ } 를 사용해 초기화 | |
| int [ ] [ ] array2 = { {10, 20}, {10, 20, 30, 40}, {10} }; |
2차원 배열인 array2 을 중괄호 { } 를 사용해 직접 인덱스를 초기화 |
| 가변 2차원 배열 조회 | |
| int [ ] [ ] array = { {10, 20, 30}, {10, 20, 30, 40}, {10, 20} }; for (int i = 0; i < array.length; i++) { for (int j = 0; j < array [ i ].length; j++) { System.out.println(array [ i ] [ j ] ); } } |
가변 2차원 배열인 array (정수형)를 선언 및 생성하고 중괄호 { } 를 사용해 초기화 for ( 초기값 ; 조건문 ; 증가연산 ) { 연산 } 행을 뜻하는 변수 i 의 조건문(for 문) 안에 열을 뜻하는 변수 j 의 조건문(for 문)을 넣는다. array (2차원 배열) 을 출력하고, 줄바꿈을한다. 조건을 만족할 때까지, 증가연산하며, for 문을 반복하여 연산(출력)한다. |
| 10 20 30 10 20 30 40 10 20 |
2) 다차원 배열 : 2차원 이상의 배열
- 대부분 3차원까지만 사용한다.
- 3차원 배열의 예시
int [ ] [ ] [ ] multiArray
~ 중괄호{ } 3개를 써서 초기화 가능
int [ ] [ ] [ ] multiArray = {{{1,2}, {3.4}}, {5,6}, {7,8}}};
- 다차원 배열 조회
~ 2차원 배열 조회 : 2중 반복문을 이용
| 최대값 구하기 | |
| int [ ] arr = { 3, 2, 1, 5, 1 }; int max = arr [0]; for (int num : arr) { if (num > max) { max = num; } } System.out.println(max); |
arr 이라는 배열(정수형)을 선언 및 생성하고 중괄호{ } 를 사용해 초기화 변수 max (정수형) 을 선언 및 생성하고, arr 배열의 0번째 값을 대입 ( max 의 초기값 세팅) 향상된 for 문 = ( 변수타입 변수명 : 배열 ) { 연산 } 변수 num(정수형)이 선언 및 생성됨 if 문 = (조건) { 연산 } 변수 max 가 arr 배열의 0번째 값으로 초기화되었고, max 값이 for 문을 통해 배열 전체를 반복 if 문을 통해, 변수 max 값보다 num 값이 크다면, max 변수에 num 값이 대입된다. 이를 for문이 끝날 때까지 반복한다. for 문이 종료된 후의 변수 max 값이 출력된다. |
| 최소값 구하기 | |
| int [ ] arr = { 3, 2, 1, 5, 1 }; int min = arr [0]; for (int num : arr) { if (num < min) { min = num; } } System.out.println(min); |
arr 이라는 배열(정수형)을 선언 및 생성하고 중괄호{ } 를 사용해 초기화 변수 min (정수형) 을 선언 및 생성하고, arr 배열의 0번째 값을 대입 ( min 의 초기값 세팅) 향상된 for 문 = ( 변수타입 변수명 : 배열 ) { 연산 } 변수 num(정수형)이 선언 및 생성됨 if 문 = (조건) { 연산 } 변수 min 이 arr 배열의 0번째 값으로 초기화되었고, min 값이 for 문을 통해 배열 전체를 반복 if 문을 통해, 변수 min 값보다 num 값이 작다면, min 변수에 num 값이 대입된다. 이를 for문이 끝날 때까지 반복한다. for 문이 종료된 후의 변수 min 값이 출력된다. |
10. 컬렉션 (참조형 보따리)
- Java 프로그래밍에서는 배열을 더 고도화시켜서 컬렉션이라는 이름으로 참조형 보따리(자료 구조)를 제공한다.
- 컬렉션은 참조형 변수만 저장함으로써 여러 많은 기능들을 제공해준다.
- 컬렉션에는 여러 종류가 있고, 컬렉션마다 데이터를 넣고 빼는 방법이 다르기 때문에 용도에 맞게 사용할 수 있다.
- 크기 자동조정 / 추가 / 수정 / 삭제 / 반복 / 순회 / 필터 / 포함 확인 등등
- List / Queue / Set / Map
| 자주 쓰는 참조형 변수 | ||
| int | 의 참조형 변수 | Integer |
| long | 의 참조형 변수 | Long |
| double | 의 참조형 변수 | Double |
| String | 은 원래부터 참조형 변수 | |
| (1) List | 순서가 있는 데이터의 집합 (데이터 중복 허용 ) - 배열과 비슷 |
| (2) Queue | 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합 (FIFO) |
| (3) Set | 순서가 없는 데이터의 집합 (데이터 중복 허용 X) |
| (4) Map | 순서가 없는 (Key, Value) 쌍으로 이루어진 데이터의 집합 (Key 값 중복 허용 안함. Key는 Unique |
(1) List
1) ArrayList
| Array | 정적배열 | 처음에 크기를 고정하여 생성한다. (정적배열) 초기화하려면 최초 길이를 알아야 한다. 기본형 변수로 저장한다. |
| ArrayList | 동적배열 | 크기가 가변적으로 늘어난다. (동적배열) 처음에 길이를 몰라도 만들 수 있다. 생성 시점에 작은 연속된 공간을 요청해서 참조형 변수들을 담아놓는다. 값이 추가될 때 더 큰 공간이 필요하면 더 큰 공간을 받아서 저장하니까 상관없다. 참조형 변수로 저장한다. |
| ArrayList 의 기능 | ||
| 선언 | ArrayList<Integer> intList | |
| 생성 | new ArrayList<Integer>( ); | |
| 값 불러오기 | intList.get( {가져올 순번} ) | |
| 초기화 | 사이즈를 지정하는 것이 없기 때문에 초기화가 필요없음 | |
| 값 추가 | intList.add( {추가할 값} ) | |
| 값 수정 | intList.set( {수정할 순번}, {수정할 값} ) | |
| 값 삭제 | intList.remove( {삭제할 순번} ) | |
| 전체 출력 | intList.toString( ) | 전체 값을 대괄호[ ] 로 묶어서 출력해준다. |
| 전체 제거 | intList.clear( ) | |
| import java.util.ArrayList; public class main { public static void main(String[ ] args) { ArrayList<Integer> intList = new ArrayList<Integer>( ); intList.add(99); intList.add(15); intList.add(3); |
java 라는 라이브러리의 util 클래스에서 ArrayList 라는 메서드를 import(가져오다) 하겠다. intList 라는 컬렉션을 선언 및 생성 ArrayList 라는 메서드를 사용 컬렉션은 참조형 변수만 저장하기 때문에 < > 안에는 int 가 아닌 래퍼클래스를 통해 참조형 변수로 만든 Integer 를 넣어 준다. 새로운 ArrayList<Integer>( ) 라는 함수를 new를 통해 생성했고, intList 에 대입 intList = 참조형 변수(정수형)으로 구성된 컬렉션 intList 에 99(정수형)라는 참조형 변수를 추가 intList 에 15(정수형)라는 참조형 변수를 추가 intList 에 3(정수형)이라는 참조형 변수를 추가 intList.add(ㅁ); = ㅁ 라는 참조형 변수(정수형)을 intList 라는 컬렉션에 추가하겠다는 뜻 |
| System.out.println(intList.get(0)); System.out.println(intList.get(1)); System.out.println(intList.get(2)); System.out.println(intList.toString( )); |
intList 컬렉션에서 0번째 값을 불러와서 출력 ( 99 를 출력 ) intList 컬렉션에서 1번째 값을 불러와서 출력 ( 15 를 출력 ) intList 컬렉션에서 2번째 값을 불러와서 출력 ( 3 을 출력 ) intList 컬렉션의 모든 값을 불러와서 출력 ( [99, 15, 3] 을 출력 ) |
| intList.set(1, 10); System.out.println(intList.get(1)); System.out.println(intList.toString( )); |
intList 컬렉션의 1번째 값을 10으로 수정 intList 컬렉션의 1번째 값을 불러와서 출력 ( 10을 출력 ) intList 컬렉션의 모든 값을 불러와서 출력 |
| intList.remove(1); System.out.println(intList.toString( )); |
intList 컬렉션에서 1번째 값을 삭제 intList 컬렉션에서 전체값을 출력 ( [ 99, 3] 을 출력 ) |
| intList.clear( ); System.out.println(intList.toString( )); |
intList 컬렉션에서 모든 값을 삭제 intList 컬렉션에서 모든 값을 출력 ( [ ] 출력 ) |
2) LinkedList
- 메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 담아 놓는다.
- 실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료 구조
- 기본적인 기능은 ArrayList 와 동일하다.
- ListedList 는 값을 여기저기 나누어서 저장하기 때문에 조회하는 속도가 느리지만,
값을 추가하거나, 삭제할 때 빠르다.
| LinkedList 의 기능 | ||
| 선언 | LinkedList<Integer> linkedList | |
| 생성 | new linkedList<Integer>( ); | |
| 값 불러오기 | linkedList.get( {가져올 순번} ) | |
| 초기화 | 사이즈를 지정하는 것이 없기 때문에 초기화가 필요없음 | |
| 값 추가 | linkedList.add( {추가할 값} ) | |
| 값 수정 | linkedList.set( {수정할 순번}, {수정할 값} ) | |
| 값 삭제 | linkedList.remove( {삭제할 순번} ) | |
| 전체 출력 | linkedList.toString( ) | 전체 값을 대괄호[ ] 로 묶어서 출력해준다. |
| 전체 제거 | linkedList.clear( ) | |
3) Stack
- Basket 구조
- 상자에 물건을 넣고 빼는 것처럼, 밑에서 위로 쌓고, 꺼낼 때는 위에서 부터 꺼낸다.
- 값을 수직으로 쌓아놓고 넣었다가 빼서 조회하는 형식
- 가장 나중에 들어간 것이 가장 먼저 나온다. ( LIFO, Last In First Out )
- 기능 : push (넣기), peek (조회), pop (꺼내기)
- 최근 저장된 데이터를 나열하고 싶거나, 데이터의 중복처리를 막고 싶을 때 사용한다.
| Stack 의 기능 | ||
| 선언 | Stack<Integer> intStack | |
| 생성 | new Stack<Integer>( ); | |
| 추가 ( push ) | intStack.push( {추가할 값} ) | |
| 조회 ( peek ) | intStack.peek( ) | 맨 위 값 (가장 최근에 넣은 값)을 조회 |
| 꺼내기 ( pop ) | intStack.pop( ) | 맨 위 값을 꺼냄 ( 꺼내고 나면 삭제됨 ) |
| 크기조회 (자료(값)의 개수) |
intStack.size( ) | intStack 의 크기를 반환(조회) |
| import java.util.Stack; public class main { public static void main(String[ ] args) { Stack intStack = new Stack( ); intStack.push(10); intStack.push(15); intStack.push(3) |
java 라는 라이브러리의 util 클래스에서 Stack 이라는 메서드를 import(가져오다) 하겠다. 정수형으로 래핑한 intStack 컬렉션을 선언 Stack 이라는 메서드를 사용 컬렉션은 참조형 변수만 저장하기 때문에 < > 안에는 int 가 아닌 래퍼클래스를 통해 참조형 변수로 만든 Integer 를 넣어 준다. 새로운 Stack( ) 이라는 함수를 new를 통해 생성했고, intList 에 대입 intStack 이라는 컬렉션에 10(정수형)이라는 자료값을 추가 intStack 이라는 컬렉션에 15(정수형)이라는 자료값을 추가 intStack 이라는 컬렉션에 3(정수형)이라는 자료값을 추가 |
| while (!intStack.isEmpty( )) { System.out.println(intStack.pop( )); } |
while 문 (반복문) = (조건) { 연산 } 반복할 때마다 조건을 체크해서, false 이면 { 연산 } 을 중단 (조건) 이 true 이 { 연산 } 을 수행 (조건) 이 false 이면 { 연산 } 을 중단 (조건) = !intStack.isEmpty( ) ! 이 있기 때문에 반대로 적용됨 intStack 이 비어있지 않다면 (조건이 true이면) { 연산 } 을 수행 intStack 이 비어있다면, (조건이 false) { 연산 } 을 중단 {연산} intStack 에서 가장 최근 자료(값)부터 꺼내고, ( 꺼낸 값들은 지워진다. ) 꺼낸 값을 출력 꺼낸 intStack 이 빈 컬렉션이 될 때까지 연산(출력)한다. |
| 3 15 10 |
|
| intStack.push(99); intStack.push(50); intStack.push(7); |
intStack 이 빈 컬렉션이 되었기 때문에 다시 값들을 추가 ( push( 추가할 값 )를 사용 ) |
| System.out.println(intStack.peek( )); System.out.println(intStack.size( )); |
intStack(컬렉션)의 맨 위 값(가장 최근에 넣은 값)을 조회 출력 (삭제되지 않는다.) intStack(컬렉션)의 크기를 조회하고 출력 |
| 7 3 // pop( ) 할 때 삭제됨 |
|
| System.out.println(intStack.pop( )); System.out.println(intStack.size( )); |
intStack(컬렉션)의 맨 위 값(가장 최근에 넣은 값)을 반환해주고 삭제함 intStack(컬렉션)의 크기를 조회하고 출력 |
| 7 2 |
|
| System.out.println(intStack.pop( )); System.out.println(intStack.size( )); |
intStack(컬렉션)의 맨 위 값(가장 최근에 넣은 값)을 반환해주고 삭제함 intStack(컬렉션)의 크기를 조회하고 출력 |
| 50 1 // pop( ) 할 때 삭제됨 |
|
| While (!intStack.isEmpty( )) { System.out.println(intStack.pop( )); } } } |
While 문 (반복문) = While ( 조건 ) { 연산 } 조건 = true 이면 {연산} 을 수행하고, 조건 = false 이면 반복을 중단하고, While 문을 빠져나온다. (조건) = intStack(컬렉션)이 비어있지 않다면, { 연산 } 을 수행 {연산} = intStack(컬렉션)의 가장 최근에 넣은 값을 반환해주고 삭제함 |
| 99 // 자료가 99 만 있어서, 99만 출력 |
| ㅁ.isEmpty( ) 메서드 |
| 현재 ㅁ 이라는 컬렉션이 비어있는지 아닌지를 boolean 값(t rue / false )으로 반환해준다. 비어있으면 true 를 반환, 비어있지 않으면 false 를 반환 |
(2) Queue
- 빨대처럼 한쪽에서 데이터를 넣고, 반대쪽에서 데이터를 뺄 수 있는 보따리(컬렉션)
- 제일 먼저 들어간 변수가 제일 먼저 조회가 됨 (FIFO, First In First Out)
- 생성자가 없는 인터페이스
| - 생성자가 존재하는 클래스인 LinkedList 를 사용하여 Queue 를 생성해서 받을 수 있다. | |
| Queue<Integer> intQueue = new LinkedList<Integer>( ); | 정수형으로 래핑한 Queue의 기능을 수행하는 intQueue 라는 컬렉션을 선언 new 라는 생성자를 통해 LinkedList(정수형) 컬렉션을 생성하고, intQueue 에 대입 ( Queue 가 부모이고, LinkedList 가 자식이기 때문이다. ) |
| Queue 의 기능 | ||
| 선언 | Queue<Integer> intQueue | |
| 생성 | new LinkedList<Integer>( ); | |
| 추가 ( push ) | intQueue.push( {추가할 값} ) | 값을 맨 위에 추가 |
| 조회 ( peek ) | intQueue.peek( ) | 맨 아래 값을 조회 |
| 꺼내기 ( poll ) | intQueue.pop( ) | 맨 아래 값을 꺼냄 ( 꺼내고 나면 삭제됨 ) |
| 크기조회 (자료(값)의 개수) |
intQueue.size( ) | intQueue 의 크기를 반환(조회) |
| import java.util.LinkedList; import java util.Queue; public class main { public static void main(String[ ] args) { Queue<Integer> intQueue = new LinkedList<Integer>( ); intQueue.add(99); intQueue.add(15); intQueue.add(3); |
java 라는 라이브러리의 util 클래스에서 LinkedList 라는 메서드를 import(가져오다) 하겠다. Queue 라는 메서드도 가져옴 정수형으로 래핑한 Queue의 기능을 수행하는 intQueue 라는 컬렉션을 선언 new 라는 생성자를 통해 LinkedList(정수형) 컬렉션을 생성하고, intQueue 에 대입 ( Queue 가 부모이고, LinkedList 가 자식이기 때문이다. ) intQueue 이라는 컬렉션에 99(정수형)이라는 자료값을 맨위에 추가 intQueue 이라는 컬렉션에 15(정수형)이라는 자료값을 맨위에 추가 intQueue 이라는 컬렉션에 3(정수형)이라는 자료값을 맨위에 추가 |
| while (!intQueue.isEmpty( )) { System.out.println(intQueue.poll( )); } |
while 문 (반복문) = while (조건) { 연산 } (조건) = !intQueue.isEmpty( ) !intQueue.isEmpty( ) = intQueue 라는 컬렉션(정수형) 이 비어있지 않다면, { 연산 } 을 수행 {연산} = System.out.println(intQueue.poll( )) = intQueue 라는 컬렉션(정수형)에서 맨 아래 값을 꺼내서 반환하고 삭제됨 while 문 = intQueue 라는 컬렉션(정수형)의 값들이 다 지워질 때까지 출력 |
| 99 15 3 |
|
intQueue.add(10); intQueue.add(20); intQueue.add(33); |
// 다시 intQueue 라는 컬렉션에 자료들을 추가 intQueue 이라는 컬렉션에 10(정수형)이라는 자료값을 맨위에 추가 intQueue 이라는 컬렉션에 20(정수형)이라는 자료값을 맨위에 추가 intQueue 이라는 컬렉션에 33(정수형)이라는 자료값을 맨위에 추가 |
| System.out.println(intQueue.peek( )); System.out.println(intQueue.size( )); |
intQueue 라는 컬렉션에서 맨 아래값을 조회하고 출력 intQueue 라는 컬렉션의 자료 크기를 반환하고 출력 |
| 33 3 // peek( ) 를 사용해도 값이 삭제되지 않는 것을 확인 |
|
| System.out.println(intQueue.poll( )); System.out.println(intQueue.size( )); |
intQueue 라는 컬렉션에서 맨 아래값을 꺼내고 (삭제됨) 출력 intQueue 라는 컬렉션의 자료 크기를 반환하고 출력 |
| 33 2 // poll( ) 를 사용하면 값이 삭제되는 것을 확인 |
|
| System.out.println(intQueue.poll( )); System.out.println(intQueue.size( )); |
intQueue 라는 컬렉션에서 맨 아래값을 꺼내고 (삭제됨) 출력 intQueue 라는 컬렉션의 자료 크기를 반환하고 출력 |
| 20 1 |
|
| while (!intQueue.isEmpty) { System.out.println(intQueue.poll( );); } } } |
while 문 = while (조건) { 연산 } intQueue 라는 컬렉션이 비워 질 때까지 자료값들을 아래에서부터 출력 |
| 10 |
(3) Set
- 순서가 없는 데이터의 집합 (데이터 중복 허용 안함)
- 순서없고 중복없는 배열
- Set 으로도 쓸 수 있지만, HashSet, TreeSet 등으로 응용하여 사용 가능
- Set 는 생성자가 없는 인터페이스여서 바로 생성할 수 없음
- 생성자가 존재하는 클래스인 HashSet 를 사용하여 Set 를 생성해서 받을 수 있다.
| Set ( HashSet ) 의 기능 | ||
| 선언 | Set<Integer> intSet | |
| 생성 | new HashSet<Integer>( ); | |
| 추가 ( add ) | intSet.add( {추가할 값} ) | 값을 맨 위에 추가 |
| 조회 ( get ) | intSet.get( {조회할 순번} ) | 순번에 있는 값을 조회 |
| 삭제 ( remove ) | intSet.remove( {삭제할 값} ) | 삭제할 값을 직접 지정 |
| 포함 확인 ( contains ) | intSet.contains( {포함 확인 값} ) | 해당값이 포함되어 있는지 boolean 값으로 반환 |
| HashSet 이외에도 TreeSet, LinkedSet 이 있다. | |
| HashSet | 가장 빠르며 순서를 전혀 예측할 수 없음 |
| TreeSet | 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 없음 |
| LinkedHashSet | 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능 |
| 보통 HashSet 을 쓰는데 순서 보장이 필요하면 LinkedHashSet 을 주로 사용한다. | |
| import java.util.HashSet; import java util.Set; public class main { public static void main(String[ ] args) { Set<Integer> intSet = new HashSet<Integer>( ); intSet.add(3); intSet.add(15); intSet.add(99); intSet.add(99); intSet.add(99); |
java 라는 라이브러리의 util 클래스에서 HashSet라는 메서드를 import(가져오다) 하겠다. Set 라는 메서드도 가져옴 정수형으로 래핑한 Set의 기능을 수행하는 intSet 라는 컬렉션을 선언 new 라는 생성자를 통해 HashSet(정수형) 함수를 생성하고, intQueue 에 대입 intSet 이라는 컬렉션에 3(정수형)이라는 자료값을 맨위에 추가 intSet 이라는 컬렉션에 15(정수형)이라는 자료값을 맨위에 추가 intSet 이라는 컬렉션에 99(정수형)이라는 자료값을 맨위에 추가 intSet 이라는 컬렉션에 99(정수형)이라는 자료값을 맨위에 추가 intSet 이라는 컬렉션에 99(정수형)이라는 자료값을 맨위에 추가 |
| for (Integer value : intSet) { System.out.println(value); } |
향상된 for 문 = ( 변수타입 변수명 : 배열 ) { 연산 } 변수타입 = 정수형 / 변수명 = value / 배열 = intSet { 연산 } 변수 (value) 값을 반환하고 출력 |
| 3 15 99 // 중복된 값을 덮어쓰인다. ( 데이터 중복 허용 X ) |
|
System.out.println(intSet.contains(15)); System.out.println(intSet.contains(4)); |
// intSet 이라는 컬렉션에 해당값( ) 이 포함되어있는지를 boolean 값으로 반환 intSet 라는 컬렉션이 15라는 값을 포함하고 있기에 true 반환 intSet 라는 컬렉션이 4라는 값을 포함하지 않기 때문에 false 반환 |
| true false |
|
| intSet.remove(3); | intSet 이라는 컬렉션에서 3이라는 값을 삭제 |
| for (Integer value : intSet ) { System.out.println(value) } } } |
향상된 for 문 = for (변수타입 변수명 : 배열 ) { 연산 } intSet 라는 컬렉션에서 값들을 변수 value 로 반환해서 출력 |
| 15 99 |
(4) Map
- 이전 컬렉션들은 value 값들만 넣어서 관리하는 자료구조 였지만, Map 은 key-value 구조로 구성된 자료구조
- key 값을 기준으로 value 를 조회할 수 있다. ( key - value pair)
- key 값 단위로 중복을 허용하지 않는다.
- Map 은 Map 자체로도 사용하지만, HashMap, TreeMap 등으로 응용하여 사용 가능
| Map (HashMap) 의 기능 | ||
| 선언 | Map<String, Integer> intMap | Key타입(문자열), Value타입(정수형)을 지정해서 선언 |
| 생성 | new HashMap< >( ); | |
| 추가 ( put ) | intMap.put( {추가할 key값}, {추가할 value 값 ) | 지정한 key에 value 값을 추가 |
| 조회 ( get ) | intMap.get( {조회할 key값} ) | key 에 있는 Value 값을 조회 |
| 전체 키 조회 | intMap.keySet( ) | 전체 key 값들을 조회 |
| 전체 value 조회 | intMap.values( ) | 전체 value 값들을 조회 |
| 삭제 | intMap.remove ( {삭제할 값} ) | key 에 있는 value 값을 삭제 |
| HashMap 이외에도 TreeMap 이 있다. | |
| HashMap | 중복을 허용하지 않고 순서를 보장하지 않음. 키와 값으로 null 이 허용 |
| TreeMap | key 값을 기준으로 정렬을 할 수 있지만 저장 시 정렬(오름차순)을 하기 때문에 저장시간이 다소 길다 |
| import java.util.Map; public class main { public static void main(String[ ] args) { Map<String, Integer> intMap = new HashMap< >( ); intMap.put("일", 11); intMap.put("이", 12); intMap.put("삼", 13); intMap.put("삼", 14); intMap.put("삼", 15) ; |
java 라는 라이브러리의 util 클래스에서 Map 이라는 메서드를 import(가져오다) 하겠다. 문자열과 정수형으로 래핑한 Map의 기능을 수행하는 intMap 이라는 컬렉션을 선언 new 라는 생성자를 통해 HashMap (문자열, 정수형) 함수를 생성하고, intMap 에 대입 // 중복된 키 값은 덮어쓴다. intMap 이라는 컬렉션에 일(문자열)이라는 key와 11이라는 value(정수형)을 추가 intMap 이라는 컬렉션에 이(문자열)이라는 key와 12이라는 value(정수형)을 추가 intMap 이라는 컬렉션에 삼(문자열)이라는 key와 13이라는 value(정수형)을 추가 intMap 이라는 컬렉션에 삼(문자열)이라는 key와 14이라는 value(정수형)을 추가 intMap 이라는 컬렉션에 삼(문자열)이라는 key와 15이라는 value(정수형)을 추가 |
| for (String key : intMap,keySet( )){ System.out.println(key); } |
향상된 for 문 = ( 변수타입 변수명 : 배열 ) { 연산 } 변수타입 = 문자열 / 변수명 = key 배열 = intMap.keySet( ) = intMap 이라는 컬렉션에 있는 keySet( ) { 연산 } = key 라는 변수를 반환하고 출력 (줄바꿈) |
| 일 이 삼 // 중복된 key 값은 덮어쓴다. |
|
for (Integer key : intMap.values( )){ System.out.println(key); } |
향상된 for 문 = ( 변수타입 변수명 : 배열 ) { 연산 } 변수타입 = 정수형 / 변수명 = intMap 배열 = intMap.values( ) = intMap 의 Value 값 모음 { 연산 } = value 변수를 반환하고 출력 (줄바꿈) |
| 11 12 15 // key 중복 허용이 안되기 때문에 삼(key) 에 해당하는 value 값은 마지막에 추가된 15로 덮어씀 |
|
| System.out.println(intMap.get("삼")); } } |
intMap(컬렉션)에서 "삼"(key)에 해당하는 value 값을 반환하고 출력 (줄바꿈) |
| 15 |
| 함수 비교 | ||
| length | length( ) | size( ) |
| 함수 비교 |
length | arrays(int[ ], double[ ], String[ ]) | length 라는 배열의 길이 값을 반환 |
| length( ) | String related Object(String, StringBuilder etc) | length( ) 는 문자열의 길이 값을 반환 (예) "ABCD".length( ) == 4 |
|
| size( ) | Collection Object(ArrayList, Set etc) | size( ) 는 컬렉션 타입 목록의 길이 값을 반환 |
*래퍼 클래스
- 기본형 변수를 클래스로 랩핑하는 변수
- 첫글자는 대문자
- 박싱과 언박싱
| 박싱 | 기본 타입에서 래퍼 클래스로 변수를 감싸는 것 |
| 언박싱 | 래퍼 클래스 변수를 기본 타입 변수로 가져오는 것 |
| Int number = 21; Integer num = new Integer(number); |
박싱 |
| number(정수형 변수)를 선언하고 21 을 대입 num 이라는 래퍼클래스를 선언 number 라는 클래스(정수형)를 생성하고 num 이라는 변수에 대입 num 은 래퍼클래스 (정수형)으로 생성됨 |
|
| int n = num.intValue( ); | 언박싱 |
| n(정수형 변수)를 선언 num(클래스)의 Value(변수) 값을 n에 대입(생성) |
*비트연산
- Bit 의 자리수를 옮기는 것
| << | 왼쪽으로 자리수 옮기기 | 자리수를 왼쪽으로 옮기는 만큼 2의 배수로 곱셈이 연산됨 |
| >> | 오른쪽으로 자리수 옮기기 | 자리수를 오른쪽으로 옮기는 만큼 2의 배수로 나눗셈이 연산됨 |