728x90

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) 생성자 매개변수 이용

    }

 

728x90
반응형
728x90

 

컬렉션 List의 메소드 중에서 매개변수에 넣는 것 파악하고

반환타입도 파악하면서

해당 반환 타입으로 뭘 할 수 있을지 고민하다가

int타입으로 반환되는 indexOf()를 if문과 연결지어 간단한 출력문구 사용

boolean으로 반환되는 isEmpty()나 remove() 등도 if문 조건으로 사용해봄

이외에도 get이나 다른 str이나 다른 타입 반환을 이용해서 ==이나 equals() 같은 걸 이용해서 값 비교해서

찾는 조건 같은걸로 while, for문 같은 것도 사용해봐야겠다

 

/******************************** collection 3rd practice ***************************************/	
public void method03() {
    // 3번째 연습할거는 오버라이딩 해제하면서, equals()와 hashCode() 비교
    ArrayList a = new ArrayList(2); // 제네릭 안써서 노란줄 경고
    ArrayList<Student> al = new ArrayList<Student>(2);
    ArrayList<Student> list = new ArrayList<>(1);

    // vo클래스에 있는 오버라이딩된 toStirng(), equals(), hashCoding() 
    // 전부 주석처리


    // add(E e):boolean
    al.add(new Student("ㄱ",100));
    al.add(new Student("ㄴ",90));
    System.out.println(al);			// [ㄱ(100점), ㄴ(90점)]
    // Object의 toString()를 오버라이딩 때문에 주소값이 아닌 객체값이 바로나옴
    // toString() 오버라이딩 안된 경우(오버라이딩 주석처리) 결과값 : [chap12_Collection.A_List.model.vo.Student@6d06d69c, chap12_Collection.A_List.model.vo.Student@7852e922]
    al.add(2, new Student("ㄷ",95));	
    System.out.println(al);	// [chap12_Collection.A_List.model.vo.Student@6d06d69c, chap12_Collection.A_List.model.vo.Student@7852e922, chap12_Collection.A_List.model.vo.Student@4e25154f]
    System.out.println(al); // toString오버라이딩 후 : [ㄱ(100점), ㄴ(90점), ㄷ(95점)]

    // add(int index, E element) 
    list.add(0, new Student("ㄱㄱ",100));
    System.out.println(list);	// [ㄱㄱ(100점)]
    list.add(1, new Student("ㄴㄴ",90));
    list.add(2, new Student("ㄷㄷ",85));
    System.out.println(list);// [ㄱㄱ(100점), ㄴㄴ(90점), ㄷㄷ(85점)]


    // addAll(Collection<? extends E> c) : boolean
    al.addAll(al);
    System.out.println(al);// [ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점)]

    // addAll(int index, Collection c) : boolean
    al.addAll(1,al);
    System.out.println(al); // [ㄱ(100점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점)]
    // toString() 오버라이딩 주석 후 : [chap12_Collection.A_List.model.vo.Student@6d06d69c, chap12_Collection.A_List.model.vo.Student@6d06d69c, chap12_Collection.A_List.model.vo.Student@7852e922, chap12_Collection.A_List.model.vo.Student@4e25154f, chap12_Collection.A_List.model.vo.Student@6d06d69c, chap12_Collection.A_List.model.vo.Student@7852e922, chap12_Collection.A_List.model.vo.Student@4e25154f, chap12_Collection.A_List.model.vo.Student@7852e922, chap12_Collection.A_List.model.vo.Student@4e25154f, chap12_Collection.A_List.model.vo.Student@6d06d69c, chap12_Collection.A_List.model.vo.Student@7852e922, chap12_Collection.A_List.model.vo.Student@4e25154f]



    // 장점1. 크기 제약 x
    // .size() : 인덱스 길이 반환
    System.out.println(al.size()); // 12


    // 장점2. 추가/삭제/정렬 기능처리 간단



    // 삭제
    // remove(int index):E
//		// remove()의 return은 삭제한 값을 돌려준다
//		list.remove(7);
    list.remove(2);
    System.out.println("remove(int index) : "+list); // [ㄱㄱ(100점), ㄴㄴ(90점)]
    System.out.println(list.remove(1)); // ㄴㄴ(90점) <- 대괄호 없고, 지운 객체 반환(pop개념) 
    System.out.println(list); // [ㄱㄱ(100점)]

    Student delList = al.remove(11);
    System.out.println("delList : "+delList);	// delList : ㄷ(95점)
    System.out.println(al);			// [ㄱ(100점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점)]
    Student delList2 = al.remove(10);
    System.out.println(delList2);  // ㄴ(90점)
    System.out.println(al);			// [ㄱ(100점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄴ(90점), ㄷ(95점), ㄱ(100점)]



    // 삭제
    // remove(Object o):boolean
    // 같은 데이터라면 앞에 있는거부터 삭제
    al.remove(new Student("ㄷ",95));
    al.remove(new Student("ㄷ",95));
    System.out.println(al.remove(new Student("ㄷ",95))); // false
    System.out.println(al);			// [ㄱ(100점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점)]
    // equals()가 오버라이딩이 안되어 있어서 값 비교가 아니라 주소값 비교라 삭제 못한 것.
    System.out.println(al.size());


    // 지네릭 추가 : <String> 
    // equals랑 hashCode가 잘 오버라이딩이 되어있기 때문에 삭제 가능
    ArrayList<String> sList = new ArrayList<>(2);

    sList.add(new String("a"));
    sList.add(1, new String("b"));
    System.out.println(sList);		// [a, b]
    // 제네릭<String> 같은 경우, toString()이 오버라이딩 안되어있거나 데이터 리턴이 없어도 객체값을 잘 내보내줌



    // set(int index, E e)
    // 해당 인덱스 번호에 값  교체
    sList.set(1, new String("changed Capital B"));
    System.out.println(sList);  // [a, changed Capital B]
    al.set(0, new Student("a",50));
    System.out.println(al);		// [a(50점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점), ㄴ(90점), ㄷ(95점), ㄱ(100점), ㄴ(90점), ㄷ(95점)]


    // get(int index):E
    // 인덱스번호의 엘리먼트 값을 가져온다
    sList.get(0);
    String str = sList.get(1);
    System.out.println(sList);	// [a, changed Capital B]
    System.out.println(str);	// changed Capital B


    // contains(Object) : boolean
    // indexObject : int 
    System.out.println(al.contains(new Student("a",50))); // false


    // int값 데이터 반환된 걸 if문에 적용
    if(al.contains(new Student("ㄱ",100))){
        System.out.println("포함 & 출력");
    }else {
        System.out.println("미포함. 값이 맞다면 equals()오버라이딩 체크해보세여");
    }	// equals()가 오버라이딩 되어있다면 값을 비교하기 때문에 contains()가 작동하고, 
        // 아닐 경우 값이 같더라도 주소값이 비교되기 때문에 작동x
    al.indexOf(new Student("ㄴ",90));
    System.out.println(al.indexOf(new Student("ㄴ",90)));	// 2
    // 반환된 인덱스번호로 if조건문 줘서 실행하기
    if(al.indexOf(new Student("ㄴ",90)) > 0) {
        al.remove(6);
        System.out.println("indexOf의 번호가 0이상이면 객체값 하나 삭제함");	// indexOf의 번호가 0이상이면 객체값 하나 삭제함
    }else {
        System.out.println("조건 미충족. do nothing");
    }

    System.out.println(sList.get(0));	// a
//		if((sList.get(0)) == "a") {
    if((sList.get(0)).equals("a")) {
        System.out.println("true");	// true
    }else {
        System.out.println("false");
    }

    // 반환된 boolean타입으로 while조건 사용하기
    System.out.println("a : "+sList.contains("a")); // true
    int i = 0;
    while(sList.contains("a")) {
        System.out.print(i+" ");	// 0 1 2 3 4 5 6 7 8 9 
        i++;
        if(i>=10) {
            break;	// while문 무한루프 + break문 사용
        }
    }
//		while(true) {
//			System.out.println("====");
//			i++;
//			if(i>=10) {
//				break;
//			}
//		}

//		while(sList.contains("a")) {
//			if(i>=10) {
//				break;
//			}
//			i += 2;
//			System.out.print(i+ " ");
//		}


    // 지네릭<String>과 일반 참조객체<Student>의 오버라이딩 비교
    //  equals메소드와 해쉬코드가 오버라이딩 되지 않으면 주소값이 달라 없는걸로 나옴. 현재는 오버라이딩된 상태


    // clear():void
    al.clear();
    System.out.println(al);// []
    // isEmpty():boolean
    al.isEmpty();
    System.out.println(al.isEmpty()); // true

    if(al.isEmpty()) {
        al.add(new Student("new",10));
        System.out.println(al);  // [new(10점)]
    }

}
728x90
반응형
728x90

 

