본문 바로가기
java

22.11.15 Collection Framework

by SoulMania 2023. 2. 15.

ch15_collection.zip
0.01MB
단원설명 & tips.txt
0.00MB
설명.txt
0.03MB

컬렉션 -> 리스트계열, 셋계열

그외 맵계열.맵은 컬렉션 자식은 아니다.

List계열 = 순서는 유지한채로 저장, 중복허용
---> 입력된 대로 순차적으로 출력된다. (ex 병원 접수 목록, 병원진료 목록, 식당 웨이팅 목록, 대기목록)
---> 제일 만만하다 ㅎㅎ 많이 쓴다는 뜻

Set 계열 = 순서 유지 안된채로 저장., 중복 허용 안됨.
---> 단순데이터 자장 (ex 반려동물 목록, 우리집에 물건 목록 등등)
---> 조금 불편하다.. 내가 원하는 값 언제 나와? 잘 판단이 안됨.(빈도상 셋이 제일 안씀)

Map 계열 --> DB쪽 개념과 유사하다.
(값인 홍길동은 여러명이어도 상관없지만 고유한 유니크한 데이터 키값은 유일해야한다.주민번호 같은 데이터가 키다)
--->키를 알아야 데이터를 추출 하거나 검색이 가능해서 작업 코드량이 많다.

(키, 값)
(key, value) => 키와 밸류를 한 쌍(pair)로서 같이 묶여서 움직인다.
key ==> 중복허용X, 키명은 유일한 값이어야 한다. => unique
value ==> 중복허용
831123

, 홍길동
801123

, 홍길동

String 클래스 매우 중요 496

Arrays 클래스 = collections 클래스 비슷한 개념 p519

객체 안만들어도 된다. static이 무조건 들어가기 때문에

배열조작 기능을 가지고 있는 클래스 - 배열복사, 항목정렬, 항목 검색

참고-----------------------

  • 이 클래스는 컬렉션에서 작동하거나 반환하는 정적 메서드로만 구성된다.
  • 여기에는 컬렉션에서 작동하는 다형성 알고리즘이 포함되어 있다.
  • Collections는 Collection과 다르다.
  • Collections는 클래스이다. 이 클래스 안에 있는 메서드는 static이기 때문에 인스턴스를 생성하지 않고 바로 사용할 수 있다.
    //향상된 for문 p169
    /*Boxing, unBoxing p527

    자동 박싱과 언박싱​

    자동 박싱 - 포장 클래스 타입에 기본값이 대입될 경우 발생​
    Integer obj = 100;
​
    자동 언박싱 - 기본 타입에 포장 객체가 대입될 경우 발생​
    int a = obj;*/

추후 프로젝트 시에 쇼핑몰 주제로하면

맵 컬렉션을 많이 쓰게 되어있다. 특히 장바구니 담당자가 죽는다...

package ch15_collection;

//java.lang패키지를 제외한 그 외 패키지는 import해야한다.
//모든 클래스의 조상클래스는 Object클래스, wrapper 클래스 또한 java.util 안에 있다.
import java.util.ArrayList; //컬렉션 프레임워크를 쓰려면 java.util에서 import 해줘야 한다.
import java.util.Date;
//import java.util.*; 귀찮으면 이렇게 쓴다.
//import 패키지명.Date;

/*collection Framework(컬렉션 프레임워크)3가지 인터페이스의 종류 & 종류별 특징
-3가지 인터페이스
-List : 순서유지, 중복허용 예)대기자 List
-Set : 순서유지X, 중복허용X 예) 반려동물 목록, 우리집에 물건 목록 등등
-Map : Key와 value가 한 pair
key는 중복허용X
value는 중복허용
*/

