우리FISA AI엔지니어링 - JAVA 2

복습

 

형변환

 

package day02_dataType;

public class Reminder {

	public static void main(String[] args) {
		// Ctrl + D = 한줄 삭제
		// Ctrl + Alt + 화살표 = 한줄복사
		// Ctrl + F11 = 실행
		// 파이썬과 달리 자바는 CamelCase를 사용
		// 주석은 //
		/*
		 * 멀티라인 주석
		 */
		// 파이썬에서는 들여쓰기로 구분했던 단위를 자바에서는 { } 중괄호로 구분
		// { -> braket
		// 엔터로 실행문 하나하나를 구분했다면 자바에는 ;를 마침표로 사용
		
		// 자료형이 정적이기 때문에 자료형 변수명 방식으로 선언
		
		int a;
		a = 10;
		
		int b =10;
		
		float c = 3.14F;
		long d = 100000000L;
		
		boolean e = true;
		
		System.out.println(a);
		System.out.println(); // sysout + Ctrl + space
		
	}

}

 

 

삭제 삽입 등

package day02_dataType;

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

public class DataType3 {

	public static void main(String[] args) {
		// Array - 길이가 고정적
		// ArrayList - 자료형은 공통, 길이가 가변적, Array와 유사한 메서드, 변수
		// 넣고, 빼기 쉽게 하기 위해
		ArrayList arr = new ArrayList();
		System.out.println(arr);
		arr.add("morning");
		arr.add("afternoon");
		arr.add(1, "late morning"); // 인덱스를 통한 중간 끼워넣기가 가능
		arr.add(true);
		arr.add(3.14);
		System.out.println(arr);
		

		
		
		ArrayList<String> arr2 = new ArrayList();
		System.out.println(arr);
		arr2.add("morning");
		arr2.add("afternoon");
		arr2.add(1, "late morning"); // 인덱스를 통한 중간 끼워넣기가 가능
//		arr2.add(true);
//		arr2.add(3.14);
		System.out.println(arr2);
		
		// set
		arr2.set(1, "lateMorning");
		System.out.println(arr2);
		System.out.println(arr2.size());
//		"morning" 찾기
		
		//String으로 자료형을 고정해뒀기 때문에 String의 메서드를 상속받아서 사용
		System.out.println(arr.contains("morning"));
		
		// remove - 삭제
		arr2.remove(0); // index로 삭제
		System.out.println(arr2);
		
		arr2.remove("afternoon"); // 값으로 삭제
		System.out.println(arr2);
		
		// 같은 함수를 서로 다른 파라미터로 이용
		// 함수, 메서드는 재사용을 위해 만듦
		
		// 자바에서 가능
		// 같은 메서드를 파라미터 개수가 달라도 사용할 수 있게
		// 같은 메서드를 서로 다른 파라미터로 사용할 수 있게
		// 오버로딩 - 같은 클래스에서 이름이 같은데 파라미터 구조가 다르면 다른 기능을 할 수 있게
		// 같은 메서드를 int냐 String이냐 다른 파라미터를 받아서 다른 결과를 리턴하도록
		
		// 오버라이딩 - 부모클래스의 메서드를 다시쓰기
		// Array로 만들어서 쓰던 변수를 ArrayList로 바꾸는 경우 -> 형변환
		// Array로 하나 만들어볼게요. "morning", "afternoon"
		String[] arr4 = {"morning", "afternoon"}; // 메모리에 바이러니로 기억하고 있기 때문에
		// list->ArrayList
		ArrayList<String> arr5 = new ArrayList(Arrays.asList(arr4));
		System.out.println(arr5);
		
		// join - String의 메서드 중 split의 반대 
		// 1. String 변수를 만든다.
		// 2. String.join(arrayList를 넣는다.)
		String str = String.join(";", arr5);
		
		// 3. sysout으로 확인. morning;afternoon
		System.out.println(str);
		
		// sort 해서 출력해야 하는 경우가 많습니다. abc 가나다 123
		arr5.sort(null); // void -> 반환값 없음
						//natural Order -> 오름차순
		
		//System.out.println(arr5.add(sort(null)));
		System.out.println(arr5);
		
		arr5.sort(Comparator.reverseOrder()); // 내림차순
		System.out.println(arr5);
		
		// DataType4라는 클래스 생성 -> 1, 2, 7, 3, -10, 0이 들어있는 Arraylist를 만듭니다.
		// 3.15라는 값을 삽입
		// 5라는 값을 삽입
		// 2 삭제
		// 내림차순 정렬
		
	}

}

 