list 안에 각각의 빈도 높은 메소드들을 다 써보고

어떤 방식으로 작동하는지와 반환값도 어떻게 반환되는지 파악하고

리스트의 코드 형태도 익숙해지는 중!

 

get 같은 경우 어디에 써먹을지 고민하게보게 됨. 해당 값을 가져와서 여기저기 유용할 것 같은데 당장 생각이 잘안난다

 

/******************************** collection 2nd practice ***************************************/	
public void method02() {

    ArrayList<Student> list = new ArrayList<Student>(3);


    // add(E e):boolean
    list.add(new Student("김",99));
    list.add(new Student("이",98));
    list.add(new Student("최",100));
    list.add(new Student("박",95)); // 길이 자동 추가 : 길이4

    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점)] 길이 4
    // Object의 toString()를 오버라이딩 때문에 주소값이 아닌 객체값이 바로나옴
    System.out.println(list.add(new Student("황",94))); // true // boolean값 반환


    // 장점1. 크기 제약 x
    // .size() : 인덱스 길이 반환
    System.out.println(list.size()); // 5


    // 장점2. 추가/삭제/정렬 기능처리 간단
    // add(int index, E elemnet) 
    list.add(5,new Student("차",88)); // 5번 인덱스에 '차' 추가
    list.add(5,new Student("사",87)); // 5번 인덱스 '차'자리에 '사'가 들어가면서 '차'가 뒤로 밀림

    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점), 황(94점), 사(87점), 차(88점)]


    // 삭제
    // remove(int index):E
