x + y -> x 피연산자 + 연산자 y 피연산자
산술연산자 - +, -, *, /, %(나머지), <<, >>
비교연산자 - >, <, >=, <=, ==, !=
논리연산자 - &&, ||, !
대입연산자 - =, ++, --
기타연산자 - (type), ? :, instance of
//기본대입연산자
int number = 10;
number = number + 2;
System.out.println("기본 -> " + number);
//복합대입연산자
number = 10;
number += 2;
number *= 2;
number /= 2;
number %= 2;
System.out.println("복합 -> " + number);
//++, --
number ++;
number ++;
number --;
System.out.println("--,++ -> " + number);
//대입연산자 주의해야할 점
int a = 10;
int b = 10;
int val = ++a + b--; // ++ a앞에 있으면 a에 ++하고 객체 바로 실행 즉 11 + 10, ++a + b 한 다음 ++함
//형변환연산자
int intNumber = 10 + (int)10.8;
double doubleNumber = 10 + (double)10.8;
//삼항연산자 비교연산자
int a = 10;
int b = 12;
boolean f = (a==b) ? true : false ;
System.out.println(f);
String s = (a==b) ? "같음" : "같지않음" ;
System.out.println(s);
int max = (a > b) ? a : b;
System.out.println(max);
int min = ( a > b ) ? b : a;
System.out.println(min);
//instance of 피연산자가 조건에 명시된 클래스의 객체인지 비교하면 맞으면 true 틀리면 false
연산자 우선순위
산술>비교>논리>대입
괄호로 감싸줌으로써 연산이 최우선순위로 계산
산술변환
연산 전에 피연산자의 타입을 일치시키는 것
두 피연산자의 타입을 같게 일치 (둘중에 저장공간 크기가 더 큰 타입으로 일치)
피연산자의 타입이 int 보다 작은 short 타입이면 int 로 변환
피연산자의 타입이 long 보다 작은 int, short 타입이면 Long 으로 변환
피연산자의 타입이 float보다 작은 long, int, short 타입이면 float 으로 변환
피연산자의 타입이 double 보다 작은 float, long, int, short 타입이면 double 으로 변환
int a = 10;
double b = 12.5
result = a+b -> 22.5
비트연산
0101 << 1010 왼쪽 2의 배수로 곱셈이 연산되는것과 동일
5 -> 10
1010 >> 0101 오른쪽 2의 배수로 나눗셈이 연산되는것과 동일
10 -> 5
ex) 3 << 2 -> 11(2) -> 1100(2)
3 << 1 -> 11(2) ->110(2)
즉 12, 6 출력
조건문(if, swich)
가위바위보
for(int i = 0 ; i < 5 ; i++) {
System.out.println("a 입력 : ");
String aHand = sc.nextLine();
System.out.println("b 입력 : ");
String bHand = sc.nextLine();
if (Objects.equals(aHand, "가위")) {
if (Objects.equals(bHand, "가위")) {
System.out.println("비겼습니다.");
} 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("b가졌습니다");
} else if (Objects.equals(bHand, "바위")) {
System.out.println("비겼습니다");
} else {
System.out.println("a가졌습니다.");
}
} else if (Objects.equals(aHand, "보")) {
if (Objects.equals(bHand, "가위")) {
System.out.println("a가졌습니다");
} else if (Objects.equals(bHand, "바위")) {
System.out.println("b가졌습니다");
} else {
System.out.println("비겼습니다.");
}
}else{
System.out.println("오류");
}
}
Objects.equals(a,b) 좌우가 같은경우 true 다른경우 false
Objects.equals(bHand, "가위") -> bHand가 "가위"라면
int month = 2;
String monthString = "";
switch (month) {
case 1:
monthString = "1월";
break;
case 2:
monthString = "2월";
break;
case 3:
monthString = "3월";
break;
default:
monthString = "오류";
}
System.out.println(monthString);
swich, if 차이점
if 문은 복합조건을 지원
if 문은 상대적으로 코드중복이 많음.
반복문(for, while, do-while)
int[] a = {3, 6, 9, 12, 15};
for (int number : a) {
System.out.print(number + " ");
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
} //foreach랑 동일
-------------------------------------
int n = 0;
while (true){
n++;
System.out.println(n);
if(n==10){
break;
}
} //10까지 출력
-------------------------------------
int n = 0;
while (true){
n++;
if(n==10){
break;
}
System.out.println(n);
} //9까지 출력
-------------------------------------
int a = 0;
while(a<10){
a++;
System.out.println(a);
}
-------------------------------------
int b = 4;
do{
System.out.println(b); //4출력 후 멈춤
}while( b < 3 );
-------------------------------------
int n = 0;
while(n<4){
n++;
if(n==3){
continue;
}
System.out.println(n);
}
continue -> n==3 만족시 print출력하지 않고 넘어감
break -> n==3만족시 종료
Scanner sc = new Scanner(System.in);
System.out.println("몇단까지 보시겠습니까");
int a = sc.nextInt();
System.out.println("몇단을 제외하시겠습니까?");
int pass = sc.nextInt();
for (int i = 1; i <= a; i++) {
if(i == pass){
continue;
}
for (int j = 1; j <= 9; j++) {
System.out.println(i+ " * " + j + " = " + + i * j);
}
}
배열선언방식
int[] a = new int[5] -> length(a) -> 5
int a[] = new int[5]
int[] arrays;
arrays = new int[3];
초기값
int[3] = 0,0,0
String[3] = "","",""
boolean[3] = false, false, false
Scanner sc = new Scanner(System.in);
System.out.println("몇개를 생성할까요?");
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = sc.nextInt();
}
System.out.println(Arrays.toString(a)); // a에 {1,2,3,4,5} 입력시 {1,2,3,4,5} 그대로 나옴
for(int result : a){
System.out.println(result); // 1,2,3,4,5 출력
}
배열초기화
int[] intArr = {1,2,3,4,5};
//배열초기화
Arrays.fill(intArr,1);
for(int result : intArr){
System.out.println(result);
}
얕은복사
int[] a = { 1,2,3,4 };
int[] b = a;
b[0] = 3;
System.out.println(a[0]); //3나옴
깊은복사
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]);
System.out.println(b[0]);
-------------------------------------------------------------------------------------
int[] a = { 1,2,3,4 };
int[] b = Arrays.copyOf(a, a.length);
-------------------------------------------------------------------------------------
int[] a = { 1,2,3,4 };
int[] b = a.clone(); //2차원 이상 배열에서는 얕은 복사로 동작함
영향을 주지 않음
기본형 변수는 소문자
참조형 변수는 대문자로 시작함
ex) int n = 10; Integer a = n;
기본형 변수는 값 자체를 저장
참조형 변수는 별도의 공간에 값을 저장 후 주소를 저장(=주소형 변수)
String str = "ABCD";
int strNum = str.length(); //4
System.out.println(strNum);
char chr = str.charAt(0); //A
System.out.println(chr);
String strSub = str.substring(0,3); //0~2까지 ABC
System.out.println(strSub);
String newStr = "ABCD";
boolean strEqual = newStr.equals(str); //newstr과 str이 일치하면 true 아니면 false / true출력
System.out.println(strEqual);
char[] strCharAry = str.toCharArray(); //String->char[] ABCD 출력
System.out.println(strCharAry);
char[] charAry = {'a', 'b', 'c'};
String charAryString = new String(charAry); //char->String->char / abc출력
System.out.println(charAryString);
2차원 배열
int[][] a = new int[][]
int a[][] = new int[][]
int[] a[] = new int[][]
int[][] arr = new int[2][3];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(i + ", "+ j);
}
}
// 0,0/ 0,1/ 0,2/ 1,0/ 1,1/ 1,2 출력
------------------------------------------------------------------------------------
int[][] arr = {
{1,2,3},
{4,5,6}
};
가변배열
//가변배열
int[][] arr = new int[3][];
//배열원소마다 각기 다른 크기로 지정
arr[0] = new int[2]; // 0, 0,1
arr[1] = new int[4]; // 1, 0,1,2,3
arr[2] = new int[1]; // 2, 0
-----------------------------------
int[][] arr2 ={
{10,20},
{10,20,30,40},
{10},
};
3차원배열
int[][][] arr = {{{1, 2}, {3, 4}, {5, 6}, {7, 8}}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
for (int k = 0; k < arr[i][j].length; k++) {
System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + arr[i][j][k] + " ");
}
}
}
}
}
//출력값
//arr[0][0][0] = 1 arr[0][0][1] = 2
//arr[0][1][0] = 3 arr[0][1][1] = 4
//arr[0][2][0] = 5 arr[0][2][1] = 6
//arr[0][3][0] = 7 arr[0][3][1] = 8
가변적으로 설정 가능
최대값 확인
int[] arr = {3,2,1,5,2};
int max = arr[0];
for(int num : arr){
if(num > max){
max = num;
}
}
System.out.println(max); //5출력
int[] arr = {3,2,1,5,2};
int min = arr[0];
for(int num : arr){
if(num < min){
min = num;
}
}
System.out.println(min);
Java Collection
기능 - 크기 자동조정, 추가, 수정, 삭제, 반복, 순회, 필터, 포함확인 등
Collection - List, Set, Queue, Map
List - 순서가 있는 데이터 집합(데이터 중복 허용) - 배열과 비슷
-Array(정적배열), List(동적배열, 크기가 가변적으로 변함)
Queue - FIFO구조, 한쪽에서 데이터를 넣고 반대쪽에서 데이터를 뺼 수 있는 집합 (원통이라고 생각)
-(Stack - LIFO구조 바구니라고 생각)
Set - 순서가 없는 데이터의 집합(데이터 중복 허용 안함) - 순서없고 중복없는 배열
Map - 순서가 없는(key, value) 쌍으로 이루어진 데이터의 집합(Key값 중복허용 안함)
Collection은 기본형 변수가아닌 참조형 변수를 저장
List사용법
.add, .set, .remove, .clear, .get
ArrayList<Integer> intList = new ArrayList<Integer>();
//값추가
intList.add(99);
intList.add(15);
intList.add(3);
System.out.println(intList.get(1));
//값변경
intList.set(1,10); // (1) 15->10으로 바꿈
System.out.println(intList.get(1));
//값삭제
intList.remove(0);
System.out.println(intList.get(0)); //(0)이 삭제되어 (1) -> (0), 10이나옴
//전체삭제
System.out.println(intList.toString());
intList.clear();
System.out.println(intList.toString());
Linkedlist
메모리에 남는 공간을 요청해서 여기 저기 나누어서 실제 값을 저장
실제 값이 있는 주소값으로 목록을 구성하고 저장하는 자료구조
기본적 기능은 ArrayList와 동일
나누어서 저장하기 때문에 조회 속도가 느림
값을 추가하거나 삭제할때는 빠름
.add, .set, .remove, .clear, .get
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.toString());
//값 추가
linkedList.add(2,4); //ArrayList랑은 다른점, 2번쨰 4를 추가(2번째 값은 3번째로 이동)
System.out.println(linkedList.toString());
//값 변경
linkedList.set(0,30);
System.out.println(linkedList.toString());
//값 삭제
linkedList.remove(0);
System.out.println(linkedList.toString());
//전체삭제
linkedList.clear();
System.out.println(linkedList.toString());
Queue
add, peek, poll
생성자가 없는 인터페이스
//Queue : FIFO
Queue<Integer> intQueue = new LinkedList<Integer>(); //생성자가 없기 때문 linkedList
intQueue.add(1);
intQueue.add(5);
intQueue.add(9);
while (!intQueue.isEmpty()){
System.out.println(intQueue.poll()); //pop -> LIFO, poll -> FIFO 1,5,9출력 intQueue에서 사라짐
}
System.out.println(intQueue.toString()); //값 X
intQueue.add(1);
intQueue.add(5);
intQueue.add(9);
intQueue.add(10);
System.out.println(intQueue.peek()); //조회 1나옴
System.out.println(intQueue.size());//size조회 4출력
Stack
push, peek, pop
최근 저장된 데이터를 나열할때, 데이터 중복처리를 막고 싶을때
//Stack : LIFO
Stack<Integer> intStack = new Stack<Integer>();
intStack.push(10); //추가 add랑 비슷
intStack.push(15);
intStack.push(1);
while (!intStack.isEmpty()){ //isEmpty -> 값이 없으면 true 있으면 false, !intStack.pop ->값이 있지만 부정을 써서 true로 만듬
System.out.println(intStack.pop()); //pop -> 상단값(마지막)부터 출력되면서 intStack에서 사라짐 1, 15, 10 순서
}
intStack.push(10);
intStack.push(15);
intStack.push(1);
System.out.println(intStack.peek()); //마지막 값 출력 -> 1 값이 안사라짐
System.out.println(intStack.size()); //3출력
Set
순서 없고, 중복 없음
순사거 보장되지 않는 대신 중복을 허용하지 않도록 프로그램에서 사용할 수 있는 자료구조
Set -> 그냥쓸 수 있으나 HashSet, TreeSet 등으로 응용해서 같이 사용 가능
Set은 생성자가 없기 때문에 바로 생성 X
HashSet -> 생성자가 존재
Set<Integer> intSet = new HashSet<Integer>();
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 값 출력 중복값은 허용하지않음.
}
System.out.println(intSet.toString()); //값 X
System.out.println(intSet.contains(2)); //2를 포함하고 있는지 true, false 값 출력, false 출력
System.out.println(intSet.contains(5)); //true 출력
Map
key -> Value pair
key값 unique해야함
Map -> HashSet, TreeSet 등으로 응용해서 같이 사용 가능
//key, value
Map<String, Integer> intMap = new HashMap<>();
intMap.put("일",11); //put -> 생성
intMap.put("이",12);
intMap.put("삼",13); //key중복
intMap.put("삼",14); //key중복
intMap.put("삼",15); //key중복
for(String key : intMap.keySet()){ //keyset -> key값만 가져옴
System.out.println(key); //이 일 삼 출력
}
for(Integer value : intMap.values()){ // values -> value값 가져옴
System.out.println(value); //12 11 15 출력 -> 중복값은 마지막값으로 나옴
}
System.out.println(intMap.get("삼"));//15출력
생성자가 없음
Queue(<->Stack) -> LinkedList 사용
Set -> HashSet 사용
Map -> HashMap 사용
1. length
- arrays(int[], double[], String[])
- length는 배열의 길이를 조회해줍니다.
2. length()
- String related Object(String, StringBuilder etc)
- length()는 문자열의 길이를 조회해줍니다. (ex. “ABCD”.length() == 4)
3. size()
- Collection Object(ArrayList, Set etc)
- size()는 컬렉션 타입목록의 길이를 조회해줍니다.
과제 (1주차 리팩토링)
next() -> 띄어쓰기 X, ex) 안녕 하세요 -> 안녕 출력
nextLine() -> 띄어쓰기 O
package Collection;
import java.io.BufferedReader;
import java.util.*;
public class 과제 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("List, HashSet, Set, Map 중 입력하세요");
String CollectionName = sc.next();
System.out.println("title제목 입력하세요");
String title = sc.nextLine();
switch (CollectionName) {
case "List": {
ArrayList<String> strList = new ArrayList<String>();
while (true) {
String text = sc.nextLine();
if (Objects.equals(text, "끝")) {
break;
}
strList.add(text);
}
String strTitle = "[ List로 저장된 " + title + " ]";
System.out.println(strTitle);
for (int i = 1; i <= strList.size(); i++) {
System.out.println(i + ". " + strList.get(i));
}
break;
}
case "HashSet" : {
HashSet<String> strHashSet = new HashSet<String>();
while (true){
String text = sc.nextLine();
if(Objects.equals(text,"끝")){
break;
}
strHashSet.add(text);
}
title = "[ HashSet으로 저장된 " + title + " ]";
System.out.println(title);
Iterator iterator = strHashSet.iterator(); //Iterator에 저장하여 꺼냄
for (int i = 0; i < strHashSet.size(); i++) {
int number = i + 1;
System.out.println(number + ". " + iterator.next());
}
break;
}
case "Set" : {
Set<String> strSet = new HashSet<String>();
while(true){
String text = sc.nextLine();
if(Objects.equals(text,"끝")){
break;
}
strSet.add(text);
}
String strTitle = "[ Set로 저장된 " + title + " ]";
System.out.println(strTitle);
int n = 1;
for(String str : strSet){
System.out.println(n++ + ". " + str);
}
break;
}
case "Map" : {
Map<Integer, String> strMap = new HashMap<>();
int lineNumber=1;
while(true){
String text = sc.nextLine();
if(Objects.equals(text,"끝")){
break;
}
strMap.put(lineNumber++,text);
}
title = "[ Map으로 저장된 " + title + " ]";
System.out.println(title);
for (int i = 1; i <= strMap.size(); i++) {
System.out.println(i + ". " + strMap.get(i));
}
break;
}
default:{
System.out.println("오류발생");
}
}
}
}
'K-Digital Training > 내일배움캠프' 카테고리의 다른 글
자바 5주차 (1) | 2023.11.01 |
---|---|
자바 4주차 (1) | 2023.11.01 |
자바 3주차 (0) | 2023.10.20 |
자바 1주차 (0) | 2023.10.20 |
내일배움캠프 시작 그리고 과제 (0) | 2023.10.05 |