1. if 문

1) if 문과 else 문의 기본 구조

- if 문 : 주어진 조건이 참일 때 실행되는 코드

- else 문: if 문의 조건이 거짓일 때 실행되는 코드

if (조건문) {
	<수행할 문장>;
    <수행할 문장2>;
} else {
	<수행할 문장3>;
    <수행할 문장4>;
}

2) 비교 연산자

// 돈이 3000원 이상 있으면 택시, 아니면 걷기
int money = 2000;
if (money > 3000) {
    System.out.println("택시");
} else {
    System.out.println("걷기");
}
 // 걷기

3) and, or, not 연산자

// 카드가 있거나 돈이3000원 이상 있으면 택시, 아니면 걷기
int money = 2000;
boolean card = true;
if (money > 3000 || card) {
    System.out.println("택시");
} else {
    System.out.println("걷기");
}

// 택시

4)  contains

- 해당 아이템이 있는지 조사하는 메서드 / 조건문에 많이 활용된다

import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
	ArrayList<String> pocket = new ArrayList<String>();
	pocket.add("paper");
	pocket.add("cellphone");
	pocket.add("money");
	
	if (pocket.contains("money")) {
		System.out.println("택시를 타고 가라");
	} else {
		System.out.println("걸어가라");
	}
	
	}
}

// 택시를 타고 가라

5) else if

- 있다와 없다중에 없을 경우 다시 경우를 나누어주는 조건문에 해당한다

(if, else가 여러번 사용되어 한 번에 이해하기가 쉽지 않고 산만한 느낌이드느데... 이를 보완하기 위해서... 자바는 여러 조건을 판단할 수 있게 하는 else if 문이 있다)

package test;
import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
	boolean hasCard = true;
	ArrayList<String> pocket = new ArrayList<String>();
	pocket.add("paper");
	pocket.add("cellphone");
	
	if (pocket.contains("money")) {
		System.out.println("택시를 타고 가라");
	} else {
		if (hasCard) {
			System.out.println("택시를 타고 가라");
		}else {
			System.out.println("걸어가라");
		}
	}
	
	}
}

// 택시를 타고 가라

아래 else if 부분들을 수정하면 조금 간단하게 나타내면 아래로 나타내질 수 있다 / else if는 개수제한 없이 사용 가능

	if (pocket.contains("money")) {
		System.out.println("택시를 타고 가라");
	}else if (hasCard) {
		System.out.println("택시를 타고 가라");
	}else {
		System.out.println("걸어가라");
	}

2. switch / case 문

: if 문과 비슷하지만 좀 더 일정한 형식이 잇는 조건문..

=> 입력 변수의 값과 일치하는 case 입력값(입력값1, 입력값2,....) 이 있다면 해당 case 문에 속한 문장들이 실행된다...

  break 문 또한 존재(해당 case문을 실행한 뒤 swirch 문을 빠져나가기 위함), break 문이 없다면, 다음 case로 이동

package test;
import java.util.ArrayList;

public class money {
	public static void main(String[] args) {
		int month = 8;
		String monthString = " ";
		switch(month) {
		case 1: monthString = "January";
		break;
		case 2: monthString = "February";
		break;
		case 3: monthString = "March";
		break;
		case 4: monthString = "April";
		break;
		case 5: monthString = "May";
		break;
		case 6: monthString = "June";
		break;
		case 7: monthString = "July";
		break;
		case 8: monthString = "August";
		break;
		case 9: monthString = "September";
		break;
		case 10: monthString = "October";
		break;
		case 11: monthString = "November";
		break;
		case 12: monthString = "December";
		break;
		default: monthString = "Invalid month";
		break;
		}
		System.out.println(monthString);
	}
}

해당하는 숫자에 대한 case가 실행되었다!!

만약 month가 1에서 12사이의 숫자가 아닌 다른 값이 저장되어 있다면 defaul: 문장이 수행된다!

값이 정형화되어 있는 경우 if 문보다는 switch/case 문을 쓰는 것이 코드의 가독성이 좋다!!

3. while 문

: 조건문이 참인 동안 수행할 문장들을 반복해서 수행한다

package test;

public class tree {
	public static void main(String[] args) {
		int treeHit = 0;
		while (treeHit < 10) {
			treeHit++; // treeHit += 1; 로도 표현가능
			System.out.println("나무를 " + treeHit + "번 찍었습니다.");
			if (treeHit == 10) {
				System.out.println("나무 넘어갑니다.");
			}
		}

	}
}

