1. ArrayList(Collection<? extends E> c) 


- Collection<? extends E> c : E타입의 클래스이거나 E타입을 상속받은 자식클래스가 제네릭타입으로 지정됨


- Collection<? super E> c : E타입의 클래스이거나 E타입의 부모클래스가 제네릭타입으로 지정됨



ex>

package test01.util;

import java.util.ArrayList;


class AA{

    private int a;


    public AA(int a){

        this.a=a;

    }

    public int getA(){

        return a;

    }

}

class BB extends AA{


    private int b;


    public BB(int a,int b){

        super(a);

        this.b=b;

    }

    public int getB(){

        return b;

    }

}

public class Test06_generic{


    public static void main(String[] args)

    {

        ArrayList<BB> list1=new ArrayList<BB>();


        list1.add(new BB(1,2));

        list1.add(new BB(3,4));

        list1.add(new BB(5,6));

        

        //ArrayList<String> list=new ArrayList<String>();

        //list.add(new AA(1));

        

        //list1은 AA의 자식클래스들을 담고 있으므로 가능!

        ArrayList<AA> list2=new ArrayList<AA>(list1);

        

        for(int i=0;i<list2.size();i++){

            AA aa=list2.get(i);

            System.out.println(aa.getA());

        }

    }

}

 






2.  제네릭 클래스


- 특정 자료형에 상관없이 똑같은 알고리즘이 적용되는 클래스인 경우 제네릭 클래스로 만들수 있다.



EX>

package test01.util;

class Data<T>{

    private T a;

    public void setA(T a){

        this.a=a;

    }

    public T getA(){

        return a;

    }

}

public class Test07_generic{


    public static void main(String[] args)

    {

        Data<Integer> d1=new Data<Integer>();

        d1.setA(10);

        System.out.println(d1.getA());

        

        Data<String> d2=new Data<String>();

        d2.setA("아리랑");

        System.out.println(d2.getA());

    }

}

 






3. 확장for문


- jdk5.0버전 이상부터 지원됨


- 형식)

    for(저장변수:컬렉션객체 또는 배열)

    {

        반복실행문장;

        ...

    }



EX>

package test01.util;

import java.util.ArrayList;


public class Test08_for{


    public static void main(String[] args)

    {

        int []a={10,20,30,40,50};


        //배열a의 요소가 순차적으로 k에 저장됨

        for(int k:a){

            System.out.print(k +" ");

        }

        System.out.println();


        ArrayList<String> list=new ArrayList<String>();

        list.add("하나");

        list.add("둘");

        list.add("세엣");

        list.add("네엣");


        for(String str:list)

        {

            System.out.print(str + " ");

        }

        System.out.println();

        

        ArrayList<Member> list1=new ArrayList<Member>();


        list1.add(new Member("song","1234","song@naver.com"));

        list1.add(new Member("kim","0000","kim@naver.com"));

        list1.add(new Member("lee","1111","lee@naver.com"));


        //확장for이용해서 list1의 데이터를 출력해 보세요.

        for(Member mm:list1)

        {

            System.out.println("아이디:" + mm.getId());

            System.out.println("비밀번호:" + mm.getPwd());

            System.out.println("이메일:" + mm.getEmail());

        }

    }

}




 

 

'JAVA' 카테고리의 다른 글

예외처리 ( Exception )  (0) 2014.09.12
Calendar 클래스  (0) 2014.09.12
자료구조 - Map  (0) 2014.09.12
자료구조 - Stack / TreeSet  (0) 2014.09.12
자료구조 API - Collection 프레임워크  (0) 2014.09.12

 

3. Map(**)


- 데이터를 저장할때 key와 value가 한쌍으로 저장되는 자료구조


- key값은 중복될 수 없으며 value는 중복이 가능하다.


- 데이터 검색시 유용하다.



ex>

package test01.util;

import java.util.HashMap;

public class Test03_Map

{

    public static void main(String[] args)

    {

        //key타입은 Integer,value타입은 String을 갖는 HashMap생성

        HashMap<Integer,String> map=new HashMap<Integer,String>();


        //Map에 값을 저장할때는 put메소드를 사용해 key와 value를 한쌍으로 저장한다.

        //V put(K key, V value)  

        map.put(1,"홍길동");

        map.put(2,"유관순");

        map.put(3,"김유신");


        //public V get(Object key)

        //키값(2)에 해당하는 value(유관순)을 얻어옴

        String aa=map.get(2);

        System.out.println(aa);

    }

}

 

 

 

