Java 제네릭, 컬렉션 , Set , List , Map , Stack

🔸 제네릭

• 데이터 타입이 결정되지 않고 , 파라미터 타입(별칭)만 지정한다 표기방법은 < > 
• 클래스 내부에서 사용할 변수(데이터) 의 타입을 외부에서 지정할 수 있게 한다
• Java 에서는 제네릭을 사용할 때 , 기본데이터 타입을 사용하는게 아니라 해당 기본 데이터 타입의
  래퍼클래스를 사용해야 한다
• 객체 생성시점 , 구현클래스 , 구현시점  , 메서드 실행시 별칭을   지정
• 데이터 타입은 클래스 혹은 인터페이스 타입만 가능

🔹 제네릭 클래스 

• 파라미터 타입을 하나 이상가지고 있는 클래스
• 여러 종류의 객체를 다루는 클래스를 제네릭 클래스로 정의하면 타입의 안정성과 형변환 코드를 제거한다
• 제네릭 클래스 
  - 자료구조 :  Set List Map
  - 데이터 반복처리 : Iterator , Enumeration
• 제네릭 클래스 구현시 주의
  - T타입의 배열생성  불가
  - T타입의 클래스 변수 생성 불가

class Box<T> {
T t; //가능
static T t; // cv 선언불가
T[] data = new T[10]; // T타입 배열 생성불가
    public void add(T t){
 	   this.t = t;
    }

 }

◻ 제네릭 클래스

public class GenericBox<T> {
    // <T> 타입 파라미터라고 한다.
    // 클래스는 제네릭 타입 매개변수 <T>를 가지고 있다
    
    private T data; // T타입의 데이터 저장할수 있는 멤버변수 data , 어떤 데이터의 값을 저장할수 있음
    
    public void add(T data) {
        this.data = data;
    }

    public T get() {
        return data;
    }
}

public class App2 {
    public static void main(String[] args) {

        /*
        제네릭이 적용된 Box 클래스
            - 객체 생성 시점에 타입파라미터에 그 객체의 타입을 지정할수 있다
            - 객체 생성시 지정한 타입의 객체만 저장할 수 있다
            - 저장된 객체를 사용할 때 형변환이 필요없다.
         */

        // 객체 생성시점에 타입을 명시함
        GenericBox<String> box1 = new GenericBox<String>();

        box1.add("기선");
        String value1 = box1.get();

        // int가 아닌 Wrapper 타입 Integer
        GenericBox<Integer> box2 = new GenericBox<>();
        box2.add(19);
        int value2 = box2.get();


    }

