국비 23일차 JAVA 컬렉션, 제네릭, List, map

2021.02.24 국비교육 23일차

[TOC]

제네릭

package com.one;

import java.util.Date;

//Object 대신에 T(Type)의미로써 참조형 타입만 지정 가능
// T는 Box 객체를 생성할 때 구체저인 타입으로 변경가능하다는 것을 알려줌

class Box<T> {
    T obj;

    public void setValue(T obj) { 
        this.obj = obj;
    }

    public T getValue() { 
        return obj;
    }
}//end Box

public class GenericTest1 {
    public static void main(String[] args) {
        //제네릭스 타입(generics type)
        Box<String> b = new Box<String>();
        b.setValue("hello");
        //b.setValue(100); //다른 타입 사용 불가
        String x = b.getValue(); //형변환 필요없음 (String)b.getValue();
        System.out.println(x.length()); // 형변환 필요없음


        System.out.println(x);
        Box<Date> b2 = new Box<>();
        b2.setValue(new Date());
        //b2.setValue("AAA"); // 다른 타입 지정 안됨

    }

}

와일드 카드 타입

package com.test;


class Group<T>{
    T obj;
    public void setValue(T obj) {
        this.obj = obj;
    }

    public T getValue() {
        return obj;
    }

}

class Person{}
class man extends Person{}
class woman extends Person{}

public class Ex10_5 {

    public static void method(Group<?> group) {}
    public static void method2(Group<? extends Person> group) {}
    public static void method3(Group<? super Person> group) {}


    public static void main(String[] args) {

        //method : 어떤 타입도 설정 가능
        method(new Group<Object>());
        method(new Group<Person>());
        method(new Group<man>());
        method(new Group<woman>());

        //method2 : person 또는 person의 자식만 가능
        //method2(new Group<Object>());
        method2(new Group<Person>());
        method2(new Group<man>());
        method2(new Group<woman>());

        //method3 : person또는 person의 부모만 가능
        method3(new Group<Object>());
        method3(new Group<Person>());
        //method3(new Group<man>());
        //method3(new Group<woman>());

    }

}

컬렉션

• 대량의 데이터 관리에 배열보다 매울 효과적 (다양한 저장구조 제공)
• 저장되는 데이터 종류 무관
• 자동으로 크기변경 가능
• 저장되는 값은 참조형만 가능
• Collections API 활용하여 컬렉션을 효율적으로 관리 가능

set

• 데이터의 저장 순서가 없기 때문에 중복 저장이 불가능

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

public class setTest {

    public static void main(String[] args) {

        Set set = new HashSet();
        HashSet set2 = new HashSet(); // 추천되는 방법

        set.add("1"); // 추가 시 자동으로 방이 증가됨
        set.add("2");
        set.add(3); // 오토박싱 -> Integer
        set.add("4");
        set.add(3.15);
        set.add(new Date());
        set.add(new Date());


        //값 출력
        System.out.println("길이 : " + set.size());
        System.out.println("포함여부 : " + set.contains(20));
        System.out.println("empty? : " + set.isEmpty());

        //System.out.println(set.remove("홍길동")); // false -> 삭제안됨
        Object [] xxx = set.toArray(); // 배열화
        for(Object o : xxx) {
            System.out.println(o);
        }

        System.out.println(set);
        set.clear(); // 전부 제거
        System.out.println(set);

    }

}

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

public class setTest2 {

    public static void main(String[] args) {

        HashSet<String> set = new HashSet(); //제너릭 지정 String만 저장

        set.add("1");
        set.add("1");
        set.add("1"); //중복불가
        set.add("1");
        set.add("2");
        set.add("3");
        set.add("4");
        set.add("5");
        set.add("6");
        //set.add(10); // 잘못된 데이터 저장 감지를 컴파일 때 인식가능

        //1. toString()
        System.out.println("set.toString : " + set.toString());
        //System.out.println("set.toString : " + set); 같은 결과

        //2.for - each
        for (String x : set) {
            System.out.println("for - each : " + x);            
        }

        //3. 일관된 방법인 Iterator 사용
        Iterator<String>ite = set.iterator();
        while(ite.hasNext()) {
            String m = ite.next(); // 중요
            System.out.println("iterator : " + m);
        }

//        while (ite.hasNext()) {
//            String string = (String) ite.next();    
//        } 자동완성 결과물


        //4.Iterator를 이용한 자료 검색

        Iterator<String> i = set.iterator();
        while (i.hasNext()) {
            String data = i.next();
            if(data.equals("1")) {
                System.out.println("data : " + data);
            }
        }
    }
}

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