내림차순 정렬 sort

package day02_dataType;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
// DataType4라는 클래스 생성 
// 1) 1, 2, 7, 3, -10, 0 이 들어있는 ArrayList arr을 만듭니다
// 2) 3.15 라는 값을 삽입 
// 3) 5라는 값을 삽입
// 4) 2 삭제
// 5) 내림차순 정렬
public class DataType4 {

	public static void main(String[] args) {
		ArrayList<Integer> arrList = new ArrayList(Arrays.asList(1, 2, 7, 3, -10, 0));
		System.out.println(arrList);
		
		// 2) 3.15라는 값을 삽입
		arrList.add((int)3.15); //버림
		System.out.println(arrList);
		
		// 2) 5를 삽입
		arrList.add(5);
		
		// 4) 2 삭제
		arrList.remove(2);
		System.out.println(arrList);
		
		// 5) 내림차순 정렬
		arrList.sort(Comparator.reverseOrder());
		System.out.println(arrList);
		
		System.out.println(arrList.size()); // 길이
		
		// getter setter
		arrList.set(2, 100);
		System.out.println(arrList);
		
		//getter - 가져오기만 할 뿐 원본 변경 x
		System.out.println(arrList.get(2) + 2);
		System.out.println(arrList);
		
		
		
//		
//		ArrayList<Number> arrList = new ArrayList<Number>(Arrays.asList(1, 2, 7, 3, -10, 0));
//        arrList.add(3.15);
//        arrList.remove(2);
//        arrList.sort(Comparator.reverseOrder());
//        System.out.println(arrList);	
//        
	}

}

 

딕셔너리

package day02_dataType;

import java.util.HashMap;
import java.util.Map;

public class DataType5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		// Map -> Dictinary
		// key - value
		// Map이 본체, Hash 구현 방식
		// ArrayList도 List가 본체, Array가 구현방식
		// String String<키자료형, 벨류자료형>
		//Map<String, String> map = new HashMap<String, String>();
		Map<String, String> map = new HashMap();
		System.out.println(map);
		
		// 가변 자료형 C R U D
		// Create
		map.put("name", "kim");
		map.put("age", "30");
		System.out.println(map);
		
		// Read - 전체, Key, Value
		System.out.println(map.get("name")); // key로 value 호출
		System.out.println(map.keySet()); // key만
		System.out.println(map.values()); // value만
		System.out.println(map.entrySet()); // 
		
		// Update - 있는 key에 대한 value는 변경, 없으면 삽입
		map.put("name", "lee");
		System.out.println(map);
		
		// Delete
		map.remove("name");
		System.out.println(map);
		
		// 특정한 key가 있는지
		map.containsKey(map.containsKey("age"));
		
		// 특정 value가 있는지
		System.out.println(map.containsKey("lee"));
		
		// 특정 key가 있는지
	}

}

 

 

set

package day02_dataType;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class DataType6 {

	public static void main(String[] args) {
		// Set -> 집합 -> 중복되지 않고, 순서가 없는 값의 묶음 
		// HashSet
		Set<String> set = new HashSet<>();
		System.out.println(set);
		
		// 중복되지 않는 값들만 걸러서 들어갑니다.
		set.add("장정우");
		set.add("신짱구");
		set.add("신짱구");
		System.out.println(set);
		
		set.remove("장정우");
		System.out.println(set);
		
		System.out.println(set.isEmpty());
		
		System.out.println(set.contains("신짱구"));

		
		
		// 중복되지 않는 값만 확인할 수 있게 set3라는 set을 만들어주세요. 
		//		"양", "염소", "염소", "염소", "염소", "양", "알파카", "알파카", 
		//		"흑염소", "흑염소", "염소(흑)", "양(아기)", "산양"		
		
    
		Set<String> set3 = new HashSet<>();
		set3.addAll(Arrays.asList("양", "염소", "염소", "염소", "염소", "양", "알파카", "알파카","흑염소", "흑염소", "염소(흑)", "양(아기)", "산양"));
		System.out.println(set3);
		
		// 다른 방법
		String[] animals = {"양", "염소", "염소", "염소", "염소", "양", "알파카", "알파카", 
		"흑염소", "흑염소", "염소(흑)", "양(아기)", "산양"};
		
		HashSet<String> set2 = new HashSet<>(Arrays.asList(animals));
		System.out.println(set2);
		

	}

}

 

