Java - Set,List

package collection;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
 
public class ExSet {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        /*
         * Set 계열
         * -순서를 유지하지 않는 집합->인덱스 번호가 없으므로 특정위치에 직접 접근 불가능
         * -중복을 허용하지 않음->효율적 중복제거 수단
         * -대표적인 구현체 클래스 : HashSet, TreeSet
         * 
         * 
         */
        
        //HashSet 인스턴스 생성-> Set 타입으로 업캐스팅도 가능(거의 모든 메서드 동일함)
        Set set= new HashSet();
        
        //isEmpty() : 객체 내의 요소가 비어있는지 판별
        System.out.println("set 객체가 비어있는가? "+ set.isEmpty());
        
        System.out.println("set 객체의 모든 요소 : "+set.toString());
        
        
        //size() : 객체 내의 요소 갯수 리턴
        System.out.println("set 객체의 요소 갯수 : "+set.size());
        //add(Object o) : 파라미터로 전달되는 요소 (o)를 추가
        //파라미터 : Object(모든 타입 데이터 추가 가능),리턴타입 : boolean
        set.add(1);
        set.add("이");
        set.add(3.14);
        
        //toString() : 객체 내의 모든 요소를 문자열로 결합하여 리턴(생략가능)
        System.out.println("set 객체의 모든 요소 : "+set.toString());//toString()메서드 생략가능
        System.out.println("set 객체가 비어있는가 ? "+set.isEmpty());
        System.out.println("set 객체의 요소 갯수 : "+set.size());
        
        System.out.println("정수 1 추가 가능한가? "+set.add(1));
        System.out.println("set 객체의 모든요소 : "+set);
        
        System.out.println("정수 4 추가 가능한가? "+set.add(4));
        set.add(5);
        set.add(6);
        System.out.println("set 객체의 모든요소 : "+set);
        
        
        //contains(Object o) : 요소 o가 객체 내에 존재하는지 여부 리턴
        System.out.println("정수 1 이 존재 하는가 ? "+set.contains(1));
        System.out.println("정수 2 이 존재 하는가 ? "+set.contains(2));
        
        
        //remove(Object o) : 요소 삭제 및 삭제 결과 리턴
        System.out.println("정수 1 삭제 결과 : "+set.remove(1));
        System.out.println("정수 2 삭제 결과 : "+set.remove(2));
        
        System.out.println("set 객체의 모든요소 : "+set);
        
        //clear() : 객체 내의 모든 요소 제거
//        set.clear();
        System.out.println("set 객체의 모든요소 : "+set);
        System.out.println("-------------------------------");
        
        //set 계열은 인덱스를 사용하지 않으므로 객체 내의 특정 요소에 별도로 접근 불가
        //->Iterator 를 사용하거나, 확장 for문을 사용하여 객체 내의 모든 요소에 접근
        
        for(Object o:set) {//Object 타입 변수에 데이터 저장필요
        System.out.println(o);
        }
        
        System.out.println("-----------------------");
        
        
        //2. Iterator(반복자) 객체를 활용하는 방법
        //Set 또는 List 객체의 iterator() 메서드를 호출하여 Iterator 객체 리턴받음
        //hasNext() 메서드로 꺼내올 요소 존재 여부를 확인하여 next() 메서드로 요소 꺼냄
        Iterator ite=set.iterator();
        while(ite.hasNext()){
            System.out.println(ite.next());
        }
        System.out.println("----------------------------------");
        
        //TreeSet : 기존 Set 타입의 특성에 정렬 기능을 추가한 클래스
        // 이진트리(Binary Tree)구조를 활용한다.
//        TreeSet set2=new TreeSet();
        Set set2= new TreeSet();
        
        set2.add(5);
        set2.add(1);
        set2.add(3);
        set2.add(2);
        set2.add(6);
        set2.add(4);
        System.out.println(set2);
        
        
        //Set 계열 또는 List 계열은 생성자에 각 객체를 전달하여 한번에 데이터 저장 가능
        
        Set set3=new HashSet(set2);//set2 의 요소들을 사용하여 새 HashSet 객체 생성
        System.out.println(set3);
    }
 
}
 
