231221 Java

금일 첫 교시는 프로그래머스 콜라 문제

class Solution {
    public int solution(int a, int b, int n) {
        int answer = 0;
        Cola cola = new Cola();
        answer = cola.bottle(a,b,n);
        // while (n >= a) {
        //     answer = answer + n / a * b;
        //     n = (n / a) * b + (n % a);
        // } // 재귀 함수 없으면 반복문으로 해결
        return answer;
    }
}

class Cola {
    int retrun = 0;
    public int bottle (int a, int b, int n) {
        retrun = retrun + n/a * b;
        n = n / a * b + n % a;
        if (n < a) return retrun;
        else return bottle(a, b, n);
    }
}

 

컬렉션 프레임워크

package study;
// 컬렉션 -> java.lang -> 예외처리 이후 DB 처리 가능
// 스레드 -> 입출력 -> 중첩
public class Study01 {
}

 

랩퍼 클래스

package com.poseidon.wrapper;
// 랩퍼 클래스
/* 주방에서 사용하는 랩 = 포장
 * 컬렉션은 R 타입만 담을 수 있음
 * P 타입을 R 타입으로 감싸 저장하면 됨 -> 래퍼
 *
 * 기본 자료형의 값을 컬렉션에 담기 위해서는 랩퍼 클래스를 사용
 * 기본 자료형에 대해서 그에 대응하는 랩퍼 클래스가 있음
 * 기본 자료형의 값을 멤버 변수의 값으로 저장하고
 * 이 값 주위로 값을 가공하는 메소드들이 감싸고 있다고 하여 랩퍼(wrapper : 감싸다) 클래스라고 함
 *
 * 기본 자료형       랩퍼 클래스
 *   byte             Byte
 *   short            Short
 *   int              Integer
 *   long             Long
 *   float            Float
 *   double           Double
 *   char             Character
 *   boolean          Boolean
 */
public class WrapperEx {
    public static void main(String[] args) {
        int num = 100;
        Integer number = 100; // 기존 int 와 다른 객체가 생성, 다른 heap 공간에 생성
        Integer number2 = new Integer(100); // java 9 이상부터 평소 선언 방법으로 해도 됨
        num = number2; // 자동 형 변환하여 대입
        byte bNum = number2.byteValue();
        short sNum = number2.shortValue();
        double dNum = number2.doubleValue();

        Short number3 = 100;
        bNum = number3.byteValue();
        System.out.println(Integer.MAX_VALUE); // int 형의 최댓값, 2147483647
        System.out.println(Integer.MIN_VALUE); // int 형의 최솟값, -2147483648
        System.out.println(Byte.MAX_VALUE); // 127
        System.out.println(Byte.MIN_VALUE); // -128

        // 박싱 언박싱
        /* 기본 타입의 값을 포장 객체로 만드는 과정 : 박싱 Boxing
         * 반대로 포장 객체에서 기본 타입의 값을 꺼내는 : 언박싱 UnBoxing
         */
        Integer integer = 30;
        Integer integer2 = new Integer("30");
        Integer integer3 = Integer.valueOf("300");
        // Integer integer = new Integer(30); 이렇게 변경됨
        // 오토박싱
        // 형 변환이 아님, 기본 자료형이 참조형으로 바뀜
        if (integer == integer2) System.out.println("같은 값");
        else System.out.println("다른 값"); // 다른 값 출력
    }
}

 

랩퍼 클래스 포장 값 비교하기

package com.poseidon.wrapper;