ex> Map

package test01.util;

public class Person

{

    private String name;

    private String phone;


    public Person(String name,String phone)

    {

        this.name=name;

        this.phone=phone;

    }

    public String getName()

    {

        return name;

    }

    public String getPhone()

    {

        return phone;

    }

}


package test01.util;

import java.util.HashMap;

import java.util.Scanner;

public class Test04_Map

{

    public static void main(String[] args)

    {

        Person per1=new Person("홍길동","010-111-1234");

        Person per2=new Person("홍길서","010-222-5678");

        Person per3=new Person("홍길남","010-333-0987");    


        //key값은 String,value값은 Person객체를 갖는 Map객체 생성

        HashMap<String,Person> map=new HashMap<String,Person>();


        //이름을 key값으로 Person객체를 value값으로 Map추가

        map.put(per1.getName(),per1);

        map.put(per2.getName(),per2);

        map.put(per3.getName(),per3);


        System.out.println("찾을 이름 입력");

        Scanner scan=new Scanner(System.in);

        String find=scan.next();


        //find를 key로 사용해서 검색하기


        Person per=map.get(find);

        if(per!=null){

            System.out.println("이름:"+per.getName() +",전화번호:" + per.getPhone());

        }else{

            System.out.println("해당 정보가 존재하지 않아요!");

        }

    }

}



 

ex> Map

package test01.util;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class Test05_Map

{

    public static void main(String[] args)

    {

        Map<Integer,String> map=new HashMap<Integer, String>();


        map.put(1,"홍길동");

        map.put(2,"홍길서");

        map.put(3,"홍길남");

        map.put(4,"홍길북");


        //Map의 key값은 중복을 허용하지 않음


        //데이터가 수정됨

        map.put(4,"홀길동");


        String value=map.get(4);


        //key값이 4인 요소 삭제

        map.remove(4);


        //public Set<K> keySet()

        //map.keySet(): map에 담긴 key값을 Set에 담아서 리턴

        Set<Integer> st=map.keySet();


        //Iterator<E> iterator()  

        //Set에 담긴 요소(key값들)을 꺼내오기 위한 Iterator얻어오기

        Iterator<Integer> it=st.iterator();


        //다음요소가 있으면 true

        while(it.hasNext())

        {

            //다음요소(key값) 꺼내오기

            Integer key=it.next();


            //key에 대응되는 Value 꺼내오기

            String val=map.get(key);


            System.out.println(val);

        }

    }

}




 

 

1. Stack


- LIFO(Last In First Out)구조의 자료구조를 갖는 클래스



ex> st에 객체 세개를 저장하고(push메소드) 세개 객체를 꺼내오세요.(pop메소드)


import java.util.Stack;

class Test01_stack{


    public static void main(String[] args)

    {

        Stack<String> st=new Stack<String>();


        //public E push(E item)

        //요소 저장하기

        st.push("하나");

        st.push("두울");

        st.push("세엣");


        //저장된 요소의 갯수 얻어오기

        int size=st.size();


        for(int i=0;i<size;i++){


            //마지막에 저장된 요소순으로 꺼내오기

            String str=st.pop();

            System.out.println(str);

        }

    }

}






2. TreeSet


ex> TreeSet객체에 값넣고 출력하기.

package test01.util;

import java.util.Iterator;

import java.util.TreeSet;

public class Test02_TreeSet

{

    public static void main(String[] args)

    {

        //TreeSet은 정렬기능을 갖고 있다.

        TreeSet<String> ts=new TreeSet<String>();

        ts.add("홍길동");

        ts.add("김철수");

        ts.add("유관순");

        

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

        while(it.hasNext())

        {

            String str=it.next();

            System.out.println(str);

        }

    }

}






 

 

 

 

                [컬렉션프레임워크]

           Collection(자료구조에 관련된 인터페이스)

                           |

                           |

        List                                Set

          |                                     |

          |                                     |

  ArrayList,Vector,...               HashSet,TreeSet,...



  * List계열의 클래스

   - 값을 저장할 때 순서가 있다.

   - 중복된 값을 저장할 수 있다.


  * Set계열의 클래스

   - 값을 저장할 때 순서가 없다.

   - 중복된 값을 허용하지 않는다.




ex> 제너릭 사용/미사용 예

import java.util.HashSet;

import java.util.Iterator;

class Test05_Set{


    public static void main(String[] args)