  public static void main(String[] args) {
    // T의 타입이 String 클래스가 된다.
    Sample<String> s1 = new Sample<String>();		
    
    // T의 타입이 Customer 클래스가 된다.
    Sample<Customer> s2 = new Sample<Customer>();
    
    // T의타입이 Apple 클래스가 된다.
    // 중첩된 제네릭 타입
    // Box가 Apple 객체를 저장하고 Sample클래스가 Box 객체를 다루기 위해 중첩 제네릭 사용
    Sample<Box<Apple>> s3 = new Sample<Box<Apple>>();	
    
    // T의 타입이 Object가 된다
    Sample s4 = new Sample();	
    Sample<Object> s5 = new Sample<Object>();

    // Sample<int> s4 = new Sample<int>(); // 컴파일 오류
    // T의 타입이 Integer가 된다.
    Sample<Integer> s5 = new Sample<Integer>();

 

🔹 제네릭 클래스를 왜 사용 하는건데 ?

• 클래스 내부에서 사용할 데이터의 타입을 외부에서 지정한다
• 객체 생성 시점에 데이터 타입을 지정
• 사과만 담을수 있는 Box 클래스

  public class Box {
    private Apple fruit; // 다른데이터 타입 저장할수 없게 Apple 타입 멤버변수 선언
    public void setFruit(Apple fruit) {
      this.fruit = fruit;
    }
    public Apple getFruit() {
      return fruit;
    }
  }

• 여러 과일을 담을수 있는 Box 클래스

  public class Box {
    private Object fruit;	// Object는 종류 상관 없이 다 저장될수 있다
    public void setFruit(Object fruit) {
      this.fruit = fruit;
    }
    public Object getFruit() {
      return fruit;
    }
  }

• 과일만 저장된다는 보장이없다
• 한 종류의 과일만 저장된다는 보장도 없다
• 꺼냈을 때 어떤과일이 나올지 예상할 수 없다

• 객체 생성시 지정된 과일만 담을수 있는 Box 클래스

  public class Box<T> {	//  T타입 파라미터
    private T fruit;	// T로 선언되었으므로 Box 객체내에서 T타입 데이터 저장가능
    public void setFruit(T fruit) {
      this.fruit = fruit;
    }
    public T getFruit() {
      return fruit;
    }
  }
  // 안정성유지를 할수 있게된다
  // 또다른 예로 class Box<String> 사용 시 문자열 데이터만 저장할 수 있다

 

📌 제네릭을 사용해 클래스를 구현한 경우의 이로운 점

• 원하지 않는 자료형의 값이 입력되는 것을 컴파일 시점에 알수 있다
• 값을 꺼낼 때 타입 형변환 하지 않아도된다 

---

🔹 와일드 카드

• 제네릭 타입을 사용할 때 불특정한 타입을 나타내는데 쓰인다
• 예를들면 List<?> 는 어떤 타입의요소도 포함할 수 있는 List를 나타낸다
• 특정 타입을 알지 못할 때 쓰인다

  ArrayList<? extends Product> list = new ArrayList<Tv>();
  ArrayList<? extends Product> list = new ArrayList<SmartPhone>();
  // list 참조변수는 Product 및 그 자손이 제네릭타입으로 지정된 ArrayList를 참조할 수 있다.

  	 <?>
            - 제한없음
            - 타입 파타미터의 구체적인 타입으로 모든 클래스 , 모든 인터페이스 적요

        <? extendx 상위타입>
            - 상위 클래스 제한
            - 하입 파라미터의 구체적인 타입으로 상위타입 혹은 지정된
            상위 타입의 하위 타입만 가능

          <?  super 하위타입>
          - 하위 클래스 제한
          - 타입 파라미터의 구체적인 타입으로 하위타입혹은 지정된 하위타입의 상위타입만 가능하다

 

class Product {
    // Product 클래스 내용
}

class Tv extends Product {
    // Tv 클래스 내용
}

class SmartPhone extends Product {
    // SmartPhone 클래스 내용
}

ArrayList<Tv> tvList = new ArrayList<>();
tvList.add(new Tv());

ArrayList<SmartPhone> phoneList = new ArrayList<>();
phoneList.add(new SmartPhone());

ArrayList<? extends Product> list1 = tvList; // Tv 타입의 ArrayList를 상한 와일드카드에 할당
ArrayList<? extends Product> list2 = phoneList; // SmartPhone 타입의 ArrayList를 상한 와일드카드에 할당

for (Product p : list1) {
    // Product 객체 또는 Product 하위 클래스 객체를 읽을 수 있음
}

for (Product p : list2) {
    // Product 객체 또는 Product 하위 클래스 객체를 읽을 수 있음
}

---

🔸 컬렉션 프레임워크

🔹 컬렉션 인터페이스 Collection<E>

• 모든 자료구조의 최상위 인터페이스

boolean add(E e)
// 자료구조에 새로운 요소를 추가한다.
boolean addAll(Collection<? extends E> c)
// 자료구조에 다른 자료구조의 모든 요소를 추가한다.
void clear()
// 자료구조의 모든 요소를 삭제한다.
boolean contains(Object e)
// 자료구조에 지정된 객체가 존재하는지 조회한다.
boolean isEmpty()
// 자료구조가 비었는지 조회한다.
Iterator<E> iterator()
// 자료구조의 각 요소를 반복해서 추출해주는 반복자객체를 반환한다.
boolean remove(Object e)
// 자료구조에서 지정된 객체를 삭제한다.
int size()
// 자료구조에 저장된 요소의 갯수를 반환한다.
Object[] toArray()
// 자료구조에 저장된 요소를 배열로 반환한다.

 

 

---

🔹 Set

• 중복을 허용하지 않는 인터페이스다 ( 동일한 요소를 여러번 추가해도 중복 저장되지 않는다)
• 순서를 보장 하지 않는다 ( 순서를 신경쓰지 않고 단순히 중복 제거 용으로 쓰면 딱리다)
• 고유한 요소만을 저장한다
• 요소의 동등성(equality)을 기준으로 판단 한다  ( equals() , hashCode() 메서드 잘쓰자 )
• HashSet - 중복허용 안함 중복제거 , 순서 보장 안함
• TreeSet - 중복허용 안함 중복제거 , 예외적으로 정렬함  요소의 크기 또는 비교 기준에 따라 결정됨

◻ TreeSet

• Set<E> 구현 클래스
• 중복된 객체의 저장을 허용하지 않느다
• 객체가 저장될 때 오름차순으로 정렬되어 저장된다
•  TreeSet에 저장하는 객체는 반드시 Comparable<E>를 인터페이스를 구현한 객체여야 한다
• String Wrapper 클래스는 Comparable<E> 인터페이스를 구현하고 있다

package Java.collection;

import java.util.TreeSet;

public class TreeSetApp1 {
    public static void main(String[] args) {

        TreeSet<String> set = new TreeSet<String>();
        set.add("나타");
        set.add("가네샤");
        set.add("소패왕");
        set.add("봉추");
        set.add("현덕");

        // 자음 순서로 정렬된 걸 확인할수 있음
        for (String name : set) {
            System.out.println(name);
        }
    }
}

// 출력
/*
가네샤
나타
봉추
소패왕
현덕
*/

public class TreeSetApp2 {

    public static void main(String[] args) {

        // 로또 번호 추출하기
        // 1. 번호추출
        // 2. 중복 체크 - Set 으로 처리
        // 3. 저장
        // 4. 정렬 - TreeSet 처리

        Random random = new Random();
        TreeSet<Integer> lotto = new TreeSet<>();
        // - TreeSet<E> 사용
        // 중복 값은 저장하지 않음 , 자동정렬 오름차순으로  해줌 개꿀

        while (true) {
            int num = random.nextInt(45) + 1;

            // 변수 lotto 에 담음
            lotto.add(num);

            if (lotto.size() == 6) {
                break;
            }
        }
        System.out.println(lotto);
    }
}

 

◻ HashSet 

• Set<E> 인터페이스를 구현한 자료구조 구현 클래스
• 중복된 객체의 저장을 허용하지 않는 자료구조 구현 클래스
• 객체의 동일성 비교를 구현하기 위해 equals() , hashcode()
  메서드를재 정의할 필요가 있다 (HashSet<E> 에 저장되는 객체가 구현 해야함)
•  String Wrapper 클래스는 equals() 와 hashCode()가 이미 재정의 되어있다

package Java.collection;

import java.util.HashSet;
import java.util.stream.Stream;

public class HashSetApp1 {
    public static void main(String[] args) {

        // String 객체를 저장하는 HashSet 객체 생성
        HashSet<String> set = new HashSet<String>();

        // boolean add(E e) 메서드를 사용해 HashSet 객체에 String 객체에 저장하기
        set.add("하나");
        set.add("둘");
        set.add("셋");
        set.add("넷");
        set.add("다섯");
        set.add("여섯");
        set.add("여섯");  // 중복 저장안된
        set.add("여섯");  // 중복 저장안된
        set.add("여섯");  // 중복 저장안된

        // int size() 메서드를 사용해 HahSet 객체에 저장된 객체 갯수 조회
        int size = set.size();
        System.out.println("저장된 객체의 갯수 : " + size); // 6 출력됨

        // 향상된 for문을 사용해 HashSet 객체에 저장된 객체들을 하나씩 처리하기
        // HashSet은 index가 없다 , 일반 for문으로 HashSet객체에 저장된 값들을 처리할수 있다

        for (String name : set) {
            System.out.println(name);
        }

        // Stream 을 사용해서 HashSet객체에 저장된 객체들을 하나씩 처리

        System.out.println("### Stream을 활용해 HashSet객체에 저장된 객체 처리");
        Stream<String> stream = set.stream();
        stream.forEach((String value) -> System.out.println(value));
//        public void Consumer<String>(){
//            public void accept(String value){
//                System.out.println(value);
//            }
//        });

        // boolean contains(Object o)를 사용해 객체의 저장여부를 조회
        boolean isExist = set.contains("둘");
        System.out.println("존재여부 : " + isExist);

        // boolean isEmpty() 를 사용해 HashSet객체가 비어있는지 조회
        boolean isEmpty = set.isEmpty();
        System.out.println("비어있는가 ? :" + isEmpty);

        // void clear() HashSet객체에 저장된 모든 객체 삭제하기
        set.clear();

        System.out.println("비어있는가 2 ? : " + set.isEmpty());
    }
}

package Java.collection;

import java.util.HashSet;
import java.util.Objects;

public class HashSetApp2 {

    public static void main(String[] args) {

        HashSet<User> set = new HashSet<>();

        set.add(new User("kim", "김유신"));
        set.add(new User("Han", "한명회"));
        set.add(new User("Han", "한명회"));
        set.add(new User("Han", "한명회"));
        set.add(new User("ryu", "류승룡"));
        set.add(new User("shin", "신라"));
        set.add(new User("kahn", "칸 케식"));
        set.add(new User("ahn", "안중근"));

        for (User u : set) {
            System.out.println(u.id + ", " + u.name + ", " + u);
        }

    }

    static class User {
        String id;
        String name;

        public User(String id, String name) {
            this.id = id;
            this.name = name;
        }

        /*
        hashCode() 와 equals() 메서드를 재정의해서
        id 값이 같은 User 객체는 같은 객체로 판단하도록 했다.
         */
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            User user = (User) o;
            return Objects.equals(id, user.id);
        }

        @Override
        public int hashCode() {
            return Objects.hash(id);    // id로만 hashCode 만들어짐 , id가 같다면 hashCode가 같다는것을 의미함
        }
    }
}

// 출력 결과
/*
Han, 한명회, Java.collection.HashSetApp2$User@11a94
ahn, 안중근, Java.collection.HashSetApp2$User@17946
kahn, 칸 케식, Java.collection.HashSetApp2$User@321cfb
ryu, 류승룡, Java.collection.HashSetApp2$User@1bb2d
shin, 신라, Java.collection.HashSetApp2$User@35da59
kim, 김유신, Java.collection.HashSetApp2$User@19eee
*/

---

 

 

🔹 List

• List<E> 인터페이스를 구현한 클래스
• 가변길이 배열을 활용해 List<E> 인터페이스를 구현 했다
• 순서가 보장되는 자료구조 구현 클래스
• 특정위치에 저장하기 , 삭제하기 , 꺼내기 
• 가장 많이 사용되는 자료구조 구현클래스

🔹 구현 클래스

• ArrayList<E> : 가장 많이 사용하는 List구현 클래스(전체 자료구조 클래스 중에서 가장 많이 사용)
• LinkedList<E> : 더블링크로 List를 구현한 클래스(요소의 추가/삭제 성능이 우수하다.)
• Vector<E> : ArrayList와 유사하는 List구현 클래스(멀티스레드 환경에 안전하다.)
• Stack<E> : LIFO(Last-In-First-Out)으로 구현된 List구현 클래스

 