enum

package day02_dataType;

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

public class DataType7 {
	
	public static void main(String[] args) {
	// enum -> 파이썬 판다스 category와 같다 
	// SQL의 enum과 같습니다
	// 값을 강제할 때 또는 반복되는 값이 나와서 매번 string으로 입력하기 귀찮을 때 
	// 반복적으로 같은 값을 쓴다 -> 개념적으로 상수와 같다라고 생각해주시면 됩니다
	// 값으로 거의 대문자를 사용한다. 
	
	// String HashSet A.... 
	
	// python, java, sql, javascript 
	// Python, PYTHON 
		System.out.println(Language.JAVA);
		
		// 여러분이 쓸 수 있는 languageList를 담을 ArrayList를 하나 만들어주세요.
		// 들어가는 자료형은 Language 입니다.
		ArrayList<Language> languageList = new ArrayList(); // 이 안에는 개발자가 따로 지정한 옵션이 아닌 옵션은 들어가지 않는다.
		languageList.add(Language.JAVASCRIPT);
		languageList.add(Language.SQL);
		System.out.println(languageList);
		
	}
}

enum Language { // 데이터의 묶음이자 타입을 만듭니다.
	JAVA, PYTHON, SQL, JAVASCRIPT // 그 타입 안에 속하는 자료들을 지정 해줍니다.
	
}

 

switch

package day02_flowControl;

public class SwitchExample {

	public static void main(String[] args) {
		// SwitchExample 이라는 Class를 만드셔서 
		// Lunch라는 enum 타입에 Chicken Kimchi Soup 
		// 3개의 값을 넣어주시고 
		// switch문으로 해당 enum이 들어오면 한국어로 결과를 출력하도록 작성해주세요
		System.out.println(Lunch.Chicken);

		Lunch lunch = Lunch.Chicken;
		
		switch (lunch) {
			case Chicken: 
				System.out.println("치킨");
				break;
			case Soup: 
				System.out.println("수프");
				break;
			case Kimchi: 
				System.out.println("김치");
				break;
			default:
				System.out.println("모르겠음");
		}
	}

}

enum Lunch {
	Chicken, Kimchi, Soup 
}

 

switch 2

package day02_flowControl;

public class flowControl_switch {

	public static void main(String[] args) {
		// switch - case 문 -> case에 맞춰서 결과값이 switching 되기 때문이다
		int a = 3;
//		
		switch(a) {
			case 1:
				System.out.println("일");
				break;
			case 2:
				System.out.println("이");
				break;
			case 3:
				System.out.println("삼");
				break;
			default:
				System.out.println("몰라요");
				break;
		}
		
//		switch (경우) {
//			case 1:
//				case1를 만족시켰을 때 실행문;
//				break; // case를 만족시켰으면 더이상 뒤의 case는 실행하지 마시라 
//			case 2:
//				case2를 만족시켰을 때 실행문;
//				break;
//			case 3:
//				case3를 만족시켰을 때 실행문;
//				break;
//			default:
//				else처럼 위의 case에 모두 해당되지 않을 때의 실행문;
//		}
			// a의 값을 확인해서 1, "일", 2 - "이", 3 = "삼", 나머지 모든 경우이면 "몰라요"
	}

}

 

flow_if

package day02_flowControl;

public class flowControl_if {

	public static void main(String[] args) {
		// if 조건
		int age = 16;
		if (age > 18) {
			System.out.println("어른입니다.");
			}
		else if (13 <= age && 18 > age) {
				System.out.println("청소년입니다.");
		}
		else {
				System.out.println("어린이입니다.");
			}
		}
		// age라는 변수를 만들어서 16이라는 값을 넣고
		// 나이가 18보다 크면 '어른입니다' 를 출력해주세요
		// 나이가 13~18미만 '청소년입니다'
		// 나머지는 '어린이입니다.'
		
