Java2 day13

JAVA2 day05
[13일차 수업내용]
1. Arrays
2. Comparable, Comparator
3. HashSet
4. Hashmap
===========================================================
1. Arrays
            - Arrays 클래스에는 배열을 다루는데 유용한 클래스가 정의
            - 클래스 내부의 모든 메소드는 static 메소드 ==> 인스턴스가 필요 없음

            ① 배열의 복사 - copyOf(), copyOfRange()
                        - copyOf()는 배열 전체를, copyOfRange()는 배열의 일부를 복사해서
                          새로운 배열을 만들어 냄
                        - copyOfRange()에 지정된 범위의 끝은 포함되지 않음

            ② 배열의 정렬과 탐색 - sort(), binarySearch()
                        - sort()는 배열을 정렬할 때, 
                          그리고 배열에 저장된 요소를 검색할 때는 binarySearch()를 사용
                        - binarySearch()는 배열이 정렬된 상태이어야 올바른 결과를 찾음

            ③ 문자열의 비교와 출력 - equals(), toString()
                        - toString()은 일차원배열에서만 사용할 수 있으며,
                          다차원배열에서는 deepToString()을 사용해야 함
                        - eqals()도 마찬가지로 일차원배열에서만 사용가능하므로,
                          다차원배열의 비교에는 deepEquals()를 사용해야 함

            ④ 배열을 List로 변환 - asList(Object... a)
                        - asList()는 배열을 List에 담아서 반환
                        - asList()가 반환한 List의 크기를 변경할 수 없으나 
                          저장된 내용의 변경은 가능
                        - 만약 크기를 변경할 수 있는 List가 필요하다면?
                          new ArrayList(Collection c); 생성자를 이용해 새로 만들어야 함

--------------------------------------------------------------
package arrays;

import java.util.Arrays;

public class ArraysEx {
            public static void main(String[] args) {
                        // copyOf(), copyOfRange()
                        int[] arr = {0, 1, 2, 3, 4};
                        int[][] arr2D = {
                                    {11, 12, 13},
                                    {21, 22, 23}
                        };

                        int[] arr2 = Arrays.copyOf(arr, arr.length);
                        // [0, 1, 2, 3, 4]
                        int[] arr3 = Arrays.copyOf(arr, 3);
                        // [0, 1, 2]
                        int[] arr4 = Arrays.copyOf(arr, 7);
                        // [0, 1, 2, 3, 4, 0, 0]
                        int[] arr5 = Arrays.copyOfRange(arr, 2, 4);
                        // [2, 3, 4] -> 답은 [2, 3] 마지막 4의 인덱스는 안찍어줌
                        int[] arr6 = Arrays.copyOfRange(arr, 0, 7);
                        // [0, 1, 2, 3, 4, 0, 0]

                        // toString()
                        System.out.println("arr : " + Arrays.toString(arr));
                        System.out.println("arr2 : " + Arrays.toString(arr2));
                        System.out.println("arr3 : " + Arrays.toString(arr3));
                        System.out.println("arr4 : " + Arrays.toString(arr4));
                        System.out.println("arr5 : " + Arrays.toString(arr5));
                        System.out.println("arr6 : " + Arrays.toString(arr6));
                        System.out.println("arr2D : " + Arrays.toString(arr2D));
                        System.out.println("arr2D : " + Arrays.deepToString(arr2D));
                        System.out.println();

                        // equals(), deepEquals()
                        System.out.println(Arrays.equals(arr, arr2));
                        System.out.println();

                        String[][] str2D = new String[][] {{"aaa", "bbb"}, {"AAA", "BBB"}};
                        String[][] str2D2 = new String[][] {{"aaa", "bbb"}, {"AAA", "BBB"}};

                        System.out.println("str2D : " + Arrays.toString(str2D));
                        System.out.println("str2D2 : " + Arrays.toString(str2D2));
                        System.out.println(Arrays.equals(str2D, str2D2));
                        System.out.println();
                        System.out.println("str2D : " + Arrays.deepToString(str2D));
                        System.out.println("str2D2 : " + Arrays.deepToString(str2D2));
                        System.out.println(Arrays.deepEquals(str2D, str2D2));
                        System.out.println();

                        // sort(), binarySearch()
                        int[] numArr = {0, 7, 5, 1, 2};
                        System.out.println("numArr : " + Arrays.toString(numArr));
                        System.out.println("index of 1 : " + Arrays.binarySearch(numArr, 1));
                        Arrays.sort(numArr);
                        System.out.println("===== After sorting =====");
                        System.out.println("numArr : " + Arrays.toString(numArr));
                        System.out.println("index of 1 : " + Arrays.binarySearch(numArr, 1));

                         // asList()
                        List list = Arrays.asList(1, 2, 3, 4, 5);
                        System.out.println("list : " + list);
                        System.out.println("list.size() : " + list.size());
                        // list.add(6); add는 쓸 수 없음
                        list = new ArrayList(list);
                        list.add(6);
                        System.out.println("list : " + list);
            }
}

