Java | 제네릭, 컬렉션프레임워크

1. 제네릭(Generic)
클래스나 메소드에서 사용할 데이터의 타입을 컴파일시에 미리 지정하는 방법

제네릭을 사용하는 이유
- 다양한 타입의 객체의 재사용을 높일 수 있음
- 클래스에서 사용할 타입을 외부에서 설정
- 반복적인 코드, 불필요한 코드를 사용하지 않도록 함
- 강제적인 형변환을 발생시키지 않음

✔ Object 클래스
- 자바의 모든 클래스의 최상위 조상 클래스
- 모든 타입은 Object 클래스로 객체화 시킬 수 있음(업캐스팅가능)
- 기본 데이터 타입을 넣을시 객체화 시킨 래퍼타입으로만 대입 받을 수 있음

//T는 타입의 약자
public class Box2<T> {
    private T num1;
    private T num2;
    public T sum(T num1, T num2){
        return num1 + num2;
    }
}
--------------------------------------
객체 생성시
Box2<Interger> box = new Box2();
box1.sum(10,20);
----->

아래 처럼 생성이 되는거임!
public class Box2<Integer> {
    private Integer num1;
    private Integer num2;
    public Integer sum(Integer num1, Integer num2){
        return num1 + num2;
    }
}

<T>: Type
<E>: Element
<K>: Key
<V>: Value
<N>: Number


2. 컬렉션 프레임워크(Collection Framework)
- 여러가지 데이터를 메모리에 쉽고 효과적으로 처리할 수 있도록 제공하는 클래스들의 집합
- 자료구조를 구현한 클래스들의 모음

자료구조
- 데이터를 효율적으로 관리할 수 있는 데이터 구조를 의미
- 데이터의 특성에 따라 체계적으로 구조화 함

알고리즘
- 어떤 문제를 풀기 위한 절차 및 방법
- 어떤 문제에 대해 입력을 넣으면 원하는 출력을 얻을 수 있도록 만드는 프로그래밍

🍟 Iterator 인터페이스
모든 컬렉션 프레임워크 인터페이스에서는 Iterator 인터페이스를 구현한 클래스의 인스턴스를 반환하는
iterator() 메소드를 정의하여 각 요소에 접근하도록 설계
- 자바의 컬렉션에 저장되어 있는 요소들을 읽어오는 방법
- 컬렉션으로부터 정보를 얻어내는 방법
- 어디에나 이터레이터 인터페이스가 있슴

Iterator의 장단점
장점: 컬렉션 프레임워크 종류에 관계없이 일관성있게 프로그래밍을 할 수 있음
단점: size 메소드를 얻어와서 반복처리하는 것보다 속도가 좋지 못함

    ✔ 동기식
    프로그램을 차례(순서)대로 처리
    ✔ 비동기식
    여러개의 프로그램을 동시에 처리, 시간이 오래걸리면 다음 문장으로 이동 후 동작하는 방식

🍟 List 인터페이스
순서가 있는 데이터들의 집합으로 데이터의 중복을 허용 하는 스타일로 설계가 되어있다
=>순서O,중복O
Vector(많이씀), ArrayList(많이씀), Queue, Stack, LinkedList

    Vector 클래스
    - 동적인 길이로 여러 데이터형을 저장하기 위해 사용
    - 자바 1.0부터 존재하는 레거시 클래스
    - 배열과 동일하게 정수 인덱스를 이용하여 엑세스를 할 수 있음
    - 동기화되어 있으며 한번에 하나의 스레드만 벡터의 메소드를 호출할 수 있음
    - 동기화라 잘 안씀

    ArrayList 클래스
    - 동적인 길이로 여러 데이터형을 저장하기 위해 사용
    - 배열과 동일하게 정수 인덱스를 이용하여 엑세스를 할 수 있음
    - 비동기식을 사용하며 멀티 스레드를 지원(벡터와 차이점)

    Queue 클래스(파이프)
    - FIFO(First in First Out)
    - 큐의 한쪽끝을 프론트로 정하여 삭제 연산만 수행함
    - 다른 한쪽끝을 리어로 정하여 삽입 연산만 수행함
    - 푸시메시지, 운영체제의 스케줄러

    Stack 클래스(프링글스통)
    - LIFO(Last Input First Out)
    - 한쪽 끝에서만 자료를 넣고 뺄 수 있는 형식의 자료구조
    - 브라우저의 뒤로가기 앞으로가기

    LinkedList 클래스
    - 각 노드가 데이터와 포인터를 가지고 한 줄로 연결되어 있는 방식
    - ArraryList에 비해 데이터의 추가나 삭제가 빠름
    - 인덱스가 없기 때문에 특정 요소에 접근이 느림
    - 탐색속도가 떨어짐
    [다른 네모의 주소,값]  ---[다른 네모의 주소,값] ----...
    이런식으로 주소들이 연결되어있어 하나를 찾으려면 맨처음부터 타고타고 넘어가야해서 시간오래걸림