  // String객체를 여러 개 저장하는 ArrayList객체 생성하기
  List<String> list1 = new ArrayList<String>();
  
  // 실수를 여러 개 저장하는 ArrayList객체 생성하기
  List<Double> list2 = new ArrayList<Double>();
  
  // Person객체를 여러 개 저장하는 ArrayList객체 생성하기
  List<Person> list3 = new ArrayList<Person>();

 

🔹 ArrayList<E> 활용하기

 

  public class Person {
    private int no;
    private String name;
    public Person() {}
    public Person(int no, String) {
      this.no = no;
      this.name = name;
    }
    public int getNo() {
      return no;
    }
    public String name() {
      return name;
    }
  }

  public static void main(String[] args) {
    // Person객체를 여러 개 저장할 수 있는 ArrayList객체 생
    List<Person> personList = new ArrayList<Person>();
    
    // ArrayList객체에 Person객체생성하기
    personList.add(new Person(100, "김유신"));
    personList.add(new Person(200, "강감찬"));
    personList.add(new Person(300, "이순신"));
    personList.add(new Person(400, "류관순"));
    
    // ArrayList객체에 저장된 Person객체의 갯수를 조회하기
    int count = personList.size();
    System.out.println("저장된 갯수: " + count); // 4가 출력됨
    
    // 향상된 for문을 사용해서 ArrayList객체에 저장된 Person객체를 순회하기
    for (Person person : personList) {
      int no = person.getNo();
      String name = person.getName();
      System.out.println("번호:" + no + ", 이름:" + name);
    }
    
    // ArrayList객체에서 0번에 저장된 Person객체 조회하기
    Person person0 = personList.get(0);
    
    // ArrayList객체에서 2번에 칸에 저장된 Person객체 삭제하기
    personList.remove(2)
    
    // ArrayList객체에서 1번에 저장된 객체를 새로운 Person객체로 변경하기
    personList.set(1, new Person(500, "안중근"));
    
    // ArrayList객체에 저장된 모든 객체 삭제하기
    personList.clear()
  }

---

🔹 Stack<E> 객체 사용