====================================================================

2. Comparable, Comparator
            - Arrays.sort()를 호출하면 컴퓨터가 알아서 배열을 정렬하는 것처럼 보이지만
              그게 아닌 사실 Comparable 인터페이스 구현에 의해 정렬이 된 것
            - Comparator와 Comparable은 모두 인터페이스로 컬렉션을 정렬하는데
              필요한 메소드를 정의하고 있으며, Comparable을 구현하고 있는 클래스들은
              주로 Integer와 같은 래퍼클래스, String과 같은 것들이며 기본적으로
              오름차순으로 정렬하도록 구현되어 있음
                        ==> Comparable을 구현한 클래스는 정렬이 가능하다는 것을 의미
            - compare()와 compareTo()는 선언형태와 이름이 약간 다를 뿐 두 객체를 비교한다는
              같은 기능을 목적으로 고안된 것
            - compareTo()의 반환값은 int이지만 실제로 비교하는 두 객체가 같으면 0,
              비교하는 값보다 작으면 음수, 크면 양수를 반환하도록 구현해야 함
            - 마찬가지로 compare()도 객체를 비교해서 음수, 0, 양수 중의 하나를 반환하도록 구현해야 함
            - Comparable을 구현한 클래스들이 기본적으로 오름차순으로 정렬되어 있지만,
              내림차순으로  정렬한다던가 아니면 다른 기준에 의해서 정렬되도록 하고 싶을 때
              Comparator를 구현해서 정렬 기준을 제공할 수 있음
            
                        * Comparable                 기본 정렬을 구현하는데 사용
                        * Comparator                 기본 정렬 기준 외의 다른 기준으로 정렬하고자 할 때 사용

------------------------------------------------------
package compare;
            
import java.util.Arrays;
import java.util.Comparator;

public class ComparatorEx {
            public static void main(String[] args) {
                        String[] strArr = {"cat", "Dog", "lion", "tiger"};
                        System.out.println("정렬 전 : " + Arrays.toString(strArr));
                        Arrays.sort(strArr);
                        System.out.println("기본정렬 후 : " + Arrays.toString(strArr));
                        Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER);
                        System.out.println("대소문자 구분하지 않은 정렬 후 : " + Arrays.toString(strArr));

                        Integer[] numArr = {2, 1, 7, 5, 8};
                        Arrays.sort(numArr);
                        System.out.println("numArr : " + Arrays.toString(numArr));

                        // 역순정렬
                        numArr = new Integer[] {2, 1, 7, 5, 8};
                        Arrays.sort(numArr, new Descending());
                        System.out.println("numArr : " + Arrays.toString(numArr));
            }
}

// 역순정렬 클래스 구현 deep 하게 하고 싶으면 더 해볼 것
class Descending implements Comparator{
            @Override
            public int compare(Object o1, Object o2) {
                        if(o1 instanceof Comparable && o2 instanceof Comparable) {
                                    Comparable c1 = (Comparable)o1;
                                    Comparable c2 = (Comparable)o2;
                                    return c1.compareTo(c2) * -1;
                        }
                        return -1;
            }
}