🍟 Set 인터페이스
순서가 없는 데이터 집합으로 데이터의 중복을 허용하지 않음
=>순서X,중복X
HashSet, TreeSet

    HashSet 클래스
    - 데이터를 중복해서 저장할 수 없음(중복은 자동으로 제거)
    - 저장 순서가 유지되지 않음
    - 정렬을 하지 않음
    - 하나의 null값을 저장할 수 있음 (null도 중복안된다는 의미)


    TreeSet 클래스
    - 데이터를 중복해서 저장할 수 없음(중복은 자동으로 제거)
    - 저장 순서가 유지되지 않음
    - 오름차순 유지되지 않음
    - 하나의 null값을 저장할 수 있음
    - 이진 탐색 트리 구조로 이루어져 있음

    ✔ 이진 탐색 트리
    추가, 삭제에는 시간이 걸리지만 정렬, 검색에 높은 성능을 자랑하는 자료구조


🍟Map 인터페이스
키와 값을 한 쌍으로 이루어지는 데이터의 집합으로 순서가 없고, 키는 중복으로 허용하지 않지만 값은 중복할 수 있다
=> 키&값, 순서X, 키중복X, 값중복O
HashMap, TreeMap, HashTable

    HashMap 클래스
    - Map 인터페이스를 구현한 대표적인 클래스
    - 키와 값으로 구성된 요소객체를 저장하는 구조를 가지고 있는 자료구조
    - 키는 중복될 수 없고, 값은 중복될 수 있음
    - 기존의 저장된 키와 동일한 키로 값을 저장하면 기존의 값은 없어지고 새로운 값으로 대체
    - 해싱(Hashing)을 사용하기 때문에 많은 양의 데이터를 검색하는데 뛰어난 성능
    - 비동기식
        키:1 값:10
        키:5 값:3
        키:1 값:5 를 쓰면 기존의 키를 찾아가서 값만 바꿈 (1:10)=>(1:5)

        a   -> a35asd435s
        abc -> b75s5ejsie
        동일한 길이의 고유 해시값을 쓰기때문에 검색속도가 빠름

    TreeMap 클래스
    - 이진트리를 기반으로 한 Map 컬렉션
    - TreeSet과의 차이점은 TreeSet은 값만 저장하는 구조라면 TreeMap은 키와 값이 저장된 key, value를 저장
    - 키는 오름차순으로 정렬됨(숫자:값, 문자열:유니코드 기준으로 정렬)
    - HashMap보다 성능이 떨어짐(데이터를 저장할 때, 삭제할 때)
    - 검색이 필요한 경우 효율성면이 좋음

    HashTable 클래스
    - 키와 값을 1:1 형태로 저장
    - 키는 값을 식별하기 위한 고유한 키, 값은 키가 가진 값
    - 동기화
    - HashMap에서는 값을 null이 입력이 가능하지만 HashTable에서는 null입력이 불가능


과제.
학생 관리 프로그램을 만들어보자

메뉴
1. 학생입력     -----> 학번,이름,나이,연락처
2. 학생리스트   -----> 학번으로 오름차순
3. 학생검색
4. 학생삭제
5. 종료

public class Object1 {
    public static void main(String[] args) {
        Box1 box1 = new Box1();
        box1.setObj("안녕하세요");
        System.out.println(box1.getObj());
//        Object str = box1.getObj();
//        String str = (String)box1.getObj();       // null 값일때 에러
//        String str = box1.getObj().toString();    // Integer 형변환 일 때 에러
        String str = String.valueOf(box1.getObj()); // 추천!

        box1.setObj(100);
        System.out.println(box1.getObj());
        //int i = box1.getObj();
        Integer i = Integer.parseInt(box1.getObj().toString());
        System.out.println(box1.getObj());

        Apple apple = new Apple("사과",1000,"red","충주","소과");
        box1.setObj(apple);
        System.out.println(apple);
        System.out.println(box1.getObj());

        //Apple apple2 = box1.getObj(); // Object형은 apple(자식) 에게 못넣음
        Apple apple2 = (Apple)box1.getObj(); // 형변환 시켜줌(다운캐스팅)
        System.out.println(apple2);  //계속 형변환해주는게 불편해서 생겨난게 제네릭!
    }
}

