힘내보자

Set

순서x 중복저장x
key로 저장
key에 null 저장불가능

HashSet

대표적인 set

LinkedHashSet

순서 o 중복저장x
순서 유지되고 중복저장 안되는 컬렉션
중복 저장이 안된 이유?
Dog클래스에 equals()를 오버라이딩 해줬기 때문에 내용비교가 가능하게 되었고
이 때문에 같은 객체로 인지되었기 때문

TreeSet

정렬을 해주는 Set
오름차순 정렬
   정렬 기준을 세워주는 건 <String>
   String 클래스 안에 comparable 인터페이스가(compareTo())가
   구현 되어있기 때문에 정렬 기준이 정해져 있고, 정렬 기준이 정해져 있는
   클래스 String이 TreeSet 안에 들어가 있기 때문에 정렬 가능

HashSet<String>은 객체도 받음

<-> ArrayList<String>은 에러났었음

HashSet hashSet = new HashSet<String>();

HashSet<String> hSet = new HashSet<>();
        hSet.add("가가");
        // addAll
        hashSet.addAll(hSet);
        System.out.println(hashSet); // [가, 가가, 나]  <- 순서xxx 기억할 것
        // HashSet<String>은 객체도 받음
        //      <-> ArrayList<String>은 에러났었음
        hashSet.add(new Dog("다",10)); // [가, 다 10.0kg, 가가, 나]

순서x 중복x HashSet, add하면 어디에 추가될까?

맨 앞에 추가됨

        // 순서x 중복x HashSet, add하면 어디에 추가될까?
        // 맨 앞에 추가됨
        set1.add(new Dog("d",10)); // [d 10.0kg, c 10.0kg, b 10.0kg, a 10.0kg, a 10.0kg]
        System.out.println(set1);
        set1.add(new Dog("e",10));
        System.out.println(set1); // [e 10.0kg, d 10.0kg, c 10.0kg, b 10.0kg, a 10.0kg, a 10.0kg]

순서o LinkedHashSet, add하면 어디에 추가될까?

마지막에 추가됨

linkedHashSet.add(new Dog("ㄱ",10));
System.out.println(linkedHashSet);  // [ㄱ 10.0kg]
linkedHashSet.add(new Dog("ㄴ",10));
System.out.println(linkedHashSet); // [ㄱ 10.0kg, ㄴ 10.0kg]
linkedHashSet.add(new Dog("ㄷ",10));
System.out.println(linkedHashSet);  // [ㄱ 10.0kg, ㄴ 10.0kg, ㄷ 10.0kg]

전체 코드

Set
순서x 중복저장x
key로 저장
key에 null 저장불가능

HashSet

LinkedHashSet
순서 o 중복저장x
순서 유지되고 중복저장 안되는 컬렉션
중복 저장이 안된 이유?
Dog클래스에 equals()를 오버라이딩 해줬기 때문에 내용비교가 가능하게 되었고
이 때문에 같은 객체로 인지되었기 때문


TreeSet
정렬을 해주는 Set
오름차순 정렬
   정렬 기준을 세워주는 건 <String>
   String 클래스 안에 comparable 인터페이스가(compareTo())가
   구현 되어있기 때문에 정렬 기준이 정해져 있고, 정렬 기준이 정해져 있는
   클래스 String이 TreeSet 안에 들어가 있기 때문에 정렬 가능


