TIL(Today I Learned)
: 매일 저녁, 하루를 마무리하며 작성 !
: ⭕ 지식 위주, 학습한 것을 노트 정리한다고 생각하고 작성하면서 머리 속 흩어져있는 지식들을 정리 !
Java 문법 종합반
2주차 : 연산자, 조건문, 반복문, 배열, 컬렉션-----------------------
- 계산 하기 (연산자)
-
연산자와 피연산자에 대한 이해
-
연산자 종류
- 산술 연산자 : + - * / % << >> : 사칙 연산과 비트연산
- 비교 연산자 : > < >= <= == != : 크고 작음과 같고 다름을 비교
- 논리 연산자 : && || ! :그리고(AND)와 또는(OR) 으로 조건을 연결
- 대입 연산자 : = ++ —- : 우변의 값을 좌변에 저장, 연산 복합 대입
- 기타 연산자 : (type) ? : instance of : 형변환 연산자, 삼항 연산자, instance of 연산자
- 연산자 우선순위
- 산술 > 비교 > 논리 > 대입
- 산술 변환
// 산술변환
public class Main {
public static void main(String[] args) {
short x = 10;
int y = 20;
int z = x + y; // 결과값은 더 큰 표현타입인 int 타입의 변수로만 저장할 수 있습니다.
long lx = 30L;
long lz = z + lx; // 결과값은 더 큰 표현타입인 long 타입의 변수로만 저장할 수 있습니다.
float fx = x; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
float fy = y; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
float fz = z; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다.
System.out.println(lz);
System.out.println(fx);
System.out.println(fy);
System.out.println(fz);
}
}- 비트 연산 :
<<(왼쪽으로 자릿수옮기기),>>(오른쪽으로 자릿수옮기기)
- 0,1 은 2진수 값이기 때문에,
- 자릿수를 왼쪽으로 옮기는 횟수만큼 2의 배수로 곱셈이 연산되는 것과 동일
- 자릿수를 오른쪽으로 옮기는 횟수만큼 2의 배수로 나눗셈이 연산되는 것과 동일
- 문맥 만들기 (조건문, 반복문)
- 만약에 : 조건문 - if, switch
- if 문
// 조건문 with else if
int number = 2;
if (number == 1) {
System.out.println("number 값은 1 입니다."); // 미출력
} else if (number == 2) {
System.out.println("number 값은 2 입니다."); // number 값은 2 입니다. 출력
} else {
System.out.println("number 값은 모르는 값입니다."); // 미출력
}
// 중첩 조건문
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 입니다."); // 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문
// 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월 출력```- 계속 : 반복문 - for, while, do-while
- for 문
// for 문
for(int i=0; i < 4; i++) { // 변수 i 값은 0 ~ 3 까지 반복
System.out.println(i + "번째 출력"); // i 변수와 문자열 합치기
}
// 향상된 for 문
int[] numbers = {3,6,9,12,15};
for(int number: numbers) {
System.out.print(number + " ");
}
// 만약 기존 for 문으로 구현한다면?
int[] numbers = {3,6,9,12,15};
for(int i = 0; i < numbers.length; i++) { // 배열에 .length 를 붙이면 길이값이 응답됩니다.
System.out.println(numbers[i]);
}- while 문, do-while 문
// while 문
int number = 0;
while(number < 3) {
number++;
System.out.println(number + "출력");
}
// do-while 문
int number = 4;
do {
System.out.println(number + "출력");
} while(number < 3); // 연산을 한번 수행 후 조건문 체크
- break 명령
// break 명령
int number = 0;
while(number < 3) {
number++;
if (number == 2) {
break; // 2일때 반복 중단
}
System.out.println(number + "출력");
}
- continue 명령
// continue 명령
int number = 0;
while(number < 3) {
number++;
if (number == 2) {
continue; // 2일때 반복 패스
}
System.out.println(number + "출력");
}```
- 분류통으로 정리하기 (배열)
- 배열
- 선언
// 배열 선언
// 일반적인 선언방식
int[] intArray; // 정수 배열
long[] longArray;
double[] doubleArray; // 실수 배열
char[] charArray; // 문자 배열
String[] stringArray; // 문자열 배열
// 배열 선언
// 2번째 선언방식
int intArray[]; // 정수 배열
long longArray[];
double doubleArray[]; // 실수 배열
char charArray[]; // 문자 배열
String stringArray[]; // 문자열 배열- 생성
// 배열 생성
//배열 생성후 초기화하면 배열의 주소가 할당된다.
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}- 순회
// 배열 단건조회
int[] intArray = new int[3]; // 모두 0으로 초기화된 사이즈8의 배열 생성
// 배열에서 2번쨰 순번의 값을 출력해본다. (0부터 순번이 시작하므로 2번째 순번은 1)
System.out.println(intArray[1]);
//길이가 8인 정수배열 선언
int[] intArray = new int[3];
// 배열이 초기화된 값을 출력해본다.
for(int i=0; i<intArray.length; i++) { // .length 는 배열의 길이
System.out.println(intArray[i]);
}
- 초기화
// 배열 초기화
import java.util.Arrays; // Arrays 클래스를 import 해주세요!
public class Main {
public static void main(String[] args) {
//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
}
System.out.println(); // 줄바꿈
//3. 배열의 주소를 모두 같은값으로 초기화
Arrays.fill(intArray, 1);//배열의 모든 값을 1로 초기화
for (int i : intArray) {
System.out.print(i); // 11111
}
}
}
// 출력
01234
11111- 복사 ( .clone())
// 얕은 복사
int[] a = { 1, 2, 3, 4 };
int[] b = a; // 얕은 복사
b[0] = 3; // b 배열의 0번째 순번값을 3으로 수정했습니다. (1 -> 3)
System.out.println(a[0]); // 출력 3 <- a 배열의 0번째 순번값도 3으로 조회됩니다.
// 깊은 복사 메서드
// 1. clone() 메서드
int[] a = { 1, 2, 3, 4 };
int[] b = a.clone(); // 가장 간단한 방법입니다.
// 하지만, clone() 메서드는 2차원이상 배열에서는 얕은 복사로 동작합니다!!
// 깊은 복사 메서드
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
// 2. Arrays.copyOf() 메서드
int[] a = { 1, 2, 3, 4 };
int[] b = Arrays.copyOf(a, a.length); // 배열과 함께 length값도 같이 넣어줍니다.
}
}
- String 배열
- 선언, 생성, 초기화
// String 배열을 아래와 같이 선언과 생성할 수 있습니다.
String[] stringArray = new String[3];
// 선언 후 하나씩 초기화 할 수 있습니다.
String[] stringArray = new String[3];
stringArray[0] = "val1";
stringArray[1] = "val2";
stringArray[2] = "val3";
// 선언과 동시에 초기화 할 수 있습니다.
String[] stringArray1 = new String[]{"val1", "val2", "val3"};
String[] stringArray2 = {"val1", "val2", "val3"};
- 다차원 배열
- 2차원 배열(2열 배열), 순회
// 중괄호를 사용해 초기화
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; // i, j 는 위 노란색 네모박스 안에있는 숫자를 의미하며 인덱스 라고 부릅니다.
}
}- 가변 배열
// 가변 배열
// 선언 및 초기화
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}
};
- 2차원 배열 이상의 다차원 배열 이해, 조회
// 3차원 배열의 이해
// 중괄호 3개를 써서 3차원 배열 초기화를 할 수 있습니다.
int[][][] MultiArray = {{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}};
// 가변 2차원 배열 조회
int[][] array = {
{10, 20, 30},
{10, 20, 30, 40},
{10, 20}
};
for (int i = 0; i < array.length; i++) { // 1차원 길이
for (int j = 0; j < array[i].length; j++) { // 2차원 길이
System.out.println(array[i][j]); // 2중 반복문으로 i, j 인덱스 순회
}
}
// 최대값 구하기
int[] arr = { 3, 2, 1, 5, 1 };
// 최대값 초기값 세팅
int max = arr[0];
// 최대값 구하기
for (int num : arr) {
if (num > max) { // 반복문 돌면서 나(max)보다 값이 작으면 저장
max = num;
}
}
// 최대값 5 출력
System.out.println(max);
// 최소값 구하기
int[] arr = { 3, 2, 1, 5, 1 };
// 최소값 초기값 세팅
int min = arr[0];
// 최소값 구하기
for (int num : arr) {
if (num < min) { // 반복문 돌면서 나(min)보다 값이 작으면 저장
min = num;
}
}
// 최소값 1 출력
System.out.println(min);
- 참조형 분류통으로 정리하기 (컬렉션)
- 컬렉션
- List : 순서가 있는 데이터의 집합 (데이터 중복 허용) - 배열과 비슷
- ArrayList
// 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
// 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
// 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 :- 빨대🥤처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합, First In First Out : 먼저 들어간 순서대로 값을 조회할 수 있다.
// 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
// (사용하기 위해선 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 출력
}
}
}- Map : 순서가 없는 (Key, Value) 쌍으로 이루어진 데이터의 집합 (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 출력
}
}학습법 특강
특강을 통해 올바른 학습법과 팁을 알아가기
야옹