public class Box1 {
//    private int num;
//    private String num;
//    private double num; 타입도 다르게받고싶은데 그러면 하나하나 이름도 다르게 생성해줘야해서 번거롭다
    //그래서 Object 타입 필드를 생성해준다
    private Object obj;

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }
}

public class Box2<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class Fruit {  //extends Object 가 생략
    private String name;
    private int price;
    private String color;
    private String from;

    public Fruit() {}

    public Fruit(String name, int price, String color, String from) {
        this.name = name;
        this.price = price;
        this.color = color;
        this.from = from;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getFrom() {
        return from;
    }

    public void setFrom(String from) {
        this.from = from;
    }

    public void info() {
        System.out.println("[과일명: "+ name+",가격 :"+price+",색상:"+color+
                ",원산지:"+from+"]");
    }

    // 오버라이딩 (시그니처가 같은)  / 오버로딩(시그니처만 다름)
    public String toString(){
        return "Fruit {"+
                "과일명: "+name+
                ", 가격: "+price+
                ", 원산지: "+from+
                "}";
    }


}

public class Apple extends Fruit {
    private String size;
    public Apple(){};
    public Apple(String name, int price, String color, String from, String size) {
        super(name, price, color, from);
        this.size = size;
    }

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }

    @Override //어노테이션
    public String toString() {
        return super.toString() +    //super은 부모클래스를 의미
                "{크기: " + size +
                '}';
    }
}

public class Generic1 {
    public static void main(String[] args) {
        // Box2<String> box1 = new Box2<String>(); 1번째 방법
        // Box2<String> box1 = new Box2<>();       2번째 방법
        Box2<String> box1 = new Box2();
        box1.setT("안녕하세요");
        System.out.println(box1.getT());
        String str = box1.getT();   //String타입으로 넘어온것이기 때문에 잘 들어감

        Box2<Integer> box2 = new Box2<>();
        box2.setT(100);
        System.out.println(box2.getT());
        Integer i = box2.getT();

        Apple apple = new Apple("사과", 1000, "red","충주","소과");
        Box2<Apple> box3 = new Box2<>();
        box3.setT(apple);

        Apple apple2 =box3.getT();
        System.out.println(apple2);

    }
}

 

public class Generic2 {
    public static void main(String[] args) {
        GenericText<String, Integer> generic2 = new GenericText();
        generic2.set("1",100);
        System.out.println("first: " + generic2.getFirst());
        System.out.println("second: " +  generic2.getSecond());

        System.out.println("K type: "+ generic2.getFirst().getClass().getName());
        //getClass().getName()은 Object에 있는 메소드. 타입 알려주는 메소드
        System.out.println("V type: "+ generic2.getSecond().getClass().getName());

    }
}

public class GenericText<K, V> {
    private K first;
    private V second;

    public void set(K first, V second){
        this.first = first;
        this.second = second;
    }

    public K getFirst() {
        return first;
    }

    public void setFirst(K first) {
        this.first = first;
    }

    public V getSecond() {
        return second;
    }

    public void setSecond(V second) {
        this.second = second;
    }
}

import java.util.Vector;

public class Vector1 {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();
        System.out.println("벡터 데이터의 길이: " + vector.size());
        System.out.println("벡터의 크기: "+ vector.capacity());

        vector.addElement("김사과");
        vector.addElement("오렌지");
        vector.addElement("반하나");
        vector.addElement("이메론");
        vector.addElement("배애리");
        vector.addElement("채리");
        vector.addElement("김사과");
        vector.addElement("배애리");

        System.out.println("벡터 데이터의 길이: " + vector.size());
        System.out.println("벡터의 크기: "+ vector.capacity());

        vector.addElement("반하나");
        vector.addElement("배예리");
        vector.addElement("반하나");
        vector.addElement("배예리");

        System.out.println("벡터 데이터의 길이: " + vector.size());
        System.out.println("벡터의 크기: "+ vector.capacity());

        System.out.println("백터의 첫번째 요소: " + vector.elementAt(0));
        System.out.println("백터의 다섯번째 요소: " + vector.elementAt(4));
        vector.remove(2);
        System.out.println("백터의 다섯번째 요소: " + vector.elementAt(4));//인덱스도 한칸씩 이동되네