public class setTest3 {

    public static void main(String[] args) {

        //홍길동 20 서울, 이순신 44 전라, 유관순 17 서울
        Set<Person> set = new HashSet<Person>();
        Person kkkk = new Person("유관순", 17, "서울");
        set.add(kkkk);
        set.add(kkkk);
        set.add(kkkk); // kkkk 객체 주소가 같기 때문에 하나가 들어감
        set.add(new Person("홍길동", 20, "서울"));
        set.add(new Person("이순신", 44, "전라"));
        set.add(new Person("이순신", 44, "전라")); // 15번과 16번의 객체 주소가 달라서 2개 다 들어감
        System.out.println(set.size());
        System.out.println(set);

        //for each를 사용한 데이터 출력
        for(Person k : set) {
            System.out.println("for - each : " +k.getName());
        }

        //Iterator 이용한 데이터 출력
        Iterator<Person> i = set.iterator();
        while (i.hasNext()) {
            Person data = i.next();
            System.out.println("iterator : " + data.getName());

        }    
    }
}

import java.util.HashSet;

public class setTest4 {

    private static void change(int num) {
        num = 10;
    }

    private static void change2(int[] num) {
        num[0] = 10;    
    }
    private static void change3(HashSet<String> num) {
        num.remove("홍길동");
    }

    public static void main(String[] args) {

        int m = 9;
        System.out.println("변경전 : " + m);
        change(m);
        System.out.println("변경후 : " + m);//m = 9 --> call by value

        int[]m2 = {9,8,7};
        System.out.println("변경전 : " + m2[0]);
        change2(m2);
        System.out.println("변경후 : " + m2[0]); // m2[0] = 10 --> call by ref


        HashSet<String> set = new HashSet<String>();
        set.add("홍길동");
        set.add("이순신");
        set.add("유관순");

        System.out.println("변경 전 : " + set);
        change3(set);// public static void change3(HashSet<String> set)
        System.out.println("변경 후 : " + set);
    }
}

set을 활용하여 DB data 끌어오기

import java.util.HashSet;
import com.service.OracleService;

public class OracleMain {

    public static void main(String[] args) {
        //OracleMain <--> OracleService

        OracleService service = new OracleService();

        HashSet<String> xxx = service.select(); //1. 데이터 요청(select), 5.데이터 반환(HashSet에 저장)

        for(String s : xxx) {
            System.out.println(s);  //홍길동 이순신 유관순 출력
        }
    }
}

package com.service;

import java.util.HashSet;
import com.dao.OracleDAO;

public class OracleService {
    //Oracle Main <--> OracleService <--> Oracle DAO

    OracleDAO dao;;

    public OracleService() {
        dao = new OracleDAO();
    }

    public HashSet<String> select() { 
        HashSet<String> xxx = dao.select(); //2.데이터 요청(select), 4.데이터 반환(HashSet에 저장)
        return xxx; //메인으로 반환
    }
}

package com.dao;

import java.util.HashSet;

public class OracleDAO {

    public HashSet<String> select() {
        //DB연동 데이터 가져오는 코드가 들어가야함
        HashSet<String>set = new HashSet<String>();
        set.add("홍길동");
        set.add("이순신");
        set.add("유관순"); //3,4 DB 접근 + 데이터 반환
        return set; // 서비스로 리턴 (4번작업)
    }
}

List

• 데이터 중복가능, 순서있음(인덱스 존재)

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

public class ListTest3 {

    public static void main(String[] args) {


        List<String> list = new ArrayList<>();
        list.add("홍길동");
        list.add("이순신");
        list.add("유관순");
        list.add("강감찬");
        list.add("세종");

        System.out.println("길이(크기) :" + list.size());
        System.out.println("값 포함여부 :" + list.contains("세종"));
        System.out.println("특정값 위치 :" + list.indexOf("세종"));
        System.out.println("값의 여부 :" + list.isEmpty());

        System.out.println(list);
        System.out.println("===============");

        //List 추출
        List<String>sub = list.subList(0, 3);
        for(String x: sub) {
            System.out.println("sub : " + x);
        }

        //Object 변환
        Object[] obj = list.toArray();
        for(Object x : obj) {
            System.out.println("object : " + x);
        }

        //중간 삽입(insert)
        list.add(0, "정조"); // 0번에 추가
        System.out.println(list);

        //수정(update)
        list.set(0, "영조");
        System.out.println(list);

        //삭제(delete)
        list.remove(0);
        list.remove("세종");
        System.out.println(list);

        List<String> list2=
                Arrays.asList("홍길동", "이순신", "세종", "세종"); // 문자열을 순서대로 넣어서 ArrayList 출력
        System.out.println(list2);

    }

}