/*
나무를 1번 찍었습니다.
나무를 2번 찍었습니다.
나무를 3번 찍었습니다.
나무를 4번 찍었습니다.
나무를 5번 찍었습니다.
나무를 6번 찍었습니다.
나무를 7번 찍었습니다.
나무를 8번 찍었습니다.
나무를 9번 찍었습니다.
나무를 10번 찍었습니다.
나무 넘어갑니다.
*/

while문의 조건문 : treeHit < 10 (10보다 작은 동안 수행) / +1 커지면서 수행하고 / 10이 되면서 종료.. while 문 빠져나옴

1) 무한 루프

: 무한하게 while 문 내의 문장들을 수행... 빠져나오지 못한다...

package test;

public class loop {
	public static void main(String[] args) {
		while (true) {
			System.out.println("Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.");
		}
	}
}

/*
Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.
Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.
Ctrl-C를 눌러야 while문을 빠져나갈 수 있습니다.
...
*/

[Ctrl] + [c] : 종료

2) while 문 빠져나가기 - break

: while 문을 강제로 멈춰야 할 때 사용한다

package test;

public class loop {
	public static void main(String[] args) {
		int coffee = 10;
		int money = 300;
		
		while (money > 0) {
			System.out.println("돈을 받았으니 커피를 줍니다.");
			coffee--;
			System.out.println("남은 커피의 양은 " + coffee + "입니다.");
			if (coffee == 0) {
				System.out.println("커피가 다 떨어졌습니다. 판매를 중지합니다.");
				break;
			}
		}
	}
}

/*
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 9입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 8입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 7입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 6입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 5입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 4입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 3입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 2입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 1입니다.
돈을 받았으니 커피를 줍니다.
남은 커피의 양은 0입니다.
커피가 다 떨어졌습니다. 판매를 중지합니다.
*/

돈이 0보다 클때동안 진행하다... 0이 되어버리면 출력후 break가 호출되어 while 문을 빠져나간다

3) while 문으로 돌아가기 - continue

: while 문 안의 문장을 수행할 때 어떤 조건을 검사해서 참이 아닌 경우 while 문을 빠져나가는 대신 while 문의 맨 처음, 즉 조건문으로 돌아가게 하고 싶은 경우 continue를 사용(빠져나가지 않고 다시 올라가서 진행)

package test;

public class loop {
	public static void main(String[] args) {
		int a = 0;
		while (a < 10) {
			a++;
			if (a % 2 == 0) {
				continue; // 짝수인 경우 조건문으로 돌아간다.
			}
			System.out.println(a); // 홀수만 출력된다
		}
	}
}

/*
1
3
5
7
9
*/

a가 짝수이면 continue문이 실행되어 while 문의 맨 처음으로 돌아가게 한다!! 

그러므로 a가 짝수이면 System.out.println(a)는 수행되지 않기 때문에 홀수만 출력될 것이다!!!!

4. for 문

: 문장을 반복해서 수행해야 할 경우에 사용

1) for 문의 기본 구조

// 기본 구조
for (초깃값; 조건문; 증갓값) {
	...
}

/////
String[] numbers = ["one", "two", "three"]
for (int i = 0; i < numbers.length; i++) :
	System.out.println(numvers[i]);
}
/*
one
two
three
*/

i의 초깃값은 0, 조건문은 i < numbers.length, 증갓값은 i++이 된다!!

=> i 값이 numbers의 개수보다 작은 동안 계속 i 값을 1씩 증가시키며 for 문의 문장들을 수행

2) for 문으로 돌아가기 - continue

: while 문과 마찬가지로 적용!

int[] marks = {90, 25, 67, 45, 80};
for (int i = 0; i < marks.length; i++) {
	if (marks[i] < 60) {
    	continue; // 조건문으로 돌아간다.
    }
    System.out.println((i+1)+"번 학생 축하합니다. 합격입니다.");
}

/*
1번 학생 축하합니다. 합격입니다.
3번 학생 축하합니다. 합격입니다.
5번 학생 축하합니다. 합격입니다.
*/

점수가 60점 미만이면 continue문이 실해되어 축하메시지를 출력하는 부분이 수행하지 않고, 

for 문의 첫부분으로 돌아갑니다!!!