public class Wrapper02 {
    public static void main(String[] args) {
        // 포장 값 비교하기
        // 포장 값 비교하기 위해 ==, != 같은 연산자를 사용하지 않아야 함
        // 해당 연산자는 내부 값을 비교하는 것이 아니라 포장 객체의 참조를 비교
        Integer obj = 127;
        Integer obj2 = 127;
        System.out.println(obj); // 127
        System.out.println(obj2); // 127
        System.out.println(obj == obj2); // true
        Integer obj3 = 301;
        Integer obj4 = 301;
        System.out.println(obj3); // 301
        System.out.println(obj4); // 301
        System.out.println(obj3 == obj4); // false
        System.out.println(obj3.equals(obj4)); // true
        // equals() 도 사용해도 됨
        // 값 비교는 compareTo(), "<=" 연산자 라고 생각하면 편함
        // 출력 값은 괄호 안의 값이 크면 -1, 같으면 0, 괄호 안이 작으면 1
        System.out.println(obj.compareTo(obj2)); // 0
        if (obj3.compareTo(obj4) == 0) {
            System.out.println("값이 같음");
        } else if (obj3.compareTo(obj4) < 0) { // -1
            System.out.println("값이 다름, obj4 가 큼");
        } else { // 1
            System.out.println("값이 다름, obj3 이 큼");
        }
        // R -> P
        // 오토 언박싱
        int iNum = obj;
        Object obj1 = 40;
        // iNum = obj1; // 불가
        iNum = (int) obj1; 
        iNum = ((Integer) obj1).intValue(); 
    }
}

 

List

package com.poseidon.coll;

import java.util.ArrayList;
import java.util.List;

// 컬렉션
// List, Set, Map
/*
 * 클래스 선언부에 <E>, <T>, <K, V> 가 붙은 것을 볼 수 있음
 * 이 것은 제네릭 이라고 함 (자바 1.5 버전에 추가)
 * E : 요소, Element
 * T : 타입, Type
 * K, V : 키, 값(밸류), Key, Value
 */
public class Coll01 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(10);
        list.add(20);

        System.out.println(list); // [10, 20]

        System.out.println(list.get(0)); // 10
        System.out.println(list.get(1)); // 20
        // System.out.println(list.get(2)); // IndexOutOfBoundsException 에러 발생

        System.out.println(list.size()); // 리스트의 길이

        list.add(0, 100); // 0 번 인덱스에 100 값을 저장
        System.out.println(list); // [100, 10, 20], 10, 20 값이 한 칸씩 뒤로 밀림

        System.out.println(list.isEmpty()); // list 가 비었는지 확인, boolean 리턴, false

        list.set(1, 40); // list 배열 1 번 인덱스의 값을 40 으로 변경
        System.out.println(list); // [100, 40, 20]

        list.remove(1); // 1 번 인덱스의 값을 삭제
        System.out.println(list); // [100, 20]

        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " "); // 100 20
        }
        for (int i : list) {
            System.out.println(i); // list 에 들어있는 모든 값 출력
        }

        list.clear(); // 리스트에 들어있는 모든 값을 삭제
        System.out.println(list.isEmpty()); // true

        ArrayList<Integer> list2 = new ArrayList<>(); // 뒤의 꺽쇠 괄호 안의 Integer 생략 가능
        List<Integer> list3 = new ArrayList<>(); // List 인터페이스를 상속하는 ArrayList 로 생성
        for (int i = 1; i <= 10; i++) {
            list2.add(i);
        }
        System.out.println(list2);
        for (int i = 0; i < list2.size(); i++) {
            list2.remove(i + 1);
        }
        System.out.println(list2); // [1, 3, 5, 7, 9]
    }
}

 

List 정렬하기

package com.poseidon.coll;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class List01 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 6; i++) {
            int random = (int) (Math.random() * 45) + 1;
            list.add(random);
        }
        System.out.println(list); // [44, 18, 11, 30, 38, 10]
        Collections.sort(list); // 배열의 값 정렬
        System.out.println(list); // [10, 11, 18, 30, 38, 44]
        Collections.reverse(list); // 배열 뒤집기
        System.out.println(list); // [44, 38, 30, 18, 11, 10]
        Collections.sort(list, Collections.reverseOrder()); // 배열 역순으로 정렬
        System.out.println(list); // [44, 38, 30, 18, 11, 10]
    }
}

 