    {

        HashSet<String> hs=new HashSet<String>();

        hs.add("봄");

        hs.add("여름");

        hs.add("가을");

        hs.add("겨울");

        hs.add(new String("여름"));


        // 제네릭을 사용하지 않은 경우

        //Iterator<E> iterator()  

        Iterator it=hs.iterator();

        while(it.hasNext())

        {

            String st=(String)it.next();

            System.out.println(st);

        }

        

        //제네릭을 사용한 경우

        Iterator<String> it2=hs.iterator();

        while(it2.hasNext())

        {

            String st=it2.next();

            System.out.println(st);

        }

    }

}








ex>HashSet객체에 Member객체 3개를 담고 데이터를 모두 출력해 보세요.

import java.util.*;

class Member{


    private String id;

    private String pwd;


    public Member(String id,String pwd)

    {

        this.id=id;

        this.pwd=pwd;

    }

    public String getId()

    {

        return id;

    }

    public String getPwd()

    {

        return pwd;

    }

    

    //equals메소드 오버라이딩:두 객체의 id와 pwd가 일치하면 true리턴

    public boolean equals(Object obj)

    {

        Member mm=(Member)obj;

        if(id.equals(mm.getId()) && pwd.equals(mm.getPwd()))

        {

            return true;

        }else

        {

            return false;

        }

    }


    //hashCode메소드 오버라이딩:두객체의 문자열이 같으면 동일한 해쉬코드반환

    public int hashCode()

    {

        return (id+pwd).hashCode();

    }

}


//HashSet객체에 Member객체 3개를 담고 데이터를 모두 출력해 보세요.

class  Test06_Set{


    public static void main(String[] args)

    {

        HashSet<Member> hs=new HashSet<Member>();

        hs.add(new Member("song","1234"));

        hs.add(new Member("kim","5678"));

        hs.add(new Member("lee","0000"));

        hs.add(new Member("kim","5678"));


        Iterator<Member> it=hs.iterator();

        while(it.hasNext())

        {

            Member mem=it.next();

            System.out.println(mem.getId() +","+ mem.getPwd());

        }

    }

}




 

 

'JAVA' 카테고리의 다른 글

자료구조 - Map  (0) 2014.09.12
자료구조 - Stack / TreeSet  (0) 2014.09.12
자료구조 API - 제네릭(Generic)  (0) 2014.09.12
자료구조 API - Vector 클래스  (0) 2014.09.12
자료구조 API - ArrayList  (0) 2014.09.12

 

1. 제네릭(Generic) 


- 자료구조관련클래스(ArrayList,Vector,..)에 특정클래스타입만 저장할 수 있도록 설정하는 것


- 자료구조관련 클래스에 실수로 다른 클래스타입을 저장됨을 방지할 수 있다. (안전하게 사용가능)


- 저장된 객체를 꺼내올때 형변환을 하지 않아도 된다.


- JDK5.0 이상 버전부터 사용 가능하다.


- 형식

 클래스명<저장할클래스타입> 객체명=new 클래스명<저장할클래스타입>();



ex>

import java.util.ArrayList;

class Test04_Generic{


    public static void main(String[] args)

    {

        //ArrayList에는 String타입의 객체만 저장하도록 설정

        ArrayList<String> list=new ArrayList<String>();


        list.add("홍길동0");

        list.add("홍길동1");

        list.add("홍길동2");


        //list.add(10);

        //-->오류발생:String외의 타입은 사용못함


        for(int i=0;i<list.size();i++){


            // 제네릭을 사용하면 요소를

            // 꺼내올때 형변환 하지 않아도 됨

            String str=list.get(i);

            System.out.println(str);

        }


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


        // list1객체에는 Student타입의

        // 객체만 저장하도록 설정

        ArrayList<Student> list1=new ArrayList<Student>();


        list1.add(new Student(1,100,80));

        list1.add(new Student(2,80,90));

        list1.add(new Student(3,100,100));


        for(int i=0;i<list1.size();i++){


            //제네릭을 사용했으므로 형변환하지 않음

            Student stu=list1.get(i);

            stu.printStu();

        }

    }

}




 

 

'JAVA' 카테고리의 다른 글

자료구조 - Stack / TreeSet  (0) 2014.09.12
자료구조 API - Collection 프레임워크  (0) 2014.09.12
자료구조 API - Vector 클래스  (0) 2014.09.12
자료구조 API - ArrayList  (0) 2014.09.12
Wrapper클래스  (0) 2014.09.12

+ Recent posts