public class ArrayList01 {

public static void main(String[] args) {
    //java.util.ArrayList list = new java.util.ArrayList(); //----> import 하기 싫다면 매번 이런형식으로 써야한다. ......ㅎㅎ
    //그냥 import하자..
    ArrayList list = new ArrayList();
    System.out.println(list); // 
    System.out.println(list.toString()); // --> 주소는 담았지만 해시코드가 아니라 배열형태로 출력.비어있다~~ 컬렉션에서 toString은 이런형태로 오버라이딩 된 것. 배열형태

    //size():리스트안에 저장된 (item)의 개수를 리턴
    //참고> .length:배열(Array)에 저장된 요소(item)의 개수를 리턴
    //Returns the number of elements in this list.
    int size = list.size(); //size메소드라서 ()가 있고 , length는 괄호가 없다. 어레이 리스트에서는 랭쓰가 아니라 size를 쓴다>?
    System.out.println("list.size()="+size);

    //.add() : value추가
    //List에는 다양한 타입의 value를 추가가 가능!
    //비교> 배열(array)에는 동일한 타입의 value를 추가 // 컬렉션은 다른타입도 다 들어간다?
    list.add("홍길동"); //add(Object)형태이기 때문에  (래퍼)클래스 변수 숫자 다 들어올 수 있다.
    list.add(new String("서울시 강남구"));
    list.add("hid");
    list.add("h123");
    list.add(20); //int 인트형태 리터럴 Integer             래퍼클래스로 변환     //프리미티브 타입을 클래스화 시킨것을 래퍼클래스라고 한다.
    list.add(182.9); //double -> 더블형태 리터럴 Double     래퍼클래스로 변환
    list.add('남'); //char -> Character                 래퍼클래스로 변환
    list.add(true); //boolean -> Boolean              래퍼클래스로 변환
    list.add(new Date());    //현재 날짜와 시간 객체 생성 java.util에 있는 Date를 쓴다.
    size = list.size(); //이렇게 하거나 위에 0개일때 size에 담았기 때문에 다시 담아줘야한다.
    System.out.println("list.size()="+size);

// System.out.println("list.size()="+list.size()); //이렇게 하거나~

    //특정위치에 있는 요소(item, element)를 가져오기
    //get(인덱스)
    Object data = list.get(0);  //배열처럼 특정 타입의 데이터만 담기는게 아니라서 리턴을 Object라고 되어있다.(모든~데이터~ 어떤타입이 담길지 모르기때문에)
    System.out.println(data); //홍길동
    //오브젝트에는 글자길이를 구하는 필드나 오브젝트가 없다. 그러면 String으로 down casting. 강제 형변환.
    //(강제형변환하고자 하는 클래스명) 변수
    //여기에서는 String으로 강제형변환하여 
    //String 클래스의 length()메소드를 호출하였다.
    //Object에는 length()메소드가 없기 때문에.
    String strData = (String)data; //한마디로 글자길이 보려면 스트링형태로 형변환하고서 출력해야한다는 뜻.
    System.out.println("글자길이 = "+strData.length()); //글자길이

// Animal = new Animal();
// Animal a = new Cat(); a.sound();
// Animal a = new Dog(); a.sound();
// Animal a = new Bird(); ((Bird)a).fly(); //-->모든 동물에 나는 기능이 없으므로 출력전에 Bird타입으로 강제 형변환 다운캐스팅 해야한다. 강제 형변환
//String 타입으로 글자길이 출력하는 것을 설명하기 위한 강제형변환 내용

// data = list.get(1); 이렇게 계속 같은 변수에 넣어도 되지만 보기 좋게 다른 변수에 담아보자~!
Object data1 = list.get(1);
System.out.println(data1); //서울시 강남구 (공백까지 총 7글자)
String strData1 = (String)data1;
System.out.println("글자길이 = "+strData1.length());
// System.out.println("글자길이 = "+((String)data1).length()); //--->변수에 안담고 이렇게 한번에 해도 된다.

    Object data2 = list.get(2); 
    System.out.println(data2); //hid
    String strData2 = (String)data2;
    System.out.println("글자길이 = "+strData2.length()); 

    Object data3 = list.get(3); 
    System.out.println(data3); //h123


    //인덱스 4,5,6,7 에 담긴 value는 
    //Object타입의 변수 date4에 저장 후 출력 --->변수 하나로 계속 저장!!
    //instanceof 클래스명 : 특정클래스의 객체이면 true 리턴

// Object data4 = list.get(4);
//// System.out.println(data4); //20
//// if(~~이 instanceof 클래스명) {
// if(data4 instanceof Integer) { //int의 래퍼클래스야? int의 객체야? 라고 물어보는것.
// System.out.println("정수 : "+data4);//20
// }else if(data4 instanceof Double) {
// System.out.println("실수 : "+data4);//182.9
// }else if(data4 instanceof Character) {
// System.out.println("문자 : "+data4);//남
// }else if(data4 instanceof Boolean) {
// System.out.println("불리언 : "+data4);//true
// }
//
// data4 = list.get(5);
//// System.out.println(data4); //182.9
// if(data4 instanceof Integer) { //int의 래퍼클래스야? int의 객체야? 라고 물어보는것.
// System.out.println("정수 : "+data4);//20
// }else if(data4 instanceof Double) {
// System.out.println("실수 : "+data4);//182.9
// }else if(data4 instanceof Character) {
// System.out.println("문자 : "+data4);//남
// }else if(data4 instanceof Boolean) {
// System.out.println("불리언 : "+data4);//true
// }
//
//
// data4 = list.get(6);
//// System.out.println(data4); //남
// if(data4 instanceof Integer) { //int의 래퍼클래스야? int의 객체야? 라고 물어보는것.
// System.out.println("정수 : "+data4);//20
// }else if(data4 instanceof Double) {
// System.out.println("실수 : "+data4);//182.9
// }else if(data4 instanceof Character) {
// System.out.println("문자 : "+data4);//남
// }else if(data4 instanceof Boolean) {
// System.out.println("불리언 : "+data4);//true
// }
//
// data4 = list.get(7);
//// System.out.println(data4); //true
// if(data4 instanceof Integer) { //int의 래퍼클래스야? int의 객체야? 라고 물어보는것.
// System.out.println("정수 : "+data4);//20
// }else if(data4 instanceof Double) {
// System.out.println("실수 : "+data4);//182.9
// }else if(data4 instanceof Character) {
// System.out.println("문자 : "+data4);//남
// }else if(data4 instanceof Boolean) {
// System.out.println("불리언 : "+data4);//true
// }

    //1. 포문으로 돌려서 위와 동일한 결과 출력!!!!

// Object data4 = null;
// for(int i=4; i<8;i++) {
// data4 = list.get(i);
// if(data4 instanceof Integer) { //int의 래퍼클래스야? int의 객체야? 라고 물어보는것.
// System.out.println("정수 : "+data4);//20
// }else if(data4 instanceof Double) {
// System.out.println("실수 : "+data4);//182.9
// }else if(data4 instanceof Character) {
// System.out.println("문자 : "+data4);//남
// }else if(data4 instanceof Boolean) {
// System.out.println("불리언 : "+data4);//true
// }
// }
//2. 포문으로 돌려서 위와 동일한 결과 출력!!!! 더 간소화
Object data4 = null;
String type="";
for(int i=4; i<8;i++) {
data4 = list.get(i);
if(data4 instanceof Integer) { //int의 래퍼클래스야? int의 객체야? 라고 물어보는것.
type="정수 : ";//20
}else if(data4 instanceof Double) {
type="실수 : ";//182.9
}else if(data4 instanceof Character) {
type="문자 : ";//남
}else if(data4 instanceof Boolean) {
type="불리언 : ";//true
}
System.out.println(type+data4);
}

// Object data4 = list.get(4);
// System.out.println(data4); //20
//
// Object data5 = list.get(5);
// System.out.println(data5); //182.9
//
// Object data6 = list.get(6);
// System.out.println(data6); //남
//
// Object data7 = list.get(7);
// System.out.println(data7); //true
//
// Object data8 = list.get(8);
// System.out.println(data8); //Mon Nov 14 16:35:51 KST 2022

}

}