문자열 List

package com.poseidon.coll;

import java.util.ArrayList;

public class List02 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("홍길동");
        list.add("김길동");
        list.add("이길동");
        list.add("박길동");
        list.add("최길동");
        list.add("홍길동");
        System.out.println(list); // [홍길동, 김길동, 이길동, 박길동, 최길동, 홍길동]
        System.out.println(list.size()); // 6
        list.remove("홍길동"); // "홍길동" 문자열 중 가장 앞에 있는 1 개 삭제
        System.out.println(list.size()); // 5
        System.out.println(list); // [김길동, 이길동, 박길동, 최길동, 홍길동]
        list.remove("홍길동");
        System.out.println(list); // [김길동, 이길동, 박길동, 최길동]
        list.remove("한길동"); // 없는 문자열 삭제해보기, boolean return 타입
        System.out.println(list); // [김길동, 이길동, 박길동, 최길동], 변함 없음
    }
}

 

제네릭

package com.poseidon.coll;

import java.util.ArrayList;
import java.util.List;

public class List03 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        // int number = list.get(0); // 오류 발생
        int number = (int) list.get(0); // List 생성이 object 타입이라 캐스트를 다 걸어야 함
        list.add("홍길동"); // 문자열 추가
        int num = (int) list.get(1); // 실행 시 오류 발생
        for (int i = 0; i < list.size(); i++) {
            int numnum = (int) list.get(i); // list 안의 값에 따라 오류 발생
        }
        // 오류 발생을 방지하기 위해 <> 안에 타입을 지정해 놓는 것
        List<Integer> list2 = new ArrayList<>();
    }
}

 

Set 컬렉션

package com.poseidon.coll;

import java.util.*;

// List : 순서가 있음, 중복 허용
// Set : 순서가 없음, 중복 불허용
// Map :
public class Set01 {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(2);
        // set.get(0); // set 은 get 메소드가 없음
        System.out.println(set); // [1, 2, 3], 중복 제거
        Set<String> set2 = new HashSet<>();
        set2.add("홍길동");
        set2.add("김길동");
        set2.add("이길동");
        set2.add("박길동");
        set2.add("최길동");
        set2.add("홍길동");
        System.out.println(set2); // [박길동, 김길동, 홍길동, 최길동, 이길동]
        System.out.println(set2.size()); // 5, "홍길동" 중복 제거

        HashSet<Integer> set1 = new HashSet<>(Arrays.asList(3,2,1));
        System.out.println(set1.isEmpty());// false
        System.out.println(set1); // [1, 2, 3]

        // 로또 만들어보기
        Set<Integer> lotto = new HashSet<>();
        while (lotto.size() < 6) { // while 문 반복하기
            lotto.add((int) (Math.random() * 45) + 1);
        }
        System.out.println(lotto);

        Set<Integer> setLotto = new HashSet<>();
        for( ;setLotto.size() < 6 ;) { // for 문 반복하기
            setLotto.add((int) (Math.random() * 45) + 1);
        }
        System.out.println(setLotto);


        List<Integer> list = new ArrayList<>(lotto); // set lotto 값을 ArrayList 에 저장
        System.out.println(list);
        for (int i : list) {
            System.out.println(i);
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("--------------------");

        // Iterator, set 에서 값을 받음
        Iterator<Integer> iterator = lotto.iterator();
        while (iterator.hasNext()) { // iterator 에 다음 값이 있는지 체크
            System.out.println(iterator.next()); // 다음 값 출력
        }
        /* 반복자
         * 컬렉션 인터페이스의 iterator() 메소드는 Iterator 를 리턴
         * Iterator 는 Enumeration 인터페이스와 비슷하나 Enumeration 보다 나중에 만들어 짐
         */
        // List 에서 중복을 제거하고 싶으면 Set 으로 변환 후 List 로 변환 시 중복 자동 제거
        List<String> names = new ArrayList<>();
        names.add("홍길동");
        names.add("김길동");
        names.add("최길동");
        names.add("홍길동");
        names.add("홍길동");
        names.add("홍길동");
        names.add("이길동");
        names.add("홍길동");
        names.add("홍길동");
        System.out.println(names.size()); // 9

        Set<String> names2 = new HashSet<>(names); // List 를 Set 으로 변환하여 중복 제거
        System.out.println(names2.size()); // 4
        System.out.println(names2); // [김길동, 홍길동, 최길동, 이길동]
        names = new ArrayList<>(names2);
        System.out.println(names); // [김길동, 홍길동, 최길동, 이길동]
    }
}

 