=====================================================================

3. HashSet
            - HashSet은 Set인터페이스를 구현한 가장 대표적인 컬렉션이며, Set 인터페이스의 특징대로
              HashSet은 중복된 요소를 저장하지 않음
            - HashSet에 새로운 요소를 추가할 때는 add()나 addAll()를 사용하는데,
              만일 HashSet에 이미 저장되어 있는 요소와 중복된 요소를 추가하고자 한다면
              이 메소드들은 false를 반환함으로써 중복된 요소이기 때문에 추가에 실패했다는 것을 알림
            - 이러한 HashSet의 특징을 이용하면, 컬렉션 내의 중복 요소들을 쉽게 제거할 수 있음

-------------------------------------------------------
package hashSet;

import java.util.HashSet;
import java.util.Set;

public class HashSetEx01 {
            public static void main(String[] args) {
                        Object[] objArr = {"1", 1, "2", "2", "3", "3", "4", "4", "4"};

                        Set set = new HashSet();

                        for(int i = 0; i < objArr.length; i++) {
                                    System.out.println(set.add(objArr[i]));
                        }
                        System.out.println("set : " + set);
            }
}
------------------------
package hashSet;

import java.util.HashSet;
import java.util.Set;

public class HashSetEx02 {
            public static void main(String[] args) {
                        Set set = new HashSet();

                        set.add("abc");
                        set.add("abc");
                        System.out.println("set : " + set);

                        Person p1 = new Person(1111, "David");
                        Person p2 = new Person(1111, "David");
                        System.out.println(p1.equals(p2));
                        System.out.println("p1.hashCode : " + p1.hashCode());
                        System.out.println("p2.hashCode : " + p2.hashCode());
                        set.add(p1);
                        set.add(p2);
                        System.out.println("set : " + set);
            }
}

class Person{
            int id;
            String name;

            public Person(int id, String name) {
                        this.id = id;
                        this.name = name;
            }

            @Override
            public String toString() {
                        return id + " : " + name;
            }

            @Override
            public boolean equals(Object obj) {
                        if(obj instanceof Person) {
                                    Person tmp = (Person)obj;
                                    return this.id == tmp.id && this.name.equals(tmp.name);
                        }
                        return false;
            }

            @Override
            public int hashCode() {
                        return (id + name).hashCode();
            }
}
-----------------------------------------
package hashSet;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetEx03 {
            public static void main(String[] args) {
                        HashSet setA = new HashSet();
                        HashSet setB = new HashSet();
                        HashSet setHab = new HashSet();
                        HashSet setKyo = new HashSet();
                        HashSet setCha = new HashSet();

                        setA.add("1");
                        setA.add("2");
                        setA.add("3");
                        setA.add("4");
                        setA.add("5");
                        System.out.println("setA : " + setA);

                        setB.add("4");
                        setB.add("5");
                        setB.add("6");
                        setB.add("7");
                        setB.add("8");
                        System.out.println("setB : " + setB);

                        // iterator()
                        Iterator it = setB.iterator();

                        // 교집합구하기
                        while(it.hasNext()) {
                                    Object tmp = it.next();
                                    if(setA.contains(tmp)) {
                                                setKyo.add(tmp);
                                    }
                        }
                        System.out.println("setKyo : " + setKyo);

                        // A 차집합
                        // setCha = setA;
                        it = setA.iterator();
                        while(it.hasNext()) {
                                    Object tmp = it.next();
                                    if(!setB.contains(tmp)) {
                                                setCha.add(tmp);
                                    }
                        }
                        System.out.println("setCha : " + setCha);

                        // 합집합
                        // setHab = setA;
                        it = setA.iterator();
                        while(it.hasNext()) {
                                    setHab.add(it.next());
                        }
                        it = setB.iterator();
                        while(it.hasNext()) {
                                    setHab.add(it.next());
                        }
                        System.out.println("setHab : " + setHab);

            }
}