package ch15_collection;

import java.util.ArrayList;

/*collection Framework(컬렉션 프레임워크) 3가지 인터페이스의 종류 & 종류별 특징
-3가지 인터페이스
-List : 순서유지, 중복허용 예)대기자 List
-Set : 순서유지X, 중복허용X 예) 반려동물 목록, 우리집에 물건 목록 등등
-Map : Key와 value가 한 pair
key는 중복허용X
value는 중복허용
*/

//p728참고
public class ArrayList02 {

public static void main(String[] args) {
    //ArrayList는 List인터페이스의 구현클래스 중의 하나
    //ArrayList = new 클래스명();
    //ArrayList 객체생성
    ArrayList list = new ArrayList();

    //value추가 : add(Object) -->> Object가 들어온다는건 뭐든 들어올 수 있다는 뜻.
    list.add("홍길동");
    list.add("이순신");
    list.add(new String("김구"));
    list.add(new String("세종대왕"));
    list.add("홍길동"); //값의 중복 허용!!!
    /*
     홍길동 - 이순신 - 김구 - 세종대왕 - 홍길동
      [0]   [1]   [2]   [3]    [4]   */

    //저장된 value개수 : size()
    System.out.println("list.size() = "+list.size()); //--->데이터 4개가 저장되어있다.

    //value꺼내기 : Object타입을 리턴하는 get(index)
    list.get(0);
    Object obj = list.get(0);
        // *나의 방식

// System.out.println(obj); //홍길동 출력
// String strData = (String)obj; //한마디로 글자길이 보려면 스트링형태로 형변환하고서 출력해야한다는 뜻.
// System.out.println("글자길이 = "+strData.length()); //홍길동 글자길이

        // *강사님 방식1
    String strObj=(String)obj; //String으로 강제형변환
    int len = strObj.length(); //String으로 변환된 value의 글자길이
    System.out.println(strObj+" 글자길이 : "+len);

        // *강사님 방식2 --->그냥 출력으로 모두 출력
    System.out.println(list.get(1)+" 글자길이 : "+ ((String)list.get(1)).length()); //--->이렇게 한번에 표현해도 된다. 근데 이렇게 쓰는게 좋은건 아니다.. 가독성이 떨어진다.

        // *강사님 방식3
    String strObj2 = (String)list.get(2); //애초에 겟 함수를 스트링형변환해서 변수에 넣어버리는 방식.
    System.out.println(strObj2+" 글자길이 : "+strObj2.length());



    System.out.println("--------------------------리스트 삭제 전--------------------------");
    //for문 활용 - 확인 0 1 2 3 < 4
    //value를 추가한 순서대로 출력된다. --> 순서유지!!! 중복허용!!
    for(int i=0; i<list.size();i++) {
        System.out.println(list.get(i));
        }



    //value삭제 : remove(index), remove(Object)
    list.remove(1);//인덱스가1인 요소가 삭제
    //==>이순신 삭제 //삭제된 후의 ArrayList를 리턴 //객체를 삭제하면 뒤에 있는 데이터의 인덱스를 끌어와서 인덱스를 하나씩 줄인다.
    /*
     홍길동 -  김구 - 세종대왕 - 홍길동
      [0]   [1]   [2]    [3]       */
    //객체 제거 : 바로 뒤 인덱스부터 마지막 인덱스까지 모두 앞으로 1씩 당겨짐
    list.remove(1); //-->데이터가 당겨져서 인덱스 1인 요소가 삭제 ===> 김구가 삭제
    /*
     홍길동 - 세종대왕 -홍길동
      [0]   [1]   [2]         */

    System.out.println("----------------------------이순신 삭제----------------------------");
    System.out.println("----------------------------김구 삭제----------------------------");

    //contains(Object) : 특정요소가 포함되어있으면 true를 리턴
    if(list.contains("김구")) { //김구가 포함되어있다면 true
            System.out.println("김구는 list에 포함 contains");
            list.remove("김구");
        }else {
            System.out.println("포함되어있지 않다.");
        }





    System.out.println("--------------------------리스트 삭제 후--------------------------");
    //for문 활용 - 확인 0 1 2 3 < 4
    //value를 추가한 순서대로 출력된다. --> 순서유지!!! 중복허용!!
    for(int i=0; i<list.size();i++) {
        System.out.println(list.get(i));
        }








}

}