  public static void main(String[] args) {
    Stack<String> stack = new Stack<String>();
    
      // Stack객체에 문자열 저장하기
      stack.push("김유신");
      stack.push("강감찬");
      stack.push("이순신");

      // Stack객체에서 맨 위에 있는 객체를 조회한다.
      String value1 = stack.peek();	// 이순신
      String value2 = stack.peek();	// 이순신
      String value3 = stack.peek();	// 이순신
    
    // Stack객체에서 맨 위에 있는 객체를 꺼낸다.(Stack에서 해당 객체는 삭제된다.)
    String value1 = stack.pop();	// 이순신
      String value2 = stack.pop();	// 강감찬
      String value3 = stack.pop();	// 김유신
    
    // Stack객체가 비어있는지 확인하기
    boolean result = stack.isEmpty(); // true가 반환된다.
  }

 

---

void add(int index, E e)
// 지정된 위치에 요소를 저장한다.

E get(int index)
// 지정된 위치의 요소를 꺼낸다

E remove(int index)
// 지정된 위치의 요소를 삭제한다.

E set(int index, E e)
// 지정된 위치의 요소를 새 요소로 교체한다.

---

🔹 Map

• Map < K ,V > 는 데이터를 Key와 Value의 쌍으로 연결지어서 저장하는 객체
• Map <K,V> 객체는 Entry < K ,V> 객체를 여러개 저장하는 객체다
• Key는 주복이 될수 없으며 타입은 대체로 String Integer Long 타입이 주로 사용된다
• Value는 실제로 Map에 저장할 정보를 가지고 있는 객체다

📌 Key와 Value 한쌍을 하나의 Entery 라고 칭하며 , 이 Entry들이 여러개가 Map이라 칭한다

 

Ex. 

Key	Value	Map < K ,V >
학번	학생 객체	Map < Integer , Student >
주문번호	주문정보 객체	Map < Long , Order >
사용자 아이디	사용자 정보 객체	Map < String , User >
상품번호	상품정보 객체	Map < Integer , Product >

 

V put(K key, V value)
// Map객체에 key, value의 쌍을 저장한다.

V get(Object key)
// Map객체에서 지정된 key에 해당하는 value를 조회한다.

V remove(Object key)
// Map객체에서 지정된 key에 해당하는 value를 삭제한다.

void clear()
// Map객체에 저장된 모든 key, value의 쌍을 삭제한다.

int size()
// Map객체에 저장된 Key,value쌍의 갯수를 반환한다.

boolean isEmpty()
// Map객체가 비어있으면 true를 반환한다.

boolean containsKey(Object key)
// Map객체에 지정된 key가 포함되어 있는지 여부를 반환한다.

boolean containsValue(Object value)
// Map객체에 지정된 value가 포함되어 있는지 여부를 반환한다.

Set<Key> keySet()
// Map객체의 모든 key를 Set객체에 담아서 반환한다.

Collection<V> values()
// Map객체의 모든 value를 Collection객체에 담아서 반환한다.

Set<Map.Entry<K, V>> entrySet()
// Map에 저장된 모든 Entry<K, V>를 Set에 담아서 반환한다.

// key : 아이디  , value : 고갱명의 쌍으로 Entry가 구성되는 HashMap객체 생성하기
        Map<String, String> map1 = new HashMap<String, String>();