=> 반복문을 수행할 때, 특정 조건에서는 수행하지 않고 건너뛰어야 할 때 사용합니다!!!!

3) 이중 for 문

: for 문을 두번 사용한 것..

// 구구단 만들기
package test;

public class gugudan {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for (int i=2; i < 10; i++) {
			for (int j=1; j <10; j++) {
				System.out.print(i*j+" ");
			}
			System.out.println(""); // 줄을 바꾸어 출력하는 역할을 한다
		}
	}
}

/*
2 4 6 8 10 12 14 16 18 
3 6 9 12 15 18 21 24 27 
4 8 12 16 20 24 28 32 36 
5 10 15 20 25 30 35 40 45 
6 12 18 24 30 36 42 48 54 
7 14 21 28 35 42 49 56 63 
8 16 24 32 40 48 56 64 72 
9 18 27 36 45 54 63 72 81 
*/

단이 바뀔때 println을 사용하여 줄바꿈하여 문자를 출력하였다!!

5. for each 문

: 이전에 배웠던 for문을 활용한 예제(첨봄)

// for each 문의 구조
for (type 변수명: iterate) {
	body-of-loop
}

iterate는 루프를 돌릴 객체이고 iterate 객체에서 한 개씩 순차적으로 변수명에 대입되어 for 문이 수행된다...

iterate에 사용할 수 있는 자료형은 루프를 돌릴 수 있는 자료형(배열이나 ArrayList등)만 가능하다...

+ 변수명의 type(자료형)은 iterate 객체에 포함된 자료형과 일치해야한다!!!

String[] numbers = {"one", "two", "three"};
for(int i = 0; i < numbers.lengh; i++) {
	System.out.println(numbers[i]);
}

// for each 문을 사용한다면...
String[] numbers = {"one", "two", "three"};
for(String number: numbers) {
	System.out.println(number);
}

문제...

1. everywhere

2. i % 3 == 0

3. i >5 / int j=0; j <5; j++;

4. int i = 1; i < 101; i++;

5. int mark: marks / total / marks.length;

6) 배열

배읠의 길이 설정하기

- 배열은 바로 옆에 []기호를 붙인다

- 배열의 길이를 먼저 설정한 뒤, 배열 변수를 생성하고 그 값을 나중에 대입

String[] weeks = new String[7];
weeks[0] = "월";
weeks[1] = "화";
weeks[2] = "수";
weeks[3] = "목";
weeks[4] = "금";
weeks[5] = "토";
weeks[6] = "일";
// 초깃값 없이 배열 변수를 만들 때에는 7과 같은 숫잣값을 넣어 길이를 정해 줘야 한다...
// 그렇지 않으면 오류가 발생한다...

배열값에 접근하기

- 해당하는 값을 얻으려면 인덱스를 이용하여야 한다

String[] weeks = {"월", "화", "수", "목", "금", "토", "일"}
System.out.println(week[3]); // 목

// weeks[3] => weeks배열의 네번째 항목을 의미(0부터 숫자를 세준다)

배열의 길이 구하기

- 배열은 보통 for 문과 함께 사용

- 배열의 길이는 length를 사용

String[] weeks = {"월", "화", "수", "목", "금", "토", "일"};
// weeks.length = 7
for (int i = 0; i < weeks.length; i++) { 
	System.out.println(weeks[i])
} 
// 월
// 화
// 수
// 목
// 금
// 토
// 일

배열 오류

- ArrayIndexOutOfBoundsException : 길이와 인덱스 사이에서생기는 오류...

   (파이썬의 인덱스아웃오브레인지 같은 느낌..)

System.out.println(weeks[7]); 
// 여덟 번째 배열값이 없으므로 ArrayIndexOutOfBoundsException 오류 발생

7) 리스트

: 배열과 비슷하지만 편리한 기능이 더 많음...

배열의 크기는 정해져 있지만 리스트는 변한다 => 저장할 값의 크기가 명확하지 않은 경우 리스트를 사용해야 한다!!

ArrayList

- 리스트 자료형에서 가장 일반적으로 사용하는 것(리스트 자료형에는 ArrayList, Vector, LinkedList 등이 있다)

1. add 메서드: 요솟값 추가

// 야구공의 시속을 리스트에 추가하는 코드 작성하기
import java.util.ArrayList;