package collection;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class Exlist {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        /*
         * List 계열
         * 순서가 유지되는 데이터 집합( 순서유지를 위해 인덱스를 사용)
         * 인덱스를 사용하므로 중복데이터 허용(인덱스를 통해 구별)
         * Set 계열과 기본적인 메서드 동일(Collection 을 상속받았으므로)
         * 인덱스를 사용하는 메서드들이 추가됨
         * 배열(Array)과 유사한 구조
         * 대표적인 구현체 클래스 : ArrayList, Vector 등
         * 
         */
        
        
        List list=new ArrayList();//ArrayList-> List 업캐스팅 가능
        
        list.add(1);
        list.add("이");
        list.add(3.14);
        System.out.println("3.14 추가 가능한가? "+list.add(3.14));//중복 허용됨
        System.out.println("전체 요소 출력 : "+list);
        
        //1번 인덱스에 정수 2 추가
        list.add(1, 2);//뒤의 데이터는 한칸씩 밀어냄)
        System.out.println("전체 요소 출력 : "+list);
        
        //remove()메서드는 정수 전달 시 인덱스로 사용됨.
//        list.remove(2);//정수 2가 아닌 2번 인덱스 요소 삭제
        list.remove((Object)2);//정수 2를 삭제 (정수2-> Object 타입으로 변환하여 지정)
        System.out.println("전체 요소 출력 : "+list);
        
        
        //set (int index, Object o): index 위치의 데이터를 o로 교체(기존 데이터 제거됨)
        list.set(3, 4);
        System.out.println("전체 요소 출력 : "+list);
        
        list.add(1);
        System.out.println("전체 요소 출력 : "+list);
        //indexOf(Object 0) : 첫번째 인덱스부터 o를 탐색, 있으면 인덱스 없으면 -1리턴
        System.out.println("정수 1의 인덱스 번호 : "+list.indexOf(1));
        System.out.println("정수 2의 인덱스 번호 : "+list.indexOf(2));
        
        //lastIndexOf(Object o) : 마지막 인덱스부터 역순으로 o를 탐색 , 출력 형식은 동일
        System.out.println("정수 1의 인덱스 번호(뒤에서부터 탐색) : "+list.lastIndexOf(1));
        System.out.println("정수 2의 인덱스 번호(뒤에서부터 탐색) : "+list.lastIndexOf(2));
        
        
        //subList(int fromIndex, int toindex) : fromIndex<= x<toIndex 범위의 서브리스트 추출
        List subList = list.subList(2, 4);//2~3번 인덱스까지의 목록 추출하여 리스트 객체 리턴
        System.out.println(subList);
        
        //get(int index) : index 위치의 요소 리턴
        System.out.println("2번 인덱스 데이터는? "+list.get(2));
        
        //for 문을 사용하여 List 객체의 모든 인덱스에 접근하여 각 요소 출력
        
        for(int i=0;i<list.size();i++) {
            System.out.println(i+"번 인덱스요소 :"+list.get(i));
        }
        
        System.out.println("-----------------");
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("-----------------");
        Iterator ite=list.iterator();
        while(ite.hasNext()) {
            System.out.println(ite.next());
        }
        
        
    }
 
}
 
package collection;
 
import java.util.ArrayList;
import java.util.List;
 
public class TestList {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        Person p=new Person("이순신",800);
        
        //ArrayList 객체를 생성하여 Person 객체 저장
        List list=new ArrayList();
        list.add(p);
        list.add(new Person("장영실",1000));
        list.add(new Person("세종대왕",1001));
        System.out.println(list);
        
        System.out.println("---------------");
        //for 문을 사용하여 ArratList 객체에 저장된 Person 객체를 하나씩 꺼내서
        //Person 객체 내의 멤버변수들에 접근
        
//        for(int i=0;i<list.size();i++) {
////            System.out.println(list.get(i));
//            
//            //list 객체의 요소 하나하나를 Person 타입으로 변환 가능한지 판별
//            Object o=list.get(i);//요소 하나를 가져와서 Object 타입으로 저장
//            if(list.get(i) instanceof Person) {//Person 타입 변환 가능 여부 판별
//                Person person= (Person)list.get(i);
//                
//                //다운캐스팅이 완료됐으므로 Person 객체의 모든 멤버에 접근 가능해짐
//                System.out.println("이름 : "+person.name+", 나이 : "+person.age);
//            }
//        }
        //향상된 for문
        for (Object o : list) {
            if(o instanceof Person) {
                Person p2=(Person)o;
                System.out.println("이름 : "+p2.name+", 나이 : "+p2.age);
            }
        }
        
        
    }
 
}
class Person{
    String name;
    int age;
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    
}
 
package collection;
 
import java.util.Set;
import java.util.TreeSet;
 
public class testSet {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        //중복되지 않는 1~10 사이의 난수 5개를 생성하여 저장
        //1.배열을 사용할 경우
        int[] arr=new int[5];
        
        int count=0;//저장되는 정수 갯수를 카운팅하는 변수
        while(count<5) {//저장되는 정수 갯수가 5까지 반복
            //난수 생성
            int rNum=(int)(Math.random()*10+1);//1~10사이의 난수 생성
 
            //for 문을 사용하여 배열 내의 모든 데이터와 생성된 난수 비교하여 중복 체크
            boolean isDuplicate=false;//중복체크 결과를 저장할 변수
            for(int i=0;i<arr.length;i++) {
                if(arr[i]==rNum) {//생성된 난수와 중복되는 정수가 있을 경우
                    isDuplicate=true;
                }
            }
            //중복 체크 결과를 확인하여 중복이 없을 경우에 배열에 난수 저장
            if(!isDuplicate) {
                //count 에 해당하는 인덱스에 난수 저장
                arr[count]=rNum;
                count++;//카운트 1 증가
            }
            
        
        }
        //저장된 모든 난수 출력
        for(int c:arr) {
            System.out.println(c);
        }
        
        System.out.println("----------------------------");
        
        //2. Set 계열 객체를 사용하여 난수 저장
        Set set= new TreeSet();
        while(set.size()<5) {
            int rNum=(int)(Math.random()*10+1);
            set.add(rNum);
        }
        System.out.println(set);
 
    }
 
}
 

list와 set에 대해 배워보았다.

배열과 비슷한 개념이었지만 훨씬 다양한 기능들을 할 수 있었고 

중복의 허용을 하냐 안하냐의 차이가 있었다. list는 중복을 허용하고 대신에 인덱스를 부여하여 접근을 하기 때문에

저장한 데이터의 특정 위치에 접근이 가능했고, set 은 중복이 되지 않고 인덱스가 부여되지 않기 때문에 특정위치에

접근이 불가능하다. 데이터의 중복을 어떻게 처리할 것이냐에 따라 list를 쓰고 set을 써야 하기 때문에 잘 판단해서 

상황에 따라 잘 써야 할 것 같다.