        System.out.println("벡터 데이터의 길이: " + vector.size());
        System.out.println("벡터의 크기: "+ vector.capacity());

        for(int i=0; i<vector.size(); i++){
            System.out.println(vector.get(i)+" ");
        }

        System.out.println( );
        vector.removeAllElements();
        System.out.println("벡터 데이터의 길이: " + vector.size());
        System.out.println("벡터의 크기: "+ vector.capacity());




    }
}

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayList1 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(80);
        arrayList.add(90);
        arrayList.add(100);
        arrayList.add(85);
        arrayList.add(80);
        arrayList.add(80);

        System.out.println(arrayList);
        System.out.println(arrayList.size());

        for(int i=0; i<arrayList.size(); i++){
            System.out.print(arrayList.get(i) + " ");
        }
        System.out.println();

        arrayList.remove(2);
        System.out.println(arrayList);

        arrayList.set(4, 85);
        System.out.println(arrayList);


        Iterator<Integer> iterator = arrayList.iterator();
        while(iterator.hasNext()){ //hasNext()는 내가 뒤지려는 컬렉션프레임워크에 데이터가있느지없는지
            System.out.print(iterator.next() + " ");  //next는 현재꺼 찍어주고 다음 포인터로 넘김
        }
    }
}

import java.util.LinkedList;
import java.util.Queue;

public class Queue1 {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>(); //Queue는 인터페이스, 큐를 구현하고있는것이 LinkedList
        queue.offer(10); //데이터 추가
        queue.offer(50);
        queue.offer(80);
        queue.offer(80);
        queue.offer(20);
        queue.offer(70);
        System.out.println(queue);
        System.out.println(queue.peek());  // 첫번째 데이터를 반환
        System.out.println(queue);
        System.out.println(queue.poll());  // 첫번째 데이터를 반환 & 삭제
        System.out.println(queue);
        queue.clear();                     // 전체 데이터 삭제
        System.out.println(queue);
    }
}

import java.util.Stack;

public class Stack1 {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(40);// 프링글스통에 push  집어넣는다
        stack.push(100);
        stack.push(50);
        stack.push(20);
        stack.push(60);
        stack.push(20);
        stack.push(80);
        System.out.println(stack);
        System.out.println(stack.peek()); // 마지막에 들어온 데이터를 반환 80 음~좋아 그리고 다시 넣어
        System.out.println(stack);
        System.out.println(stack.pop()); // 팍~ 하고 날아가 없어져버림 저새키뭐야 날아간거뭐야?80
        System.out.println(stack);
    }
}

import java.util.LinkedList;

public class LinkedList1 {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("김사과");
        linkedList.add("반하나");
        linkedList.add("오렌지");
        linkedList.add("이메론");
        linkedList.add("채애리");
        System.out.println(linkedList);
        System.out.println(linkedList.peek());  // 첫 데이터를 반환
        System.out.println(linkedList);
        System.out.println(linkedList.poll());  // 첫 데이터를 반환, 삭제
        System.out.println(linkedList);
        linkedList.remove("오렌지");
        System.out.println(linkedList);



    }

}

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

public class HashSet1 {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();

        hashSet.add("김사과");
        hashSet.add("반하나");
        hashSet.add("오렌지");
        hashSet.add("이메론");
        hashSet.add("채애리");
        System.out.println(hashSet);
        hashSet.add("김사과");
        hashSet.add("이메론");
        hashSet.add("배애리");
        System.out.println(hashSet);

        for(String s: hashSet){
            System.out.print(s + " ");
        }