public class Sample {
	public static void main(String[] args) {
    	ArrayList pitches = new ArrayList();
        pitches.add("138");
        pitches.add("129");
        pitches.add("142");
    }
}
// import 문 : 다른 패키지나 클래스를 현재 코드에서 사용하기 위해 선언하는 문장
// ArrayList를 사용하려면 import java.util.ArrayList와 같은 import 문을 작성해야 한다
// Java.util 패키지는 자바가 기본적으로 제공하는 패키지이다


// 원하는 위치에 넣고 싶다면....
pitches.add(0, "133");  -> 첫번째 위치에 133 삽입
pitches.add(1, "133");  -> 두번째 위치에 133 삽입

2. get 메서드 : 특정 인덱스의 값을 추출

import java.util.ArrayList;

public class Sample {
	public static void main(String[] args) {
    	ArrayList pitches = new ArrayList();
        pitches.add("138");
        pitches.add("129");
        pitches.add("142");
        # 선수의 특정 투구 속도를 출력하고 싶다면!!!
        System.out.println(pitches.get(1));   // 129
    }
}

3. size 메서드 : 요소의 개수를 리턴

System.out.println(pitches.size()); // 3

4. contains 메서드 : 리스트 안에 해당 항목이 있는지 판별해 그 결과를 boolean으로 리턴한다...

System.out.println(pitches.contains("142")); // true

5. remove 메서드 : 2가지 방식이 있는데... 1. remove(객체), 2. remove(인덱스)

// remove(객체)를 사용하면 리스트에서 객체에 해당하는 항목을 삭제 , 그 결과로 true 또는 false를 반환
System.out.println(pitches.remove("129")); // true

// remove(인덱스)를 사용하면 인덱스에 해당하는 항목을 삭제한 뒤, 그 항목을 리턴
System.out.println(pitches.remove(0)); // 138

제네릭스(generics)

: 자료형을 안전하게 사용할 수 있도록 만들어 주는 기능(자료형을 강제로 바꿀 때 생길 수 있는 캐스팅 오류를 줄인다)

- 일반적인 방식 : ArrayList<String> pitches = new ArrayList<String>();

- 선호되는 방식 : ArrayList<String> pirches = new ArrayList<>();  

=>  <>에 해당하는 부분의 자료형은 명확하므로 굳이 적지 않아도 된다... (오히려 적으면 인텔리제이에서는 경고 메세지..)

- 제네릭스를 사용하지 않는다면... 값을 가져올 때 매번 Object 자료형(모든 객체가 상속하고 있는 가장 기본적인 자료형)에서 String 자료형으로 변환해야한다.... 

// 제네릭스를 사용하지 않은 예시
ArrayList pitches = new ArrayList();
pitches.add("138");
pitches.add("129");

// 형 변환이 필요함
String one = (String) pitches.get(0);
String two = (String) pirches.get(1);

// 제네릭스를 사용한 예시
ArrayList<String> pitches = new ArrayList<>();
pitches.add("138");
pitches.add("129");

// 형변환이 필요없음
String one = pitches.get(0)
String two = pitches.get(1)

다양한 방법으로 ArrayList 만들기

1. ArrayList의 add 메서드 사용 : ArrayList 객체에 요소 추가

import java.util.AttayList;

public class Sample {
	public staatic void main(String[] args) {
    	ArrayList<String> pitches = new ArrayList<>(); // 제네릭스를 사용한 표현
        pitches.add("138");
        pitches.add("129");
        pitches.add("142");
        System.out.println(pitches); // [138, 129, 142]

2. 이미 문자열 배열이 있다면...(java.util.Arrays 클래스의 asList 메서드를 사용)

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
    	String[] data = {"138", "129", "142"}; // 이미 투구 수 데이터 배열이 있다
        ArrayList<String> pitches = new ArrayList<>(Arrays.asList(data));
        System.out.println(pitches);  // [138, 129, 142]
    }
}

3. 문자열 배열 대신 문자열 자료형을 여러개 전달하여 생성할 수도 ....

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
        ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        System.out.println(pitches);  // [138, 129, 142]
    }
}

String.join("구분자", 리스트 객체)

: ArrayList의 각 요소를 무언가로(콤마(,))로 구분하여 1개의 문자열로 만들기...

1) join이 없다면... 콤마를 하나하나 추가하여 마지막에 콤마는 제거한 후 출력

2) join을 사용한다면 간단하게 처리할수 있다!!

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
    	ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        String result = String.join(",", pirches);
        System.out.println(result); // "138, 129, 142"
    }
}