package ch15_collection;

import java.util.List;
import java.util.ArrayList;

/*제네릭 타입이란? (p654~)​
타입을 파라미터로 가지는 클래스와 인터페이스​
선언 시 클래스 또는 인터페이스 이름 뒤에 “<>” 부호 붙임​
“<>” 사이에는 타입 파라미터 위치​

타입 파라미터​
일반적으로 대문자 알파벳 한 문자로 표현​
개발 코드에서는 타입 파라미터 자리에 구체적인 타입을 지정해야​ 한다. */

public class ArrayList03 {

public static void main(String[] args) {
    //ArrayList는 List인터페이스의 구현클래스
    //컬렉션에는 다양한 타입을 저장할 수 있지만
    //여기에서는 String만 저장하는것으로 제한
    List<String> list1 = new ArrayList<String>(); // <String> 을 넣자마자 노란색 줄이 사라지면서 list1.add(1); 가 빨간줄이 뜸... 인트타입이 이제 안먹히기 시작. 이런것이 제너릭이다.
    list1.add("김길동");
    list1.add("장길동");
    list1.add("홍길동");
    //list1.add(1);
    //The method add(int, String) in the type List<String> is not applicable for the arguments (int)

    //다양한 타입을 넣을 수 있다는 것이 컬렉션의 장점이지만.... 만약 스트링 타입의 데이터만 있다면....
    //매번 String타입으로 형변환 하는 것도...번거로움....그래서 하는것.

    System.out.println("---------------------for문 이용 출력------------------------------------");
    //String str1="";
    //String 타입으로 형변환  코드들 모두 필요 없음.
    for(int i=0; i<list1.size();i++) { 
        //str1=(String)list1.get(i);
        System.out.println(list1.get(i));

    }

    System.out.println("---------------------향상된 for문 이용 출력------------------------------------");
    //String 타입으로 형변환  코드들 모두 필요 없음.
    for(String obj:list1) { //콜론기준 왼쪽은  타입 임시변수, 오른쪽에 배열명 또는 컬렉션 명,
        //str1=(String)obj;
        System.out.println(obj+"의 글자길이 : "+obj.length());
    }


    System.out.println("-------------------------------------------------------------------------------");
    //-------------위에는 제너릭 테스트!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 스트링만 받도록---------------------





    //클래스타입     참조변수 = new 클래스명();
    //부모클래스타입     참조변수 = new 자식클래스명();
    //인터페이스명     참조변수 = new 구현클래스명();
    //ArrayList는 List인터페이스의 구현클래스
    //ArrayList list = new ArrayList(); //클래스명으로 객체 선언 했는데 얘는 어레이리스트만 사용가능.
    List list = new ArrayList(); //더 넓은 범위로 사용 가능. List라는 인터페이스로 객체 선언 // 인터페이스 List도 import해줘야 한다.
    list.add("김길동");
    list.add("장길동");
    list.add("홍길동");

    System.out.println("---------------------for문 이용 출력------------------------------------");
    String str="";
    for(int i=0; i<list.size();i++) { //String 타입으로 형변환 추가
        str=(String)list.get(i);
        System.out.println(str);

// System.err.println(str); //이건 빨간 글자네;;;
//System.out.println((String)list.get(i)); //이렇게 해도 출력 된다.
}

    System.out.println("---------------------향상된 for문 이용 출력------------------------------------");
    for(Object obj:list) { //콜론기준 왼쪽은  타입 임시변수, 오른쪽에 배열명 또는 컬렉션 명,
        str=(String)obj;
        System.out.println(str+"의 글자길이 : "+str.length());

    }




}

}