        // Map 객체에 새로운 Entry 저장
        map1.put("hong", "홍길동");
        map1.put("kim", "김유신");
        map1.put("Gil", "길태미");
        map1.put("Chuck", "척계광");

        System.out.println(map1);	// {hong=홍길동, Chuck=척계광, Gil=길태미, kim=김유신}

        String value1 = map1.get("Gil");	
        String value2 = map1.get("chuck");	
        String value3 = map1.get("Han");	

        System.out.println(value1);	// 길태미
        System.out.println(value2);	// null - 대소문자 틀림
        System.out.println(value3);	// null - 존재하지 않음
        
                // map 객체에서 지정된 key에 해당하는 Entry 삭제
        map1.remove("hong");

        // 이미 존재하는 key로 다시 값을 저장하면 기존 값을 덮어쓴다
        map1.put("kim", "김좌진");

        System.out.println(map1);   // {Chuck=척계광, Gil=길태미, kim=김좌진}

 

🔹 Map 객체

Map<string,Object> map = new HashMap<>()

해당 코드 같은 형태로 Map객체를 생성하면 key , value의 쌍으로 다양한 타입의 값을 저장 할 수 있다

📌 처리할 정보의 형태가 다영한 경우 (값의 갯수 , 값의 종류가 다양하는 변하는 정보 다룰 때)

if문의 조건식에서 비교 값으로 이용되는 값을 Map 객체의 key로 활용ㄹ하면 if문을 제거 할 수 있다

Map < String , Double > map = new HashMap<>();
map.put("gold" , 0.05);
map.put("silver" , 0.02);
map.put("bronze" , 0.01);

// 고객등급과 구매금액을 전달받아 포인트 반환
// 포인트 적립률은 고객등급에 따라 달라지는데 Map에 포인트 등급을 key , 적립률을 value로 저장
// 맵에서 고객등급의 key로 적립률을 조회할수 있다


public int getPoint(String grade, int orderPrice) {
double pointDepositRate = map = get(grade);
return (int) (orderPrice * pointDepositRate);
	}
    
// 여러개의 같은 값을 가진 것들 끼리 분류
// Ex)
// 고객이름에서 성씨별 인원수 계산하기
// 상품목록에서 상품 카테고리별로 상품 수 계산
// 연설문에서 단어별 빈도수 계산하기

 