//		// remove()의 return은 삭제한 값을 돌려준다
//		list.remove(7);
    System.out.println("remove(int index):E = "+list.remove(6)); // remove(int index):E = 차(88점)
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점), 황(94점), 사(87점)]


    // 삭제
    // remove(Object o):boolean
    list.remove(new Student("사",87));
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점), 황(94점)]

    System.out.println(list.remove(new Student("황",94))); // true - 반환값 불리안 겟
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박(95점)]


    // 지네릭 추가 : <String> 
    ArrayList<String> listStr = new ArrayList<String>(2);
    listStr.add("임");
    listStr.add("강");
    listStr.add("심");
    System.out.println(listStr); // [임, 강, 심]
    System.out.println(listStr.remove(2)); // 심
    System.out.println(listStr); // [임, 강] -> print에 써도 잘지워진다
    listStr.remove(new String("강"));
    System.out.println(listStr); // [임]
    // equals랑 hashCode가 잘 오버라이딩이 되어있기 때문에 삭제 가능


    // set(int index, E e)
    // 해당 인덱스 번호에 값  교체
    list.set(3, new Student("박박",99));
    System.out.println(list); // [김(99점), 이(98점), 최(100점), 박박(99점)]
    System.out.println(list.set(2, new Student("최최",1000))); // 최(100점)
    System.out.println(list); // [김(99점), 이(98점), 최최(1000점), 박박(99점)]


    //get(int index):E
    // 인덱스번호의 엘리먼트 값을 가져온다
    Student stu = list.get(1);
    System.out.println(stu); 		 // 이(98점)
    System.out.println(list.get(0)); // 김(99점)



    // contains(Object) : boolean
    // indexObject : int 

    System.out.println(list.contains(new Student("김",99))); // true
    System.out.println(list.indexOf(new Student("김",99)));	// 0

    // 지네릭<String>과 일반 참조객체<Student>의 오버라이딩 비교
    System.out.println(listStr.contains(new String("임")));   // true
    System.out.println(listStr.indexOf(new String("임")));	 // 0
    System.out.println(listStr.indexOf(new String("임없음"))); // -1 : 없는 값이라 -1반환
    //  equals메소드와 해쉬코드가 오버라이딩 되지 않으면 주소값이 달라 없는걸로 나옴. 현재는 오버라이딩된 상태


    // clear():void
    list.clear();
    System.out.println(list); 			 // []
//		System.out.println(listStr.clear()); // clear는 반환타입이 없는 void라 print시켜서 java.lang.Error 
    listStr.clear();

    // isEmpty():boolean
    System.out.println(list.isEmpty());		// true
    System.out.println(listStr.isEmpty());	// true


}
728x90
반응형
728x90

 

