190614_Day45 <회원가입 마무리>, <JCF 자바컬렉션 프레임워크>

---

190614_Day45 <회원가입 마무리>, <JCF 자바컬렉션 프레임워크>

< Java Collection Framework ( JCF ) >컬렉션 프레임워크

• 자료구조를 바탕으로 객체들을 추가 삭제 검색 할 수 있도록 인터페이스와 클래스들을 포함
• 데이터(참조데이터)를 담는 바구니
• JCF는 구조를 정의하기 위해 Collection, List, Set, Map 인터페이스를 참조함
• 배열보다 더 편리하게 객체를 다룰 수 있습니다.
• JCF내의 클래스들을 java.util.*안에 위치
• 객체를 수집해서 저장하는 역할을 하기 위해 사용방법을 미리 정해 놓은 라이브러리

• 대표적인 인터페이스 : List, Set, Map

• List

  • 순차적 나열 순서지정이 가능한 요소들의 집합
  • 객체를 일렬로 늘어놓은 구조를 가지며 객체저장시 자동 인덱스가 부여
  • ArrayList, Vector, LinkedList
  • 순서를 유지하고 저장
  • 중복저장 가능

• Set
  • HashSet, TreeSet
  • 순서를 유지하지 않고 저장
  • 중복을 허용하지 않는 요소들의 집합
• SortedSet
  • 값들이 정렬된 Set

• Map
  • 키와 키에 대응하는 값으로 이루어진 구조.
• SortedMap
  • 키가 정렬된 Map.

VO새로 만들기는 부담스러울때 Map을 사용하기도 한다!

ListTest

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

import j0610.model.dto.Person;

class A{    
    void method1(Vector v) {
       for(int i=0; i<v.size(); i++) {
           System.out.println(v.get(i));
       }
    }

    void method2(ArrayList v) {
        for(int i=0; i<v.size(); i++) {
            System.out.println(v.get(i));
        }
    }