 // VO 객체를 대체하는 Map객체

   //     상품 정보를 저장하는 Product 클래스
  /*      public class Product{
            private int no;
            private String name;
            private String maker;
            private int price;
            private double discountRate;
        }

        Product item1 = new Product(100,"galaxy22","samsung",990000,0.05);
        Product item2 = new Product(100,"galaxy23","samsung",990000,0.05);
        Product item3 = new Product(100,"galaxy24","samsung",990000,0.05);
        Product item4 = new Product(100,"galaxy25","samsung",990000,0.05);


     //   상품 정보를 저장하는 Map 객체
        Map<String,Object> item = new HashMap<>();
        item.put("no",100);
        item.put("name","galaxy22");
        item.put("maker","samsung");
        item.put("price",990000);
        item.put("discountRate",0.05);
        
        */
        
            Map<String, Object> item2 = new HashMap<String, Object>();
        item2.put("no", 101);
        item2.put("name", "galaxt22");
        item2.put("maker", "samsung");
        item2.put("price", 900000);
        item2.put("discountRate", 0.05);

        // 상품정보가 저장된 Map객체를 여러개 저장하는 List객체 생성
        List<Map<String, Object>> items = new ArrayList<>();
        items.add(item1);
        items.add(item2);
        
        // List 객체에 모든 정보 추력
            for (Map<String, Object> map : items) {
            int no = (Integer) map.get("no");
            String name = (String) map.get("name");
            String maker = (String) map.get("maker");
            int price = (Integer) map.get("price");
            double discountRate = (double) map.get("discountRate");

            System.out.println("번호 : " + no);
            System.out.println("이름 : " + name);
            System.out.println("제조사 : " + maker);
            System.out.println("가격 : " + price);
            System.out.println("할인율 : " + discountRate);
            System.out.println();
            System.out.println();

        }

---