		// if ~ else
		// if ~ else if ~ else
		
	
}

 

flow_while

package day02_flowControl;

public class flowControl_while {

	public static void main(String[] args) {
		// while (조건) {
			// 조건이 만족될 경우의 실행문
			// }

		// 1. 외부에 실마리 -> while (언젠가 참이 될 조건) -> ++ -- 와 함께 많이 사용됩니다.
//		0~10까지를 출력하는 while문을 만들거에요.
		int i = 0; // 초기값
		
//		while (i < 11) {
////			System.out.println(++i);
//			System.out.println(i);   
//			i++; // i += 1 -> 후위증가연산자
////			++i;
//		}
		
//		// 2. while True -> if -> break 걸어주는 방법
//		while (true) {
//			System.out.println(i++);
//			
//			if (i == 11) {
//				break;
//			}
//		}
		
		// 0~10 사이에서 값을 하나씩 증가시키면서 3의배수는 출력하지 않는 while문을 만들어 주세요.
		// continue -> 한번만 상황을 빠져나가는 명령어
		
		i = 0;
//		while (i < 11) {
//			i++;
//			if (i % 3 == 0) {
//				continue;
////				System.out.println("3의배수입니다");
////				Unreachable code
//			}
//			System.out.println(i);
//			

		while (true) {
			i++;

			if (i % 3 == 0) {
				continue;
			}
			System.out.println(i);
			
			if (i > 10) {
				break;
			}
		}		
	
	// 0에서 11사이에서 3의 배수만 출력하는 while문
	// 최대한 효율적으로 - 짧거나(개발 생산성), 덜 반복하거나(메모리 효율)
	while (i < 11) {
		System.out.println(i);
		i += 3;
		}
		// do(딱 한번은 판단없이 실행) while(조건을 만족하는 동안만 실행) 
		// i < 11
		i = 13;
		do {
			System.out.println(i);
		} while (i < 11);
		

}
		

}

 

조건문 예시

package day02_flowControl;

public class IfExample {

	public static void main(String[] args) {
//		IfExample 이라는 class를 만드셔서 
//		arr 이라는 int Array에 값을 받아올 건데
//		size가 0이거나 null인 경우에는 
//		"결과가 없습니다"를 화면에 출력하는 조건문을 만들고
//		실행해주세요.
		int arr[] = null;
		System.out.println(arr);

//		int arr1[] = null;
//		System.out.println(arr1);
		
//		// 1. if ~ else if - size가 0이거나 null
//		if (arr == null) {
//			System.out.println("결과가 없습니다");
//		} else if (arr.length == 0) {
//			System.out.println("결과가 없습니다");
//		}


	// 2. 다중조건 -1. ||  첫번째 조건 확인 true -> 두번째는 보지도 않고 넘김 (Circuit Evaluation)
//	if (arr == null || arr.length == 0) {
//		System.out.println("결과가 없습니다");
//		}
	
	// 2. 다중조건 -2. 
	// java.lang.NullPointerException 
	// null 이 가지지 않는 변수나 함수를 사용하려고 할 때 나는 에러 
//	if (arr.length == 0 || arr == null ) {
//		System.out.println("결과가 없습니다");
//		}
	
	// 3. 중첩조건문 
	// java.lang.NullPointerException 
	// null 이 가지지 않는 변수나 함수를 사용하려고 할 때 나는 에러 
	if (arr != null ) {
		System.out.println("arr은 null이 아닙니다.");
		
		if (arr.length==0) {
		System.out.println("결과가 없습니다.");
		}
	} else {
		if (arr == null) {
			System.out.println("결과가 없습니다");
		}
	}
	}
}

 

 

연산자

package day02_flowControl;