순서x 중복x HashSet, add하면 어디에 추가될까?
맨 앞에 추가됨
순서o LinkedHashSet, add하면 어디에 추가될까?
마지막에 추가됨

 public void method01() {
        HashSet set0 = new HashSet();
        HashSet<Dog> set1 = new HashSet<>(); // 뒤 제네릭 생략 → 타입추론 : 뒤 생략가능하다는 의미


        // add(E e):boolean
        set1.add(new Dog("a",10));
        set1.add(new Dog("b",10));

        System.out.println(set1);   // [b 10.0kg, a 10.0kg]

        // set 중복 저장안되는데 중복 저장 되는 이유 : equals() 오버라이딩 안되어있어서
        set1.add(new Dog("a",10));
        System.out.println(set1);   // [b 10.0kg, a 10.0kg, a 10.0kg]

        // add(Object e):boolean
        Dog puppy = new Dog("c",10);
        set1.add(puppy);
        System.out.println(set1);   // [c 10.0kg, b 10.0kg, a 10.0kg, a 10.0kg]
        // 순서x 중복x HashSet, add하면 어디에 추가될까?
        // 맨 앞에 추가됨
        set1.add(new Dog("d",10)); // [d 10.0kg, c 10.0kg, b 10.0kg, a 10.0kg, a 10.0kg]
        System.out.println(set1);
        set1.add(new Dog("e",10));
        System.out.println(set1); // [e 10.0kg, d 10.0kg, c 10.0kg, b 10.0kg, a 10.0kg, a 10.0kg]


        // LinkedHashSet
        // 순서 o 중복저장x
        // 순서 유지되고 중복저장 안되는 컬렉션
        // 중복 저장이 안된 이유?
        // Dog클래스에 equals()를 오버라이딩 해줬기 때문에 내용비교가 가능하게 되었고
        // 이 때문에 같은 객체로 인지되었기 때문
        LinkedHashSet<Dog> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add(new Dog("ㄱ",10));
        System.out.println(linkedHashSet);  // [ㄱ 10.0kg]



        // 순서o LinkedHashSet, add하면 어디에 추가될까?
        // 마지막에 추가됨
        linkedHashSet.add(new Dog("ㄴ",10));
        System.out.println(linkedHashSet); // [ㄱ 10.0kg, ㄴ 10.0kg]
        linkedHashSet.add(new Dog("ㄷ",10));
        System.out.println(linkedHashSet);  // [ㄱ 10.0kg, ㄴ 10.0kg, ㄷ 10.0kg]
        linkedHashSet.add(new Dog("ㄷ",10));
        // equals() 주석 처리후에는 중복가능해짐
        System.out.println(linkedHashSet);  // [ㄱ 10.0kg, ㄴ 10.0kg, ㄷ 10.0kg, ㄷ 10.0kg]
        // equals() 주석 풀고 난 후에는 중복x
        System.out.println(linkedHashSet);  // [ㄱ 10.0kg, ㄴ 10.0kg, ㄷ 10.0kg]


        // HashSet<String>
        // equals() 오버라이딩 필요x
        HashSet hashSet = new HashSet<String>();
        // equals() 메소드 주석처리함

        hashSet.add("가");
        hashSet.add("나");
        System.out.println(hashSet);    // [가, 나]
        HashSet<String> hSet = new HashSet<>();
        hSet.add("가가");
        // addAll
        hashSet.addAll(hSet);
        System.out.println(hashSet); // [가, 가가, 나]  <- 순서xxx 기억할 것
        // HashSet<String>은 객체도 받음
        //      <-> ArrayList<String>은 에러났었음
        hashSet.add(new Dog("다",10)); // [가, 다 10.0kg, 가가, 나]
        hashSet.add("나나");
        System.out.println(hashSet); // [가, 다 10.0kg, 가가, 나나, 나]
        // 순서 없어서 가운데에도 추가되고 앞에 추가되기도 하고...
        hashSet.remove(new Dog("다",10));
        System.out.println(hashSet); // [가, 가가, 나나, 나]

        // TreeSet
        // 정렬을 해주는 Set
        // 오름차순 정렬
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("아");
        treeSet.add("이");
        treeSet.add("우");

        System.out.println(treeSet); // [아, 우, 이]
        treeSet.addAll(hashSet);
        System.out.println(treeSet); // [가, 가가, 나, 나나, 아, 우, 이]



        // 전체데이터 넣는 방법
        // 1) addAll()
        // 2) 생성자 매개변수 이용

    }

Collection

Set

인터페이스 Set의 주요 클래스

HashSet

LinkedHashSet

TreeSet

add(E e)

add(Object e):boolean

package controller;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.TreeSet;
import model.vo.pModelVo02;