리스트 정렬하기

: 순서대로 정렬하기 위해서는 리스트의 sort 메서드 사용하기

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class Sample {
	public static void main(String[] args) {
    	ArrayList<String> pitches = new ArrayList<>(Arrays.asList("138", "129", "142"));
        pitches.sort(Comparator.naturalOrder()); // 오름차순 정렬
        System.out.println(pitches); // [129, 138, 142]
    }
}

- 오름차순 정렬 : Comparator.naturalOrder()

- 내림차순 정렬 : Comparator.reverseOrder()

8) 맵

- 딕셔너리와 유사하고  키와 값을 한 쌍으로 갖는 자료형

- 배열처럼 순차적으로 요솟값을 구하지 않고 키를 이용해 값을 얻는다

- HashMap, LinkedHashMap, TreeMap 등이 있다...

HashMap : 맵 자료형의 가장 기본

1. put 메서드 : key와 value를 추가

import java.util.HashMap;
public class Sample {
	public static void main(String[] args) {
    	HashMap<String, String> map = new HashMap<>();
        map.put("people", "사람");
        map.put("baseball", "야구");
    }
}
// key, value에 String 이외의 자료형은 사용할 수 없다

2. get 메서드 : key에 해당하는 value를 얻음

import java.util.HashMap;
public class Sample {
	public static void main(String[] args) {
    	HashMap<String, String> map = new HashMap<>();
        map.put("people", "사람");
        map.put("baseball", "야구");
        System.out.println(map.get("people")); // 사람
    }
}

// 맵의 key에 해당하는 value가 없을 떄 get 메서드를 사용하면 null이 리턴
System.out.println(map.get("java")); // null

// null 대신 기본값을 얻고 싶다면 getOrDefault 메서드를 사용하면 된다
System.out.println(map.getOrDefault("java", "자바")); //자바

3. containsKey 메서드 : 맵에 해당 key가 있는지를 true 또는 false로 리턴

HashMap<String, String> map = new HashMap<>();
map.put("people", "사람");
map.put("baseball", "야구");
System.out.println(map.containsKey("people")); // true

4. remove 메서드 : 맵의 항목을 삭제하는 메서드로, 해당 key의 항목을 삭제한 후 value 값을 리턴

HashMap<String, String> map = new HashMap<>();
map.put("people", "사람");
map.put("baseball", "야구");
System.out.println(map.remove("people")); // 사람

5. size 메서드 : 맵 요소의 개수를 리턴

HashMap<String, String> map = new HashMap<>();
map.put("people", "사람");
map.put("baseball", "야구");
System.out.println(map.containsKey("people")); 
System.out.println(map.size()); // 1

6. keySet 메서드 : 맵의 모든 key를 모아서 리턴

import java.util.HashMap;

public class Sample {
	public static void main(String[] args) {
    	HashMap<String, String> map = new HashMap<>();
        map.put("people", "사람");
        map.put("baseball", "야구");
        System.our.println(map.keySet()); // [baseball, people]
    }
}

++ ) 맵의 가장 큰 특징은 순서에 의존하지 않고 key로 value 값을 가져오는것이지만... 가끔 map에 입력된 순서대로 데이터를 가져오거나 입력한 key에 의해 정렬하도록 저장하고 싶을 수 있다...

- LinkedHashMap : 입력된 순서대로 데이터를 저장

- TreeMap : 입력된 key의 오름차순으로 데이터를 저장

9) 집합

: 집합과 관련된 것을 쉽게 처리하기 위해 만든것으로... HashSet, TreeSet, LinkedHashSet 등이 있다...

- 특징 2가지...

1. 중복을 허용하지 않는다

2, 순서가 없다(리스트와 배열은 순서가 있죠..., 순서가 없는 자료형이라 인덱싱을 지원하지 않는다)

교집합, 합집합, 차집합 구하기

1. 집합 자료형 2개 만들기

2. 교집합 구하기

3. 합집합 구하기

4. 차집합 구하기