public class operand {
	// 연산자 - 단항 / 이항 / 삼항 연산자 
	public static void main(String[] args) {
		// 연산자 
		// 부호연산자 ( +, - )  - 부호를 결정하는 연산자
		int num = +9;
		int num1 = -9;
		System.out.println(num);
		System.out.println(num1);
		
		// 대입연산자  = 
		int a = 1;
		// 단항:  증감연산자 (전위연산자 / 후위연산자) 
		System.out.println(a); // 1
		// 실행 후에 값을 1 추가하고 싶은 경우  - 후위연산자
		System.out.println(a++); // 1
		System.out.println(a); // 2        a = a+1
		
		// 실행 전에 값을 1 추가하고 싶은 경우  - 전위연산자
		System.out.println(++a); // 3
		System.out.println(a); // 3      a+1 = a
		
		// 관계연산자   >, <, <=, >=, ==, !=  -> true/false 로 판단의 결과 리턴
		int b = 3;
		System.out.println(a == b);
		System.out.println(a != b);
		
		// 논리연산자 &&(and), ||(or), !(not) -> true
		System.out.println((a > 0) && (b > 0));
		System.out.println((a > 0) || (b > 0));
		System.out.println((a > 0) || !(b > 0));
		System.out.println((a > 0) && !(b > 0));
		
		// 비트연산자  
		System.out.println((a > 0) & (b > 0));
		System.out.println((a > 0) | (b > 0));
		System.out.println((a > 0) | !(b > 0));
		System.out.println((a > 0) & !(b > 0));
		
		boolean c = false;
		boolean d = false;
		System.out.println(c && (d = true));
		// && 연산 -> c를 판단할 때 결과는 확정 
		// d에 대해서는 보지도 않음
		// d = true 는 실행 안됨
		System.out.println(d);
		
		boolean f = false;
		boolean g = false;
		System.out.println(f & (g = true));
		System.out.println(g); 
		// 비트연산은 앞 뒤를 다 보고 연산 -> f의 결과와 상관없이 g를 실행
		
		// 복합대입연산자 += -> 1이 아닌 어떤 값을 사칙연산에서 적용 
		System.out.println(a);
		a = a % 2;
		System.out.println(a);
		a %= 2; // 	a = a + 2;
		System.out.println(a);
		
		// 조건연산자(삼항연산자) -> 간단한 조건문 대신 할 수 있어서 
//		(조건) ? 참 : 거짓
		int age = 16;
		String answer = (age > 18) ? "어른입니다" : "어린이입니다";
		System.out.println(answer);
		
		a = 5;
		b = 3;
		
		boolean flag = (a > b) && (a > 0); 
		System.out.println(flag);
				
		

	}

}

 

 

for문

 

package day02_flowControl;

public class flowControl_for {

	public static void main(String[] args) {
//		int i = 0; // 초기값
//		while (i < 11) { // 조건식
////			System.out.println(++i);
////			i++;  // 증감식
//		}
		
		// for (초기값;조건식;증감식){
//		}
			int a = 3;
			// int a = 3;
			
			for (int i = 0; i < 11; i++){
				System.out.println(i);
			}
			
			// 2씩 건너뜀 -> 보기에 편하지는 않죠 
			for (int i = 0; i < 11; i++){
				System.out.println(++i);
			}
			
			// for문 - 참조자료형과 많이 사용됨 arr[i]
	        // 다양한 치즈의 종류를 for문으로 출력
	        String[] cheese = {"cheddar", "gouda", "edam"
	                , "provolone", "parmesan"};
	        //    초기값      조건식              증감식
	        for (int i = 0; i < cheese.length ;i++) {
	        	System.out.println(cheese[i]);
	        }
	        
	        System.out.println("--------");
	        // 0, 2, 4번 인덱스만 호출
	        for (int i = 0; i < cheese.length ; i+=2) {
	        	System.out.println(cheese[i]);
	        }
	        
        
        // 치즈를 인덱스 거꾸로 출력
        //    초기값      조건식              증감식
        for (int i = cheese.length - 1 ; i >= 0; i--) {
        	System.out.println(i+ ' ' + cheese[i]); // 4 3 2 1 0
        	}

        System.out.println("---------");
	
	// for chees in cheese  
        // 방향 조절이 불가능합니다
        // 집합자료형에서 인덱스를 경유하지 않고 값을 가져올 수 있습니다 
	for (String chees : cheese) {
		System.out.println(chees);
		}
	}


}

 

 

java 쉽지 않다..