간간히 남아있는 List에 대한 기억을 되살리면서

List 한번 써봄

 

package chap12_Collection.A_List.controller;

import java.util.ArrayList;
import chap12_Collection.A_List.model.vo.Student;


public class ListController {
	
	public void method01() {

		ArrayList<Student> list = new ArrayList<Student>(3);
		
		// add(E e):boolean
		list.add(new Student("김철수",0));
		list.add(new Student("최철수",100));
		list.add(new Student("박철수",70));
		
		System.out.println("list = "+list); // list = [김철수(0점), 최철수(100점), 박철수(70점)]
		// ArrayList는 ___의 ____를 ____했기 때문에 list만 찍어도 안에 내용이 나온다
		// Object의 toString()를 오버라이딩 했기에
		
	
		// 장점1. 크기 제약 x
		// 값 추가 & 추가시, 자동 길이 추가
		list.add(new Student("이철수",80)); // 길이 3 -> 4로 자동추가
		System.out.println("list에 담긴 element 개수 : "+list.size());
	
	
		// 장점2. 추가/삭제/정렬 기능처리 간단
		// add(int index, E elemnet) 
		list.add(0, new Student("황철수",55)); // 0번 인덱스 자리에 객체추가
		System.out.println(list); // [황철수(55점), 김철수(0점), 최철수(100점), 박철수(70점), 이철수(80점)]
		System.out.println("list에 담긴 element 개수 : "+list.size()); // list에 담긴 element 개수 : 5
		
		
		// 삭제
		// remove(int index):E
//		// remove()의 return은 삭제한 값을 돌려준다
		Student stu = list.remove(4);
		System.out.println(stu);	// 이철수(80점)
		System.out.println(list);	// [황철수(55점), 김철수(0점), 최철수(100점), 박철수(70점)]
		
		
		
		// 삭제
		// remove(Object o):boolean
		list.remove(new Student("박철수",70)); // 주소값 비교
		System.out.println(list.remove(new Student("김철수",0))); // true -> boolean 반환
		System.out.println("list : " +list);  // list : [황철수(55점), 김철수(0점), 최철수(100점)]
		

	}
	

	
}

 

728x90
반응형
728x90

 

 

 

 

 

package MVC.controller;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

import MVC.model.vo.pModelVo04;

public class pController04 {
	