import java.util.Arrays;
import java.util.HashSet;
 
 public class Sample {
 	public static void main(Stirng[] args) {
    	// 집합 자료형 두개 만들기 
    	HashSet<Integer> s1 = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6));
        HashSet<Integer> s2 = new HashSet<>(Arrays.asList(4, 5, 6, 7, 8, 9));
        
        // (교집합) = retainAll 메서드 이용
        HashSet<Integer> intersection = new HashSet<>(s1); // s1으로 intersection 이라는 HashSet 객체를 복사해 생성
        intersection.retainAll(s2); // 교집합 수행
        System.out.println(intersection); // [4, 5, 6]
        
        // (합집합) = addAll 메서드 이용
        HashSet<Integer> union = new HashSet<>(s1); // s1으로 union 생성
        union.addAll(s2); // 합집합 수행
        System.out.println(union);  // [1, 2, 3, 4, 5, 6, 7, 8, 9]
        
        // (차집합) = removeAll 메서드 이용
        HashSet<Integer> substract = new HashSet<>(s1); // s1으로 substract 생성
        substract.removeAll(s2); // 차집합 수행
        System.out.println(substract); // [1, 2, 3]
    }
}

집합 자료형과 관련된 메서드 - add, addAll, remove

1. add: 집합 자료형에 값을 추가

import java.util.HashSet;

public class Sample {
	public static void main(String[] args) {
    	HashSet<Stirng> set = new HashSet<>();
        set.add("Jump");
        set.add("To");
        set.add("Java");
        System.our.println(set); // [Java, To, Jump]
    }
}

2. addAll : 한꺼번에 여러개 값을 추가

import java.util.HashSet;

public class Sample {
	public static void main(String[] args) {
    	HashSet<Stirng> set = new HashSet<>();
        set.add("Jump");
        set.add("To");
        set.addAll(Arrays.asList("To", "Java"));
        System.our.println(set); // [Java, To, Jump]
    }
}

3. remove : 특정 값을 제거할 떄 사용

import java.util.HashSet;

public class Sample {
	public static void main(String[] args) {
    	HashSet<Stirng> set = new HashSet<>(Arrays.asList("Jump", "To", "Java"));
        set.add("To");
        System.our.println(set); // [Java, Jump]
    }
}

10) 상수 집합

 : enum 자료형은 서로 연관 있는 여러 개의 상수 집합을 정의할 때 사용

public class Sample {
	enum CoffesType {
    	AMERICANO,
        ICE_AMERICANO,
        CAFE_LATTE
    };
    
    public static void main(String[] args) {
    	System.out.println(CoffeeType.AMERICANO);  // AMERICANO
        System.out.println(CoffeeType.ICE_AMERICANO);  // ICE_AMERICANO
        System.out.println(CoffeeType.CAGE_LATTE);   // CAFE_LATTE
    }
}


// 반복문에서도 사용 가능
public class Sample {
	enum CoffesType {
    	AMERICANO,
        ICE_AMERICANO,
        CAFE_LATTE
    };
    
     public static void main(String[] args) {
     	for(CoffeeType type: CoffeeType.values()) {
        	System.out.println(type);  // 순서대로 AMERICANO, ICE_AMERICANO, CAFE_LATTE 출력
        }
    }
}

- enum 사용의 장점

1. 매직 넘버를 사용할 때보다 코드가 명확하다

2. 잘못된 값을 사용해 생길 수 있는 오류를 막을 수 있다

11) 형 변환과 final

: 형 변환이란 자료형을 다른 자료형으로 바꾸는 것 ("123"과 같은 문자열을 123과 같은 숫자형으로)

형변환 

1.  문자열을 정수로

String num = "123";
//문자열을 정수로 바꾸기 위해서는 Integer 클래스를 사용해야 한다

public class Sample {
	public static void main(String[] args) {
    	String num = "123";
        int n = Integer.parseInt(num);
        System.out.println(n); 			// 123
    }
}

2. 정수를 문자열로 : 정수 앞에 빈 문자열을 더해 주기 

public class Sample {
	public static void main(String[] args) {
    	int n = 123;
        String num = "" + n;
        System.out.println(num);  // 123
    }
}

 ++)  String.valueOf(정수), Integer.toString(정수) 모두 정수를 문자열로 바꾼다....

public class Sample {
	public static void main(String[] args) {
    	int n = 123;
        String num1 = String.valueOf(n);
        String num2 = Integer.toString(n);
        System.out.println(num1);   // 123
        System.out.println(num2);   // 123
    }
}

3. 소수점이 포함되어 있는 숫자 형태의 문자열의 변환

public class Sample {
	public static void main(String[] args) {
    	String num = "123.456";
        double d = Double.parseDouble(num);
        System.out.println(d);    // 123.456
    }
}