package ch15_collection;

import java.util.Arrays;
import java.util.List;

//p729참고
/*참고 -Arrays​ 클래스(교재p519~)

  • 배열 조작 기능을 가지고 있는 클래스 - 배열 복사, 항목 정렬, 항목 검색​
  • 제공하는 정적 메소드
    => 참조변수 (객체 주소)​가 아닌 클래스명.메소드명()
    */
    public class ArraysAsList_p729 { 
      //클래스명.메소드명()
  //Arrays.asList(a):고정된 객체들로 구성된 List생성
  //아래는 고정된 String 객체를 요소로 갖는 ArrayList객체 생성
  List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");  

  //향상된 for문 이용 출력
    // for(타입 변수명:컬렉션명) {
    // System.out.println();
    // }}//메소드
  • for(String stooge:stooges) { System.out.println(stooge); } //정수로 고정Integer된 객체를 요소로 갖는 ArrayList 객체 생성 //Boxing :기본 int인 10등등이 Integer클래스로 자동박싱 List<Integer> list = Arrays.asList(10, 20, 30, 90, 100); for(Integer v : list) { //--> 변수v의 타입은 Integer인 wrapper클래스 System.out.println(v); //Integer로 했을떄 나오기는 하지만.... 클래스이기 때문에 v.하면 여러가지 메소드 사용가능. } for(int v : list) { //변수 v의 타입은 기본타입인 int에 저장되면서 //자동으로 형변환되었다. => 클래스에서 -> 기본타입으로 자동형변환 즉 언박싱(unBoxing) System.out.println(v); //Integer로 했을떄 나오기는 하지만.... v.하면... 그런거 없음... 클래스가 아니기 때문.. 언박싱 되었기때문에 } //향상된 for문 p169 /*Boxing, unBoxing p527 자동 박싱과 언박싱​ 자동 박싱 - 포장 클래스 타입에 기본값이 대입될 경우 발생​ Integer obj = 100; 자동 언박싱 - 기본 타입에 포장 객체가 대입될 경우 발생​ int a = obj;*/
  • public static void main(String[] args) {

}//클래스

package ch15_collection;

import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*collection Framework(컬렉션 프레임워크) 3가지 인터페이스의 종류 & 종류별 특징
-3가지 인터페이스
-List : 순서유지, 중복허용 예)대기자 List - 구현클래스 ArrayList, Vector, LinkedList....
-Set : 순서유지X, 중복허용X 예) 반려동물 목록, 우리집에 물건 목록 등등
-Map : Key와 value가 한 pair
key는 중복허용X
value는 중복허용
*/
//p736
public class HashSet01 {

public static void main(String[] args) {
    //HashSet객체생성
    //클래스타입 참조변수 = new 클래스명();
    //HashSet set = new HashSet(); //컨트롤 + 쉬프트 + o 하면 자동 임포트 선언된다. ---> 얘는 HashSet의 자식이나 해당 구현클래스만 참조변수에 들어갈 수 있다.
     //인터페이스명 참조변수 = new 클래스명();
     Set set = new HashSet();  //다형성을 코드화하여 Set이라는 상위인터페이스의 구현클래스들의 set이라는 참조변수에 들어갈 수 있다. 


     //value 추가
     set.add(1);    //다양한 타입을 저장
     set.add(20); //int 인트형태 리터럴 Integer             래퍼클래스로 변환     //프리미티브 타입을 클래스화 시킨것을 래퍼클래스라고 한다.
     set.add(182.9); //double -> 더블형태 리터럴 Double     래퍼클래스로 변환
     set.add('남'); //char -> Character                 래퍼클래스로 변환
     set.add(true); //boolean -> Boolean              래퍼클래스로 변환
     set.add(new Date());    //현재 날짜와 시간 객체 생성 java.util에 있는 Date를 쓴다.

     set.add("홍길동");
     set.add("이순신");
     set.add(new String("김구"));
     set.add(new String("세종대왕"));
     set.add("이순신"); //한번 더 똑같은 값을 입력해서 총 11번 데이터 입력을 했는데 총 데이터 개수는 10개로 출력된다. 홍길동도 1번만 출력된다.  ★★★★★★★★★중복 허용X!!!!!!!!!!!!!!!!!!


     //value개수
     System.out.println("set.size() = "+set.size()); //--->데이터 4개가 저장되어있다.

     //value꺼내기
         //-ArrayList는 배열형태로 인덱스 번호를 get(1)에 넣어서 출력 하지만... 얘 순서.. 즉 인덱스가  의미 없다.
    //while문 활용 
    //value를 추가한 순서와 무관하게 출력된다. --> ★★★★★★순서유지X!!! 
     Iterator iterator = set.iterator(); //Iterator 타입의 라는 값을 리턴해주니까 Iterator타입의 참조변수를  선언한다. //인터페이스 타입의 참조변수
     while(iterator.hasNext()) { //다음요소가 존재한다면 true 리턴!!! //hasNext 다음 것 꺼낼 것 있어? 오케이 있네 다음거 가져와~ 라는 메소드!
            Object obj = iterator.next(); //오브젝트 타입을 리턴하니까 오브젝트 타입으로 참조변수 선언
            System.out.println(obj);
            }
     //4개일때는 이런식으로 입력순서와 무관하게 출력된다.

// set.size() = 4 이렇게 입력한 순서와 다르게 출력된다.
// 홍길동
// 김구
// 이순신
// 세종대왕

     //10개일때는 이런식으로 입력순서와 무관하게 출력된다.

// set.size() = 10
// 1
// 20
// 홍길동
// 남
// Tue Nov 15 15:10:06 KST 2022
// 김구
// 182.9
// 이순신
// 세종대왕
// true

     //삭제 : remove(Object):삭제되면 true리턴
     if(set.remove("홍길동")) {
         System.out.println("삭제완료"); //삭제완료
     }else {
         System.out.println("삭제X");
     }

     //확인: contains(Object) : 제시된 요소가 포함되면 true리턴
     if(set.contains("홍길동")) {
         System.out.println("포함OK");
     }else {
         System.out.println("포함X"); //포함X
     }




     //저장된 모든객체 : void clear()
     set.clear();
     System.out.println("clear() 후 set.size()="+set.size());


     //컬렉션이 비어있는지 조사 : isEmpty()
     //Returns true if this set contains no elements.
     if(set.isEmpty()) {
         System.out.println("컬렉션이 비어있다");
     }else {
         System.out.println("비어있지 않다!!!");
     }





}

}