Set 에 같은 값을 추가하였을 때

기존 값이 유지되는지, 기존 값을 삭제하고 새로운 값을 추가하는 지 확인하는 법

package com.poseidon.coll;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

// set 에 하나의 값만 저장하는데, 그게 처음 값인지 나중에 들어온 값인지 확인
public class Set02 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("홍길동");
        set.add("홍길동");
        set.add("홍길동");
        set.add("홍길동");
        String name = new String("홍길동");
        System.out.println(System.identityHashCode(name));
        System.out.println(System.identityHashCode(set));
        set.add(name);

        name = new String("박길동");
        System.out.println(System.identityHashCode(name));
        set.add(name);

        System.out.println(set.size());
        System.out.println("---------");
        // 클래스를 만들어 static 변수로 값을 변경시켜 저장해보기
        Set<Human> humans = new HashSet<>();
        Human n = new Human();
        System.out.println(n.ssn); // 1
        humans.add(n);
        n.ssn = 10;
        humans.add(n);
        n.ssn = 20;
        humans.add(n); // 한 객체를 여러 번 추가하기 때문에 기존 값 삭제 후 새로운 값 덮어쓰기
        System.out.println(humans.size()); // 1
        System.out.println(n.ssn); // 20, 기존 1, 10 값은 사라지고 20 이 추가됨
        humans.add(new Human());
        humans.add(new Human());
        humans.add(new Human()); // 추가할 때마다 heap 공간에 새로운 객체를 생성하여 추가
        humans.add(new Human()); // 새로운 객체가 Set 에 추가되기 때문에 중복이 아님
        System.out.println(humans.size()); // 5
        List<Human> list = new ArrayList<>(humans);
        System.out.println(list.get(0).ssn); // 3
        for (Human h : list) {
            System.out.print(h.ssn + " "); // 3 4 20 5 2
        }
    }
}

class Human {
    int ssn;
    static int number;

    public Human() {
        this.ssn = ++number;
    }
}

 

Map, set 과 map 의 중복 값 추가 시 덮어쓰기 여부 확인

package com.poseidon.coll;

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

/*
 * List : 순서 O, 중복 O
 * Set : 순서 X, 중복 X
 * Map : Key 와 Value 를 쌍으로 저장
 *       Key 는 중복 X, Value 는 중복 O
 */
public class Map01 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        HashMap<String, String> map2 = new HashMap<>(); // 둘 다 가능
        map.put("제주도", "귤");
        map.put("수원", "왕갈비");
        map.put("수원", "반도체");
        map.put("춘천", "닭갈비");
        System.out.println(map.size()); // 3, Key 기준으로 count, key 중복 제거
        System.out.println(map); // {수원=반도체, 제주도=귤, 춘천=닭갈비}
        System.out.println(map.get("수원")); // 반도체, 기존 값 삭제 후 새로운 value 저장
        System.out.println(map.containsKey("수원")); // true, key 여부 확인, boolean 리턴
        System.out.println(map.containsValue("쌀")); // false, value 여부 확인, boolean 리턴
        System.out.println(map.containsValue("왕갈비")); // false, 이미 교체 된 value
        System.out.println(map.containsValue("반도체")); // true
    }
}