====================================================================== 
4. HashMap
            - HashMap은 Map을 구현했으므로, 키(key)와 값(value)을 묶어서 하나의 데이터(entry)로
              저장한다는 특징을 가짐
            - HashMap은 키(key)와 값(value)를 Object 타입으로 저장(무엇이든 다 저장)
            - 즉, (Object, Object)형식으로 저장하기 때문에 어떠한 객체도 저장할 수 있지만
              주로 key값은 String대문자 또는 소문자로 통일해서 사용

                        * 키(key)            컬렉션 내의 키(key)중에서 유일해야 함
                        * 값(value)          키(key)와 달리 데이터의 중복을 허용

            - 키(key)는 저장된 값(value)을 찾는데 사용되는 것이기 때문에 컬렉션 내에서 유일해야 함
            - 즉, HashMap에 저장된 데이터를 하나의 키(key)로 검색했을 때 결과가 단 하나여야 함을 뜻함
            - 만일 하나의 키에 대해 여러 검색결과 값을 얻는다면 원하는 값이 어던 것인지 알 수 없기 때문

-----------------------------------------------------------

package hashMap;

import java.util.HashMap;
import java.util.Scanner;

public class HashMapEx01 {
            public static void main(String[] args) {
                        HashMap map = new HashMap();
                        map.put("myId", "1234");
                        map.put("asdf", "1111");
                        map.put("asdf", "1234");
                        // put(Object key, Object value) : map에 key, value entry를 추가
                        System.out.println("map : " + map);

                        Scanner s = new Scanner(System.in);
                        while(true) {
                                    System.out.println("id와 패스워드를 입력해주세요.");
                                    System.out.print("id > ");
                                    String id = s.nextLine().trim();      // trim() : 좌우 공백 제거

                                    System.out.print("password > ");
                                    String password = s.nextLine().trim();
                                    System.out.println();

                                    if(!map.containsKey(id)) { // 입력한 id가 map의 key 중 일치하는 값이 없다면
                                                System.out.println("입력하신 id는 존재하지 않습니다. 다시 입력해주세요.");
                                                continue;
                                    } else {
                                                if(!map.get(id).equals(password)) { 
                                                            // 입력한 id값에 대한 비밀번호가 일치하지 않는다면
                                                            // get(Object key) : key에 상응하는 value값을 반환한다.
                                                            System.out.println("비밀번호가 일치하지 않습니다.");
                                                } else {
                                                            System.out.println("id와 비밀번호가 일치합니다.");
                                                            break;
                                                }
                                    }
                        }
            }
}
----------------------------------------------

package hashMap;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class HashMapEx02 {
            public static void main(String[] args) {
                        HashMap map = new HashMap();
                        map.put("김자바", 90);
                        map.put("김자바", 100);
                        map.put("이자바", 100);
                        map.put("강자바", 80);
                        map.put("박자바", 90);

                        System.out.println("map : " + map);

                        // 1. key값을 Set(list는 중복이 안되기 때문에 set이 어울림)으로 변경
                        Set set = map.keySet();
                        System.out.println("참가자명단 : " + set);

                        // 2. value값을 Collection으로 변경
                        Collection value = map.values();
                        System.out.println("점수 목록 : " + value);

                        int total = 0;
                        double avg = 0.0;

                        Iterator it = value.iterator();

                        while(it.hasNext()) {
                                    total += (int)it.next();
                                    // int i = (Integer)it.next();
                                    // total += i;
                        }
                        System.out.println("총점 : " + total);
                        avg = (double)total / map.size();
                        // avg = (double)total/ value.size();
                        System.out.println("평균 : " + avg);

                        // Collections 클래스는 컬렉션을 다루기 위해 유용한 메소드들이 모여있다.
                        System.out.println("최대점수 : " + Collections.max(value));
                        System.out.println("최소점수 : " + Collections.min(value));
            }
}