2023-04-04
연산자
연산자&피연산자
- 연산자 : 덧셈, 뺄셈 처럼 계산할 기호
- 피연산자 : 연산자로 인해 계산되는 숫자
int x = 5;
int y = 10;
int z = x + y; // 5(피연산자) +(연산자) 10(피연산자)종류
- 우선순위
산술 -> 비교 -> 논리 -> 대입
산술 연산자
- 사칙연산 및 비트연산을 포함함
+,-,*,/,%,<<,>>
- 산술변환
- 연산 전에 피연산자의 타입을 일치시키는 것
(둘 중에 저장공간 크기가 더 큰 타입으로 일치)
- 비트연산
- Bit : 0,1 둘 중에 하나의 값만을 저장하는 컴퓨터가 저장(표현)가능한 가장 작은 단위
- 비트연산 : Bit의 자리수를 옮기는 것
<<(왼쪽으로 자리수 옮기기),>>(오른쪽으로 자리수 옮기기)- 0,1 은 2진수 값이기 때문에
△ 자리수를 왼쪽으로 옮기는 횟수만큼 2의 배수로 곱셈이 연산되는 것과 동일함
△ 자리수를 오른쪽으로 옮기는 횟수만큼 2의 배수로 나눗셈이 연산되는 것과 동일함
비교 연산자
- 값의 크고 작음을 비교하거나, 같고 다름을 비교하여 참(true)/거짓(false) 값인 boolean값을 출력함
>,<,>=,<=,==,!=
논리 연산자
- 비교 연산의 결과값으로 받을 수 있는 boolean값을 연결하는 연산자
- 조건을 연결하였을 때의 boolean값들을 조합하여 참(true)/거짓(false) 값인 boolean값을 출력함
&&(AND = 피연산자 모두 참),
||(OR = 피연산자 둘 중 하나라도 참),
!(피연산자의 반대 boolean값)
대입 연산자
- 변수를 바로 연산해서 그 자리에서 저장하는 연산자
- 기본 대입 연산자 :
= - 복합 대입 연산자 :
+=,-=,*=등 ++:+= 1//--:-= 1
※ 주의할 점
++(피연산자), --(피연산자) 는 연산 전에 1이 더해지거나 뺌
(피연산자)++, (피연산자)-- 는 연산 후에 1이 더해지거나 뺌
기타 연산자
- 형변환 연산자
- 괄호 안에 변환할 타입을 넣으면 피연산자의 타입이 변경됨
int intNumber = 93 + (int) 98.8; // 93 + 98
double doubleNumber = (double) 93 + 98.8; // 93.0 + 98.8- 삼항 연산자
- 비교 연산의 결과값에 따라 응답할 값을 직접 지정할 수 있는 연산자
(조건) ? (참결과) : (거짓결과)
int x = 1;
int y = 3;
boolean a = (x == y) ? true : false;
System.out.println(a); // false
boolean b = (x != y) ? true : false;
System.out.println(b); // true- instance of 연산자
- 피연산자가 조건에 명시된 클래스의 객체인지 비교하여 참(true)/거짓(false)을 응답해주는 연산자
(객체명) instance of (클래스명)
조건문
특정 조건에 따라 다른 연산을 수행하고 싶을 때
if,switch
if문
if - else
if (조건) {연산} else {연산}- if의 소괄호( ) 안의 조건이 boolean값 true를 만족하면 중괄호{ } 안의 연산을 수행함
- if의 소괄호( ) 안의 조건이 boolean값 false면 else 뒤에 있는 중괄호{ } 안의 연산을 수행함
if - else if
if (조건) {연산} else if (조건) {연산} else {연산}- else if의 소괄호( ) 안의 조건이 boolean값 true를 만족하면 else if 뒤에 있는 중괄호{ } 안의 연산을 수행함
중첩 if
- if문, else if문, else문 안에 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 {
System.out.println("flag 값은 true 고, number 값은 모르겠습니다.");
}
} else {
if (number == 1) {
System.out.println("flag 값은 false 고, number 값은 1입니다.");
} else if (number == 2) {
System.out.println("flag 값은 false 고, number 값은 2입니다.");
} else {
System.out.println("flag 값은 false 고, number 값은 모르겠습니다.");
}
}switch문
switch (피연산자) { case (조건) : (연산) }- case문과 함께 사용하며 if문보다 좀 더 가독성이 좋은 조건문 표현식임
- case는 여러개 설정할 수 있음
- 각 case의 연산 마지막에는
break;를 꼭 넣어줘야 함 - switch문 중괄호{ } 안의 제일 마지막에
default : (연산)을 명시해주어 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 비교
- 복합조건
- if문은 복합조건을 지원함
: 괄호( ) 안에 조건 여러개를 지정하여 조건문을 수행할 수 있음 - switch문은 피연산자 한개에 대한 조건만 지원함
- 코드중복
- if문은 코드중복이 많음
- switch문은 코드중복이 적음
반복문
특정 조건에 따라 반복해서 동일한 연산을 수행하고 싶을 때
for,while,do-while
for문
for (초기값; 조건문; 증가연산) {연산}초기값이조건문을 만족할 때까지{연산}을 수행하면서 회차마다증가연산을 수행함
for (int i = 0; i < 4; i++) {
System.out.println(i + "번째 출력");
}
//
0번째 출력
1번째 출력
2번째 출력
3번째 출력향상된 for문
for (변수타입 변수명 : 목록변수) {연산}- 향상된 for문은 연속된 변수목록을 출력할 때 쓰임
int[] numbers = {3, 6, 9, 12, 15};
for (int number: numbers) {
System.out.print(number + " ");
}
// 3 6 9 12 15 while문
while (조건문) {연산}- 초기값 없이 조건문만 명시함
- 조건문을 만족해야지만 연산이 반복수행됨
int number = 0;
while (number < 3) {
number++;
System.out.println(number + " 출력!");
}
//
1 출력!
2 출력!
3 출력!do-while문
do {연산} while (조건문)- 최소 1회 연산수행 후 조건문을 체크하여 더 반복할지 결정함
int number = 4;
do {
System.out.println(number + " 출력!");
} while (number < 3);
//
4 출력!break 명령
break;명령을 호출하면 가장 가까운 블럭의 for문, while문, switch문을 중단함
continue 명령
continue;명령을 호출하면 for문, while문에서 해당 순서를 패스함
배열
선언
타입[] 변수명;또는타입 변수명[];
int[] intArr;
int intArr[];생성
new명령을 통해 생성하며, 대괄호[ ]안에 크기를 지정해줌타입 변수명[] = new 타입[];- 배열은 생성될 때 각 타입별 초기값으로 초기화 되어 채워짐
- int : 0 / boolean: false / String : null
int[] intArray = new int[3]; // {0, 0, 0}
boolean[] boolArray = new boolean[3]; // {false, false, false}
String[] stringArray = new String[3]; // {"", "", ""}순회
- 배열의 값을 하나씩 뽑아서 조회
- 단건 조회
int[] intArray = new int[3];
System.out.println(intArray[1]);- 다건 조회
int[] intArray = new int[3];
for (int i = 0; i < intArray.length; i++) {
System.out.println(intArray[i]);
}초기화
- 중괄호{ } 사용
- 배열에 특정값 대입
int[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"a", "b", "c", "d"};- for문 사용 (혹은 향상된 for문)
for (int i = 0; i < intArray.length; i++) {
intArray[i] = i;
}
for (int item: intArray) {
System.out.println(intArray[item]);
}
//
0
1
2
3
4- Arrays.fill
- 배열의 주소를 모두 같은 값으로 초기화
Arrays.fill(intArray, 1);
for (int item: intArray) {
System.out.println(intArray[item]);
}
//
1
1
1
1
1복사
- 얕은 복사
- 주소값만 복사되고 실제값은 1개로 유지됨
int[] a = {1, 2, 3, 4};
int[] b = a;
b[0] = 3;
System.out.println(a[0]);
// 3
a 배열의 0번째 순번값도 수정됨- 깊은 복사
- 진짜 새로운 배열을 똑같이 만들고 싶을 때
int[] c = {1,2,3,4};
int[] d = Arrays.copyOf(c, c.length);
// d 라는 새로운 배열이 생김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"};메서드
- length()
- 문자열의 길이 반환
- 응답값 : int
- charAt(int index)
- 문자열에서 해당 index의 문자를 반환
- 응답값 : char
- substring(int from, int to)
- 문자열에서 해당 범위(from~to)에 있는 문자열을 반환
(to는 범위에 포함되지 않음) - 응답값 : String
- equals(String str)
- 문자열의 내용이 같은지 확인
- 응답값 : boolean
- toCharArray()
- 문자열을 문자배열(char[ ])로 변환해서 반환
- 응답값 : char[ ]
- new String(char[] charArr)
- 문자배열(char[ ])을 받아서 String으로 복사해서 반환
- 응답값 : String
2차원 배열
선언
- 1차원 배열에 대괄호를 하나 더 추가해주면 됨
int[][] array;
int array[][];
int[] array[];생성
int[][] array = new int[][];초기화
- 중괄호{ } 사용
int[][] array = {
{1, 2, 3},
{4, 5, 6}
};- for문 사용
- 선언/생성 후 반복문 사용
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}
};collection
- 배열보다 다수의 참조형 데이터를 더 쉽고 효과적으로 처리할 수 있는 기능을 많이 가지고 있음
- List, Set, Queue, Map
List(ArrayList)
- 순서가 있는 데이터의 집합 (데이터 중복 허용) - 배열과 비슷
- 처음에 길이를 몰라도 만들 수 있음 - 동적배열 (크기가 가변적으로 늘어남)
// 선언 & 생성
ArrayList<Integer> intList = new ArrayList<Integer>();
// 추가
intList.add(1);
intList.add(2);
intList.add(3);
// 수정
intList.set(1, 10); // 배열의 1번 인덱스 값(2)을 10으로 변경
System.out.println(intList.get(1)); // 10
System.out.println(intList.get(0)); // 1
// 삭제
intList.remove(0); // 배열의 0번 인덱스를 삭제하고 나머지 배열을 앞으로 당김
System.out.println(intList.get(0)); // 10
// 배열 전체 값 조회하기
System.out.println(intList.toString()); // [10, 3]
// 전체 삭제
intList.clear();
System.out.println(intList.toString()); // []LinkedList
- 메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 담아놓음
실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조 - 기본적 기능은 ArrayList와 동일하나 LinkedList는 값을 여기 저기 나누어 담았으므로, 조회하는 속도가 느림
- 대신 값을 추가하거나, 삭제할 때는 빠름
LinkedList<Integer> linkedList = new LinkedList<Integer>();
linkedList.add(5);
linkedList.add(10);
linkedList.add(3);
System.out.println(linkedList.get(0)); // 5
System.out.println(linkedList.get(1)); // 10
System.out.println(linkedList.get(2)); // 3
System.out.println(linkedList.toString()); // [5, 10, 3]
// 이렇듯 조회할 때는 arraylist 보다 속도가 현저히 느리다.
// 추가
linkedList.add(200);
System.out.println(linkedList.toString()); // [5, 10, 3, 200]
linkedList.add(2, 4); // 2번 인덱스에 값(4)를 추가
System.out.println(linkedList.toString()); // [5, 10, 4, 3, 200]
// 수정
linkedList.set(1, 30);
System.out.println(linkedList.toString()); // [5, 30, 4, 3, 200]
// 삭제
linkedList.remove(1);
System.out.println(linkedList.toString()); // [5, 4, 3 200]
// 전체 삭제
linkedList.clear();
System.out.println(linkedList.toString()); // []Stack
- 수직으로 값을 쌓아놓고, 넣었다가 빼는 집합
- FILO(First in Last Out) : 먼저 들어간 것이 나중에 나옴
- push, peek, pop
Stack<Integer> intStack = new Stack<Integer>();
intStack.push(10);
intStack.push(15);
intStack.push(1);
// 다 지워질 때까지 출력
while (!intStack.isEmpty()) {
System.out.println(intStack.pop());
} // 나중에 넣은 순서대로 1
15
10
// 다시 추가
intStack.push(10);
intStack.push(15);
intStack.push(1);
// peek : 제일 나중에 넣은 것 출력
System.out.println(intStack.peek()); // 1
// size
System.out.println(intStack.size()); // 3Queue
- 빨대처럼 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺄 수 있는 집합
- FIFO(First In First Out) : 먼저 들어간 순서대로 값을 조회할 수 있음
- add, peek, poll
- 생성자가 없는 인터페이스
Queue<Integer> intQueue = new LinkedList<>();
intQueue.add(1);
intQueue.add(5);
intQueue.add(9);
while (!intQueue.isEmpty()) {
System.out.println(intQueue.poll());
} // 넣은 순서대로 1
5
9
intQueue.add(1);
intQueue.add(5);
intQueue.add(9);
System.out.println(intQueue.peek()); // 1
System.out.println(intQueue.size()); // 3Set
- 순서가 없는 데이터의 집합 (데이터 중복 허용 안함) - 순서없고 중복없는 배열
- Set 은 생성자가 없는 껍데기라서 바로 생성할 수 없음
- HashSet, TreeSet 등으로 응용해서 같이 사용 가능
- 생성자가 존재하는 HashSet 을 이용해서 -> Set 을 구현
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) {
System.out.println(value);
} // 중복 허용 안하므로 1
5
9
12
// contains : 포함 여부
System.out.println(intSet.contains(2)); // false
System.out.println(intSet.contains(5)); // trueMap
- 순서가 없는 (Key - Value) 쌍으로 이루어진 데이터의 집합
- Key값 중복 허용 안함 (unique)
- HashMap, TreeMap 으로 응용해서 같이 사용 가능
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문)
for (String key: intMap.keySet()) {
System.out.println(key);
} // 중복 허용 안하므로 일
이
삼
// value 값 전체 출력 (향상된 for문)
for (Integer value: intMap.values()) {
System.out.println(value);
} // 중복 허용 안하므로 11
12
15
// 중복되는 값의 맨 마지막 값으로 덮어쓰기됨
System.out.println(intMap.get("삼")); // 152주차 숙제
package week02;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Scanner;
public class Main02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String collectionName = sc.next();
String title = sc.next();
switch (collectionName) {
case "List":
ArrayList<String> strList = new ArrayList<>();
while (true) {
String text = sc.next();
if (Objects.equals(text, "끝")) {
break;
}
strList.add(text);
}
System.out.println("[ List로 저장된 " + title + " ]");
for (int i = 0; i < strList.size(); i++) {
int number = i + 1;
System.out.println(number + ". " + strList.get(i));
}
break;
case "Set":
LinkedHashSet<String> strSet = new LinkedHashSet<>();
while (true) {
String text = sc.next();
if (Objects.equals(text, "끝")) {
break;
}
strSet.add(text);
}
System.out.println("[ Set 으로 저장된 " + title + " ]");
Iterator iterator = strSet.iterator();
for (int i = 0; i < strSet.size(); i++) {
int number = i + 1;
System.out.println(number + ". " + iterator.next());
}
break;
case "Map":
Map<Integer, String> strMap = new HashMap<>();
int lineNumber = 1;
while (true) {
String text = sc.next();
if (Objects.equals(text, "끝")) {
break;
}
strMap.put(lineNumber++, text);
}
System.out.println("[ Map 으로 저장된 " + title + " ]");
for (int i = 0; i < strMap.size(); i++) {
int number = i + 1;
System.out.println(number + ". " + strMap.get(i + 1));
}
break;
default:
System.out.println("저장할 수 없는 자료구조 입니다.");
}
}
}