4. 정수와 실수 사이의 형 변환

public class Sample {
	public static void main(String[] args) {
    	int n1 = 123;
        double d1 = n1;
        System.out.println(d1);  // 123.0
        
        double d2 = 123.456;
        int n2 = (int) d2;
        System.out.println(n2);  // 123
    }
}

5. 실수 형태의 문자열을 정수로 바꿀 때

public class Sample {
	public static void main(String[] args) {
    	String num = "123.456";
        int n = Integer.parseInt(num);  // 실수 형태의 문자열을 정수로 변환할 경우 numberformatException이 발생
    }
}

// 실수 형태의 문자열을 숫자형으로 바꾸려면... Double.parseDouble()을 이용해 실수로 변환 후 사용

final

: 자료형에서 값을 단 한 번만 설정할 수 있게 강제하는 키워드 (다시 설정 안됩니다)

public class Sample {
	public static void main(String[] args) {
    	final int n = 123;   // final로 설정하면 값을 바꿀 수 없다
        n = 456;
    }
}

리스트의 경우도 final로 선언하면 재할당은 불가능...(더하거나 뺴기는 가능)

import java.util.ArrayList;
import java.util.Arrays;

public class Sample {
	public static void main(String[] args) {
    	final ArrayList<String> a = new ArrayList<>(Arrays.asList("a", "b"));
        a = new ArrayList<>(Arrays,asList("c", "d")); // 컴파일 오류 발생
    }
}

// 그러므로 final은 프로그램을 수행하면서 그 값이 바뀌면 안 될 때 사용한다

리스트의 재할당 뿐만아니라 더하거나 빼는 것도 할 수 없게 하고 싶다면... List.of를 작성하여 수정할 수 없는 리스트로 만들 수 있다!!!

import java.util.List;

public class Sample {
	public static void main(String[] args) {
    	final List<String> a = List.of("a", "b");
        a.add("c"); // UnsupportedOperationException 발생
    }
}

++) 문제 풀이

6. myList.sort(Comparator,reverseOrder());

7. String result = String.join(" ", myList);

8. int result = grade.remove("B")

9. ArrayList<Integer> result = new ArratList<>(temp);

10. 
public class Sample{
	enum CoffeeType {
    	AMERICANO,
        ICE_AMERICANO,
        CAFE_LATTE
    };
    
 ...
 
 printCoffeePrice(CoffeeType,AMERICANO);

드디어 배열로 넘어갔습니다^^

파이썬반에 들어가면서 파이썬에 대해 열심히 배우고 있는데요...

자바를 놓아버리면 안될거 같아서 꾸준히 해보려고 합니다 💪💪💪

이번주 목표는 알고리즘 스터디(파이썬) 열심히 하기 !  , 백준 자바 1차원 배열 끝내기입니다 !!

import java.util.Scanner;

public class Solution_10807 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		# 정수의 개수 N 입력받기
        int N = sc.nextInt();
		
        # N개의 배열 만들기
		int arr[] = new int[N];
		for(int i = 0; i < N; i++) {
			arr[i] = sc.nextInt();
		}
        
        # 같은 수로 찾을 v 입력받기
		int v = sc.nextInt();
		sc.close();
		
        # 배열중에서 v와 같은 수 카운트
		int count = 0;
		for(int i = 0; i < N; i++) {
			if(v == arr[i])
				count++;
		}
		System.out.println(count);
	}
}

파이썬 계속하다보니 자바 배열 개념이 기억이 안나서 조금 다시 보고 풀었습니다 ㅎㅎ

이 문제의 핵심은 int arr[] = new int[N] 배열 만들기이지 않았을까..

import java.util.Arrays;를 왜 안 쓰지 찾아봤는데 배열 정렬, 비교, 채우기 할 떄 사용하면 되더라구여,,,

일반적인 생성만을 할 때는 아마도 안 적는 것 같습니다(?)

https://chb2005.tistory.com/6

요 블로그 참고해서 문제 풀었습니다 😮👍🙌

< 10951. A+B - 4 > 

입력이 끝날 때까지 A+B를 출력하는 문제. EOF에 대해 알아 보세요!!

아무생각 없이 앞문제랑 똑같네 뭐야,,, 하면서 열심히 적었는데 계속 런타임 에러가 나더라구요....ㅠ

그래서 다시 문제를 살펴봤는데 문제 밑에 EOF에 대해 알아보라고 하더라구여 ;;;;