package ch15_collection;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*collection Framework(컬렉션 프레임워크) 3가지 인터페이스의 종류 & 종류별 특징
-3가지 인터페이스
-List : 순서유지, 중복허용 예)대기자 List - 구현클래스 ArrayList, Vector, LinkedList....
-Set : 순서유지X, 중복허용X 예) 반려동물 목록, 우리집에 물건 목록 등등
-Map : Key와 value가 한 pair
key는 중복허용X
value는 중복허용
*/
//p734~736
public class HashSet02 {

public static void main(String[] args) {
    //HashSet 기본생성자를 호출하여
    //인터페이스타입의 set참조변수에 저장
    //Set set = new HashSet(); 
    Set<String> set = new HashSet<String>(); //제너릭 타입으로 문자열받 입력받게 수정
    set.add("hoNg");
    set.add("kIm");
    set.add("LeE");
    //set.add(true); 제너릭 선언 후, 에러난다.String value만 저장하기로 제한하였으므로 입력받을 수 없다.


    Iterator<String> iter = set.iterator();// 스트링데이터만 있는데 앞에 Iterator는 Object 타입이기 때문에 여기도 제너릭 선언!!!

// Iterator iter = set.iterator();// 스트링데이터만 있는데 앞에 Iterator는 Object 타입이기 때문에 여기도 제너릭 선언!!!
String e="";
while(iter.hasNext()) {
e = iter.next(); //제너릭 선언 전에는 여기도 Object타입인데 제너릭 선언 후에는 String으로 바뀜
// iter.next(); //제너릭 선언 전에는 여기도 Object타입인데 제너릭 선언 후에는 String으로 바뀜 그리고 이렇게 타입변환을 해야 대소문자 변환 메소드를 사용할 수 있다.
//String의 toUpperCase():대문자로 변환
//String의 toLowerCase():소문자로 변환
System.out.println(e+"의 대문자처리="+e.toUpperCase());
System.out.println(e+"의 소문자적용="+e.toLowerCase());

    }

    //향상된 for    문을 이용하여 출력
    //for-each    문을 이용하여 출력
    for(String i : set) {
        System.out.println(i);
    }

}

}