list 다른 객체 가져와서 리스트 만들기

import java.util.ArrayList;
import java.util.Iterator;

public class ListTest5 {

    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();
        Person p1 = new Person("홍길동", 10, "서울");
        Person p2 = new Person("이순신", 20, "경기");
        Person p3 = new Person("유관순", 30, "제주");

        list.add(p1);
        list.add(p2);
        list.add(p3);

        System.out.println(list.get(0)); //홍길동 정보 출력

        //1. for-each 이름만 출력
        System.out.println("for-each 출력");
        for(Person p : list) {
            System.out.println(p.getName());
        }

        //2.for 문
        System.out.println("for출력");
        for(int i =0; i<list.size();i++) {
            System.out.println(list.get(i).getName());
        }

        //3. iterator 사용
        System.out.println("iterator 출력");
        Iterator<Person> it = list.iterator();

        while(it.hasNext()) {
            Person p = it.next();
            System.out.println(p.getName());

        }

    }

}

Comparator 인터페이스 활용 ArrayLIst 정렬

import java.util.Comparator;

public class PersonAgeSortComparator implements Comparator<Person>{

    @Override
    public int compare(Person o1, Person o2) {

        int num = -1;
        if(o1.getAge() > o2.getAge()) {
            num = 1; 
        }

        return num; // 내림차순 : 음수값 // 오름차순 : 양수값 or 0
    }
}

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

public class ListTest6 {

    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(9);
        list.add(6);
        list.add(1);
        list.add(3);
        list.add(4);

        System.out.println("정렬 전 " + list);
        Collections.sort(list);
        System.out.println("sort 정렬 후 "+ list);
        Collections.reverse(list);
        System.out.println("reverse 정렬 후" + list);

        ArrayList<Person> list2 = new ArrayList<Person>();
        list2.add(new Person("홍길동", 20, "서울"));
        list2.add(new Person("이순신", 44, "전라"));
        list2.add(new Person("강감찬", 33, "전라"));

        System.out.println("정렬 전 : " + list2);
        Collections.sort(list2, new PersonAgeSortComparator());
        System.out.println("정렬 후 : " +list2);
    }

}

Map

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

public class MapTest {

    public static void main(String[] args) {

        Map map = new HashMap(); // 다형성
        map.put("one", "홍길동");
        map.put("two", new Date());

        System.out.println(map.get("one")); // key : "one"
        System.out.println(map.get("two"));
    }
}

import java.util.HashMap;

public class MapTest2 {

    public static void main(String[] args) {

        HashMap<String, String> map = new HashMap<>();
        map.put("oen", "홍길동");
        map.put("two", "이순신");
        map.put("three", "유관순");
        map.put("one", "강감찬"); // 홍길동 -> 강감찬 덮어쓰기
        map.put("one", null);//강감찬 -> null
        map.put(null, null); //이렇게 사용 안함


        System.out.println(map.get("one")); // null
        System.out.println(map.get("four")); // null
    }

}

import java.util.HashMap;

public class MapTest4 {

    public static void main(String[] args) {

        HashMap<String, String> map = new HashMap<>();
        map.put("oen", "홍길동");
        map.put("two", "이순신");
        map.put("three", "유관순");

        System.out.println(map.get("one"));
        System.out.println(map.get("two"));
        System.out.println(map.get("three"));

        System.out.println("HashMap 크기 : " +map.size());
        System.out.println("키 포함 여부 : " + map.containsKey("one"));
        System.out.println("키 포함 여부 : " + map.containsValue("유관순"));

//        map.replace("three", "강감찬");
//        map.remove("two");
//        map.clear();
//        System.out.println("변경 후 : " + map);
    }

}

key	value
one	홍길동
two	이순신
three	유관순

Map의 데이터 전체 사용

1. KeySet을 얻기(key의 모음 : 저체 키값만 얻어옴) //set은 중복 허용 안됨
2. keyset을 사용하여 전체 순회(for each, iterator)
3. key에 해당하는 value값 꺼냄

        //key값 얻기
        Set<String> keys = map.keySet();
        System.out.println(keys);

        for(String key : keys) {
            System.out.println(map.get(key));
        }

        //iterator 활용(key)
        Iterator<String>its = keys.iterator();
        while(its.hasNext()) {
            String key = its.next();
            System.out.println(key + " " + map.get(key));