        Iterator<String> iterator = hashSet.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next() +  " ");
        }
        System.out.println();

    }
}

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSet1 {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(10);
        treeSet.add(8);
        treeSet.add(20);
        treeSet.add(35);
        treeSet.add(21);
        treeSet.add(10);
        treeSet.add(4);
        System.out.println(treeSet);
        treeSet.add(35); //중복 x
        treeSet.add(45);
        treeSet.remove(20); //삭제
        System.out.println(treeSet);

        System.out.println(treeSet.size());
        System.out.println(treeSet.first());
        System.out.println(treeSet.last());
        System.out.println(treeSet.higher(21));
        System.out.println(treeSet.lower(21));

        for(int i: treeSet){
            System.out.println(i + " ");
        }

        Iterator<Integer> iterator = treeSet.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }
}

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMap1 {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("apple","김사과");
        hashMap.put("banana","반하나");
        hashMap.put("orange","오렌지");
        hashMap.put("melon","이메론");
        hashMap.put("cherry","채리");
        hashMap.put("berry","배애리");
        hashMap.put("berry","ddd");
        System.out.println(hashMap);

        System.out.println(hashMap.get("orange"));
        System.out.println(hashMap.keySet());  //키 전체 출력 Set<k>
        System.out.println(hashMap.entrySet());  //Set<Map.Entry<K,​V>> 으로 return

        for(String k: hashMap.keySet()){
            System.out.println("key:"+k+", value:"+hashMap.get(k));
        }

        System.out.println(hashMap.entrySet());

        for(Map.Entry<String, String> entry : hashMap.entrySet()){
            System.out.println("key:"+entry.getKey()+", value:"+entry.getValue());
        };
        System.out.println("-----------------------------------------------------------");
        //Iterator<String> keys = hashMap.get(); //iterator에서 hashMap넣으려고하면 key만 담음
//        while(keys.hasNext()){
//            System.out.println("key:"+keys.next()+", value:"+hashMap.get(keys.next()));
//            //이렇게 하면 next때문에 키랑 벨류값이 한칸씩 밀림?
//        }
//        while(keys.hasNext()) {
//            String key = keys.next();
//            System.out.println("key:" + key + ", value:" + hashMap.get(key));
//            //이렇게 하면 next때문에 키랑 벨류값이 한칸씩 밀림?
//        }

        }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Scanner;

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

        //값 입력받기 위한 Scanner
        Scanner sc = new Scanner(System.in);

        //연락처 정보 객체를 담을 ArrayList
        ArrayList<NumberBook> arrayList = new ArrayList<>();

        //외부저장소 데이터 불러오기
        try{
            Scanner sc2 = new Scanner(new FileInputStream("output.txt"));
            while(sc2.hasNextLine()){
                String[] str = sc2.nextLine().split(", ");
                NumberBook numberBook2 = new NumberBook(str[0], str[1], str[2], str[3], str[4]);
                arrayList.add(numberBook2);
            }
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }

        boolean exit = true;


        while(exit){
            System.out.println("원하는 메뉴를 선택하세요!");
            System.out.println("1. 연락처 정보 등록하기");
            System.out.println("2. 등록된 연락처 보여주기");
            System.out.println("3. 연락처 정보 수정하기");
            System.out.println("4. 연락처 정보 삭제하기");
            System.out.println("5. 번호로 인물정보 찾기");
            System.out.println("6. 연락처 정보 외부저장소에 저장");
            System.out.println("7. 프로그램 종료");
            System.out.println("입력 >> ");

            try{
                int action = sc.nextInt();  //int가 아닌 값을 입력시 InputMismatch try/catch문


                switch(action){

                    // 중복없이 연락처 정보를 등록하기
                    case 1:
                        System.out.println("전화번호를 -(하이픈)없이 입력해주세요.");
                        String number1 = sc.next();

                        // 번호가 11자리를 넘어가거나, 9자리 미만이면 처음부터 다시!
                        if(number1.length() > 11 || number1.length() < 9){
                            System.out.println("전화번호 자리수가 이상합니다. 메인으로 돌아갑니다.");
                            continue;
                        }

                        // 번호 중복 점검
                        boolean flag = true;

                        for(int i = 0; i < arrayList.size(); i++){
                            if(number1.equals(arrayList.get(i).getNumber())){
                                System.out.println("중복된 번호입니다. 메인으로 돌아갑니다.");
                                flag = false;
                            }
                        }

                        if(flag == false) break;

                        //이름 입력
                        System.out.println("이름을 입력하세요.");
                        String name1 = sc.next();

                        //주소 입력
                        System.out.println("주소를 입력하세요.");
                        String address1 = sc.next();

                        //메모 입력
                        System.out.println("메모할 내용을 입력하세요.");
                        String memo1 = sc.next();

                        //등록날짜 입력
                        System.out.println("등록날짜를 입력하세요.");
                        String date1 = sc.next();

                        NumberBook numberBook = new NumberBook(name1, number1, address1, memo1, date1);
                        arrayList.add(numberBook);

                        System.out.println("연락처에 정보가 저장되었습니다. 😀");
                        break;

                    // 등록된 모든 연락처 데이터를 "이름"기준 오름차순으로 보여줌
                    case 2:
                        for(int i = 0; i < arrayList.size(); i++){
                            for(int j = i+1; j < arrayList.size(); j++){    //arrayList.get(i).getName()
                                //성씨를 뽑아서 char로 뽑아서 int로 만들기
                                int firstWord1 = arrayList.get(i).getName().charAt(0);
                                int firstWord2 = arrayList.get(j).getName().charAt(0);
                                //비교를 위해 한글자 단위로 쪼개서 char를 int에 담아줌

                                //성씨가 같을때 두번째 글자로 비교하기 위해 (세번째 글자는 굳이 안만들겠습니다 ㅎㅎ;;)
                                int secondWord1 = arrayList.get(i).getName().charAt(1);
                                int secondWord2 = arrayList.get(j).getName().charAt(1);


                                //값을 옮겨줄 때 사용할 빈 방
                                NumberBook binbang = new NumberBook();


                                //비교대상보다 크면 맨 뒤로 빼주기 위해 값을 저장 -> remove지움 -> add
                                if(firstWord1 > firstWord2){
                                    binbang.setName(arrayList.get(i).getName());
                                    binbang.setNumber(arrayList.get(i).getNumber());
                                    binbang.setAddress(arrayList.get(i).getAddress());
                                    binbang.setMemo(arrayList.get(i).getMemo());
                                    binbang.setDate(arrayList.get(i).getDate());
                                    arrayList.remove(i);
                                    arrayList.add(binbang);
                                    i = 0;
                                    j = i+1;
                                    //ArrayList는 배열과 달리 add가 맨 뒤에 되기 때문에 if에 걸리면 처음 자리부터 다시 비교
                                }

                                // 만약 성씨가 똑같다면? 두번째 글자로 비교 => 세번째 글자는 길어져서 굳이 안 쓰겠습니다 ㅎㅎ;
                                if(firstWord1 == firstWord2){

                                    if(secondWord1 > secondWord2){
                                        binbang.setName(arrayList.get(i).getName());
                                        binbang.setNumber(arrayList.get(i).getNumber());
                                        binbang.setAddress(arrayList.get(i).getAddress());
                                        binbang.setMemo(arrayList.get(i).getMemo());
                                        binbang.setDate(arrayList.get(i).getDate());
                                        arrayList.remove(i);
                                        arrayList.add(binbang);
                                        i = 0;
                                        j = i+1;
                                        //ArrayList는 배열과 달리 add가 맨 뒤에 되기 때문에 if에 걸리면 처음 자리부터 다시 비교
                                    }

                                }


                            }
                        }
                        //정렬된 ArrayList를 출력해줌
                        for(NumberBook n : arrayList){
                            System.out.println(n);
                        }

                        break;

                    // 연락처 내용 수정하기
                    case 3:
                        System.out.println("수정하실 연락처의 번호를 입력하십시오.");
                        String number2 = sc.next();

                        //번호가 11자리를 넘어가거나, 9자리 미만이면 처음부터 다시!
                        if(number2.length() > 11 || number2.length() < 9){
                            System.out.println("전화번호 자리수가 이상합니다. 메인으로 돌아갑니다.");
                            continue;
                        }

                        //중복 점검
                        boolean flag2 = true;

                        for(int i = 0; i < arrayList.size(); i++){
                            if(number2.equals(arrayList.get(i).getNumber())){

                                arrayList.remove(i);

                                //이름 입력
                                System.out.println("이름을 입력하세요.");
                                String name2 = sc.next();

                                //주소 입력
                                System.out.println("주소를 입력하세요.");
                                String address2 = sc.next();

                                //메모 입력
                                System.out.println("메모할 내용을 입력하세요.");
                                String memo2 = sc.next();

                                //등록날짜 입력
                                System.out.println("등록날짜를 입력하세요.");
                                String date2 = sc.next();

                                NumberBook numberBook2 = new NumberBook(name2, number2, address2, memo2, date2);
                                arrayList.add(numberBook2);

                                flag2 = false;
                                break;
                            }
                        }

                        if(flag2 == true){
                            System.out.println("입력하신 번호는 연락처에 없습니다. 😥");
                        }

                        break;

                    // 연락처 정보 삭제하기
                    case 4:
                        System.out.println("삭제하실 연락처의 번호를 입력하십시오.");
                        String number3 = sc.next();

                        //번호가 11자리를 넘어가거나, 9자리 미만이면 처음부터 다시!
                        if(number3.length() > 11 || number3.length() < 9){
                            System.out.println("전화번호 자리수가 이상합니다. 메인으로 돌아갑니다.");
                            continue;
                        }

                        //중복 점검
                        boolean flag3 = true;

                        for(int i = 0; i < arrayList.size(); i++) {
                            if (number3.equals(arrayList.get(i).getNumber())) {
                                System.out.println(arrayList.get(i).getName() + "님의 입력하신 번호의 연락처를 삭제했습니다. 😎");
                                arrayList.remove(i);
                                flag3 = false;
                            }
                        }

                        if(flag3 == true){
                            System.out.println("입력하신 번호는 연락처에 없습니다. 😥");
                        }

                        break;

                    // 번호로 검색해서 해당 연락처 정보 확인하기
                    case 5:
                        System.out.println("확인하실 연락처의 번호를 입력하십시오.");
                        String number4 = sc.next();

                        //번호가 11자리를 넘어가거나, 9자리 미만이면 처음부터 다시!
                        if(number4.length() > 11 || number4.length() < 9){
                            System.out.println("전화번호 자리수가 이상합니다. 메인으로 돌아갑니다.");
                            continue;
                        }

                        //중복 점검
                        boolean flag4 = true;

                        for(int i = 0; i < arrayList.size(); i++) {
                            if (number4.equals(arrayList.get(i).getNumber())) {

                                System.out.println(arrayList.get(i));
                                flag4 = false;
                            }
                        }

                        if(flag4 == true){
                            System.out.println("입력하신 번호는 연락처에 없습니다. 😥");
                        }

                        break;

                    // 외부 저장소에 등록한 연락처 데이터 저장 (쓰기)
                    case 6:
                        try{
                            PrintWriter pw = new PrintWriter(new FileOutputStream("output.txt"));

                            for(int i = 0; i < arrayList.size(); i++){
                                pw.print(arrayList.get(i).toString());
                                pw.print("\n");
                            }
                            pw.close();

                        }catch (FileNotFoundException e){
                            e.printStackTrace();
                        }
                        System.out.println("저장된 연락처 정보를 외부저장소에 저장하였습니다. 👍");
                        break;

                    case 7:
                        System.out.println("프로그램을 종료합니다.");
                        exit = false;
                        break;


                }

            }catch(InputMismatchException e){
                System.out.println("숫자를 입력하셔야합니다. int타입!");
                sc.nextLine();
                continue;
            }


        }
    }
}

 