	// Map
	// {key=value} 형식으로 출력됨 // map도 중괄호{} 찍혀서 나온다
	public void pMap() {
		
		// 1.HashMap
		// 2.TreeMap
		
		
		// 1.HashMap
		// put(K key, V value):V
		// 반환타입 : value
		System.out.println("===HashMap===");
		
		HashMap<String, pModelVo04> hmap = new HashMap<>();
		
		hmap.put(new String("블루베리류"), new pModelVo04("블루베리",100)); // 순서x
		hmap.put(new String("사과류"), new pModelVo04("아오리",200));
		System.out.println(hmap);	// {사과류=아오리[200원], 블루베리류=블루베리[100원]}
		System.out.println(hmap.put(new String("참외류"), new pModelVo04("참외",300))); // null
		System.out.println(hmap.put(new String("1"), new pModelVo04("1",300))); 	// null
		System.out.println(hmap);		// {사과류=아오리[200원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		
		
		
		// 2.containsKey(Object key)
		// 키나 값이 들어가 있는지를 확인하는 메소드
		// containsKey(Object key):boolean	
		// containsValue(Object value):boolean	
		
		hmap.containsKey(new String("블루베리류"));
		System.out.println(hmap);   // {사과류=아오리[200원], 1=1[300원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		System.out.println(hmap.containsKey(new String("블루베리류")));// true
		
		hmap.containsValue(new pModelVo04("블루베리",100));
		System.out.println(hmap.containsValue(new pModelVo04("블루베리",100))); // false
		System.out.println(hmap.containsValue(new pModelVo04("블루베리",100))); // true    // model에서 오버라이딩 후 true
		
		
		// 3.get()
		// get(Object key) : v
		// key값에 맞는 'value값 반환'
		hmap.get(new String("참외류"));
		System.out.println(hmap.get(new String("사과류"))); // 아오리[200원]
		System.out.println(hmap.getClass()); // class java.util.HashMap
		System.out.println(hmap); // {사과류=아오리[200원], 1=1[300원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		
		System.out.println("===4.remove()======");
		// 4-1.remove(Object key):V
		System.out.println(hmap.remove("1")); // 1[300원]
		System.out.println(hmap); // {사과류=아오리[200원], 블루베리류=블루베리[100원], 참외류=참외[300원]}
		
		// 4-2.remove(Object key, Object value):default boolean
		hmap.remove(new String("블루베리류"),new pModelVo04("블루베리",100));
		System.out.println(hmap.remove(new String("블루베리류"),new pModelVo04("블루베리",100)));//false
		System.out.println(hmap); // {사과류=아오리[200원], 참외류=참외[300원]} 오버라이딩 적용
		

		
		// 5.keySet() & entrySet()
		System.out.println("===keySet() & entrySet()======");
		
		// keySet()
		// keySet():Set<K>
		// 맵에 있는 key들을 set에 담아 반환
		
		// 방법1
		System.out.println(hmap.keySet()); // [사과류, 참외류]
		
		// 방법2
		// set의 [] 없이 안에 값만 뽑고 싶다면 방법2 사용
		Set<String> sset = hmap.keySet();
		Iterator<String> is = sset.iterator();
		while(is.hasNext()) {
			String s = is.next();
			System.out.print(s+" "); // 사과류  참외류 
		}
		System.out.println();
		
		
		// entrySet()
		// entrySet():Set<Map.Entry<K,V>>
		// map에 있는 entry들을 set 담에 반환(키와 값의 쌍을 set에 담아 반환)
		// entry 의미 : 키와 값을 묶은 것(키와 값의 쌍)
		
		// 방법1
		System.out.println(hmap.entrySet());//[사과류=아오리[200원], 참외류=참외[300원]]
		
		// 방법2
		// set의 [] 없이 안에 값만 뽑고 싶다면 방법2 사용
		Set<Entry<String,pModelVo04>> eset = hmap.entrySet();
		Iterator<Entry<String,pModelVo04>> it_eset = eset.iterator();
		while(it_eset.hasNext()){
			Entry<String, pModelVo04> a = it_eset.next();
			System.out.print(a+" ");  		// 사과류=아오리[200원] 참외류=참외[300원] 
		}									
		System.out.println();
		
		
		// size():int
		System.out.println(hmap.size()); // 2
		
		
		
		// TreeMap
		System.out.println("===TreeMap1===");
		
		TreeMap<String,pModelVo04> treeM = new TreeMap<>();
		
		treeM.put(new String("TreeMap"),new pModelVo04("Map",1));
		System.out.println(treeM.put(new String("TreeMap"),new pModelVo04("Map",1)));//Map[1원]
		System.out.println(treeM); // {TreeMap=Map[1원]}
		
		// putAll()
		// putAll(Map<? extends K,? extends V> m):void
		// 다른 맵의 값을 추가
		treeM.putAll(hmap);
		System.out.println(treeM); // {TreeMap=Map[1원], 사과류=아오리[200원], 참외류=참외[300원]}
		
		// remove(Object key):V
		System.out.println(treeM.remove(new String("참외류"))); // 참외[300원]
		System.out.println(treeM); // {TreeMap=Map[1원], 사과류=아오리[200원]}
		
		// replace(K key, V oldValue, V newValue):boolean
		treeM.replace(new String("TreeMap"),new pModelVo04("Map",1), new pModelVo04("맵",2)); 
		System.out.println(treeM); // {TreeMap=맵[2원], 사과류=아오리[200원]}
		
		// remove(Object key, Object value):boolean
		System.out.println(treeM.remove(new String("사과류"),new pModelVo04("아오리",200))); // true 오버라이딩 적용
		treeM.remove(new String("사과류"),new pModelVo04("아오리",200));
		System.out.println(treeM); // {TreeMap=맵[2원]}
		
		

		
	}	
		
}

 

 

 

 

728x90
반응형
728x90

@Override

public boolean equals(Object obj) 

@Override
	public boolean equals(Object obj) {
		// 객체 비교
		if (this == obj) { // this는 주소값 비교할려고 넣은 것
			return true;
		}
		if(obj == null) {
			return false;
		}
		if(getClass() != obj.getClass()) { // 내 클래스 정보와 상대방의 클래스 정보가 같은지 비교
			return false;
		}
		
		pModelVo02 other = (pModelVo02)obj; // 다운캐스팅 : obj->Snack
		if(name == null) {      // other는 레퍼런스 변수
			if(other.name != null) { 
				return false;
			}
		}else if(!name.equals(other.name)) { // 이름에 대한 비교
			return false;
		}
		
		if(weight != other.weight) { // 목록에 대한 비교
			return false;
		}
		return true;
	}

 