    void methodCommon(List list) {
        for(int i=0; i<list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
//--------------------------------------------------
public class ListTest {    
  public static void main(String[] args) {
     //java.util.List(인터페이스)
     //   ----> 구현클래스: Vector, ArrayList, LinkedList
      Vector v = new Vector();
         v.add("홍길동");
         v.add("길라임");

      A a  = new A();
        a.method1(v);

      System.out.println("===============");  
      ArrayList ar = new ArrayList();
         ar.add("김주원");
         ar.add("김유신");
       a.method2(ar);


      List v2 = new Vector();
          v2.add(100);
          v2.add(200);
          a.methodCommon(v2);
      List ar2 = new ArrayList();
          ar2.add(3000);
          ar2.add(4000);

      //ArrayList와 Vector는 사용문법이 같다
        // 차이점 : ArrayList가 처리 속도가 빠르다. 
      //(이유 : Vector에는 동기화 코드가 추가되어있으므로 )

//          자료(데이터에 대한 추가, 검색, 수정, 삭제
          Vector<String> v3 = new Vector<String>();
          v3.add("길동");
          v3.add("라임");
          v3.add("즈원");

          //백터 toString()오버라이딩을 구현해서 저장된 데이터를 보여줌
          System.out.println(v3);

          ArrayList<String> alist = new ArrayList<String>();
          alist.add("이");
          alist.add("딩");
          alist.add("듀");
          System.out.println(alist);

          LinkedList<String> linkList = new LinkedList<String>();
          linkList.add("a");
          linkList.add("b");
          linkList.add("c");
          System.out.println(linkList);
          System.out.println("==================================");

          /*
           * ArrayList => 데이터 1개 저장 : 한개의 index 필요
           *     만약 데이터의 수가 많고 (1000000), 첫번째 데이터 삭제할 때(인덱스 : 0)를 삭제할때
           *  뒤의 999999데이터는 인덱스를 다시 지정해야 함.
           */
          /*
           * LinkedList => 데이터 1개 저장 : 한개의 index, 앞의 데이터 주소, 뒤의 데이터 주소 저장 필요
           * 만약 데이터의 수가 많고 (1000000), 첫번째 데이터 삭제할 때(인덱스 : 0)를 삭제할때
           * 201호 202호 203호
           * "김"  "이"  "비"에서 삭제시 하나씩 땡겨옴!
           */

          //ArrayList와 LinkedList 속도 테스트
           ArrayList<Person> list10 = new ArrayList<Person>();
           LinkedList<Person> list20 = new LinkedList<Person>();

           //첫번째 : 순자적인 입력, 데이터를 뒤로 추가

          long start = System.currentTimeMillis();
          for(int i=0; i<1000000; i++) {//반복횟수
              list10.add(new Person(1,"홍길동",13,"학생"));
          }
          long end = System.currentTimeMillis();
          System.out.println("ArrayList데이터입력시간(순차):"+ (end-start));
          //---------------------------------------------------------------
          start = System.currentTimeMillis();
          for(int i=0; i<1000000; i++) {//반복횟수
              list20.add(new Person(1,"홍길동",13,"학생"));
          }
          end = System.currentTimeMillis();
          System.out.println("LinkedList데이터입력시간(순차):"+ (end-start));
          //---------------------------------------------------------------
          System.out.println("==========================");
          //두번째:중간 입력(ArrayList는 인덱스에 대한 재배열)!!
          // List[]        0,"길동"입력
          // List["길동"]   0,"주원"입력
          // List["주원","길동"]   0,"라임"입력
          //        0     1
          // List["라임","주원","길동"]
          //               1    2
          ArrayList<Person>  list30 = new ArrayList<Person>();
          LinkedList<Person>  list40 = new LinkedList<Person>();

          start = System.currentTimeMillis();
          for(int i=0; i<1000000; i++) {//반복횟수
              //list30.add(int index, Object 데이터);
              list30.add(0, new Person(1,"홍길동",13,"학생"));
          }
          end = System.currentTimeMillis();
          System.out.println("ArrayList데이터입력시간(중간입력):"+ (end-start));

          start = System.currentTimeMillis();
          for(int i=0; i<1000000; i++) {//반복횟수          
              list40.add(0, new Person(1,"홍길동",13,"학생"));
          }
          end = System.currentTimeMillis();
          System.out.println("LinkedList데이터입력시간(중간입력):"+ (end-start));

          /*
           * 결론
           * 만약 데이터의 수가 적고, 순차적 저장을 하며 조회업무를 많이한다면 => ArrayList
           * 만약 데이터의 수가 많고, 순차적인지 않은 저장을 하며, 삭제업무를 많이 한다 => LinkedList
           */
  }
}

SetTest

import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class SetTest
{
    public static void main(String[] args)
    {
        // Set: 중복데이터 제거(유일한 데이터만 저장), (저장되는)순서가 일정치 않다. null허용? O

        // Set<String> set = new HashSet<String>();

        SortedSet<String> set = new TreeSet<String>();// 정렬된 Set : null허용? X
        // 데이터 추가
        set.add("홍길동");
        set.add("길라임");
        set.add("김주원");
        set.add("홍길동");
        set.add("이순신");
        set.add("홍길동");
        // set.add(null);
        // set.add(null);

        System.out.println("Set에 저장된 요소 갯수: " + set.size());

        // 모든 요소 출력
        Iterator<String> it = set.iterator();// ---> 모든 데이터 얻어오기
        // 열거형 인터페이스

        while (it.hasNext())
        { // ---> it에 열거된 데이터가 존재한다면 true리턴
            System.out.println(it.next()); // 데이터 뽑아오기
        }

        /*
         * 출력결과) null 김주원 홍길동 길라임 이순신
         * 
         * 
         */

    }// main
}

LottoSet

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

public class LottoSet
{
    //로또번호 -> 1~45까지의 중복되지 않는 6개의 수
    public static void main(String[] args)
    {
        Random r = new Random();
        Set<Integer> set = new HashSet<Integer>();
        while(true)
        {
            set.add( r.nextInt( 45 ) + 1 );
            if( set.size() == 6 ) break;
        }

        Object []ob = set.toArray();

        for (int i = 0; i < ob.length; i++)
        {
            System.out.println(ob[i]);            
        }
    }
}

MapTest

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

import j0611.model.dto.Person;

public class MapTest
{
    //Map - 지도 (위도, 경도)
    //            x축, y축 처럼!
    //저장데이터(키값, 데이터값) 사용!
    /*
     *  Map<K,V>
     *      - 사물함 클래스 ( 책 : 데이터, 열쇠 : 키 )
     *      - K : Key의 자료형, V : Value의 자료형
     *      - Key는 보통 문자열 사용, Value(저장데이터)는 Object
     *      - Key값은 중복X ( 유일한 값 )
     */

    //★ 기억!
    // - 저장 : map.put(키값, 저장할 데이터);
    // - 조회 : map.get(키값);
    public static void main(String[] args)
    {
        Map<String, Object> map = new HashMap<>();
        //데이터 입력 ("기묭진" , 13, "학생")
//        map.put(String key, Object value)
        map.put("name", "기묭진");
        map.put("age", 13);
        map.put("job", "학생");

        Map<String, String> map2 = new HashMap<>();
        //데이터 입력 ( "기묭진", "이딩듀", "이비키", "진주니어", "김바나" )
        map2.put("k1", "기묭진");
        map2.put("k2", "이딩듀");
        map2.put("k3", "이비키");
        map2.put("k4", "진주니어");

        //전체데이터 출력?
        System.out.println( "map2.toString() = " + map2.toString() );
        //map2.toString() = {k1=기묭진, k2=이딩듀, k3=이비키, k4=진주니어}

        //특정 데이터 출력 ( K2키에 저장된 데이터를 출력! )
        //map2.get(Object key);
        map2.get("k2");
        System.out.println(map2.get("k2"));
        //이딩듀

        //특정 데이터 삭제( 특정 키삭제 : K3 )
        //map2.remove(Object key)
        map2.remove("k3");
        System.out.println(map2.toString());
        map2.put("k3", "돌아온 이비키");
        System.out.println(map2.toString());
        map2.remove("k2");
        map2.put("k2", "돌아온 자다가 뿡뿡 두번하고 자는척하는 이딩듀");
        System.out.println(map2.toString());

        //특정 키에 저장된 데이터 수정
        map2.replace("k4", "이딩푸들과 진주니어");

        //전체 데이터 출력
        Collection<String> col = map2.values();

        Iterator<String> it = col.iterator();

        System.out.println("<<전체 map2데이터>>");
        while (it.hasNext())
        {
            System.out.println(it.next());
        }

        //map2의 ket값만 따로 얻어오기
        System.out.println("<<전체 map2의 키 출력>>");
        Set<String> set = map2.keySet();
        Iterator<String> keyset = set.iterator();
        while(keyset.hasNext())
        {
            String key = keyset.next();
            System.out.println(key + "에 저장된 데이터 : " + map2.get(key));
        }

        /*
         * 문제 ) Map m3; 에 Person클래스 (4, "길동" , 13,  "학생")
         *                     Car클래스 ("소나타", 4, 100)
         *                     거리데이터 (10KM)를 저장하시오
         */

        Map<String, Object> map3 = new HashMap<>();
        Person p = new Person(4, "길동" , 13,  "학생");
//        Car c = new Car("소나타", 4, 100);
        String d = "10km";
        map3.put("Person", p);
        map3.put("Distance", d);
        System.out.println(map3.toString());

        //문제) distance키에 저장된 거리를 출력
        System.out.println("거리 : " + map3.get("anykey")); // 일치하는 key없을 때 리턴 null
        //문제) person키에 저장된 이름과 나이를 출력
//        Object ob = map3.get("person");
//        System.out.println("이름 : " + ob.getName()); 에러발생, 부모레퍼런스 ob통해 자식메소드 호출 불가
        Person ob = (Person) map3.get("person");
        System.out.println(ob.getName());
        System.out.println(ob.getAge());

    }
}

---

Mission

serviceform에서 String keyword = tf_search.getText(); 부분 수정하기

---

• 인터페이스	구현 클래스	특징
  List	LinkedList Stack Vector ArrayList	순서 있는 데이터 집합 데이터의 중복을 허용
  Set	HashSet TreeSet	순서 유지하지 않는 데이터 집합 데이터의 중복을 허용하지 않는다.
  Map	HashMap TreeMap HashTable Properties	Key와 Value의 쌍으로 이루어진 데이터의 집합 순서는 유지되지 않는다. 키의 중복을 허용하지 않는다. 값의 중복은 허용한다.