    public static void main(String[] args) {
        Map<String, MessageSender> map = new HashMap<String, HashMapApp4.MessageSender>();

        map.put("sms", new SmsMessageSender());
        map.put("Email", new EmailMessageSender());
        map.put("kakao", new KakaotalkMessageSender());

        User user1 = new User();
        user1.name = "홍길동";
        user1.senderTypes = new String[]{"sms", "kakao"};
        System.out.println("###" + user1.name + "에게 이벤트 메시지 전송하기");

        for (String type : user1.senderTypes) {   // type에는 "sms", "kakao"가 전달한다
            MessageSender ms = map.get(type);
            ms.send();
        }
    }


    static class User {
        String name;         // 고객명
        String[] senderTypes;   // 고객이 수신동안 메시지 수신방법들
    }

    static interface MessageSender {
        void send();
    }

    static class SmsMessageSender implements MessageSender {
        public void send() {
            System.out.println("SMS로 메시지를 보낸다.");
        }
    }

    static class EmailMessageSender implements MessageSender {
        public void send() {
            System.out.println("Email로 메시지를 보낸다");
        }
    }

    static class KakaotalkMessageSender implements MessageSender {
        public void send() {
            System.out.println("카카오톡으로 메시지를 보낸다");
        }
    }

Map < String , Double > map = new HashMap<>();
map.put("gold" , 0.05);
map.put("silver" , 0.02);
map.put("bronze" , 0.01);

// 고객등급과 구매금액을 전달받아 포인트 반환
// 포인트 적립률은 고객등급에 따라 달라지는데 Map에 포인트 등급을 key , 적립률을 value로 저장
// 맵에서 고객등급의 key로 적립률을 조회할수 있다


public int getPoint(String grade, int orderPrice) {
double pointDepositRate = map = get(grade);
return (int) (orderPrice * pointDepositRate);
	}
    
// 여러개의 같은 값을 가진 것들 끼리 분류
// 고객이름에서 성씨별 인원수 계산하기

---

🔹 Stack 클래스

•  last-in-first-out (LIFO) 자료구조 구현 클래스
• 후입선출 : 가장 나중에 추가한 값이 제일 먼저 인출된다.
• Stack은 List 인터페이스의 구현체다
• Stack 구현클래스의 고유한 기능을 사용하기 위해서는 Stack 타입의 참조변수에 객체를 대입해야 한다

    E push(E item)
//        지정된 객체를 스택의 맨 위에 추가한다

   E pop()
//   스택의 맨 위에 있는 객체를 삭제하고, 그 객체를 반환한다

    E peek()
//      스택의 맨 위에 있는 객체를 삭제없이 반환한다.

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

        stack.push("홍길동");
        stack.push("고길동");
        stack.push("김유신");
        stack.push("김시민");

        System.out.println(stack);	// [홍길동, 고길동, 김유신, 김시민]

        String name2 = stack.pop();
        System.out.println("인출할 객체 : " + name2);	// 인출할 객체 : 김시민
        System.out.println("stack 확인 : " + stack);	// stack 확인 : [홍길동, 고길동, 김유신]