@Override

public int hashCode()

	@Override
	public int hashCode() {
		final int PRIME = 31; // 컴퓨터가 이해하기 좋은 숫자가 31이라함
		int result = 1;
		
		result = PRIME * result + (name == null ? 0 : name.hashCode()); // 내 해쉬코드가 아니라 스트링의 해쉬코드를 가져오는 것
		result = PRIME * result + weight; // 형이 안맞아서 에러나니 캐스팅 또는 소수점 없게끔 계산
		
		return result;
	}

 

@Override

public int compareTo(Object o)

	@Override
	public int compareTo(Object o) {
	    // Dog 이름 오름차순
		// Object o를 다운 캐스팅 해줘야함
		pModelVo02 otherP = (pModelVo02)o;
		
		String other = otherP.name;
		
		int result = name.compareTo(other); // compareTO 자체가 인트값 반환
		return 0;
	}

 

 

728x90
반응형
728x90

 

 

 

package controller;
import java.util.ArrayList;
import model.vo.pModelVo01;

public class pController01 {

	public void firstR() {
		
//		ArrayList list = new ArrayList();
		ArrayList<pModelVo01> list = new ArrayList<pModelVo01>(3); // 지네릭스 : 데이터타입 한정
		
		System.out.println(list); // 결과값 : []
								  // 리스트 자체가 대괄호 자동생성
		// 1. add(E e):boolean : 추가
		list.add(new pModelVo01("1번", 1));
		list.add(new pModelVo01("2번", 2));
		list.add(new pModelVo01("3번", 3));
		System.out.println(list);
		System.out.println("리스트 길이 : "+list.size());
//		list.add("hi",0);
		
		// 2. add(int index, E elemnet) : 자리 지정 추가
		list.add(0, new pModelVo01("0번",0));
		System.out.println(list);
		System.out.println("리스트 길이 : "+list.size());
		list.add(0, new pModelVo01("===",0));
		System.out.println(list);
		System.out.println(list.size());
		
		// 3.  remove(int index):E : 삭제
		list.remove(0);
		System.out.println(list);
		pModelVo01 a = list.remove(0); // .remove()의 삭제한 반환값  확인용 변수 
		System.out.println(a);
		System.out.println(list);
		System.out.println(list.size());
		
		
		//4 remove(Object o):boolean 
		
		pModelVo01 pm = new pModelVo01("1번",1);
		list.remove(pm);
		System.out.println(list); // 주소값이 다르기에 삭제 안한 것
		
		ArrayList<String> remve = new ArrayList<String>();
		remve.add("ㄱ");
		remve.add("ㄴ");
		remve.add("ㄷ");
		System.out.println(remve); // [ㄱ, ㄴ, ㄷ]
		System.out.println(remve.remove(new String("ㄷ")));
		System.out.println(remve); // [ㄱ, ㄴ]
		
		// set(int index, E e)
		// 해당 인덱스번호의 내용을 교체
		list.set(0, new pModelVo01("2번",2));
		list.set(2, new pModelVo01("2번",2));
		System.out.println(list); // [2번(2점), 2번(2점), 2번(2점)]
		
		// get(int index):E
		list.get(0);
		pModelVo01 tmp = list.get(0);
		System.out.println(tmp); // 2번(2점)
		
		System.out.println("==========================");
		// contains(Object) : boolean
		list.contains(new pModelVo01("2번",2));
		System.out.println(list);
		System.out.println(list.contains(new pModelVo01("2번",2)));
		System.out.println(remve.contains(new String("ㄴ")));
		
		// indexOf: int 
		// 해당 인덱스 번호 반환
		remve.add("ㄷ");		
		remve.add("ㄹ");		
		remve.add("ㅎ");		
		int aa = remve.indexOf(new String("ㅎ"));
		int aaa = list.indexOf(new pModelVo01("2번",2));
		System.out.println(aaa);
		
		// clear():void
		// isEmpty():boolean
		list.clear();
		remve.clear();
		System.out.println(list);
		System.out.println(remve);
		System.out.println(list.isEmpty());
		System.out.println(remve.isEmpty());
		
	}
	
}
728x90
반응형

+ Recent posts