20230404 TIL
오늘은 자바 연산자, 조건문, 반복문, 배열, 및 컬렉션을 배웠다.
📋 연산자
- 연산자 : 덧셈, 뺄셈 처럼 계산할 기호 ➕
- 피연산자 : 연산자로 인해 계산되는 숫자 🔢
📌 연산자의 종류
| 종류 | 예시 | 설명 |
|---|---|---|
| 산술 연산자 | +, -, *, /, %, <<, >> | 사칙 연산과 비트연산 |
| 비교 연산자 | <, >, <=, >=, ==, != | 크고 작음과 같고 다름을 비교 |
| 논리 연산자 | &&, ㅣㅣ, ! | 그리고(AND)와 또는(OR) 으로 조건을 연결 |
| 대입 연산자 | =, ++, -- | 우변의 값을 좌변에 저장, 연산 복합 대입 |
| 기타 연산자 | (type), ? :, instance of | 형변환 연산자, 삼항 연산자, instance of 연산자 |
- 산술연산자 : 연산 결과 값 출력
// 사칙 연산
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, 나눗셈 (몫)
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- 비교 연산자 : boolean 값 (true, false) 출력
// 비교 연산자 (참이면 true, 거짓이면 false)
System.out.println(10 > 9); // 10 는 9 보다 크다 (true)
System.out.println(10 >= 9); // 10 는 9 보다 크거나 같다 (true)
System.out.println(10 < 9); // 10 는 9 보다 작다 (false)
System.out.println(10 <= 9); // 10 는 9 보다 작거나 같다 (false)
System.out.println(10 == 10); // 10 는 10 와 같다 (true)
System.out.println(10 == 9); // 10 는 9 과 같다 (false)
System.out.println(10 != 10); // 10 는 10 와 같지 않다 (false)
System.out.println(10 != 9); // 10 는 9 과 같지 않다 (true)- 논리 연산자 : 비교 연산의 결과값으로 받을 수 있는 boolean 값을 연결하는 연산자
// And 연산 (모든 피연산자가 true이면, true, 아니면 false )
System.out.println((5 > 3) && (3 > 1)); // 5 는 3 보다 크고, 3 은 1 보다 크다 (true)
System.out.println((5 > 3) && (3 < 1)); // 5 는 3 보다 크고, 3 은 1 보다 작다 (false)
// Or 연산 (피연산자 중 하나라도 true이면, true, 아니면 false )
System.out.println((5 > 3) || (3 > 1)); // 5 는 3 보다 크거나, 3 은 1 보다 크다 (true)
System.out.println((5 > 3) || (3 < 1)); // 5 는 3 보다 크거나, 3 은 1 보다 작다 (true)
System.out.println((5 < 3) || (3 < 1)); // 5 는 3 보다 작거나, 3 은 1 보다 작다 (false)
// 논리 부정 연산자 (반대 값)
System.out.println(!(5 == 5)); // false
System.out.println(!(5 == 3)); // true- 대입 연산자 : 변수를 바로 연산해서 그자리에서 저장하는 연산자
- 기본 연산자 : =
- 복합 연산자 : +=, -=, *=, /= ....
- 증감 연산자 : ++, -- (피연산자 뒤에 붙이냐, 앞에 붙이냐에 따라서 연산순서가 달라진다)
//대입 기본 연산자
int number = 10;
number = number + 2;
System.out.println(number); // 12
number = number - 2;
System.out.println(number); // 10
number = number * 2;
System.out.println(number); // 20
number = number / 2;
System.out.println(number); // 10
number = number % 2;
System.out.println(number); // 0
//대입 복합 연산자
number = 10;
number += 2;
System.out.println(number); // 12
number -= 2;
System.out.println(number); // 10
number *= 2;
System.out.println(number); // 20
number /= 2;
System.out.println(number); // 10
number %= 2;
System.out.println(number); // 0
// 대입 증감 연산자
int a = 10;
int b = 10;
int val = ++a + b--; // a 는 연산전에 +1, b 는 연산후에 -1
System.out.println(a); // 11
System.out.println(b); // 9
System.out.println(val); // 21
// 11 + 9 가 왜 21 나오는 이유
// a 는 val 연산전에 ++ 가 수행되어서 11로 연산되었지만
// b 는 val 연산후에 -- 가 수행되어서 기존값이 10으로 연산된 후 -- 가 수행되었다.
// 따라서 연산된 a값인 11과 연산되기전 b값인 10이 더해져서 21이 된것이다.-
기타 연산자
-
형변환 연산자 : (type)
int intNumber = 93 + (int) 98.8; // 93 + 98 double doubleNumber = (double) 93 + 98.8; // 93.0 + 98.8 -
삼향 연산자 : 비교 연산의 결과값에 따라 응답할 값을 직접 지정할 수 있는 연산자
// 삼항 연산자 (조건문) ? (참 결과) : (거짓 결과) 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) ? x : y; System.out.println(min); // 1
-
🥇 연산자 우선순위
연산자 우선순위 : 괄호 안에 있는 연산 > 산술 > 비교 > 논리 > 대입 📌 산술변환
두 피연산자의 타입을 같게 일치시킨다. (둘중에 저장공간 크기가 더 큰 타입으로 일치) short x = 10;
int y = 20;
int z = x + y; // 결과값은 더 큰 표현타입인 int 타입의 변수로만 저장할 수 있습니다.
🧿 비트 연산
Bit의 자리수를 옮기는 것 // 참고, 3의 이진수값은 11(2) 입니다. 12의 이진수값은 1100(2) 입니다.
// (2) 표기는 이 숫자가 이진수값이라는 표식 입니다.
System.out.println(3 << 2);
// 3의 이진수값인 11(2) 에서 왼쪽으로 2번 옮겨져서 1100(2) 인 12값이 됩니다.
System.out.println(3 >> 1);
// 3의 이진수값인 11(2) 에서 오른쪽으로 1번 옮겨져서 1(2) 인 1 값이 됩니다.📋 조건문, 반복문
특정 조건에 따라 다른 연산을 수행하고싶을때 조건문을 사용합니다.
특정 조건에 따라 반복해서 동일한 연산을 수행하고 싶을때 반복문을 사용합니다.
📌 조건문
- if 문
- if (조건) {연산} : if 의 소괄호() 안의 조건이 boolean 값 true 를 만족하면 중괄호 {} 안의 연산을 수행합니다.
- if (조건) {연산} - else {연산} : if 의 소괄호() 안의 조건이 boolean 값 false 를 만족하면 else 의 중괄호 {} 안의 연산을 수행합니다.
- if (조건) {연산}-else if(조건) {연산} : else if 의 소괄호() 안의 조건이 boolean 값 true 를 만족하면 else if 의 중괄호 {} 안의 연산을 수행합니다.
- 중첩 if (조건) : if 안에 if 문
// if 조건문
boolean flag = true;
int number = 2;
if (flag) {
if (number == 1) {
System.out.println("flag 값은 true, number 값은 1 입니다."); // 미출력
} else if (number == 2) {
System.out.println("flag 값은 true, number 값은 2 입니다."); // 출력
}
}
else {
if (number == 1) {
System.out.println("flag 값은 false, number 값은 1 입니다."); // 미출력
} else if (number == 2) {
System.out.println("flag 값은 false, number 값은 2 입니다."); // 미출력
}
}- switch / case 문 : 가독성이 좋은 조건문 표현식
switch (피연산자) { case(조건): (연산) }- case(조건): (연산) 은 여러개를 설정할 수 있고 각 case 의 연산문 마지막에는 break; 를 꼭 넣는다.
- switch문 중괄호 안의 제일 마지막에 default: (연산) 을 명시해주어 case 조건들이 모두 만족하지 않을때 수행할 연산을 정해주어야한다. 단, 없다면 생략해도 된다.
// switch/case 문
int month = 8;
String monthString = "";
switch (month) {
case 1: monthString = "1월";
break;
case 2: monthString = "2월";
break;
case 3: monthString = "3월";
break;
case 4: monthString = "4월";
break;
case 5: monthString = "5월";
break;
case 6: monthString = "6월";
break;
case 7: monthString = "7월";
break;
case 8: monthString = "8월";
break;
case 9: monthString = "9월";
break;
case 10: monthString = "10월";
break;
case 11: monthString = "11월";
break;
case 12: monthString = "12월";
break;
default: monthString = "알수 없음";
}
System.out.println(monthString); // 8월 출력if문과, switch문을 같이 사용해도 된다.
📌 반복문
- for 문
- for (초기값; 조건문; 증가연산) { (연산) } 형태로 사용
- 초기값이 조건문을 만족할때까지 (연산)을 수행하면서 회차마다 증가연산을 수행
// for 문
for(int i=0; i < 4; i++) { // 변수 i 값은 0 ~ 3 까지 반복
System.out.println(i + "번째 출력"); // i 변수와 문자열 합치기
}
// 출력
0번째 출력
1번째 출력
2번째 출력
3번째 출력- 향상된 for 문
- for ((변수 타입) (변수 명) : 목록변수) { (연산) } 형태로 사용
- 향상된 for 문은 연속된 변수목록을 출력할때 사용
- 변수 타입 과 변수 명 은 for 문안에서 연산을 수행할 변수를 정의
// 향상된 for 문
int[] numbers = {3,6,9,12,15};
for(int number: numbers) {
System.out.print(number + " ");
}
// 출력
3 6 9 12 15- while 문 / do-while 문
- 초기값 없이 조건문만 명시하여 반복
- while
- while(조건문) { (연산) } 형태로 사용
- 조건문을 만족해야지만 연산이 반복수행
- while(조건문) { (연산) } 형태로 사용
- do-while
- do { (연산) } while(조건문) 형태로 사용
- 최초 1회 연산수행 후 조건문을 체크하여 더 반복할지 결정
- do { (연산) } while(조건문) 형태로 사용
// while 문
int number = 0;
while(number < 3) {
number++;
System.out.println(number + "출력");
}
// 출력
1출력
2출력
3출력
// do-while 문
int number = 4;
do {
System.out.println(number + "출력");
} while(number < 3); // 연산을 한번 수행 후 조건문 체크
// 출력
4출력❌ break, ✔ continue
- break : 가장 가까운 블럭의 for 문 또는 while 문을 중단한다.
- continue : for 문 또는 while 문에서 해당 순서를 패스하고 싶을때 continue 명령을 사용
// break 명령
int number = 0;
while(number < 3) {
number++;
if (number == 2) {
break; // 2일때 반복 중단
}
System.out.println(number + "출력");
}
// 출력
1출력
// continue 명령
int number = 0;
while(number < 3) {
number++;
if (number == 2) {
continue; // 2일때 반복 패스
}
System.out.println(number + "출력");
}
// 출력
1출력
3출력📋 배열/자료구조
여러개의 변수를 분류통 같은곳에 모아서 저장하고 사용하고 싶을 때 사용한다.
📌 배열
📍 선언
-
타입[]변수;ex.
int[] intArray; -
타입변수[];ex.
int intArray[];
📍 생성
new타입[];
ex.new int[];- 분류통(배열)은 생성될때 각 타입별 초기값으로 초기화 되어 채워집니다.
- 예를들어, int 는0, boolean 은false, String 은null값과 같은 초기값이 정해져 있습니다.
📍 순회
변수들을 하나씩 꺼내서 사용하는것
- 단건 조회
- 배열에는 순번이 있고 해당 순번을 통해 하나의 값을 조회
- 해당 배열변수 뒤에 순번을 대괄호 []로 감싸서 명시
- 배열 순회
- 반복문 안에서 단건 조회헀던것처럼 대괄호 [] 안에 반복문 순번값 i 를 넣어준다.
// 배열 생성
int[] intArray = new int[3]; // {0, 0, 0}
boolean[] boolArray = new boolean[3]; // {false, false, false}
String[] stringArray = new String[3]; // {"", "", ""}
// 배열 선언 먼저 -> 나중에 초기화 가능
int [] intArray2;
intArray2 = new int[3]; // {0, 0, 0}
// 생성한 배열을 '순회' -> 배열의 값을 하나씩 뽑아서 조회한다.
// (1) 단건 조회
System.out.println(intArray[1]);
// (2) 다건 조회
// .length : 길이를 구하는 메서드
for (int i = 0; i<intArray2.length; i++) {
System.out.println(intArray2[i]);
}📍 초기화
- 중괄호{} 를 사용해서 초기화
- 반복문 for문을 사용해서 초기화 (또는 향상된 for문)
- Arrays.fill 메소드를 사용해서 초기화
// 배열 초기화
//1. 배열에 특정값 대입하며 선언
int[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"a", "b", "c", "d"};
//2-1. for문을 통해 값을 대입
for (int i = 0; i < intArray.length; i++) {
intArray[i] = i;
}
//2-2. 향상된 for문을 통한 배열 출력
for (int i : intArray) {
System.out.print(i); // 01234
}
//3. 배열의 주소를 모두 같은값으로 초기화
Arrays.fill(intArray, 1);//배열의 모든 값을 1로 초기화
for (int i : intArray) {
System.out.print(i); // 11111
}📍 배열 복사
- 얇은 복사
주소값만 복사되고 실제값은 1개로 유지되는 것 - 깊은 복사
실제 값을 가지고 있는 배열의 기본형 값을 꺼내서 복사
// 깊은 복사 메서드
// 1. clone() 메서드
int[] a = { 1, 2, 3, 4 };
int[] b = a.clone(); // 가장 간단한 방법이다.
// 하지만, clone() 메서드는 2차원이상 배열에서는 얕은 복사로 동작합니다.
// 2. Arrays.copyOf() 메서드
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); // 배열과 함께 length값도 같이 넣어주어야한다.
}
}📌 String 배열
문자열 = 문자배열
String = char[]
String을 더 많이 쓰는 이유는 참조형 변수가 더 많은 기능들을 가지고 있기 때문이다.
// String 기능 활용하기
String str = "ABCD";
// length()
int strLength = str.length();
System.out.println(strLength); // 4 출력
// charAt(int index)
char strChar = str.charAt(2); // 순번은 0부터 시작하니까 2순번은 3번째 문자를 가리킵니다.
System.out.println(strChar); // C 출력
// substring(int from, int to)
String strSub = str.substring(0, 3); // 0~2순번까지 자르기 합니다. (3순번은 제외)
System.out.println(strSub); // ABC 출력
// equals(String str)
String newStr = "ABCD"; // str 값과 같은 문자열 생성
boolean strEqual = newStr.equals(str);
System.out.println(strEqual); // true 출력
// toCharArray()
char[] strCharArray = str.toCharArray(); // String 을 char[] 로 변환
// 반대로 char[] 를 String로 변환하는 방법
char[] charArray = {'A', 'B', 'C'};
String charArrayString = new String(charArray); // char[] 를 String 으로 변환📌 다차원 배열
📍 선언, 생성
1차원 배열에 대괄호를 하나더 추가
- 선언 :
타입[][]변수,타입변수[][];
ex.int[][] intArray;,int intArray[][]; - 생성 :
new타입[][]
ex.new int[][];
📍 초기화
- 중괄호{} 를 사용해서 선언과 동시에 초기화
- 반복문 for문을 사용해서 초기화
// 중괄호를 사용해 초기화
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;
}
}💻 가변배열
행마다 다른 길이의 배열을 저장할 수 있는 배열
// 가변 배열
// 선언 및 초기화
int[][] array = new int[3][];
// 배열 원소마다 각기다른 크기로 지정 가능합니다.
array[0] = new int[2];
array[1] = new int[4];
array[2] = new int[1];
// 중괄호 초기화할때도 원소배열들의 크기를 각기 다르게 생성 가능합니다.
int[][] array2 = {
{10, 20},
{10, 20, 30, 40},
{10}
};📋 컬렉션
배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 많이 가지고 있다.
📌 컬렉션의 종류
- List : 순서가 있는 데이터의 집합 (데이터 중복 허용) - 배열과 비슷
- Set : 순서가 없는 데이터의 집합 (데이터 중복 허용 안함) - 순서없고 중복없는 배열
- Queue : - 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합
- First In First Out : 먼저들어간 순서대로 값을 조회할 수 있다.
- Map : 순서가 없는 (Key,Value) 쌍으로 이루어진 데이터의 집합 (Key값 중복 허용 안함)
📌 LIST
- ArrayList : 배열(Array)처럼 일렬로 데이터를 저장하고 조회하여 순번값(인덱스)로 값을 하나씩 조회할 수 있습니다.
- 배열(Array)처럼 크기가 정해져 있지않고 필요할때마다 크기가 점점 더 늘어납니다.
// ArrayList
// (사용하기 위해선 import java.util.ArrayList; 를 추가해야합니다.)
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> intList = new ArrayList<Integer>(); // 선언 및 생성
intList.add(1);
intList.add(2);
intList.add(3);
System.out.println(intList.get(0)); // 1 출력
System.out.println(intList.get(1)); // 2 출력
System.out.println(intList.get(2)); // 3 출력
System.out.println(intList.toString()); // [1,2,3] 출력
intList.set(1, 10); // 1번순번의 값을 10으로 수정합니다.
System.out.println(intList.get(1)); // 10 출력
intList.remove(1); // 1번순번의 값을 삭제합니다.
System.out.println(intList.toString()); // [1,3] 출력
intList.clear(); // 전체 값을 삭제합니다.
System.out.println(intList.toString()); // [] 출력
}
}- LinkedList : 메모리에 남는 공간을 요청해서 여기저기 나누어서 실제값을 담아놓고, 실제값이 있는 주소값으로 목록을 구성하고 저장합니다.
- 기본적인 기능은 ArrayList 와 동일하지만 LinkedList 는 값을 나누어 담기 때문에 모든값을 조회하는 속도가 느립니다. 대신에, 값을 중간에 추가하거나 삭제할때는 속도가 빠릅니다.
// LinkedList
// (사용하기 위해선 import java.util.LinkedList; 를 추가해야합니다.)
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<Integer> linkedList = new LinkedList<>(); // 선언 및 생성
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
System.out.println(linkedList.get(0)); // 1 출력
System.out.println(linkedList.get(1)); // 2 출력
System.out.println(linkedList.get(2)); // 3 출력
System.out.println(linkedList.toString()); // [1,2,3] 출력 (속도 느림)
linkedList.add(2, 4); // 2번 순번에 4 값을 추가합니다.
System.out.println(linkedList); // [1,2,4,3] 출력
linkedList.set(1, 10); // 1번순번의 값을 10으로 수정합니다.
System.out.println(linkedList.get(1)); // 10 출력
linkedList.remove(1); // 1번순번의 값을 삭제합니다.
System.out.println(linkedList); // [1,4,3] 출력
linkedList.clear(); // 전체 값을 삭제합니다.
System.out.println(linkedList); // [] 출력
}
}- Stack : 값을 수직으로 쌓아놓고 넣었다가 빼서 조회하는 형식으로 데이터를 관리 합니다. (Last-In-First-out)
- 최근 저장된 데이터를 나열하고 싶거나 데이터의 중복처리를 막고싶을때 사용합니다.
// Stack
// (사용하기 위해선 import java.util.Stack; 를 추가해야합니다.)
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Stack<Integer> intStack = new Stack<Integer>(); // 선언 및 생성
intStack.push(1);
intStack.push(2);
intStack.push(3);
while (!intStack.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intStack.pop()); // 3,2,1 출력
}
// 다시 추가
intStack.push(1);
intStack.push(2);
intStack.push(3);
// peek()
System.out.println(intStack.peek()); // 3 출력
System.out.println(intStack.size()); // 3 출력 (peek() 할때 삭제 안됬음)
// pop()
System.out.println(intStack.pop()); // 3 출력
System.out.println(intStack.size()); // 2 출력 (pop() 할때 삭제 됬음)
System.out.println(intStack.pop()); // 2 출력
System.out.println(intStack.size()); // 1 출력 (pop() 할때 삭제 됬음)
while (!intStack.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intStack.pop()); // 1 출력 (마지막 남은거 하나)
}
}
}📌 Queue
- Queue : 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합 입니다.
- First In First Out : 먼저들어간 순서대로 값을 조회할 수 있다.
Queue는 생성자가 없는 껍데기라서 바로 생성할수는 없습니다. 그래서 생성자가 존재하는 클래스인LinkedList를 사용하여Queue를 생성해서 받을 수 있습니다.
// Queue
// (사용하기 위해선 java.util.LinkedList; 와 import java.util.Queue; 를 추가해야합니다.)
import java.util.LinkedList;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
Queue<Integer> intQueue = new LinkedList<>(); // 선언 및 생성
intQueue.add(1);
intQueue.add(2);
intQueue.add(3);
while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intQueue.poll()); // 1,2,3 출력
}
// 다시 추가
intQueue.add(1);
intQueue.add(2);
intQueue.add(3);
// peek()
System.out.println(intQueue.peek()); // 1 출력 (맨먼저 들어간값이 1 이라서)
System.out.println(intQueue.size()); // 3 출력 (peek() 할때 삭제 안됬음)
// poll()
System.out.println(intQueue.poll()); // 1 출력
System.out.println(intQueue.size()); // 2 출력 (poll() 할때 삭제 됬음)
System.out.println(intQueue.poll()); // 2 출력
System.out.println(intQueue.size()); // 1 출력 (poll() 할때 삭제 됬음)
while (!intQueue.isEmpty()) { // 다 지워질때까지 출력
System.out.println(intQueue.poll()); // 3 출력 (마지막 남은거 하나)
}
}
}📌 Set
- Set : 순서가 없는 데이터의 집합 (데이터 중복 허용 안함) - 순서없고 중복없는 배열
- 순서가 보장되지 않는 대신 중복을 허용하지 않도록 유지
Set는 생성자가 없는 껍데기라서 바로 생성할수는 없습니다. 그래서 생성자가 존재하는 클래스인HashSet를 사용하여Set를 생성해서 받을 수 있습니다.
// Set
// (사용하기 위해선 import java.util.Set; 와 java.util.HashSet; 를 추가해야합니다.)
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(1);
intSet.add(2);
intSet.add(3);
intSet.add(3); // 중복된 값은 덮어씁니다.
intSet.add(3); // 중복된 값은 덮어씁니다.
for (Integer value : intSet) {
System.out.println(value); // 1,2,3 출력
}
// contains()
System.out.println(intSet.contains(2)); // true 출력
System.out.println(intSet.contains(4)); // false 출력
// remove()
intSet.remove(3); // 3 삭제
for (Integer value : intSet) {
System.out.println(value); // 1,2 출력
}
}
}📓 Set의 종류
- Hashset : 가장 빠르며 순서를 전혀 예측할 수 없음
- TreeSet : 정렬된 순서대로 보관하며 정렬 방법을 지정할 수 있음
- LinkedHashSet : 추가된 순서, 또는 가장 최근에 접근한 순서대로 접근 가능
보통 HashSet 을 쓰는데 순서보장이 필요하면 LinkedHashSet 을 주로 사용
📌 Map
- Map : key-value 구조로 구성된 데이터를 저장할 수 있습니다.
- key 값을 기준으로 vlaue를 조회할 수 있습니다.
- key 값 단위로 중복을 허용하지 않는 기능을 가지고 있습니다.
// Map
// (사용하기 위해선 import java.util.Map; 를 추가해야합니다.)
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); // 중복 Key값은 덮어씁니다.
intMap.put("삼", 15); // 중복 Key값은 덮어씁니다.
// key 값 전체 출력
for (String key : intMap.keySet()) {
System.out.println(key); // 일,이,삼 출력
}
// value 값 전체 출력
for (Integer key : intMap.values()) {
System.out.println(key); // 11,12,15 출력
}
// get()
System.out.println(intMap.get("삼")); // 15 출력
}
}📓 Map의 종류
- HashMap : 중복을 허용하지 않고 순서를 보장하지 않음 , 키와 값으로 null이 허용
- TreeMap : key 값을 기준으로 정렬을 할 수 있습니다. 다만, 저장시 정렬(오름차순)을 하기 때문에 저장시간이 다소 오래 걸림
📓 오늘 느낀 점 한줄 요약
"자바의 숲으로!" 🏃♂️
20230404 TIL
매일 매일 성장하자