public class NumberBook {
    private String name;
    private String number;
    private String address;
    private String memo;
    private String date;

    public NumberBook(){}

    public NumberBook(String name, String number, String address, String memo, String date) {
        this.name = name;
        this.number = number;
        this.address = address;
        this.memo = memo;
        this.date = date;
    }

    @Override
    public String toString() {
        return name + ", " + number + ", " + address + ", " + memo + ", " + date;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getMemo() {
        return memo;
    }

    public void setMemo(String memo) {
        this.memo = memo;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }
}

import java.util.ArrayList;
import java.util.Scanner;

public class VocaMain {
    public static void main(String[] args) {
        System.out.println("✔[영어 단어장]✔");
        System.out.println("print: 지금까지 등록한 영단어가 출력");
        System.out.println("find: 영어 단어를 검색할 수 있음");
        System.out.println("exit: 프로그램을 종료");

        Scanner sc = new Scanner(System.in);
        ArrayList<Word> list = new ArrayList<>();

        while(true){
            System.out.println("✔ 영어단어 또는 메뉴를 입력하세요");
            String eng = sc.next();
            if(eng.equals("exit"))break;

            switch(eng){
                case "print":
                    for(int i=0; i<list.size();i++){
                        System.out.println(list.get(i));
                        //System.out.println(list.get(i).getEnglish() +"/"+list.get(i).getKorean());
                    }
                    break;
                case "find":
                    System.out.println("찾는 단어를 입력하세요");
                    String find = sc.next();
                    boolean isFind =false;
                    for(int i=0; i<list.size();i++){
                        if(list.get(i).getEnglish().equals(find)){
                            isFind=true;
                            System.out.println(list.get(i).getEnglish() +"/"+list.get(i).getKorean());
                            break;
                        }
                    }
                    if(!isFind) System.out.println("검색한 결과를 찾지못했습니다");
                    break;
                default:
                    System.out.println("* 뜻을 입력하세요: ");
                    String kor = sc.next();
                    System.out.println("* 레벨을 입력하세요: ");
                    int lev = sc.nextInt();
                    System.out.println("* 날짜를 입력하세요: ");
                    String wdate = sc.next();
                    Word w = new Word(eng, kor, lev, wdate);
                    list.add(w);
//                    System.out.println(list);
            }
        }

        System.out.println("프로그램을 종료합니다");
    }
}

public class Word {
    private String english;
    private String korean;
    private int level;
    private String wdate;