package ch15_collection;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/*collection Framework(컬렉션 프레임워크) 3가지 인터페이스의 종류 & 종류별 특징
-3가지 인터페이스
-List : 순서유지, 중복허용 예)대기자 List - 구현클래스 ArrayList, Vector, LinkedList....
-Set : 순서유지X, 중복허용X 예) 반려동물 목록, 우리집에 물건 목록 등등 - 구현클래스 HashSet, TreeSet
-Map : Key와 value가 한 pair - 구현클래스 HashMap, HashTable, LinkedHashMap, Properties, TreeMap
key는 중복허용X
value는 중복허용
*/
//제너릭 p.655, p.743코드
public class HashMap01_p743 {

public static void main(String[] args) {
    //클래스명     참조변수    =    new 클래스명();
    //HashMap map = new HashMap(); 이런식으로 하면 해쉬맵에 관련된 것만 사용가능.
    //HashMap()객체 호출하여 Map 생성
    //인터페이스명     참조변수    =    new 구현클래스();
    //Map<String, Integer> map = new HashMap<String, Integer>(); //이 방식으로 해야 폭 넓게 사용 가능!!
    //Map map = new HashMap();
    //위의코드는 아래와 동일하다.
    //Map<Object, Object> map = new HashMap<Object, Object>(); 아무것도 명시 안하면 이렇게 선언되는것과 같다.


    //key, value추가 : put(Object key, Object value)
    //아래코드처럼 key와 value타입은 Object타입으로 추가가능하다.
    Map<Object, Object> map = new HashMap<Object, Object>();
    map.put(1, 1);            //<Integer, Integer>
    map.put(2, 3.14);        //<Integer, Double>
    map.put(9.9, "홍");        //<Integer, String>
    map.put(true, false);    //<Boolean, Boolean>
    map.put("문자열", new Date());//<String, Date>

    //map.get() -->얘는 다양하게  입력하였기 때문에 오브젝트 타입


    //Object타입 key가 들어갈 수 있지만 편의상 String
    Map<String, Integer> map1 = new HashMap<String, Integer>();
    //map1.put("신구", 80.8);
    //여기에서는 80.8.은 실수타입.
    //즉 실수의 wrapper클래스인 Double타입으로 값을 추가하겠다고 하였지만 위에서 new HashMap<String, Integer>(); 하면서
    //값을 Integer. 즉 정수형태의 값만들 저장하겠다고 제한하였기 때문에 Double형태인 실수는 입력할 수 없다.(강제형변환해서 가능은하지만... 좋은 코드가 아니다.)
    //The method put(String, Integer) in the type Map<String,Integer> is not applicable for the arguments (String, double)
    map1.put("신구", 80);
    map1.put("홍길동", 90);
    map1.put("동장군", 80); //value 동일
    map1.put("홍길동", 100);

    //만약 key가 동일하다면 마지막 key가 가진 value로 저장된다.
    //여기에서("홍길동", 90)이
    //        ("홍길동", 100)으로 덮어씌워졌다.
    //그래서 get("홍길동")하니 value 100이 출력되었다.
    //키가 중복이 되면 마지막 값이 출력... 먼저 입력된 홍길동, 90은 지워져버린다.        
    System.out.println(map1.get("홍길동")); //100



    System.out.println(map1.get("동장군")); //80

    //key를 이용하여 value 꺼내기
    //key를 알면 get(키 명)
    Integer i1 = map1.get("신구");
    System.out.println(i1);//80  //얘는 정수만 입력 됐기 때문에 인티저로 뜬다.

    int i2 = map1.get("신구");
    //Integer타입을 int타입의 변수에 저장 ->언박싱 unBoxing
    //unBoxing이란 wrapper 클래스 타입 -> 기본 타입으로 전환
    System.out.println(i2);//80



    //key를 모르면 모든 key를 꺼내기 => while반복문
    //꺼낸  key 각각에 대한 value를 꺼내기


}

}

 

저작자표시

'java' 카테고리의 다른 글

22.11.24 java & DB(Oracle) 연동  (0) 2023.02.15
22.11.16 Collection Framework_2  (0) 2023.02.15
23.02.14 인터페이스의 구현클래스 super  (0) 2023.02.14
22.11.14 인터페이스, 컬렉션프레임워크  (0) 2023.02.13
22.11.11 상속, 다형성(Polymorphism), Override, Class 형변환  (0) 2023.02.13

관련글

티스토리툴바