public class pController02 {
	public void firstR() {
		
		HashSet<pModelVo02> hs = new HashSet<>();
		System.out.println("====HashSet====");
		
		hs.add(new pModelVo02("name",1));
		hs.add(new pModelVo02("dont",2));// 순서x
		hs.add(new pModelVo02("dont",2));// 중복x 
		System.out.println(hs);			 // 주소값달라서 중복됨
		
		// 중복 가능케 할려면? 
		// model 데이터에서 오버라이딩or 이미되었는 String,Integer클래스 사용
		HashSet<String> strs = new HashSet<>();
		strs.add(new String("a")); // 모델에서 세팅값의 Set이 아니라서 
		strs.add(new String("b")); // 값이 문자열 하나
		strs.add(new String("b")); // 중복x
		System.out.println(strs);
		
		System.out.println("====LinkedHashSet====");
		// LinkedHashSet
		// 순서유지되는 set
		// add(Object e):boolean
		// 리턴 : 트루반환
		LinkedHashSet<pModelVo02> lhs = new LinkedHashSet<>();
		lhs.add(new pModelVo02("1",1)); // 순서O
		lhs.add(new pModelVo02("2",2)); // 중복x 이나 주소값 달라 중복됨
		lhs.add(new pModelVo02("2",2)); // [(1-1), (2-2)] model에서 오버라이딩 후 중복x
		System.out.println(lhs); // [(1-1), (2-2)]
		System.out.println(lhs.add(new pModelVo02("3",3))); // true
		System.out.println(lhs); // [(1-1), (2-2), (3-3)]
		
		System.out.println("====TreeSet====");
		// TreeSet
		// 정렬가능 set
		TreeSet<pModelVo02> ts = new TreeSet<>(lhs);// 정렬할 set값 넣기
		System.out.println(ts); // error : comparable x 
		// 에러원인 : 정렬기준점인 comparable없음
		// 에러메세지 : The type pModelVo02 must implement the inherited abstract method Comparable.compareTo(Object)
		// compareTo(Object o) 후 정상작동
		ts.iterator(); // 반복자iterator를 오름차순으로 반환
		System.out.println(ts);
		
		
		Iterator<pModelVo02> it = lhs.iterator(); // iterator 인덱스 없다
		while(it.hasNext()) { 
			pModelVo02 p = it.next(); 
			System.out.println(p);
		}	
		
		
		// String클래스에 comparable이 이미 오버라이딩 되어있어서 정상작동
		TreeSet<String> trs = new TreeSet<>();
		trs.add(new String("a")); // set 중복x
		trs.add(new String("a")); 
		trs.add(new String("d")); // 정렬
		trs.add(new String("c")); 
		trs.add(new String("b"));
		System.out.println(trs);  // [a, b, c, d]
		
		
//		TreeSet<pModelVo02> tss = new TreeSet<>(lhs); // error : java.lang.ClassCastException
//		System.out.println(tss);
		
	}

package controller;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;

import model.vo.pModelVo02;


public class pController02 {

	public void firstR() {
		
		// HashSet
		HashSet<pModelVo02> hset =new HashSet<>();
		
		hset.add(new pModelVo02("힘내",1));
		hset.add(new pModelVo02("포기 ㄴ",2));
		System.out.println(hset);
		
		pModelVo02 pmv = new pModelVo02("a",0);
		hset.add(pmv);
		hset.add(new pModelVo02("추가",3));
		System.out.println(hset);
		
		HashSet<String> strSet = new HashSet<String>();
		strSet.add("안녕");
		strSet.add(new String("안녕"));
		System.out.println(hset);
		System.out.println(strSet);
		strSet.remove(new String("안녕"));
		System.out.println(strSet);
	
	}
	public void second() {	

		// LinkedHashSet
		// 순서 유지
		LinkedHashSet<pModelVo02> lhSet = new LinkedHashSet();
		
		lhSet.add(new pModelVo02("a",1));
		lhSet.add(new pModelVo02("b",2));
		lhSet.add(new pModelVo02("c",3));
		System.out.println(lhSet);
		
		// TreeSet
		// 정렬 가능
		// 정렬 기능 + 기준 필요
		// 기준이 되는 오버라이딩은 String class 제네릭으로 대체
		TreeSet<String> tSet = new TreeSet<>();
//		tSet.add(new String("A",1));
//		tSet.add(new String("B",2));
		System.out.println(tSet);
		
		tSet.add("A");
		tSet.add("C");
		tSet.add("B"); 			  // 추가 순서는 ACB
		System.out.println(tSet); // 결과는        ABC (정렬 적용 확인)
		
		
		
	}
	
}

package model.vo;

public class pModelVo02 {

	private String name;
	private double weight;
	
	public pModelVo02() {}
	public pModelVo02(String name, double weight) {
		this.name = name;
		this.weight = weight;
	}


	// getter & setter
	public void setName(String name) {
		this.name = name;
	}
	public void setWeight(double weight) {
		this.weight = weight;
	}
	public String getName() {
		return name;
	}
	public double getWeight() {
		return weight;
	}
	
	//toString
	@Override
	public String toString() {
		return name+"("+weight+"kg)";
	}

}

package run;
import controller.pController02;

public class pRun02 {
	public static void main(String[] args) {
		
		pController02 p = new pController02();
//		p.firstR();
		p.second();

	}
	
}