    public Word(String english, String korean, int level, String wdate) {
        this.english = english;
        this.korean = korean;
        this.level = level;
        this.wdate = wdate;
    }

    public String getEnglish() {
        return english;
    }

    public void setEnglish(String english) {
        this.english = english;
    }

    public String getKorean() {
        return korean;
    }

    public void setKorean(String korean) {
        this.korean = korean;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public String getWdate() {
        return wdate;
    }

    public void setWdate(String wdate) {
        this.wdate = wdate;
    }

    @Override
    public String toString() {
        // apple: 사과(레벨1, 날짜 2022-10-05)
        return english + ": " + " (레벨"+ level + ", 날짜" +wdate + ")";
    }
}

import java.util.ArrayList;
import java.util.Scanner;

public class assignment {
    public static void main(String[] args) {
        System.out.println("✔[학생관리프로그램]✔");
        System.out.println("학생입력: 학생 등록");
        System.out.println("print 학생리스트: 지금까지 등록되어 있는 학생 출력");
        System.out.println("find 학생검색: 학생을 검색할 수 있음");
        System.out.println("remove 학생삭제: 학생을 삭제할 수 있음");
        System.out.println("exit 종료: 프로그램을 종료");


        Scanner sc = new Scanner(System.in);
        ArrayList<Student> list = new ArrayList<>();

        while(true){
            System.out.println("✔ 학생이름 또는 메뉴를 입력하세요");
            String name = sc.next();
            if(name.equals("exit"))break;

            switch(name){
                case "print":
                    String[] arr = new String[list.size()];
                    Student temp = new Student();


                    for(int i=0; i<list.size();i++){
                        for(int j=i+1; j<list.size();j++) {
                            if(list.get(i).getCnum()>list.get(j).getCnum()){
                                temp = list.get(i);
                                System.out.println(list.get(i)+"ddd");
                                list.set(i,list.get(j));
                                list.set(j,temp);
                            }

                        }
                    }
                    for(int i=0; i<list.size();i++){
                        System.out.println(list.get(i));
                    }

                    break;

                case "find":
                    System.out.println("찾는 학생을 입력하세요");
                    String find = sc.next();
                    boolean isFind =false;
                    for(int i=0; i<list.size();i++){
                        if(list.get(i).getName().equals(find)){
                            isFind=true;
                            System.out.println(list.get(i));
                            break;
                        }
                    }

                    if(!isFind) System.out.println("검색한 결과를 찾지못했습니다");
                    break;
                case "remove":
                    System.out.println("삭제하려는 학생을 입력하세요");
                    String delete = sc.next();
                    boolean isRemove = false;
                    for(int i=0; i<list.size();i++){
                        if(list.get(i).getName().equals(delete)){
                            list.remove(i);
                            isRemove=true;
                            System.out.println(delete+"학생을 삭제완료 하였습니다");
                            break;
                        }
                    }
                    if(!isRemove){
                        System.out.println("해당 학생이 존재하지 않습니다");
                    }
                    break;

                default:
                    try{
                        System.out.println("* 학번을 입력하세요: ");
                        int cnum = sc.nextInt();
                        System.out.println("* 나이를 입력하세요: ");
                        int age = sc.nextInt();
                        System.out.println("* 연락처를 입력하세요: ");
                        String phonenum = sc.next();

                        Student s = new Student(cnum,name,age,phonenum);
                        list.add(s);
                        System.out.println("등록완료!");
    //                    System.out.println(list);
                    }catch(Exception e){
                        System.out.println("잘못입력했다");
                    }

            }
        }

        System.out.println("프로그램을 종료합니다");
    }
}

public class Student {
    //학번,이름,나이,연락처
        private int cnum;
        private String name;
        private int age;
        private String phonenum;

    public Student(){};
    public Student(int cnum, String name, int age, String phonenum) {
        this.cnum = cnum;
        this.name = name;
        this.age = age;
        this.phonenum = phonenum;
    }

    public int getCnum() {
        return cnum;
    }

    public void setCnum(int cnum) {
        this.cnum = cnum;
    }

    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;
    }

    public String getPhonenum() {
        return phonenum;
    }

    public void setPhonenum(String phonenum) {
        this.phonenum = phonenum;
    }


    @Override
        public String toString() {
            // apple: 사과(레벨1, 날짜 2022-10-05)
            return "학번 : " + cnum + " | 이름 : "+name+" | 나이 : "+age+" | 연락처 : "+ phonenum;
        }


}