EOF는 또 뭐람...

EOF 먼저 알아보겠습니다 🤔🤔

EOF : 데이터 소스로부터 더 이상 읽을 수 있는 데이터가 없음을 나타내는 용어

알고리즘 문제를 풀때 입력값을 얼마나 받을지 명시하지 않을 경우 사용합니다!!

1) Scanner 사용 시

• hasNext() 메소드 사용
• 입력된 토큰이 있으면 true를 반환하고, 그렇지 않을 경우 false를 반환합니다

2) BufferReader 사용시

• null 이 아님을 명시해 줍니다!!

파이썬과 C++ 언어 사용의 경우에 다 다르므로 자신이 사용하는 언어 별 EOF를 검색하시면 될 것 같아요 😂

import java.util.Scanner;
 
public class Main {
	public static void main(String args[]){
		
		Scanner in=new Scanner(System.in);
			
		while(in.hasNextInt()){
		
			int a=in.nextInt();
			int b=in.nextInt();
			System.out.println(a+b);
		}	
		in.close();
	}
}

원래라면 while(true)를 써줄껀데 마지막 데이터를 알 수 없으니까 while(in.hasNextInt())를 사용해줬다

진짜 몇번 틀렸는지 셀 수는 있지만ㅋ 많이 틀렸다..

이거 BufferReader로 바꾸면 또 많이 틀릴것 같았지만 해봐야할 거 같아서 일단 해봤다.

import java.io.*;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		StringTokenizer st;
		
		while (true) {
			String str = br.readLine();
			if (str == null) {
				break;
				
			}
			
			st = new StringTokenizer(str);
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			
			bw.write(a + b + "\n");
		}
		bw.close();
	}
}

값이 없으면 멈춰야 하니까 str == null을 사용해줬다.

메모리나 시간적으로나 적게 걸려서 버퍼리더 쓰는 연습을 열심히 해야할 것 같다.. 실제로 자바가 다른 언어보다 느리다고 하니 더더욱 버퍼 연습해야할 듯

<10952. A+B - 5>

package bj0715;

import java.util.Scanner;

public class Main {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
	
		while (true) {
			int a = sc.nextInt();			
			int b = sc.nextInt();
			
			if (a == 0 && b == 0) {
				sc.close();
				break;
			}
			
			else  {
				System.out.println(a + b);
			}
		}
	}
}

처음에 문제도 제대로 안 일고 테스트 케이스를 만들었는데 계속 정답이 안 나와서 다시 보니까

테스트 케이스를 입력한다는 조건이 없었다 ;;;;;

이래서 문제를 잘 읽어야 한다고...

아무리 생각해도 for 문을 사용해서는 문제가 안풀리겠다 생각했는데 반복문에 for만 있었던게 아니었던거 같다^^ 싶었음

그래서 while문을 사용해줬구여... 문제는  a, b 둘다 0일때만 while문을 빠져나가는 것으로 간단하게 해결했습다 😂

for문, while문은 서로 변환이 가능하기 때문에 반복문을 작성할 때 어느 쪽을 선택해도 좋지만, for문은 반복 횟수를 알고 있을 때 주로 사용하고 while문은 조건에 따라 반복할 때 주로 사용한다고 합니다!!

근데 sc.close가 입력을 다 받고 난 후로는 어디든 써도 된다고 알고 있는데 프린트 앞줄에 썼는데 안되더라구여..

혹쉬 아시는 분 있으시면 댓글 남겨주삼유 ✍️✍️

2438. 별 찍기 - 1

- Scanner문 사용 

import java.util.Scanner;

public class Main {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
        sc.close();
		
		
		for (int i =1; i<=N; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print("*");
			}
		System.out.println();
		} 
	}
}

N개의 줄에 N개의 별이 나와야 하므로 이중 포문을 돌려주고 띄워줘야하니까

N개의 줄에 해당하는 포문으로 나와서 println()을 넣어줬습니다~~~

별찍기 --2 번은 BufferedReader/BufferWriter 써보겠습니다

2439. 별 찍기 - 2

import java.io.*;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		StringTokenizer st;
		int N = Integer.parseInt(br.readLine());
		br.close();
		
		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N - i; j++) {
				bw.write(' ');
			}
			for (int k = 1; k <= i; k++) {
				bw.write('*');
			}
			bw.newLine();
		}
		bw.flush();
		bw.close();
	}
}