https://brunch.co.kr/@mindbook/15 https://report.roa.ai/article/171766 https://news.mt.co.kr/mtview.php?no=2021040917214674629 ++

서드 파티 : 제품을 제조하고 있는 메이커나 그 계열 회사 또는 기술 제휴를 하고 있는 기업 이외의 기업

throws IOException ";" 이거를 붙이면 이오류가 뜬다...잘보자..

Test168~Test173

◼ 객체 직렬화(Object Serialization)

// 객체를 보낸다? → 객체를 저장 → 잘게 자르고 → 다시잘 합치고

▪ 객체 직렬화(Object Serialization) 는

메모리에 생성된 클래스 객체의 멤버 변수의 현재 상태를 그대로 보존해서 파일에 저장하거나 네트워크를 통해 전달할 수 있는 기능으로 멤버 변수의 값을 보존한다거나 다른 네트워크에 있는 호스트에 값을 보낼 경우 사용하게 된다.

즉, 객체 직렬화는 내용물(객체를 구성하는 데이터)을 바이트 단위로 변환하여 파일 또는 네트워크를 통해 송수신(스트림)이 가능하게 만들어주는 것으로 이 때, 객체란 멤버 변수의 메모리만으로 구성된 것을 말한다.

따라서. 메소드와 생성자는 객체 직렬화의 대상에서 제외된다!!! check!!! (객체 기능, 행위 이런것)

▪ 객체 직렬화의 장점

객체 자체의 내용을 입출력 형식에 구애받지 않고 객체를 파일에 저장함으로써 영속성을 제공할 수 있으며 객체 자체를 네트워크를 통해 손쉽게 교환할 수 있게 된다.

객체 직렬화는 자바 1.1 이후에 도입되었는데 그 이유는 RMI 와 Bean 때문이었다. RMI는 원래 객체 통신을 지원해야 하기 때문에 객체가 그대로 이동할 수 있어야 한다. 따라서 이를 지원하기 위해서는 객체 직렬화가 필수적이었다.

또한 Bean 은 설계 시 상태에 대한 정보를 저장할 때 이 객체 직렬화를 사용하면 편하게 객체 상태를 저장할 수 있다.

※ RMI(Remot Method Invocation) 서로 다른 가상 기계장치에 존재하는 함수를 호출하고 실행하는 기능을 담당한다. 서로 다른 통신 구조에 위치한 각각의 원격 객체들 간의 통신 구조를 지원하는 개념으로 이해하면 좋겠다.

※ ★Bean(빈)★ 스트링에서 적극적으로 활용 예정 --그림캡쳐(오디오컴포넌트) C/S(Client 와 Server) 구조적 모델에서 서버측 구조에 해당하며 재사용 가능한 소프트웨어 개체를 만들 수 있게(게임팩처럼) 하는 컴포넌트 기술. 작성된 개체의 공유가 가능하며 프로젝트에 쉽게 포함시킬 수 있도록 한다. 클라이언트에게 빈이라는 프로그램 컴포넌트를 분배하는 방식으로 처리

▪ Serializable 인터페이스

객체 직렬화를 하기 위해 먼저 객체 직렬화가 가능하도록 java.io.Serializable 인터페이스를 구현해 주어야 한다. 이 인터페이스는 객체 직렬화가 제공되어야 한다는 사실을 JVM 에게 알려주는 역할을 수행한다. 또한, Serializable 인터페이스는 다른 인터페이스와 달리 구현해야 할 메소드가 없기 때문에 단지 선언만 해주면 된다.

 형식)
   1.
   public class 클래스명 implements Seralizable
   {
        //...
   }

   2.
   Serializable 인터페이스를 구현한 후
   ObjectInputStream 클래스와 ObjectOutputStream 클래스를 이용하여
   객체 단위로 입출력을 수행하게 된다.

※** 멤버 변수가 static 으로 선언된 경우 (즉, 클래스 변수일 경우) 객체 직렬화의 대상에서 제외된다. **

▪ Object Stream

java.io.ObjectInputStream ObjectInputStream 클래스는 ObjectOutputStream 클래스에 의해 파일에 저장되어 있는 객체나 네트워크를 통해 전달된 객체의 직렬화를 해제하는 기능을 제공한다. 단, java,io,Serializable 인터페이스와 java.io.Enternalizable 인터페이스를 지원해주는 객체에 대해서만 사용이 가능하낟. 즉, SSerializable 인터페이스와 Enternalizable 인터페이스를 구현한 객체에서만 사용이 가능하다는 것이다. 이 때, readObject() 메소드를 이용하여 스트림으로부터 직렬화된 객체를 읽을 수 있으며 이렇게 읽은 객체 배열, 문자열 또는 각 객체 등 원래의 형(Type)으로 캐스팅 해주어야 한다.

▪ 객체 직렬화(Object Serialization) 코드📝

import java.io.File;
import java.util.Hashtable;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;


import java.io.FileInputStream;
import java.io.ObjectInputStream;

import java.util.Enumeration;


public class Test173
{
    public static void main(String[] args)  throws Exception
    {
        String appDir = System.getProperty("user.dir");   //캐릭터셋할때 사용해본적 있음! 인코딩방식

        // 테스트
        //System.out.println(appDir);
        //--==>> C:\JavaStudy

        // 파일 객체 생성
        File f0 = new File(appDir,"\\data\\test.ser");
        //-- appDir → C:\JavaStudy
        //-- appDir 위치(경로)를 중심으로 "\\data\\test.ser"를
        //   구성하겠다는 의미.
        //-- 결과적으로 『C:\JavaStudy\data\test.ser』 구성

        //테스트(확인)
        // ①
        //System.out.println(f0.getParentFile().exists());
        //--==>> false

        //테스트(확인)
        // ② 『C:\JavaStudy』 경로에 『data』 디렉토리 생성한 후 확인
        //System.out.println(f0.getParentFile().exists());
        //--==>> true

        // 디렉터리 구성이 존재하지 않는 상황이라면.....
        if(!f0.getParentFile().exists())
        {
            //  디렉터리를 만들겠다.      //--data 파일 없으면 data파일 생성됨!
            f0.getParentFile().mkdirs();
                            // ------ makedirectorys
        }

        // Hashtable 자료구조 인스턴스 생성
        Hashtable<String,String> h1 = new Hashtable<String,String>();

        // 생성한 h1 이라는 Hashtable 자료구조에 요소 추가  (구성하는 값의 순서는 의미 X)
        h1.put("3","손효진");
        h1.put("4","채효진");
        h1.put("2","김효진");
        h1.put("5","권효진");
        h1.put("1","장효진");

        // 테스트(확인)
        //System.out.println(h1.get("1"));
        //--==>> 장효진

        // 파일 전용 출력 스트림 생성(수도꼭지 열기)
        FileOutputStream fos = new FileOutputStream(f0);  //출력 스트림에 띄운 배 :f0
        //-- 파일 전용 출력 스트림(물줄기)에
        //   f0라는 파일 객체를 띄위겠다....  (흘려 내보낼 수 있도록...)
        //InputStreamReader isr = new InputStreamReader(System.in);

        // 객체 전용 출력 스트림 생성
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //-- 객체 전용 출력 스트림(물줄기)으로
        //   fos 라는 파일 전용 출력 스트림을 감싸겠다.
        //BufferedReader br = new BufferedReader(isr);

        // 위의 구문과 동일한 구문
        //ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(f0));

        //위의 개념과 비료할 구조적으로 동일한 구문
        //BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // ※ ObjectOutputStream 클래스는
        //    객체들을 출력하는 기능을 제공하는 클래스로
        //    출력 스트림에 출력하기 전에
        //    내부적으로 객체 직렬화를 수행하게 된다.
        //    자바 기본형 데이터 또는 객체들을
        //    파일에 저장하거나 네트워크를 통해 전달하기 위해
        //    전달할 객체를 직렬화하는 기능을 제공하는 것이다.



        // 생성된 스트림에 내보낼 객체를 기록
        oos.writeObject(h1);

        oos.close();
        //-- ObjectOutputStream 리소스 반납

        fos.close();
        //-- FileOutputStream 리소스 반납

        // 내보내기 끝~!!!


        // ---------------------------------------------------------- 직렬화

        // data파일에 test.ser이 생김

        // 읽어들이기 시작~!!!


        if (f0.exists())        //-- f0 파일 객체가 존재한다면...
        {
            FileInputStream fis = new FileInputStream(f0);
            ObjectInputStream ois = new ObjectInputStream(fis);
            //파일을 읽어들이고 그파일로부터 객체를 읽어들인다.


            // ois(ObjectInputStream)로 부터 읽어들인 객체(Object) (-> readObject 를 통해 처리)
            // 원래의 형(Hashtable)으로 캐스팅하여
            // h2라는 Hashtable 자료구조에 담아내기
            Hashtable h2 = (Hashtable)ois.readObject();   // 대상이 해시테이블인데 오브젝트로 읽어오니까 다운캐스팅해주어야함
            // Object obj = ois.readObject();
            // Hashtable h2 = (Hashtable)obj;
            // 이거 두줄을 한줄로 만든것

            ois.close();
            //-- ois 리소스 반남 -> ObjectInputStream 리소스 반납

            fis.close();
            //-- fis 리소스 반납 -> FileInputStream 리보스 반남

            //----------------------------------------------------여기까지 수행하면 읽어들이는 작업 끝~!!!

            // 읽어들인 h2 객체의 내용 확인
            String key;
            String value;

            // ※ Iterator 사용할 수 없음
            Enumeration e = h2.keys();


            while(e.hasMoreElements())
            {
                key = (String)e.nextElement();   //다운캐스팅
                //-- key값을 읽어들이는 과정

                //확인
                //System.out.println(key);
                /*
                5
                4
                3
                2
                1
                */

                value = (String)h2.get(key);
                //-- key를 활용하여 value 얻는 과정

                System.out.println(key + " → " + value);
                /*
                5 → 권효진
                4 → 채효진
                3 → 손효진
                2 → 김효진
                1 → 장효진
                */
            }




        }



    }
}

여기까지 JAVA Fundamental 끝! 자바 세미프로젝트 시작!

◼ == vs equals

• 데이터 타입에는 7가지 boolean, int, double, short, long, float,char 가 있다.
• ** non primitive data type에는 **String, Array, Date, File 등등이 있다

• 비교연산자 "==" *는 변수가 *그 변수의 값을 가리키는 곳의 위치가 같으냐를 따진다. 그와 반면에 "equals" *메소드는 *변수 내부의 내용이 같은가를 따진다.

- 결론: 원시데이터타입(primitive) 은 ==를 비원시데이터타입은 .equals()를 사용하자!

◼ 인터페이스(Interface)

▪ 인터페이스(Interface)란

완전히 미완성된 채로 남겨져 인터페이스 안에 존재하는 그 어떤 메소드도 몸체(정의부)가 없기 때문에 사실상 실행 부분이 존재하지 않는다. 클래스를 위한 템플릿으로써의 기능을 수행하는 추상 클래스의 한 종류이다.

▪ 인터페이스는 클래스와 달리 다중 상속이 가능하며 인터페이스 자체도 상속된다.

기존의 C++언어 등에서 지원되는 다중 상속이 사용 과정에서 많은 문제점을 노출시켰기 대문에 자바에서는 다중 상속의 개념을 인터페이스라는 개념으로 변형하여 인터페이스를 통해 다중 상속을 구현하는 방법을 지원한다.

▪ 인터페이스는 상수와 추상 메소드만 가질 수 있으며

인터페이스 안의 메소드들은 접근제어지시자를 명시하지 않아도 (원래는 디폴트임!) 『public』으로 설정되어 클래스에서 구현(implements)함으로써 바로 접근이 이루어질 수있다.

▪ 인터페이스 특징

• 추상 클래스의 일종으로 선언만 있고 정의가 없다.

• final 변수는 가질 수 있다.(상수의 개념)

• 인터페이스는 『public static final』만 만들 수 있다.

• 인터페이스를 구현하기 위해서는 『extends』 대신에

    『implements』를 이용한다.

• 하나 이상의 인터페이스를 implements 할 수 있다.(다중 상속 가능)

• 인터페이스를 implements 한 클래스는

  인터페이스의 모든 메소드를 Overriding 해야한다.

• 인터페이스가 다른 인터페이스를 상속받을 수 있으며

  이 때, 『extends』 키워드를 사용한다.
  또한, 클래스와 달리 인터페이스는 다중 상속이 가능하다.

  ▪ 인터페이스(Interface) 1 코드 설명📝

  // 인터페이스
  interface Demo
  {
    public static final double PI = 3.141592;
  
    // 인터페이스의 멤버 면수는
    // 『static final』을 별도로 명시하지 않아도
    // 자동으로 『static final』인 상태~!!!
    public int a = 10;  //-- 안됌 static final 상수만 가질 수 있음!! 그런데 됌! 엥
  
  

// 인터페이스의 메소드는 선언만 가능(정의 불가)
// 자동으로 『abstract』인 상태
//public void print()
/*
{
    System.out.println("PI : " + PI);   // 메소드를 선언만 해야지 정의하는건 안댐
}
*/

//public abstract void print();
public void print();                //-- 어차피 모든 메소드가 추상이기 때문에 abstract생략 가능~!!

}

// class DemoImpl // class DemoImpl extends Demo ( X ) // abstract class DemoImpl extends Demo ( X ) // class DemoImpl implements Demo ( X )

//추상 클래스 - 인터페이스를 구현하는 추상 클래스 //abstract class DemoImpl implements Domo // ↓ (print를 정의하는 순간 abstract뗀다) //클래스 - 인터페이스를 구현하는 클래스 class DemoImpl implements Demo

{ //public void print(); @Override public void print() { System.out.println("클래스에 정의된 메소드..."); }

public void write()
{
    System.out.println("클래스에 정의된 메소드...");
}

}

// main() 메소드를 포함하고 있는 외부의 다른 클래스 public class Test113 { public static void main(String[] args) { //Demo ob = new Demo(); // 인터페이스는 인스턴스 생성불가~!!

    //DemoImpl ob = new DemoImpl();    //추상클래스는 print만 건들이면 생성가능한데 지금은 안댐
    //-- print() 메소드 재정의 후 가능~!!!

    //DemoImpl obTemp = new DemoImpl();   //더이상 추상이아니고 클래스이기 때문에 인스턴스 생성 가능!
    //Demo ob = (Demo)obTemp;             //DemoImpl는 오버라이딩으로 덮어쓰기 다해서 클래스가 된 아이니까! 업캐스딩 가능한~!!
    //Demo ob = obTemp; 

    //new DemoImpl(); 만 해도 인스턴스 생성됨!! 근데 이제 우리가 담아둘게 필요하니까 앞에 DemoImpl obTemp 쓴것!

    // ○ 업 캐스팅
    // 인터페이스 객체는 상위 객체
    Demo ob = new DemoImpl();
    ob.print();
    //--==>> 인터페이스 메소드 재정의...

    //ob.write();
    //--==>> 에러 발생(컴파일 에러)

    // ○ 다운 캐스팅
    ((DemoImpl)ob).write();
    //--==>> 클래스에 정의된 메소드...

    System.out.println(Demo.PI);            //-- static 이어서 가능한~!!
    //--==>> 3.141592

    System.out.println(Demo.a);           //-- 눈에 보이지는 않지만 얘도 static

    //Demo.a = 30;                        //-- final 이기 때문에....
    //--==>> 에러발생


}

}

### ▪  인터페이스(Interface)2 코드 설명📝
```java
// 인터페이스  -> 이안에는 추상메소드밖에 못오기 때문에 abstract 생략 가넝한~!!
interface ADemo
{
    public void write();
}

// 인터페이스
interface BDemo
{
    public void print();
}

// ※ 인터페이스는 2개 이상을 구현(implements)할 수 있다.
//   -> 다중 상속이 되지 않는 부분을 보완(보충)하는 개념

// 클래스
//class DemoImpl
//class DemoImpl extends ADemo, BDemo      //--다중 상속안됨
//class DemoImpl implements ADemo, BDemo 
//  ↓
//추상클래스 - 두 인터페이스를 구현한 추상 클래스
//abstract class DemoImpl implements ADemo, BDemo
//  ↓
// 클래스 - 두 인터페이스를 구현한 클래스
class DemoImpl implements ADemo, BDemo 
{
    /*
    public abstract void write();

    public abstract void print();
    */

    // ※ JDK 1.5(5.0)에서는 인터페이스 메소드를
    //    오버라이딩(Override)할 때
    //  『@Override』 어노테이션(annotation)을 사용할 수 없다.
    //    JDK 1.6(6.0) 이후부터 적용 가능한 문법이다.
    //    단, 상속받은 클래스의 메소드를
    //    오버라이딩(Overriding) 할때에는
    //    JDK 1.5(5.0)에서도 『@Override』 어노테이션(annotation)
    //  사용이 가능하다.

    @Override
    public void write()
    {
        System.out.println("ADemo 인터페이스 메소드 write()...");

    }

    @Override
    public void print()
    {
        System.out.println("BDemo 인터페이스 메소드 write()...");
    }
}

// main() 메소드를 포함하고 있는 외부의 다른클래스
public class Test114
{
    public static void main(String[] args)
    {
        //ADemo ob = new ADemo();      //-- 인터페이스 -> 인스턴스 생성 불가
        //BDemo ob = new BDemo();      //-- 인터페이스 -> 인스턴스 생성 불가

        //ADemo, BDemo 인터페이스를 구현(implements)한 클래스(-> DemoImpl)
        //기반의 인스턴스 생성
        DemoImpl ob1 = new DemoImpl();

        ob1.write();
        ob1.print();
        //--==>> ADemo 인터페이스 메소드 write()...
        //       BDemo 인터페이스 메소드 write()...

        ADemo ob2 = new DemoImpl();        //--업 캐스팅
        BDemo ob3 = new DemoImpl();        //--업 캐스팅

        //ob2.print();                //--==>> 에러 발생 ADemo 에는 print없어서 안됨!
        //ob3.write();                //--==>> 에러 발생 BDemo 에는 write없어서 안됨!

        ob3.print();                
        ob2.write();
        //--==>>BDemo 인터페이스 메소드 write()...
        //        ADemo 인터페이스 메소드 write()...

        ((BDemo)ob2).print();        
        ((ADemo)ob3).write();    
        //--==>>BDemo 인터페이스 메소드 write()...
        //        ADemo 인터페이스 메소드 write()...
        //가넝한~!! 왜냐면 DemoImpl 가  print랑 write를 둘다 구현했으니까~!!!
        //--DemoImpl 클래스가 두 인터페이스를 모두 구현했기 때문에 가능하다.
        // 만약 DemoImpl 클래스가 이들 중 한 인터페이스만 구현한 상황이라면
        // 이 구문은 런타임 에러 발생하는 구문이 된다.

        // 다운 캐스팅
        ((DemoImpl)ob3).write();                    //check~!!
        //--==>> ADemo 인터페이스 메소드 write()...


    }
}

▪ 인터페이스(Interface)3 코드 설명📝

// 인터페이스
interface Demo
{
    public void write();
    public void print();
}


//  인터페이스를 구현하는 추상 클래스
abstract class DemoImpl implements Demo
{
    @Override
    public void write()
    {
        System.out.println("write() 메소드 재정의...");
    }

    //public abstract void print();
}


// 추상 클래스를 상속받는 추상 클래스
//abstract class DemoImplSub extends DemoImpl
//  ↓
// 추상 클래스를 상속받는 클래스
class DemoImplSub extends DemoImpl
{
    @Override
    public void print()
    {
        System.out.println("print() 메소드 재정의");
    }

}


// main() 메소드를 포함하고 있는 외부의 다른클래스
public class Test115
{
    public static void main(String[] args)
    {
        //Demo ob1 = new Demo();
        //-- 인터페이스 -> 인스턴스 생성 불가 

        //DemoImpl ob2 = new DemoImpl();
        //-- 추상 클래스 -> 인스턴스 생성 불가

        DemoImplSub ob3 = new DemoImplSub();

        ob3.write();
        ob3.print();
        //--==>> write() 메소드 재정의...
        //       print() 메소드 재정의
    }
}

◼ 『extends』vs『implements』

클래스 extends 클래스
클래스 extends 추상클래스

인터페이스 extends 인터페이스
인터페이스 extends 인터페이스, 인터페이스

추상클래스 implements 인터페이스
추상클래스 implements 인터페이스, 인터페이스

클래스 implements 인터페이스
클래스 implements 인터페이스, 인터페이스

※ 인터페이스는 클래스와는 달리 다중 상속이 가능하며, 인터페이스 자체도 상속된다.

※ 인터페이스 멤버 변수인 데이터는 접근제어지시자를 명시하지 않아도 기본 상수(primitive constant)인 static final 의 변경자로 설정된다. 클래스에서 인터페이스를 추가하여 사용할 경우 인터페이스를 구현하는 클래스는 인터페이스의 상위 인터페이스가 제공하는 추상 메소드를 포함한 모든 메소드를 구현하지 않을 경우 추상(abstract) 클래스로 선언해야 한다.

• 형식

  • 인터페이스는 메소드를 선언만 하고 정의는 없다.
    • 인터페이스를 implements 할 경우 반드시 하위 클래스는 인터페이스의 모든 메소드를 오버라이딩(Overriding)해야 한다.
    • 인터페이스는 자동적으로 다음과 같이 처리된다. _ 멤버 변수 : public static final_ 메소드 : public abstract
    • 다중 상속은 콤마(『,』)로 구분되며 여러 개의 인터페이스를 상속할 수 있다.
    • 인터페이스 끼리 상속할 경우는 『implements』가 아니라 『extends』키워드를 사용한다.

• 인터페이스의 선언 인터페이스는 클래스 내부 구현을 제외한 참조형만 선언한 것이므로 메소드를 선언만 하고 정의할 수 없다. 또한, 클래스에서의 변수는 값이 변할 수 있지만 인터페이스에서의 변수는 상수처럼 값이 바뀔 수 없기 때문에 선언 시에 미리 값을 할당해 놓아야 한다.

• 인터페이스의 구현 인터페이스는 클래스를 위한 템플릿이기 때문에 사용 가능한 인터페이스가 되기 위해서는 자바 프로그램에서 인터페이스를 구현해 주어야 하는데 이러한 기능을 하는 것이 『implements』 에약어이다.

• 클래스는 동시에 두 개 이상의 인터페이스를 implements 할 수 있다~!!!

  ▪ 『extends』vs『implements』 코드 설명📝

  // 인터페이스
  interface ADemo
  {
    public void write();
  }
  

// 인터페이스 interface BDemo { public void print(); }

// ※ 클래스는 다중 상속을 지원하지 않지만, // 인터페이스는 다중 상속을 지원한다.

// 두 인터페이스(ADemo,BDemo)를 상속받은 인터페이스 interface CDemo extends ADemo, BDemo { //public void write(); //public void print();

public void test();

}

// 클래스 // class Demoimpl // ↓ // 추상 클래스 - CDemo 인터페이스를 구현하는 추상 클래스 // 두 인터페이스(ADemo,BDemo)를 상속받은 인터페이스(CDemo)를 구현한 추상 클래스 //abstract class DemoImpl implements CDemo // ↓ // 두 인터페이스(ADemo,BDemo)를 상속받은 인터페이스(CDemo)를 구현한 후 모든 메소드를 재정의한 클래스 class DemoImpl implements CDemo { @Override public void test() { System.out.println("test()..."); }

@Override
public void write()
{
    System.out.println("write()...");
}

@Override
public void print()
{
    System.out.println("print()...");
}

}

// main()메소드를 포함하고 있는 외부의 다른 클래스 public class Test116 { public static void main(String[] args) { // 두 인터페이스르 상속받은 인터페이스를 구현하고 // 모든 메소드를 재정의한 클래스에 대한 인스턴스 생성 DemoImpl ob = new DemoImpl();

    ob.test();
    ob.write();
    ob.print();
}

}

/* test()... write()... print()... 계속하려면 아무 키나 누르십시오 . . . */ ```

Test160Test168 Test168Test173

◼ 자바의 기본 입출력(I/O)

바이트기반 스트림 / 문자기반스트림 으로 나뉨

• 입력(input) 바이트기반 스트림(밖에 수도꼭지)
• 입력(input) 문자기반 스트림(밖에 수도꼭지)
• 출력(output) 바이트기반(내부에 수도꼭지)
• 출력(output) 문자기반(내부에 수도꼭지)

수제비처럼 하나씩하나씩 떼서 넣고 하나씩하나씩 나오고

임시적으로 물을 저장해놓을 수 있는 버퍼가 달려있는 스트림이있음(주사기처럼 차면 밀어놓고) 버퍼되어있는 물줄기 / 버퍼되어있지 않은 물줄기

이것도 바이트기반 스트림 / 문자기반스트림 으로 나뉨

• 입력(input) 바이트기반에 버퍼 달려있는것
• 입력(input) 문자기반에 버퍼가 달려있는것
• 출력(output) 바이트기반에 버퍼 달려있는것
• 출력(output) 문자기반에 버퍼가 달려있는것

이제 그럼 알아할 것은!! 수도꼭지 트는 방법 수도꼭지 잠그는 방법 하나하나떠서 그스트림에 올리는 방법 스트림에 있는걸 끄집어 내는 방법 바이트기반 스트림할떼 주의할점 문자기반 스트림할떼 주의할점 이거 보면 끝

▪ 자바의 기본 입출력 개요

• 자바에서의 모든 데이터 입출력은 『스트림(stream)』이라는 개념에 의해

  이루어 지는데, 『스트림(stream)』이라는 단어의 사전적 의미는
  "흐르는 물"의 개념이며, 이는 연속된 일련의 데이터를 일컫는다.

• 데이터 입출력 시 모든 데이터를 형태와 관계없이 일련된 흐름으로

  전송을 하는 것이 스트림 입출력 모델의 기본 개념이다.

• 기본적으로 『스트림(stream)』에는

  바이트 기반의 스트림과, 문자 기반의 스트림이 있다.

▪ 바이트 스트림(byte-stream) 입출력

• InputStream 클래스와 OutputStream 클래스, 그리고 이들의 하위 클래스를

  통해서 제공되는 바이트 스트림(byte-stream)을 위한 표준 입출력으로
  8비트 크기를 갖는 바이트들의 스트림이 입출력된다.
  (바이트, 바이트배열, 정수 등)

▪ 문자 스트림(chrarcter-stream) 입출력

• Reader 클래스와 Writer 클래스, 그리고 이들의 하위 클래스에 의해

  구현되었으며, 8비트 크기를 갖는 바이트들의 스트림이 아닌
  16비트 크기를 갖는 유니코드 문자들의 스트림이라는 점에서 차이가 있다.
  (문자, 문자배열, 문자열 등)

※ 스트림의 특징

- 스트림은 FIFO 구조이다.
  FIFO 구조란, 먼저 들어간 것이 먼저 나오는 형태로
  스트림의 데이터는 순차적으로 흘러가며 순차적 접근 밖에는 허용되지 않는다.

- 스트림은 단방향이다.
  자바에서 스트림은 읽기 쓰기가 동시에 이루어지지 않는다.
  따라서 읽기 쓰기가 필요하다면 읽는 스트림과 쓰는 스트림을
  하나씩 열어서 사용해야 한다.

- 스트림은 지연될 수 있다.
  스트림에 넣어진 데이터는 처리되기 전에는 스트림에 사용하는 스레드는
  지연(blocking) 상태에 빠진다.
  네트워크 상에서는 데이터가 모두 전송되기 전까지 스레드는 지연(blocking)
  상태가 된다.

▪ read() : InputStream 클래스의 대표적 메소드 코드📝

// Test170.java 파일과 비교~!!!

import java.io.IOException;

public class Test168
{
    public static void main(String[] args) throws IOException
    {
        int data;
        char ch;

        System.out.println("문자열 입력(종료:Ctrl+z)");

        // read() : InputStream 클래스의 대표적 메소드(→ 바이트 스트림)
        while ((data = System.in.read()) != -1)  //null 이 아니라면           //-- System.in.read때문에  IOException
        {
            ch = (char)data;
            System.out.print(ch);
            /*
            문자열 입력(종료:Ctrl+z)
            abcd
            abcd
            1234
            1234
            가나다라
            °¡³ª´?¶?
            ^Z
            계속하려면 아무 키나 누르십시오 . . .
            */

            //write() : OutputStream 클래스의 대표적 메소드(→ 바이트 스트림)
            System.out.write(ch);
            /*
            문자열 입력(종료:Ctrl+z)
            abcd
            abcd
            1234
            1234
            가나다라
            가나다라
            ^Z
            계속하려면 아무 키나 누르십시오 . . .
            */
        }

    }
}

▪ OutputStream 코드📝

import java.io.OutputStream;
import java.io.IOException;

public class Test169
{
    //public static void main(String[] args)  throws IOException;    -> error: missing method body, or declare abstract 발생함!
    public static void main(String[] args)  throws IOException
    {
        // System.in  :  자바의 표준 입력 스트림(바이트 기반)
        // System.out :  자바의 표준 출력 스트림

        OutputStream out = System.out;

        byte[] ch = new byte[3];

        ch[0] = 65;    // A
        ch[1] = 97;    // a
        ch[2] = 122;   // z

        out.write(ch);  //-- 밖으로 내보낼 데이터(변수)를 스트림에 기록

        out.flush();    //-- 기록된 스트림을 내보내는(밀어내는) 기능을 수행
                        //   지금은 Buffer 를 활용하지 않고 있는 상황이기 때문에
                        //   생략이 가능한 코드
                        //   (Buffered 되어 있는 스트림(stream)일 경우 생략 불가)

        out.close();    //-- 출력 스트림(물줄기)에 대한 리소스 반납
                        //   (out 스트림(수도꼭지를 잠가버린 상황)

        System.out.println("절대적인 신뢰를 갖고 있는 구문...");    //밖으로 나가는 물줄기를 잠궈버려서 출력안됨!! out.close()
        //-- 『out.close()』를 작성한 이후 출력되지 않는 구문
        //    출력되는 스트림(물줄기)을 닫았기 때문에...

    }
}

▪ Reader 코드📝

// Reader 실습
// Test168.java 파일과 비교~!!!

import java.io.Reader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test170
{
    public static void main(String[] args) throws IOException
    {
        int data;
        char ch;


        //System.in          : 자바 표준 입력 스트림 -> 바이트 기반 스트림
        //InputStreamReader  : 바이트 기반 스트림을 -> 문자 기반 스트림으로
        //                        변환해주는 역할 수행
        //Reader             : 문자 기반 스트림 객체
        Reader rd = new InputStreamReader(System.in);
    //  ----- 문자      --------번역-----  --------바이트

        System.out.println("문자열 입력(종료:Ctrl+z)");

        while ((data = rd.read()) != -1)
        {
            ch = (char)data;
            //System.out.write(ch);
            /*
            문자열 입력(종료:Ctrl+z)
            abcd
            abcd
            1234
            1234
            가나다라
             섆|
            ^Z
            계속하려면 아무 키나 누르십시오 . . .
            */

            System.out.print(ch);
            /*
            문자열 입력(종료:Ctrl+z)
            abcd
            abcd
            1234
            1234
            가나다라
            가나다라
            ^Z
            계속하려면 아무 키나 누르십시오 . . .
            */
        }

    }
}

▪ Buffer 코드📝

public class Test171
{
    public static void main(String[] args)
    {
        //System.out : 자바 기본 출력 스트림   -> 여기엔 기본적으로 버퍼가 포함되어있음

        System.out.write(65);    //--'A'
        System.out.write(66);    //--'B'

        System.out.write(180);
        System.out.write(235);   //-- 180 + 235 = '대'

        System.out.flush();
        //-- 현재 구문에서는 생략 불가~!!!

        // 출력 버퍼가 채워지지 않으면
        // 출력할 데이터(자료)를 출력 디바이스(장치)로 보내지 않기 때문에
        // flush() 메소드를 통해 아직 다 채워지지 않은
        // 출력 버퍼의 내용을 출력장치로 밀어내어 보낼 수 있도록 처리해야 한다.
    }
}

▪ Reader Writer 코드📝

// Reader Writer 실습

import java.io.InputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class Test172
{
    public void process(InputStream is)   //InputStream  바이트기반의 입력 스트림
    { 
        int data;

        System.out.println("문자열 입력(종료 : Ctrl+z)");

        try
        {
            //매개변수 is 라는 바이트기반 객체(InputStream)fmf
            //문자 스트림으로 변환하여
            //(-> InputStreamReader 가 수행)
            //Reader 타입의 rd 에서 참조할 수 있도록 처리
            Reader rd = new InputStreamReader(is);   //is 는 System.in으로 넘겨준 InputStream 을 번역해서(인풋 스트림리더) 문자열로


            //바이트 기반 스트림인 자바 기본 출력 스트림(System.out)을
            //문자 스트림으로 변환하여
            //(-> OutputStreamWriter 가 수행)
            //Writer 타입의 wt 에서 참조할 수 있도록 처리
            Writer wt = new OutputStreamWriter(System.out);     //아웃풋스트림롸이터 바이트기반을 문자기반으로 바꿔주는 것

            while ( (data = rd.read()) != -1)
            {
                wt.write(data);   //-- 스트림 물줄기에 기록             //출력스트림을 쓰겠다  문자열기반
                wt.flush();       //-- 기록한 스트림을 밀어내어 내보냄  //출력스트림을 밀어내겠다 문자열기반
            }


        }
        catch (IOException e)
        {
            System.out.println(e.toString());
        }
    }


    public static void main(String[] args)
    {
        Test172 ob = new Test172();
        ob.process(System.in);   //System.in 바이트기반의 입력 스트림
    }
}

/*
문자열 입력(종료 : Ctrl+z)
abcd
abcd
1234
1234
가나다라
가나다라
^Z
계속하려면 아무 키나 누르십시오 . . .
*/

Test160~Test168

◼ Map

// Map 은 다른 자료구조보다 사용빈도가 높다! Map -> Hashtable, HashMap

• 두개는 기능은 비슷. 해시테이블은 동기화기능이 있고 해시맵은 동기화 기능이 없다.
• java.util.Map 인터페이스는 키(key)를 값(value)에 매핑(mapping)하며, 동일한 키를 등록할 수 없고, 유일해야 하며(고유해야 하며) 각 키는 한 개의 값만을 매핑해야 한다. 즉, 하나의 키 값에 대응하는 하나의 값을 갖는 자료구조이다.

▪ Hashtable<K, V> 클래스

• 해시테이블 구조를 객체 모델링한 클래스로

  검색이 용이하기 때문에 사용 빈도가 높은 편에 속한다.

• 해시테이블이란 키(key)와 그에 상응하는 데이터(value)로

  구분된 데이터 구조이다.

• 데이터를 저장하고, 검색하기 위해서 키(key)로 접근하며

  이 구조에서는 키 값을 부여하면 해당 데이터가 변환된다.

• 또한, Hashtable 클래스는 key 또는 value 의 값으로 null 을 허용하지 않는다. ★★★

  ▪ Hashtable 코드📝

  import java.util.Hashtable;
  

public class Test166 { private static final String[] names = {"서효진","김효진","최효진","손효진","최효진2","이효진" };

private static final String[] tels
    ={"010-0000-0000","010-1111-1111","010-2222-2222"
            , "010-3333-3333", "010-4444-4444", "010-5555-5555"};


public static void main(String[] args)
{
    // Hashtable 자료구조 인스턴스 생성
    Hashtable<String, String> ht = new Hashtable<String, String>();    // key 랑 value 값 제네릭으로

    // ht 라고 명명한 Hashtable 자료구조에
    // 배열(names, tels)에 담겨있는 데이터를 요소로 담아내기
    // -> put(k, v)     //해시테이블에 자료를 담는 가장 기본적인 메소드
    for (int i=0; i<names.length; i++)
    {
        ht.put(names[i],tels[i]);
    }

    // ht 라는 Hashtable 의 값을... key 를 이용하여 검색
    // -> get(k)
    String findName1 = "최효진";
    String str = ht.get(findName1);
    if (str != null)
    {
        System.out.println(findName1 + "전화번호 : " + str);
    }
    System.out.println();
    //--==>> 최효진전화번호 : 010-3288-6988

    // ht 라는 Hashtable 자료구조에... key 가 존재하는지의 여부 확인
    // -> containsKey()
    String findName2 = "윤효진";
    if (ht.containsKey(findName2))
    {
        System.out.println(findName2 + "데이터가 존재합니다.");
    }
    else
        System.out.println(findName2 + "데이터가 존재하지 않습니다.");
    System.out.println();
    //--==>> 윤효진데이터가 존재하지 않습니다.


    String findName3 = "이효진";
    if (ht.containsKey(findName2))
    {
        System.out.println(findName3 + "데이터가 존재합니다.");
    }
    else
        System.out.println(findName3 + "데이터가 존재하지 않습니다.");
    System.out.println();
    //--==>> 이효진데이터가 존재하지 않습니다.

    // ht 라는 Hashtable 자료구조에... value 가 존재하는지의 여부 확인
    // -> contains()

    String findTel1 = "010-0000-0000";
    if (ht.contains(findTel1))
        System.out.println(findTel1 + "데이터가 존재합니다.");
    else
        System.out.println(findTel1 + "데이터가 존재하지 않습니다.");
    System.out.println();
    //--==>> 010-0000-0000데이터가 존재합니다.

    // ht 라는 Hashtable 자료구조에서... 『김효진』데이터 삭제
    // -> remove()
    ht.remove("김효진");
    //-- 『remove』 메소드 인자값으로 key 를 넘겨받지만
    //    이 때, key 만 삭제되는 것이 아니다.
    //    해당 key 와 연결되어(매핑되어) 있는 value 도 함께 remove() 된다.

    //삭제(remove()) 이후 key 가 존재하는지 확인
    if(ht.containsKey("김효진"))
        System.out.println("김효진이 존재합니다.");
    else
        System.out.println("김효진 어디갔어!?!?");
    System.out.println();
    //--==>> 김효진 어디갔어!?!?

    // 삭제(remove()) 이후 value 가 존재하는지 확인
    if(ht.contains("010-1111-1111"))
        System.out.println("010-1111-1111데이터가 존재합니다.");
    else
        System.out.println("010-1111-1111 데이터가 존재하지 않습니다.");
    System.out.println();
    //--==>>  010-1111-1111 데이터가 존재하지 않습니다.
    // 마치 가비지 컬렉션과 같은 구조이다!!


    // null 관련 처리 관찰
    // null은 히든 벨류든 해시테이블에 적재할 수없다!
    //ht.put(null, null);             //-- key 와 value 모두 null        → 런타임 에러(NullPointerException)
    //ht.put("장효진",null);          //-- value 가 null                    → 런타임 에러(NullPointerException)
    //ht.put(null,"010-6666-666");    //-- key 가 null                        → 런타임 에러(NullPointerException)


    // 중복된 key 입력
    ht.put("손효진","010-1234-1234");

    System.out.println(ht.get("손효진"));
    System.out.println();
    //--==>> 010-1234-1234
    //-- 기존 "010-3333-3333" 에서 "010-1234-1234"로 변경되었음을 확인
    //   (덮어쓰기 개념)


    // 중복된 value 입력
    ht.put("권효진","010-2222-2222");
    System.out.println(ht.get("최효진"));
    System.out.println(ht.get("권효진"));
    System.out.println();
    //--==>> 010-2222-2222
    //         010-2222-2222

    // ※ value 는 중복된 값이 입력되어도 기본 데이터에 아무런 영향을 미치지 않음.



}

}

### ▪ HashMap<K, V> 클래스                                                
- Hashtable 클래스와 마찬가지로 Map 인터페이스에서 상속받은
      HashMap 클래스의 기능은 Hashtable 과 동일하지만
      Synchronozation 이 없기 때문에 동시성 문제가 없다면
      (즉, 멀티 스레드 프로그램이 아닌 경우라면)
      HashMap 을 사용하는 것이 성능을 향상시킬 수 있다.
      (Hashtable보다 성능이 좋다!)

- **또한, HashMap 은 Hashtable 클래스와 달리 null을 허용한다. ★★★**

※ 비어있는 값도 별도로 체크해서 처리하려면 HashMap을 써야함!

### ▪ HashMap 코드📝
```java
import java.util.HashMap;
import java.util.Map;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test167
{
    public static void main(String[] args) throws IOException
    {
        // HashMap 자료구조 인스턴스 생성
        //HashMap<String, String> map = new HashMap<String, String>();    //리스트 이외에는 인터페이스 자료구조로 생성해주는거 없읍!(비교)
        Map<String,String> map = new HashMap<String,String>();


        // map 이라는 해시맵 자료구조에 요소 추가
        // -> put()
        map.put("드라마","빈센조");
        map.put("영화","그래비티");
        map.put("만화","도라에몽");

        // 더미 확인
        System.out.println(map);
        //--==>> {드라마=빈센조, 영화=그래비티, 만화=도라에몽}

        // null 입력 시도
        map.put(null, null); 
        map.put("소설", null);
        map.put(null,"생각하는사람");
        //--==>> 에러 안남!
        //-- 위의 데이터 입력 유형에 따라 모든 종류의 데이터 입력이 가능하지만
        //   최초 null 을 key로 매핑하는 null 을 덮어쓰는 상황이 발생하게 된다.
        //   즉, HashMap 은 null을 하나의 고유한 key 값으로 간주한다.(인식한다.)

        // 더미 확인
        //System.out.println(map);
        //--==>> {null=생각하는사람, 소설=null, 드라마=빈센조, 영화=그래비티, 만화=도라에몽}  // nulln, null 덮어쓰기 발생
        //map.put(null,"생각하는사람"); 이거 주석처리하면!
        //--==>> {null=null, 소설=null, 드라마=빈센조, 영화=그래비티, 만화=도라에몽}

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.print("카테고리, 타이틀 입력(컴마 구분) : ");   //"그림,모나리자"
        String[] temp;

        for (String str; ((str=br.readLine()) != null); )
        {
            temp = str.split(",");  // {"그림", "모나리자""}
            if(temp.length<2)
            {
                System.out.print("카테고리, 타이틀 입력(컴마 구분) : ");
                continue;
            }
            map.put(temp[0].trim(), temp[1].trim());
            System.out.println(map);
        }

    }
}

// 일괄 작업을 끝내시겠습니까 (Y/N)?    -> ctrl + c
// 다집지 못하고 넘어온 컬렉션에 주요 클래스 주요 메소크가 많음!! 따로 공부하자!

Test160~Test168

◼ Set

// Set -> HashSet, TreeSet

• 순서 없음.
• 중복을 허용하지 않는 구조(기본)

▪ HashSet

java.util.HashSet 클래스는 Set 인터페이스를 구현하는 클래스로 순서의 개념이 아니라 집합의 개념으로 이해해야 하는 자료구조이다. 이로 인해 데이터의 중복을 허용하지 않는다. 또한, 동기화를 지원하지 않는다.

▪ HashSet 코드📝

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

public class Test164
{
    public static void main(String[] args)
    {
        //Set ob = new Set();  인터페이스 이니까 이렇게 안되고 제너렉표현식도 안댐
        //Set<String> ob = new Set<String>();

        Set<String> dog = new HashSet<String>();

        //  dog 라는 Set 자료구조에 요소 추가
        dog.add("푸들");
        dog.add("골든리트리버");
        dog.add("요크셔테리어");
        dog.add("진돗개");
        dog.add("닥스훈트");


        // 기존 데이터 Set 출력
        System.out.print("기존 데이터 Set : ");
        for (String s : dog)
        {
            System.out.print(s + " ");
        }
        System.out.println();
        //--==>> 기존 데이터 Set : 진돗개 골든리트리버 요크셔테리어 푸들 닥스훈트
        //-- 요소의 적재된(격납된, 구성된) 순서가 의미 없는 자료구조이기 때문에
        //   데이터 입력 순서 -> 자료구조의 요소 격납 순서
        //   이들이 서로 관계 없이 구성되어 있는 것을 확인

        // 데이터(요소) 추가
        dog.add("말티즈");
        dog.add("보더콜리");
        dog.add("스피치");

        dog.add("진돗개");
        dog.add("진돗개");
        dog.add("진돗개");
        dog.add("진돗개");

        dog.add("닥스훈트");
        dog.add("닥스훈트");
        dog.add("닥스훈트");
        dog.add("닥스훈트");

        dog.add("말티즈");
        dog.add("보더콜리");
        dog.add("스피치");

        dog.add("푸들");
        dog.add("골든리트리버");
        dog.add("요크셔테리어");
        dog.add("진돗개");
        dog.add("닥스훈트");

        //  추가 후 데이터 Set 출력
        System.out.print("추가 후 데이터 Set : ");
        for (String s : dog)
        {
            System.out.print(s + " ");
        }
        System.out.println();
        //--==>> 추가 후 데이터 Set : 진돗개 골든리트리버 요크셔테리어 스피치 푸들 닥스훈트 말티즈 보더콜리

        //중복을 허용하지 않는댔는데 에러안남!!
        // ※ 데이터가 추가되는 순서와 상관없이 목록이 구성되어 있으며
        //    같은 데이터가 여러 번 반복해서 추가될 경우
        //    이들 중 하나만 유효한 데이터로 구성되어 있는 것을 확인할 수 있다.
        //    (아무리 추가해도 한 번만 출력됨)

        // ※ 또한, 자료구조의 특성 상 중복 데이터를 허용하지 않는다고 해서
        //    중복 데이터를 추가할 경우 오류가 발생한다는 의미는 아니다.


    }
}

▪ TreeSet

java.util.TreeSet 클래스는 Set 인터페이스를 상속한 SortedSet 인터페이스를 구현한 클래스로 데이터를 추가하면 데이터들이 자동으로 오름차순 정렬이 수행된다.

자동정렬이 포함되어있으니까 메모리소비가 심하고 좀 덜쓰게 됨. 적은양의 데이터를 쓸대면 사용하지만 많은양의 데이터에선 안씀 성능떨어짐

▪ TreeSet 코드📝

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


public class Test165
{
    public static void main(String[] args)
    {
        // TreeSet 자료구조 인스턴스 생성
        TreeSet<String> set = new TreeSet<String>();

        //TreeSet 자료구조 set 에 요소 추가 -> add();
        set.add("하울의움직이는성");
        set.add("이웃집토토로");
        set.add("아기공룡둘리");
        set.add("귀멸의칼날");
        set.add("겨울왕국");
        set.add("짱구는못말려");
        set.add("인사이드아웃");
        set.add("미래소년코난");
        set.add("원령공주");

        // Iterator 를 활용한 set 요소 전체 출력
        System.out.print("전체 요소 출력 : ");
        Iterator<String> it = set.iterator();
        while (it.hasNext())
        {
            System.out.print(it.next() + " ");
        }
        System.out.println();
        //--==>> 전체 요소 출력 : 겨울왕국 귀멸의칼날 미래소년코난 아기공룡둘리 원령공주 이웃집토토로 인사이드아웃 짱구는못말려 하울의움직이는성
        // 가나다라마바사... 순서(자동으로 오름차순 정렬)



        // TreeSet 자료구조 인스턴스 생성
        //TreeSet<String> set2 = new TreeSet<String>();
        //TreeSet<GradeVO> set2 = new TreeSet<GradeVO>();
        TreeSet<GradeVO> set2 = new TreeSet<GradeVO>(new MyComparator<GradeVO>());


        //GradeVO ob = new GradeVO();

        //set2.add(GradeVO);  //-- 인스턴스를 생성해줘야함!!
        //set2(ob);
        set2.add(new GradeVO("20211523","김효진",90,80,70));  // ob 대신에 new GradeVO()s넣어줄수있음
        set2.add(new GradeVO("20211524","최효진",91,81,71));
        set2.add(new GradeVO("20211525","이효진",98,78,88));
        set2.add(new GradeVO("20211526","박효진",72,49,99));
        set2.add(new GradeVO("20211527","정효진",56,31,90));

        // Iterator 를 활용한 set2 요소 전체 출력
        //Iterator<String> it = treeset.iterator;  이거아니다....
        /*
        Iterator<GradeVO> it2 = set2.iterator();
        while (it2.hasNext())
        {
            System.out.println(it2.next() + " ");  //넥스트로 접근하는게 전부 그래이드브이오타입이다
        }
        System.out.println();
        */
        //--==>> 에러 발생

        //트리셋구조가 비교하려면 정렬이 되어있어야하는데 그렇지 못해서 에러 발생
        //==>class MyComparator<T> implements Comparator<T>클래서 만들어주고
        //TreeSet<GradeVO> set2 = new TreeSet<GradeVO>(new MyComparator<GradeVO>()); 추가해줌!

        // MyComparator 클래스 설계/ TreeSet 생성 구문 변경 후 다시 실행
        /*
        Iterator<GradeVO> it2 = set2.iterator();
        while (it2.hasNext())
        {
            System.out.println(it2.next() + " ");  //넥스트로 접근하는게 전부 그래이드브이오타입이다
        }
        System.out.println();
        //--==>> 해시코드로 나옴(이걸로 적재는 제대로 되었구나 확인은 가능)
        */

        Iterator<GradeVO> it2 = set2.iterator();
        while (it2.hasNext())
        {
            GradeVO vo = it2.next();
            System.out.printf("%7s %7s %4d %4d %4d %6d\n"
                            , vo.getHak(), vo.getName()
                            , vo.getKor(), vo.getEng(), vo.getMat()
                            , vo.getTot());
        }
        System.out.println();


    }
}

// VO   → Value Object의 줄임말
// DTO  → Data Transfer Object    VO와 DTO는 거의 같은 개념으로 씀(실무에서는)
// DAO  → Data Access Object


class GradeVO
{
    //  주요 속성 구성
    private String hak;          //-- 학번
    private String name;         //-- 이름
    private int kor, eng, mat;   //-- 국거점수, 영어점수, 수학점수

    // 생성자(사용자 정의 생성자 -> 5개의 매개변수를 가진 생성자)
    GradeVO(String hak, String name, int kor, int eng, int mat)
    {
        this.hak = hak;
        this.name = name;
        this.kor = kor;
        this.eng = eng;
        this.mat = mat;
    }

    // 생성자(사용자 정의 생성자 -> 매개변수 없는 생성자)
    //-- 매개변수가 존재하는 생성자 사용자 정의생성자로 구성하였기 때문에
    //   default 생성자가 자동으로 삽입되지 않을 것을 우려하여
    //   추가로 정의한 생성자
    GradeVO()
    {
    }

    //각 getter/ setter만들기
    // hak getter
    String getHak()   //public 생략 가
    {
        return hak;
    }
    // hak setter
    void setHak(String hak)
    {
        this.hak = hak;
    }

    // name getter
    String getName()
    {
        return name;
    }
    // name setter
    void setName(String name)
    {
        this.name = name;
    }
    //    kor getter
    int getKor()
    {
        return kor;
    }

    void setKor(int kor)
    {
        this.kor = kor;
    }

    int getEng()
    {
        return eng;
    }

    void setEng(int eng)
    {
        this.eng = eng;
    }

    int getMat()
    {
        return mat;
    }

    void setMat(int mat)
    {
        this.mat = mat;
    }

    // 추가 메소드 정의(총점 산출)
    int getTot()
    {
        return kor + eng + mat;
    }




}


class MyComparator<T> implements Comparator<T>
{
    @Override
    public int compare(T o1,T o2)  //앞뒤 비교해서 뒤가 더 큰지(-1) 작은지(1) 같은지(0) 알려주는 메소드
    {
        GradeVO s1 = (GradeVO)o1;
        GradeVO s2 = (GradeVO)o2;

        /*
        //학번 기준(오름차순)
        return Integer.parseInt(s1.getHak()) - Integer.parseInt(s2.getHak());   //String 타입이니까 Integer.parseInt
        //                         "20211523"                    "20211524"
        //return Integer.parseInt( "20211523") - Integer.parseInt("20211524");
        //return 20211523 - 20211524
        //return -1
        */

        //학번 기준(내림차순)
        //return Integer.parseInt(s2.getHak()) - Integer.parseInt(s1.getHak());

        //총점 기준(오름차순)
        //return s1.getTot() - s2.getTot();

        //총점 기준(오름차순)
        //return s2.getTot() - s1.getTot();

        // 이름 기분 (오름차순)  // API도큐먼트 참조해서 찾아보기!   String 에 compareTo
        //return s2.getName() - s2.getName();                       //--check~!!  이름은 이렇게 비교할 수 없음!
        // return 정수형;
        //System.out.println(s1.getName().compareTo(s2.getName()));

        //return s1.getName().compareTo(s2.getName());

        // 이름 기분 (내림차순)
        return s2.getName().compareTo(s1.getName());


    }
}

▪ 문자열 compareTo 메소드

• 문자열 compareTo 메소드는 int형과 다르게 리턴값이 다르다.

1. 문자열이 같은 경우 0 리턴
2. 비교대상이 문자열에 포함되어 있는 경우 s1.length - s2.lenth리턴
3. 다른 문자열인 경우 해당 문자의 아스키코드의 차이를 리턴한다.

▪ VO / DTO / DAO

• VO → Value Object의 줄임말
• DTO → Data Transfer Object VO와 DTO는 거의 같은 개념으로 씀(실무에서는)
• DAO → Data Access Object

Test160~Test168

◼ List(리스트)

List → Vector, ArrayList, ...

• 순서 있음
• 배열과 유사
• 중복 허용(순서로 식별 가능하기 때문에)

▪ ArrayList 클래스와 Vector 클래스

• ArrayList 와 Vector 클래스는 List 를 크기 변경이 가능한 배열로 구현한 것으로 차이점은 Vector 클래스의 객체는 기본적으로 동기화 되지만, ArrayList 는 그렇지 않다는 점이다.

• 비동기화 컬렉션은 동기화된 컬렉션보다 더 나은 성능을 제공하며 스레드들이 컬렉션을 공유하지 않는 프로그램에서는 일반적으로 ArrayList 를 Vector 보다 더 선호하며, ArrayList 는 동기화를 고려하지 않는 Vector 처럼 동작함으로써 스레드 동기화에 따르는 부담을 가지지 않기 때문에 Vector 보다 더 빠르게 실행된다.

• null을 포함한 모든 요소를 허용하며 List 인터페이스를 구현하는 것 외에 리스트에 격납하기 위해 내부적으로 사용되는 배열의 사이즈를 조작하는 메소드를 제공한다.

  ▪ List 코드 1📝

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

public class Test161 { public static void main(String[] args) { // ArrayList 자료구조 인스턴스 생성 //ArrayList list = new ArrayList(); //Vector list = new Vector(); //List list = new Vector(); List list1 = new ArrayList();

    // list1 에 요소 추가 -> add()
    list1.add("나이브스아웃");
    list1.add("인셉션");
    list1.add("인터스텔라");

    // ArrayList 자료구조 인스턴스 생성
    List<String> list2 = new ArrayList<String>(list1);

    // list2 에 요소 추가
    list2.add("모가디슈");


    // ArrayList 자료구조 인스턴스 생성
    List<String> list3 = new ArrayList<String>();

    // list3 에 list2 의 전체 요소 추가  -> addAll();
    list3.addAll(list2);

    // "인셉션 dkvdp "분노의질주" 추가
    // ① "인셉션 찾기 -> indexOf() -> 위치값 인덱스 반환
    int n = list3.indexOf("인셉션");

    //System.out.println("인셉션 위치 : " + n);
    //--==>> 인셉션 위치 : 1

    // ② "인셉션" 찾은 인덱스 위치에 "분노의질주" 투입(삽입)
    list3.add(n,"분노의질주"); //그냥 add하면 뒤에 붙는데 index값 add는 index값에 붙음
    //--==>> [나이브스아웃, 분노의질주, 인셉션, 인터스텔라, 모가디슈]

    // 출력 -> 더미 데이터 확인
    System.out.println("============================================================");
    System.out.println(list1);
    //--==>> [나이브스아웃, 인셉션, 인터스텔라]
    System.out.println(list2);
    //--==>> [나이브스아웃, 인셉션, 인터스텔라, 모가디슈]
    System.out.println(list3);
    //--==>> [나이브스아웃, 인셉션, 인터스텔라, 모가디슈]

    System.out.println();

    // 출력 → listIterator() 메소드를 활용하여 출력
    System.out.println("============================================================");
    list3.listIterator();
    ListIterator<String> li = list3.listIterator();
    while (li.hasNext())
    {
        System.out.print(li.next() + " ");
    }
    System.out.println();
    //--==>> 나이브스아웃 분노의질주 인셉션 인터스텔라 모가디슈  // 얘는 더미를 찍은 것과는 다름!

    System.out.println();

    // 출력 -> 역순으로 출력 .hasPrevious()
    System.out.println("============================================================");
    while (li.hasPrevious())
    {
        System.out.print(li.previous() + " ");
    }
    System.out.println();
    //--==>> 모가디슈 인터스텔라 인셉션 분노의질주 나이브스아웃

}

}

### ▪ List 인터페이스
- 순서가 있음, 배열과 유사, 중복을 허용(순서로 식별 가능하기 때문에)
- 주요 구현 클래스
ㆍVector(동기화 지원)
ㆍArrayList(동기화 지원하지 않음)
ㆍLinkedList(체인, 링크, 결합)
### ▪ List 코드 2📝
```java
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.ListIterator;


public class Test162
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();

        list.add("서울");
        list.add("부산");
        list.add("인천");
        list.add("대구");
        list.add("광주");
        list.add("대전");
        list.add("울산");
        list.add("세종");

        // 더미 체크
        System.out.println(list);
        //--==>> [서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]

        System.out.println("전체 갯수 : " + list.size());
        //--==>> 전체 갯수 : 8

        //첫 번째 요소만 출력
        System.out.println("첫 번째 요소 : " + list.get(0));
        //--==>> 첫 번째 요소 : 서울

        // 마지막 요소만 출력
        System.out.println("마지막 요소 : " + list.get(list.size()-1));   //--check~!!
        //--==>> 마지막 요소 : 세종

        // 처음 위치에 "목포" 추가
        list.add(0, "목포");

        //더미 체크
        System.out.println(list);
        //--==>> [목포, 서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]

        // 처음 위치의 데이터(요소)를 "대한민국"으로 변경    -> 덮어쓰기
        list.set(0,"대한민국");

        //더미 체크
        System.out.println(list);
        //--==>> [대한민국, 서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]

        // "서울" 존재여부 확인
        if (list.contains("서울"))
            System.out.println("서울이 존재합니다.");
        //--==>> 서울이 존재합니다.

        // "대한민국" 지우기
        //list.remove("대한민국");  //--(O)
        list.remove(0);                //--(O)     //--check~!!

        //더미 체크
        System.out.println(list);
        //--==>> [서울, 부산, 인천, 대구, 광주, 대전, 울산, 세종]

        //ArrayList 자료구조 list 의 전체 요소 출력
        System.out.println("전체 출력...①");
        for (int idx=0; idx<list.size();idx++)
        {
            System.out.print(list.get(idx) + " ");
        }
        System.out.println();
        //--==>> 전체 출력...①
        //         서울 부산 인천 대구 광주 대전 울산 세종

        System.out.println("역순 출력...②");
        for (int idx=list.size()-1; idx>=0; idx--)         //--check~!!
        {
            System.out.print(list.get(idx) + " ");
        }
        System.out.println();
        //--==>> 역순 출력...②
        //         세종 울산 대전 광주 대구 인천 부산 서울

        System.out.println("전체 출력...③");      //for-each 구문사용
        for (String s : list )
        {
            System.out.print(s + " ");
        }
        System.out.println();
        //--==>> 전체 출력...③
        //         서울 부산 인천 대구 광주 대전 울산 세종

        System.out.println("전체 출력...④");
        Iterator<String> it = list.iterator();
        while (it.hasNext())
        {
            String s = it.next();
            System.out.print(s + " ");
        }
        System.out.println();
        //--==>> 전체 출력...④
        //         서울 부산 인천 대구 광주 대전 울산 세종


        System.out.println("전체 출력...⑤");
        ListIterator<String> li = list.listIterator();
        while (li.hasNext())
        {
            System.out.print(li.next() +  " ");
        }
        System.out.println();
        //--==>> 전체 출력...⑤
        //         서울 부산 인천 대구 광주 대전 울산 세종

        System.out.println("역순 출력...⑥");
        while (li.hasPrevious())
        {
            String s = li.previous();
            System.out.print(s+ " ");
        }
        System.out.println();
        //--==>> 역순 출력...⑥
        //         세종 울산 대전 광주 대구 인천 부산 서울


    }
}

▪ asList()메소드와 toArray()메소드

• String[] -> List : Arrays.asList()
• List -> String[] : List.toArray()

  ▪ asList()메소드와 toArray()메소드 코드📝

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

public class Test163 { public static void main(String[] args) { List mList = new ArrayList();

    mList.add("1");
    mList.add("2");
    mList.add("3");

    // List -> String[]
    String[] sArrays = mList.toArray(new String[mList.size()]);  //스트링배열의 형태로 리스트를 배열로 변경

    for (String s:sArrays)
    {
        System.out.print(s +" ");
    }
    System.out.println();
    //--==>> 1 2 3

    // String[] -> list
    List<String> mNewList = Arrays.asList(sArrays);
    // ※ 『Arrays.asList()』의 반환 자료형 List이기 때문에

    for (String s : mNewList)
    {
        System.out.print(s + " ");
    }
    System.out.println();
    //--==>> 1 2 3

}

}

어닝 쇼크(earning shock) : 기업이 시장에서 예상했던 것보다 저조한 실적을 발표하여 주가에 영향을 미치는 현상을 일컫는 경제용어. 주식시장에서 '어닝(earning)'은 기업의 실적을 뜻 분기 또는 반기별로 기업들이 집중적으로 그동안의 영업 실적을 발표하는 시기를 '어닝 시즌(earning season)' 이와 대조적으로 영업 실적이 예상보다 높은 경우에는 주가가 큰 폭으로 상승할 가능성이 있는데, 이를 '어닝 서프라이즈(earning surprise)'

뉴스1 "샴페인 너무 빨리 터트렸나"…'연봉 잔치' 벌인 게임업계, 실적 '빨간불' https://news.naver.com/main/read.naver?mode=LSD&mid=shm&sid1=105&oid=421&aid=0005539897

Test160~Test168

◼ Enumeration/Iterator

// 둘의 기능은 비슷하지만 호환성 때문에 둘다 사용법을 알고 있어야함!!

Enumeration는 자바초기버젼에서 제공되는것으로 Hashtable, Vector 에서 사용가능하다. Iterator는 jdk1.2에서 제공되는 것으로 Collection인터페이스를 구현상속한 모든 컬렉션 클래스에서 사용가능하다.

▪ Enumeration 과 Iterator 인터페이스

Colloection Framework에는 Enumeration 과 Iterator 라는 인터페이스가 있다. 사전적인 의미로는 반복, 순환 이라는 의미를 가지고 있으며 어떤 객체들의 모임이 있을 때, 이 객체들을 어떤 순서에 의해 하나씩 접근하여 사용하기 위한 인터페이스라고 할 수 있다.

- java.util.Enumeration<E> 인터페이스
  : 이 인터페이스는 단지 두개의 메소드만을 제공하며
  『hasMoreElements()』 메소드를 통해
  인터페이스 안에 다음 요소가 있는지에 대한 질의를 한다.
  만약 true 가 반환되었다면 다음 인덱스에 요소가 존재한다는 의미이며
  『nextElement()』메소드로 다음 요소를 꺼내어 사용하며 되는 것이다.

  ex) // v 라는 자료구조에 저장된 모든 요소 접근 및 출력
        for (Enumeration e = v.elements(); e.hasMoreElements();)
      {
        System.out.println(e.nextElement());
      }
- java.util.Iterator<E> 인터페이스
  : Enumeration 과의 차이점은 단지 『remove()』메소드가 추가된 것 뿐이다.
  Iterator가 가지고 있는 『hasNext()』와 『Next()』메소드는
  이름만 약간 다를 뿐 Enumeration 인터페이스가 가지고 있는
  『hasMoreElements()』 와 『nextElement()』와
  정확히 일치하는 기능을 수행한다.
  Enumeration  대신 Iterator를 JDK1.2 부터 추가하여 사용하게 된 이유는
  Enumeration 인터페이스는 집합 내에서 요소를 제거할 방법이 없기 때문에
  이를 보완하기 위해 나온 것이 Iterator 인터페이스이다.

▪ Enumeration 과 Iterator 인터페이스 코드 설명📝

import java.util.Vector;
import java.util.Enumeration;
import java.util.Iterator;

public class Test160
{
    public static void main(String[] args)
    {
        // 벡터 자료구조 인스턴스 생성
        Vector<String> v = new Vector<String>();

        // 벡터 자료구조 v 에 요소 추가
        v.add("Java");
        v.add("Oracle");
        v.add("Jsp");
        v.add("Servlet");
        v.add("Spring");

        // ① Emuneration
        //    - hasMoreElements()
        //    - nextElement()
        Enumeration<String> e = v.elements();
        while (e.hasMoreElements())  // true / false
        {
            System.out.println(e.nextElement());
        }
        System.out.println();
        //Java
        //Oracle
        //Jsp
        //Servlet
        //Spring

        System.out.println("---------------------------------------");


        // ① Iterator
        //    - hasNext()
        //    - next()
        Iterator<String> it = v.iterator();
        while (it.hasNext())
        {
            System.out.println(it.next());
        }
        System.out.println();
        //Java
        //Oracle
        //Jsp
        //Servlet
        //Spring
    }
}

Test152~Test159

◼ 컬렉션 프레임워크(Collection Framework)

▪ 메뉴선택 프로그램 설명코드📝

/*
Test159 클래스를 완성하여 다음 기능을 가진 프로그램을 구현한다.
실행 예)
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 1
        1번째 요소 입력 : 떡볶이
        1번째 요소 입력 성공~!!!
        요소 입력 계속(Y/N)? : Y

        2번째 요소 입력 : 탕수육
        2번째 요소 입력 성공~!!!
        요소 입력 계속(Y/N)? n
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 2
        [벡터 전체 출력]
            떡볶이
            탕수육
        벡터 전체 출력 완료~!!!
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 3
        검색할 요소 입력 : 냉면
        [검색 결과 출력]
        항목이 존재하지 않습니다.
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 3
        검색할 요소 입력 : 떡볶이
        [검색 결과 출력]
        항목이 존재합니다.
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 4
        삭제할 요소 입력 : 그릭요거트
        [삭제 결과 출력]
        항목이 존재하지 않아 삭제할 수 없습니다.
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 4
        삭제할 요소 입력 : 탕수육
        [삭제 결과 출력]
        서승균 항목이 삭제되었습니다.
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 5
        변경할 요소 입력 : 밥
        [변경 결과 출력]
        변경할 대상이 존재하지 않습니다.
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 5
        변경할 요소 입력 : 떡볶이
        수정할 내용 입력 : 치킨
        [변경 결과 출력]
        변경이 완료되었습니다.
        [메뉴 선택]
        1. 요소 추가
        2. 요소 출력
        3. 요소 검색
        4. 요소 삭제
        5. 요소 변경
        6. 종료
        >> 메뉴 선택(1~6) : 6
        프로그램 종료
    계속하려면 아무 키나 누르세요...
*/

import java.util.Vector;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

class Menus    //--완성
{
    public static final int E_ADD = 1;     //-- 요소 추가
    public static final int E_DISP = 2;    //-- 요소 출력
    public static final int E_FIND = 3;    //-- 요소 검색
    public static final int E_DEL = 4;     //-- 요소 삭제
    public static final int E_CHA = 5;     //-- 요소 변경
    public static final int E_EXIT = 6;    //-- 종료

}



public class Test159
{

    // 주요 속성 구성 -- 완성
    private static final Vector<Object> vt;
    private static BufferedReader br;
    private static Integer sel;         //-- 선택 값
    private static String con;            //-- 계속 여부

    // static 초기화 블럭 -- 완성
    static
    {
        //Vector 자료구조 생성
        vt = new Vector<Object>();

        // BufferedReader 인스턴스 생성
        br = new BufferedReader(new InputStreamReader(System.in));

        // 사용자 입력값 초기화
        sel = 1;
        con = "Y";
    }

    //메뉴 출력 메소드
    public static void menuDisp()
    {
        System.out.println("\n\t[메뉴 선택]");
        System.out.println("\t1. 요소 추가");
        System.out.println("\t2. 요소 출력");
        System.out.println("\t3. 요소 검색");
        System.out.println("\t4. 요소 삭제");
        System.out.println("\t5. 요소 변경");
        System.out.println("\t6. 종     료");
        System.out.println();
        System.out.print("\t>> 메뉴 선택(1~6) : ");
    }

    // 메뉴 선택 메소드
    public static void menuSelect() throws IOException
    {

        do
        {
            //System.out.print("\t>> 메뉴 선택(1~6) : ");   //-- 여기에 해도 상관없음
            sel = Integer.parseInt(br.readLine());    
        }
        while (sel<1 || sel>6);

    }

    // 선택된 메뉴 실행에 따른 기능 호출 메소드
    public static void menuRun() throws IOException, NumberFormatException
    {
            /*
            if (sel ==1)    
            {
                addElement();
            }
            else if (sel ==2)
            {
                dispElement();
            }
            else if (sel ==3)
            {
                findElement();
            }
            else if (sel ==4)    
            {
                delElement();
            }
            else if (sel ==5)    
            {
                chaElement();
            }
            else if (sel ==6)    
            {
                exit();
            }
            */
            switch (sel)
            {
                case Menus.E_ADD  : addElement(); break;
                case Menus.E_DISP : dispElement(); break;
                case Menus.E_FIND : findElement(); break;
                case Menus.E_DEL  : delElement(); break;
                case Menus.E_CHA  : chaElement(); break;
                case Menus.E_EXIT : exit(); break;     //만약 456을 안적으면 exit가 실행된다!
                default : System.out.println("\t >> 메뉴 선택 오류~!!!"); break;
            }

    }

    // 요소 추가(입력) 메소드
    public static void addElement() throws IOException
    {        
        do
        {
            System.out.printf("\t%d번째 요소 입력 : " ,vt.size()+1);     //check~!!    처음에는 요소가 없고
            String temp = br.readLine();
            vt.add(temp);    //--boolean 사용해도 됨! 확인!
            System.out.println();
            System.out.printf("\t%d번째 요소 입력 성공~!!!",vt.size());    //check~!!  여기선 추가요소가 있으니까!!!
            System.out.println();
            System.out.print("\t요소 입력 계속(Y/N)? : ");
            con = br.readLine().toUpperCase();  //check~!!
            //con = br.readLine()
        }
        //while (con != "n" || con != "N" || con != "y" || con != "Y");
        //while(con.equals("y") || con.equals("Y"));
        while(con.equals("Y"));  //.toUpperCase() 나 .toLowerCase()쓰면 하나만 쓰면됨~!

        System.out.println();

        //if(con.equals("y") || con.equals("Y"))
            //addElement();   //-- 재귀 함수
    }

    // 요소 출력 메소드
    public static void dispElement() 
    {
        System.out.println();
        // 벡터 자료구조 v 의 전체 요소 출력
        System.out.println("\t[백터 전체 출력]");
        for (int i=0; i<vt.size();i++)
            System.out.printf("%s\n", vt.get(i));    
        System.out.println("\t벡터 전체 출력 완료~!!!");

    }

    // 요소 검색 메소드
    public static void findElement() throws IOException
    {
        System.out.println();
        String temp = "";

        System.out.print("\t검색할 요소 입력 : ");
        temp = br.readLine();

        int i = vt.indexOf(temp);

        System.out.println("\t[검색 결과 출력]");
        if (i<0)
            System.out.println("\t항목이 존재하지 않습니다.");        
        else
            System.out.println("\t항목이 존재합니다.");        
    }

    // 요소 삭제 메소드
    public static void delElement() throws IOException
    {
        System.out.println();
        System.out.print("\t삭제할 요소 입력 : ");
        String temp = br.readLine();
        System.out.println();

        System.out.println("\t[검색 결과 출력]");
        if (vt.contains(temp))     
        {
            int i = vt.indexOf(temp);
            vt.remove(i);            //--boolean 사용해도 됨! 확인!
            System.out.printf("\t%s 항목이 삭제되었습니다.\n",temp);
        }
        else
            System.out.println("\t항목이 존재하지 않아 삭제할 수 없습니다.");

    }

    // 요소 수정(변경) 메소드
    public static void chaElement() throws IOException
    {
        System.out.println();
        System.out.print("\t변경할 요소 입력 : ");
        String temp = br.readLine();
        if (vt.contains(temp))     
        {
            System.out.print("\t수정할 내용 입력 :");
            String change = br.readLine();    
            int i = vt.indexOf(temp);
            vt.set(i, change);

            System.out.println();
            System.out.println("\t[변경 결과 출력]");
            System.out.println("\t변경이 완료되었습니다.");
        }
        else
        {
            System.out.println("\n\t[변경 결과 출력]");
            System.out.println("\t변경할 대상 존재하지 않습니다.");
        }
    }

    //프로그램 종료 메소드 -- 완성
    public static void exit()
    {
        System.out.println("\t프로그램 종료~!!!");
        System.exit(-1);
    }



    // main() 메소드 -- 완성
    public static void main(String[] args) throws IOException
    {
        do
        {
            menuDisp();
            menuSelect();
            menuRun();

        }
        while (true);
    }

}

/*
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 1
1번째 요소 입력 : 정효진
1번째 요소 입력 성공~!!!
요소 입력 계속(Y/N)? : y
2번째 요소 입력 : 김효진
2번째 요소 입력 성공~!!!
요소 입력 계속(Y/N)? : n
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 2
[백터 전체 출력]
정효진
김효진
벡터 전체 출력 완료~!!!
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 3
검색할 요소 입력 : 정효진
[검색 결과 출력]
항목이 존재합니다.
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 4
삭제할 요소 입력 : 정효진
[검색 결과 출력]
정효진 항목이 삭제되었습니다.
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 5
변경할 요소 입력 : 김효진
수정할 내용 입력 :김연경
[변경 결과 출력]
변경이 완료되었습니다.
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 2
[백터 전체 출력]
김연경
벡터 전체 출력 완료~!!!
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 6
        프로그램 종료~!!!
계속하려면 아무 키나 누르십시오 . . .
*/

Test152~Test159

◼ Vecotr(벡터)

//배열을 떠올리고 배열의 제한사항 2개가 허물어져 있다고 생각하면됨! 
//배열의 같은요소로 구성해야한다는 제한사항이 있었는데 벡터는 상관없음
// 배열은 크기가 정해져 있는데 벡터는 길기가 변할 수 있다.

자바의 자료구조 기능을 제공하는 클래스들 중 가장 기본적인 클래스로 배열과 비슷하지만, 배열과 달리 다른 종류의 데이터 형을 가진 데이터 요소를 가질 수 있으며, 데이터가 가득차면 자동으로 저장 영역을 확장시키게 된다.

또한, 객체 래퍼러스를 저장하기 때문에 JDK 1.5 이전에는 자바 기본형 데이터는 저장할 수 없었으나 JDK 1.5 이후부터는 오토박싱 / 오토언박싱 기능이 지원되면서 기본 데이터형도 저장이 가능해졌다.

벡터 클래스의 기본 구조는 시퀀스(Sequence) 데이터 구조에 기반하며(==순차적이다.) 시퀀스 데이터 접근을 순차적인 인텍스 값에 대한 위치로 접근하게 된다. 따라서, 자료구조의 양 끝단에서만 접근이 가능한 큐나 한쪽 끝에서만 접근이 가능한 스택과 달리 시퀀스 개념의 인덱스 값을 이용하여 자료구조 임의의 지점에서 저장 및 접근이 가능하다.

벡터의 시퀀스 구조는 List 인터페이스(순서 중요!)를 통해 제공받고 있기 때문에 List 인터페이스의 모든 메소드를 사용할 수 있다.

▪ Vecotr(벡터) 메소드

• void add(int index, E element) // add랑 insertElementAt은 매개변수 넣는 위치 반대!!check~!!

• void insertElementAt(e obj, int index) 주어진 위치에 객체를 저장한다. 주어진 위치의 객체부터 오른쪽으로 하나씩 이동한다.

• void addElement(E obj)

• boolean add(E e) 객체를 벡터 끝에 추가한다.

• void removeElementAt(int index)

• E remove(int index) 주어진 위치의 객체를 제거한다. 제거 후 주어진 위치 다음의 객체부터 하나씩 왼쪽으로 이동한다. E remove(int index) 메소드는 저장되었던 객체를 반환한다.

• boolean removeElement(Object obj)

• boolean remone(Objext obj) 대상 객체를 제거한다. 제거 후 주어진 위치 다음의 객체부너 하나씩 왼쪽으로 이동한다. 객체가 정상적으로 제거되었으면 true 를 반환한다.

• void removeAllElement()

• void clear() 벡터의 모든 요소를 제거한다.

• void setElementAt(E obj, int index)

• E set(int index, E element) 벡터의 index 위치에 주어진 객체를 저장한다. 주어진 위치에 저장되어 있던 객체는 소멸한다.(-> 덮어쓰기의 개념)

• E elementAt(int index)

• E get(int index) 주어진 위치에 저장되어있는 객체를 반환한다.

• Enumeration elements() 벡터의 모든 요소를 반환한다.

• int indexOf(Object o) 주어진 객체가 저장된 위치를 반환한다. 존재하지 않을 경우 『음수』를 반환한다.

• int indexOf(Object o, int index) 주어진 객체가 저장된 위치를 index 위치부터 찾아서 반환한다. index 위치는 스캔을 시작하는 위치.

• boolean contains(Object o) 벡터가 주어진 객체를 포함하고 있는지의 여부를 반환한다.

• void ensureCapacity(int minCapacity) 벡터의 용량을 주어진 크기보다 크도록 조절한다.

• E firstElement() 벡터의 첫번째 요소의 데이터를 반환한다.

• E lastElement() 벡터의 마지막 요소의 데이터를 반환한다.

• void setSize(int newSize) 벡터의 크기를 조절한다. 만약 주어진 크기가 현재 크기보다 작다면 나머지는 버린다. 반대로 주어진 크기가 현재 크기보다 크다면 빈 공간은 null 로 채우게 된다. (객체를 참조하지 않음을 의미)

• int capacity() 현재 벡터의 용량을 반환한다.

• int size() 현재 벡터에 저장된 객체의 갯수(size)를 반환한다.

• int trimtoSize() 벡터의 용량을 저장된 객체의 갯수에 맞도록 최소화한다.

▪ 벡터 코드 설명📝

import java.util.Vector;
import java.util.Iterator;

public class Test154
{
    // 정적 문자열 배열 선언 및 초기화
    private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};

    public static void main(String[] args)
    {
        int i;
        String str;

        //Vector(벡터) 자료구조 v 생성
        Vector<Object> v = new Vector<Object>();

        // v 라는 Vector(벡터) 자료구조에
        // color 배열에 담겨있는 데이터 담아내기
        // add()
        for (i=0; i<colors.length; i++)
        {
            v.add(colors[i]);
        }

        // 데이터(요소) 추가
        // v.addElement()
        v.addElement("하양");  //가장 뒤에 추가됨!


        // firstElement()
        str = (String)v.firstElement();
        System.out.println("첫 번째 요소 : " + str);
        //--==>> 첫 번째 요소 : 검정

        // get()  두번째 요소를 꺼내는 메소드는 없기때문에1
        str = (String)v.get(1);  // v.get(0) 1번째요소 ~~
        System.out.println("두 번째 요소 : " + str);
        //--==>> 두 번째 요소 : 노랑

        str = (String)v.get(0);
        System.out.println("첫 번째 요소 : " + str);

        // elementAt
        str = (String)v.elementAt(1);
        System.out.println("두 번째 요소  : " + str);
        //--==>> 두 번째 요소  : 노랑

        // lastElement()
        str = (String)v.lastElement();
        System.out.println("마지막 요소 : " + str);
        //--==>> 마지막 요소 : 연두

        // ※ 데이터 요소 추가 후 
        //--==>> 마지막 요소 : 하양

        // ※ 벡터 자료구조에 요소 추가시(→ add() / addElement())
        //        인덱스 마지막(가장 끝)의 위치에 추가되는 것을 확인할 수 있다.

        // 전체 요소 출력 → 전체 요소 접근 → check~!!!
        // 『Iterator(이터레이터 or 아이터레이터)』를 통해 전체 요소에 순차적 접근
        //  util패키지에 있음~!!
        //  『hasNext()』 :  다음 데이터 요소가 있는지의 여부를 확인하여 반환
        //  『next()』    :  다음 데이터 요소를 직접적으로 반환

        Iterator<Object> it = v.iterator();

        while (it.hasNext())
        {
            str = (String)it.next();
            System.out.print(str +  " ");
        }
        System.out.println();
        //--==>> 검정 노랑 초록 파랑 빨강 연두 하양

    }
}

『Iterator(이터레이터 or 아이터레이터)』

util패키지에 있음~!!

• 『hasNext()』 : 다음 데이터 요소가 있는지의 여부를 확인하여 반환
• 『next()』 : 다음 데이터 요소를 직접적으로 반환

▪ .copyValueOf((char[])o))사용 벡터 코드 설명📝

import java.util.Vector;
import java.util.Iterator;

class MyVector extends Vector<Object>    // <Object>형태로 상속받을때 <Object>를 붙인다.

{
    // 생성자
    MyVector()
    {
        //--Vector(1,1) : 부모 생성자에 두 개의 매개변수를 넣음 (슈퍼 클래스)
        super(1,1);
        //-- 첫 번째 인자 : 주어진 용량
        //   두 번째 인자 : 증가량
    }

    void addInt(int i)
    {
        addElement(new Integer(i));
    }

    void addFloat(float f)
    {
        addElement(new Float(f));
    }

    void addString(String s)
    {
        addElement(s);
    }

    void addCharArray(char[] a)
    {
        addElement(a);
    }


    void write()
    {

        Object o;
        int length = size();
        System.out.println("벡터의 요소 갯수 : " + length);



        for (int i=0; i<length; i++)
        {

            o = elementAt(i);   //elementAt(0) : 0번째꺼 가지고 오겠다!

            // 『instanceof』 연산자    check~!!!
            //-- 처리해야 하는 대상의 객체 타입 확인  // 오브젝트는 오브젝트인데 무슨 타입이니?


            if (o instanceof String)    //-- o가 String타입인지 확인하는 연산자
            {
                System.out.println("문자열 : " + o.toString());
            }

            else if (o instanceof Integer)
                  // ------------ o 가 인티저타입으로 만들어진 객체(오브젝트)   백터는 기본자료형은 취할 수 없음!
            {

            System.out.println("정수형 : " + o);
                                          //--- 객체를 출력하면 클래스명@해시코드가 나옴 근데 왜 잘나와? (오토박싱)
                                          //  모르겠으면 래퍼클래스 가서 다시 복습하자!
            }

            else if (o instanceof Float)
            {
                System.out.println("실수형 : " + o);
            }
            else if (o instanceof char[])     //캐릭터타입은 래퍼클래스가아니기때문에 오토박싱 안댄다.
            {
                /* 이러면 너무너무 복잡 그래서 밑에처럼
                for (int i; i<(char[])o.length; i++)
                {
                    System.out.println(((char[])o)[i]);
                }
                */

                // System.out.println("문자배열 : " + o);
                // System.out.println("문자배열 : " + o.toString());
                //System.out.println("문자배열 : " + String.copyValueOf(문자배열);
                //System.out.println("문자배열 : " + String.copyValueOf({'s','t','u','d','y'});
                System.out.println("문자배열 : " + String.copyValueOf((char[])o));    //check~!!!
                                                //       ------------ char 배열값을 연결해 문자열로 반환

                                                //객체를 출력하면 클래스명@해시코드가 나옴
            }
            else
            {
                System.out.println("타입 확인 불가~!!!");
            }

        }
        //--==>> 벡터의 크기 : 4
        //       정수형 : 5
        //       실수형 : 3.14
        //       문자배열 : 안녕하세요
        //       문자배열 : study



        //-------------------------------------------------------------------------

        System.out.println();

        Iterator<Object> it = this.iterator();    //<Object> 확인
        while (it.hasNext())
        {
            System.out.println(it.next());
        }

        //--==>> 5
        //       3.14
        //       안녕하세요
        //       [C@6d06d69c           //--> 이게 문제 그래서 위에 만듬

    }

}



public class Test155
{
    public static void main(String[] args)
    {
        //Myvector 클래스 기반 인스턴스 생성
        MyVector v = new MyVector();

        // 주요 변수 선언 및 초기화
        int digit = 5;
        float real = 3.14f;
        String s = new String("안녕하세요");
        char[] letters = {'s','t','u','d','y'};

        v.addInt(digit);             //-- 벡터 자료구조에 정수 저장
        v.addFloat(real);            //-- 벡터 자료구조에 실수 저장
        v.addString(s);                 //-- 벡터 자료구조에 문자열 저장
        v.addCharArray(letters);     //-- 벡터 자료구조에 문자 배열 저장

        v.write();
        //--==>> 벡터 요소 개수 : 0
    }


}

▪ 벡터 추가, 변경, 정렬, 검색 코드 설명📝

import java.util.Vector;
import java.util.Collections;

public class Test156
{

    // 정적 문자열 배열 선언 및 초기화
    private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};


    public static void main(String[] args)
    {
        // 벡터 자료구조 생성
        Vector<String> v = new Vector<String>();

        // 벡터 자료구조 v 에 colors 데이터를 요소로 추가
        for (String color : colors)
        {
            v.add(color);
        }

        System.out.println("첫 번째 요소 : " + v.firstElement());
        System.out.println("두 번째 요소 : " + v.get(1));
        System.out.println("마지막 요소  : " + v.lastElement());
        System.out.println("요소의 갯수  : " + v.size());
        //첫 번째 요소 : 검정
        //두 번째 요소 : 노랑
        //마지막 요소  : 연두
        //요소의 갯수  : 6

        // ○ 첫 번째 요소를 "하양"으로 변.경. -> set()
        v.set(0, "하양");
        System.out.println("첫 번째 요소 : " + v.firstElement());
        System.out.println("두 번째 요소 : " + v.get(1));
        System.out.println("요소의 갯수  : " + v.size());
        //첫 번째 요소 : 하양
        //두 번째 요소 : 노랑
        //요소의 갯수  : 6
        //--==>> 이걸 통해서 한 칸씩 밀린 것이 아니라 검정에 하양이 덮어쓴 것


        // ○ 첫 번째 요소를 "주황"으로 추.가. -> insertElementAt()   // 매개변수 순서가 다르니까 기억!!  // 위에꺼랑 차이 확인!!
        v.insertElementAt("주황",0);

        System.out.println("첫 번째 요소 : " + v.firstElement());
        System.out.println("두 번째 요소 : " + v.get(1));
        System.out.println("요소의 갯수  : " + v.size());
        //첫 번째 요소 : 주황
        //두 번째 요소 : 하양
        //요소의 갯수  : 7

        // ○ 전체 출력
        System.out.print("전체 출력 : ");
        for (String str : v)
            System.out.print(str + " ");
        System.out.println();


        /* 나의 시도
        Iterator<Object> it = v.iterator();

        while (it.hasNext())
        {
            str = (String)it.next();
            System.out.print("전체 출력 : " + 

        }

        Iterator<Object> it = v.iterator();

        while (it.hasNext())
        {
            str = (String)it.next();
            System.out.print(str +  " ");
        }
        System.out.println();
        */




        // ○ 오름차순 정렬
        Collections.sort(v);

        // ○ 오름차순 정렬 후 전체 출력
        System.out.print("오름차순 정렬 후 전체 출력 : ");
        for (String str : v)
        {
            System.out.print(str + " ");
        }
        System.out.println();
        //--==>> 오름차순 정렬 후 전체 출력 : 노랑 빨강 연두 주황 초록 파랑 하양


        //○ 검색
        // 『Collections.binarySearch()』  -> 검색 기능 수행
        //  단, 오름 차순 정렬이 수행되어 있는 자료에 대해서만 사용이 가능하다. check~!!
        // 검색 결과가 존재하지 않을 경우 『음수』를 반환한다.

        int idxBlue = Collections.binarySearch(v, "파랑");  //인덱스 값을 반환하여 정수 형태
        System.out.printf("파랑 : %d 번째 인덱스에 위치하고 있다.", idxBlue);
        System.out.println();
        //--==>> 파랑 : 5 번째 인덱스에 위치하고 있다.

        int idxNavi = Collections.binarySearch(v,"남색");
        System.out.printf("남색 : %d 번째 인덱스에 위치하고 있다.", idxNavi);
        System.out.println();
        //--==>> 남색 : -1 번째 인덱스에 위치하고 있다.   //--음수 나오면 남색은 없는거다!  → 검색 결과 없음


        // ○ 내림차순 정렬 → 별도의 메소드가 존재하지 않는다! 매개변수를 하나더 추가
        Collections.sort(v,Collections.reverseOrder());


        // ○ 내림차순 정렬 후 전체 출력
        System.out.print("내림차순 정렬 후 전체 출력 : ");
        for (String str :v)
            System.out.print(str + " ");
        System.out.println();
        //--==>> 내림차순 정렬 후 전체 출력 : 하양 파랑 초록 주황 연두 빨강 노랑

        // ○ 내림차순 정렬 후 검색 테스트
        idxBlue = Collections.binarySearch(v, "파랑");
        System.out.printf("파랑 : %d 번째 인덱스에 위치하고 있다.", idxBlue);
        System.out.println();
        //--==>> 파랑 : -8 번째 인덱스에 위치하고 있다.  → 못찾았음... 


        idxBlue = Collections.binarySearch(v,"파랑", Collections.reverseOrder());
        System.out.printf("파랑 : %d 번째 인덱스에 위치하고 있다.", idxBlue);
        System.out.println();
        //--==>> 파랑 : 1 번째 인덱스에 위치하고 있다.


    }
}

▪ 벡터 검색 및 삭제 코드 설명📝

//앞에는 인덱스를 가지고 값을 확인했다면 이제는 값을 가지고 인덱스를 확인

import java.util.Vector;

public class Test157
{

    // 정적 문자열 배열 선언 및 초기화
    private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};

    public static void main(String[] args)
    {
        //  벡터 자료구조 v 생성
        Vector<String> v = new Vector<String>();

        // 벡터 자료구조 v 에 colors 데이터를 요소로 추가
        for(String color : colors)
            v.add(color);

        // 벡터 자료구조 v 의 전체 요소 출력
        System.out.print("전체 요소 출력 : ");
        for (String str :v )
        {
            System.out.print(str +  " ");
        }
        System.out.println();
        //--==>> 전체 요소 출력 : 검정 노랑 초록 파랑 빨강 연두

        // indexOf()
        String s1 = "분홍";

        int i = v.indexOf(s1);
        System.out.println(s1 + "-> index 위치 : " + i);
        System.out.println();
        //--==>> 분홍-> index 위치 : -1

        String s2 = "노랑";

        // 『v.conrains(s)』 
        //  벡터 자료구조 v 에 찾고자 하는 s가 포함되어 있다면....
        if (v.contains(s2))     
        {
            // 벡터 자료구조 v 에서 s2의 인덱스 위치 확인하고!
            i = v.indexOf(s2);
            System.out.println(s2 + "-> index 위치 : " + i);


            // 우선 위의 코드를 통해 제거하고자 하는 대상의 위치를 찾고
            // 찾았으면 삭제해라~!!!
            v.remove(i);
        }

        // 찾아서 삭제한 후 전체 요소 출력
        System.out.print("삭제한 후 전체 요소 출력 : ");
        for (String str : v)
        {
            System.out.print(str + " ");
        }
        System.out.println();
        //--==>> 삭제한 후 전체 요소 출력

        //추가 테스트
        System.out.println(colors);
        //--==>> [Ljava.lang.String;@15db9742    //colors배열의 해시코드

        System.out.println(v);
        //--==>> [검정, 초록, 파랑, 빨강, 연두]  //더미

        // ※ 확인용 더미 데이터는
        //    실제 요소(데이터)가 아니기 대문에
        //    이를 활용하여 연산을 진행하거나 해서는 안된다.  check~!!!


    }
}

▪ 벡터 자료구조 객체 선언 및 생성 시 코드 설명📝

//  벡터 자료구조 객체 선언 및 생성 시
//  사용자 정의 클래스 활용 → 자료형


import java.util.Vector;

// 사용자 정의 클래스 설계 → 자료형처럼 활용
class MyData
{
    // 주요 속성 구성 → 주요 변수 선언(멤버 변수)
    private String name;      //-- 이름
    private int age;          //-- 나이

    // getXxx() → getter
    // setXxx() → setter
    //Setter는 Main 함수에서 인스턴스 필드에 접근해서 사용하는 함수
    //Getter도 Main 함수에서 인스턴스 필드에 접근해서 사용하는 함수


    //  getter / setter 구성
    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;
    }

    // 생성자 (매개변수 2개인 생성자)  →  사용자 정의 생성자
    public MyData(String name, int age)
    {
        this.name = name;
        this.age = age;
    }

    // 생성자 (매개변수 없는 생성자) → 사용자 정의 생성자
    public MyData()
    {
        name = "";
        age = 0;
    }


}

public class Test158
{
    public static void main(String[] args)
    {
        // 벡터 자료구조 생성
        Vector<MyData> v = new Vector<MyData>();

        // 벡터 자료구조 v 에
        // 황선우 13세 / 김연경 7세 / 김제덕 50 세
        // 담아내기

        /*
        // 방법① 
        MyData st1 = new MyData();
        st1.setName("황선우");
        st1.setAge(13);
        v.add(st1);

        MyData st2 = new MyDate();
        st2.setName("김연경");
        st2.setAge(7);
        v.add(st2);

        MyData st3 = new MyDate();
        st3.setName("김제덕");
        st3.setAge(50);
        v.add(st3);
        */

        /*
        // 방법②
        // 마이데이터 타입 인스턴스 생성
        MyData st1 = new MyData("황선우",13);
        v.add(st1);
        MyData st2 = new myData("김연경",7);
        v.add(st2);
        MyData st3 = new myData("김제덕",50);
        v.add(st3);
        */

        // 방법③
        v.add(new MyData("황선우",13));
        v.add(new MyData("김연경",7));
        v.add(new MyData("김제덕",50));

        /* 내가 푼 추가하는 법
        v.addElement(new MyData("황선우",13));
        v.addElement(new MyData("김연경", 7));
        v.addElement(new MyData("김제덕", 50));
        System.out.println("벡터의 요소 갯수 : " + length);


        // 벡터 자료구조 v 의 전체 요소 출력
        System.out.print("전체 요소 출력 : ");
        for (MyData str :v )
        {
            System.out.print(str +  " ");
        }
        System.out.println();
        //--==>> 
        */

        // 벡터 자료구조 v 에 담긴 내용(요소) 전체 출력하기
        // 실행 예)
        // 이름 : 황선우, 나이 : 13세
        // 이름 : 김연경, 나이 : 7세
        // 이름 : 김제덕, 나이 : 50세


        // 방법① 
        for (MyData m : v)
        {
            //System.out.println("이름 : " + m.getName() + ", " + "나이 : " + m.getAge() + "세");  //m.name 못하게 막아놔서 m.getName()
            System.out.printf("이름:%s, 나이:%d세\n",m.getName(),m.getAge());
        }
        System.out.println();
        //이름:황선우, 나이:13세
        //이름:김연경, 나이:7세
        //이름:김제덕, 나이:50세

        //예전 Record클래스를 배열에 인스턴스 넣어서 했던것처럼 생각 벡터 하나의 요소마다 각각의 MyData 인스턴스가 들어가 있다고 생각


        // 방법②
        for (int i=0; i<v.size();i++)
        {
            System.out.printf("이름:%s, 나이:%d세\n",v.elementAt(i).getName(),v.elementAt(i).getAge());
        }
        System.out.println();
        //이름:황선우, 나이:13세
        //이름:김연경, 나이:7세
        //이름:김제덕, 나이:50세

        // 방법③
        for (Object temp : v)
        {
            System.out.printf("이름:%s, 나이:%d세\n",((MyData)temp).getName(), ((MyData)temp).getAge());
                                                    //------------ 다운 캐스팅
        }
        System.out.println();
        //이름:황선우, 나이:13세
        //이름:김연경, 나이:7세
        //이름:김제덕, 나이:50세

     }
}

Test152~Test159

◼ 큐(Queue)

적용 예) 이메일 전달 푸쉬 알림 기능 쇼핑몰에서 주문을 처리하는 방식(선착순) 콜센터의 백엔드-전화 온 순서대로 상담을 처리 등

▪ 큐(Queue) 개요

큐(Queue)는 FIFO(First Input First Output, 선입선출) 구조로 먼저 입력된 자료를 먼저 출력하며, Queue 인터페이스를 구현한 클래스는 큐와 관련된 다양한 기능을 제공한다.

※ Queue 인터페이스 인스턴스를 생성하기 위해서는 new 연산자를 이용하여 Queue 인터페이스를 구현한(implements) 클래스의 생성자를 호출한다.

ex) Queue ob = new LinkedList();

++ Queue는 인터페이스 Stack은 클래스!

▪ 큐(Queue) 코드 설명1📝

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

public class Test152
{
    public static void main(String[] args)
    {
        // Queue 자료 구조 생성
        //Queue myQue = new Queue();  //-- (X)큐는 인터페이스라서 이렇게 생성할 수 없다!
        Queue<Object> myQue = new LinkedList<Object>();   //제네릭 표현

        // 데이터 준비
        String str1 = "선풍기";
        String str2 = "에어컨";
        String str3 = "부채";
        String str4 = "그늘";

        //myQue 라는 Queue 자료구조에 데이터 추가
        myQue.offer(str1);
        myQue.offer(str2);
        myQue.offer(str3);
        boolean test = myQue.offer(str4);

        System.out.println(myQue);
        //--==>> [선풍기, 에어컨, 부채, 그늘] 
        //데이터의 컨트롤은 이런 더미로 하면 안된다!
        //더미는 딸기 바나나 포도라고 적혀있는 쪽지 이걸로 직접적인 데이터 컨트롤 할 수 없다.

        System.out.println(test);
        //--==>> true

        // Queue 자료구조에서 요소를 제거하지 않고 head 요소 반환
        System.out.println("값1 : " +(String) myQue.element());
        //                                      -----
                                             //    큐(데이터타입)
                                            //--------------- 
                                            //    오브젝트(데이터타입)
        System.out.println("값2 : " +(String) myQue.element());
        //--==>>값1 : 선풍기
        //        값2 : 선풍기

        System.out.println();

        String val;

        // 방법 ①
        // peek()
        //-- 큐의 head 요소 반환. 제거 안함.
        //   큐가 empty 일 경우 null 반환.
        /*
        while (myQue.peek() != null)           //-- 지영을 확인하고 제거하지 않음.
        {
            //poll()
            //-- 큐의 head 요소 반환. 제거함.
            // 큐가  empty 일 경우 null 반환
            val = (String)myQue.poll();        //-- 지영을 확인하고 출력하면서 제거함.
            System.out.println("요소 : " + val);     
        }
        System.out.println();

        //--==>> 요소 : 선풍기
        //         요소 : 에어컨
        //         요소 : 부채
        //         요소 : 그늘
        // 픽폴하는건데 지금은 폴폴하면 두개당 하나씩나와서 에어컨나오고 그늘 나옴


        //String[] arr = {"홍길동", "이순신", "강감찬"};
        //                ----------------------------
        //                        문자열(데이터타입)
        */


        //테스트
        /*
        while (myQue.poll() != null)
        {
            val = (String)myQue.poll();
            System.out.println("요소 : " + val);  
        }
        System.out.println();
        */
        //--==>> 요소 : 에어컨
        //         요소 : 그늘

        // 방법 ②
        /*
        while (true)  //무한루프
        {
            val = (String)myQue.poll();
            if (val==null)
                break;
            else
             System.out.println("요소 : " + val);
        }
        System.out.println();
        */
        //--==>>요소 : 선풍기
        //        요소 : 에어컨
        //        요소 : 부채
        //        요소 : 그늘

        // 방법 ③
        while (!myQue.isEmpty())
        {
            val = (String)myQue.poll();
            System.out.println("요소 : " +val);
        }
        System.out.println();
        //--==>>요소 : 선풍기
        //        요소 : 에어컨
        //        요소 : 부채
        //        요소 : 그늘

    }
}

▪ 큐(Queue) 코드 설명2📝

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

public class Test153
{
    // 정적 문자열 배열 선언 및 초기화
    private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};


    public static void main(String[] args)
    {
        // Queue 자료구조 생성
        Queue<String> qu = new LinkedList<String>();
        //-- Queue 인터페이스 기반의 인스턴스를 생성하기 위해서는
        //   new 연산자를 이용하여 Queue 인터페이스를 implements 한
        //   하위 클래스의 생성자를 호출해야 한다.

        // qu 라는 Queue 자료구조에
        // color 배열의 데이터 입력 -> offer()
        for (String color : colors)
            qu.offer(color);      //--지정된 요소를 큐에 삽입한다.

        // qu 라는 Queue 자료구조의 모든 데이터 전체 출력
        while (qu.peek() != null)
            System.out.print(qu.poll() + " ");
        System.out.println();
        //-- peek()
        //        : 큐의 head 요소를 반환하고 삭제하지 않으며
        //          큐 자료구조가 비어있는 상태가 되면 null 반환
        //-- poll()
        //        : 큐의 head요소를 반환하고 삭제하며
        //          큐 자료구조가 비어있는 상태가 되면 null 반환

        //--==>> 검정 노랑 초록 파랑 빨강 연두
    }
}

Test140~Test151

◼ 컬렉션 프레임워크(Collection Framework)

자바의 정석 p.578 ★★★★★자바에서 아주 중요한 개념!!!★★★★★

적용 예) 웹브라우저에서 '뒤로가기'기능! Ctrl + z 기능 앱에서 되돌리기 기능

▪ 컬렉션 프레임워크(Collection Framework) 개요

/*
○ 컬렉션 프레임워크(Collection Framework)
    == 컬렉션(Collection) + 프레임워크(Framwork)
       ------------------   --------------------
              |             ★ 환경, 틀, 약속 ★
                  |
        집합 → 수집품, 소장품, (물건 또는 사람들의) 무리, 더미, 수집, 수거
              -----------------------------------------------------------
                    모아놓은 것들...모여있는 것들...


    ==> 컬렉션 프레임 워크는 자바에서 내세울 수 있는 자료 구조

▪ 자료

현실 세계로부터 단순한 관찰이나 측정을 통해 수집된 사실이나 개념의 값들 또는 그 값들의 집합.

가공되지 않은 데이터 / 관찰된 팩트 즉, 사실을 수집해서 모아 놓은 것 ex) 극장에 방문된 사람 인원들 월요일 몇명 화요일 몇명 그냥 카운트

+ 정보

가공된 데이터 / 그 자료를 특정 목적에 맞게 가공해서 판단의 근거로 사용될 수 있도록 의미와 가치를 부여한 것 ex) 주말에 방문한 사람들 통계해서 주말에 사람 많다.

↓

▪ 자료구조

자료 처리를 위한 자료의 표현, 저장, 관계, 관리 및 이용에 관한 방법 등의 개념을 이해하여 프로그램에 사용하고 컴퓨터에 의해 처리되는 과정에서 적절한 자료의 표현, 구성, 저장 및 처리를 위한 알고리즘의 작성 및 선택과 이용 방법을 연구하는 분야

↓

▪ 컬렉션 프레임워크(Collection Framwork)

컬렉션(모아놓은 데이터들)의 표현과 조작을 위한 통일된 아키텍처로 컬렉션 프레임워크를 구성하는 요소는 다음과 같다.

1. 인터페이스(Interface) 기본적으로 컬렉션에 필요한 데이터 관리 기능을 제공한다. 예를 들어, list 는 추가, 삭제, 검색 등의 기능을 제공하는 컬렉션 인터페이스가 존재하며 각 컬렉션마다 고유의 인터페이스가 정의되어 있다.

2. 구현(Implementation) 인터페이스를 구현한 클래스로 각 컬렉션을 실제 어떤 자료구조를 이용하여 표현했느냐에 따라 컬렉션의 종류가 달라지게 된다.

3. 알고리즘(Algorithms) 각 컬렉션들마다 유용하게 사용할 수 있는 메소드를 의미한다.

※ 자바 컬렉션은 견고한 컬렉션 프레임워크 기반 위에 정의되어 있으므로 각 컬렉션 종류마다 제공되는 메소드의 일관성이 있기 때문에 한 가지 컬렉션을 익혀두면 다른 컬렉션을 사용하는데 용이하다.

List 인터페이스 Set 인터페이스 Map 인터페이스

◼ 스택(Stack)

운영체제에서 메모리관리는 다 스택으로 함 가장 먼저 들어간게 나중에 나옴! 나중에 들어간게 먼저 나온다.

Stack 클래스는 오브젝트 후입선출(LIFO, Last Input First Output) 구조의 Stack을 나타낸다. 이는 벡터(Vector)를 스택으로 처리하는 5개의 메소드로 벡터(Vector) 클래스를 확장하게 된다.

통상의 push() 메소드와 pop() 메소드가 제공되는 것 외에 스택의 선두 항목으로 peek() 을 실시하는 메소드, 스택이 비어있는지의 여부를 확인하는 메소드 isEmpty(), 스택에서 항목을 찾아서 선두로부터 몇 번째인지를 찾아내는 메소드 등이 제공된다.

스택이 처음으로 작성되었을 때, 항목은 존재하지 않는다.

• boolean empty() 스택이 비어있는지 확인한다.
• E Object peek() 스택의 맨 위의 객체를 스택에서 제거하지 않고 반환한다.
• ** E Object pop()** 스택의 맨 위의 객체를 반환하고 스택에서 제거한다.
• E Object push(E item) 객체를 스택 자료구조에 저장한다.
• int search(Object o) 스택의 맨 위에서부터 파라미터 값으로 넘겨받은 객체까지의 거리를 반환한다. 맨 위의 객체의 경우 1을 반환하고 그 아래 객체는 2를 반화하는 형식.

제네릭, 제네릭표현식

<E> (->엘리먼트) <K, V> (->웹자료형) 

▪ 스택(Stack) 코드 설명- add()/.isEmpty()/pop()📝

import java.util.Stack;

public class Test150
{
    public static void main(String[] args)
    {
        //Stack 자료구조 생성
        //Stack<String> myStack = new Stack<String>();   //String이면 132번에 형변환 안해줘도댐
        Stack<Object> myStack = new Stack<Object>();

        String str1 = "바나나";
        String str2 = "딸기";
        String str3 = "복숭아";
        String str4 = "수박";

        // myStack 이라는 Stack 자료구조 안에 str1 ~ str4 까지 담아내기
        // add(), push()
        myStack.add(str1);
        myStack.add(str2);
        myStack.add(str3);
        myStack.add(str4);

        // peek() : 스택 맨 위의 객체 반환.(뭐 다 라고 알려주고) 제거하지 ㅇ낳는다.
        String val1 = (String)myStack.peek();      //-- 형 변환 check~!!!     
                                                   //myStack은 Object형식인데 String 에 담겠다 -> 업캐스팅이 일어남!
        System.out.println("val1 : " + val1);
        //--==>> val1 : 수박

        String val2 = (String)myStack.peek();
        System.out.println("val2 : " + val2);
        //--==>> val2 : 수박

        String val3 = (String)myStack.peek();
        System.out.println("val3 : " + val3);
        //--==>> val2 : 수박

        // peek() 는 제거하지 않으니까 계속 같은값만 반환!


        String value = "";
        // myStack 이라는 이름을 가진 Stack 자료구조에
        // 데이터가 비어있는 상황이 아니라면...(즉, 값이 들어있는 상태라면...)
        //  is Empty()
        // Stack 안에 있는 값 모두 반환!

        // 바나나
        // 딸기
        // 복숭아
        // 수박
        while (!myStack.isEmpty())     // !false → true
        {
            // pop() : 스택 맨 위의 객체 반환. 제거한다.
            value = (String)myStack.pop();      // 바나나(데려오고 제거) 딸기 복숭아 수박(여기까지오면 다 제거됨) ->isEmpty
            System.out.println("value: " + value);
        }
        //--==>> value: 수박
        //         value: 복숭아
        //         value: 딸기
        //         value: 바나나

    }
}

▪ 스택(Stack) 코드 설명- push()/.Empty()/pop()📝

import java.util.Stack;

public class Test151
{
    // 정적 문자열 배열 선언 및 초기화
    private static final String[] colors = {"검정", "노랑", "초록", "파랑", "빨강", "연두"};

    //사용자 정의 생성자
        public Test151()
        {
            // st라는 Stack 자료구조 생성
            // 제네릭을 활용하여 자료구조에 담기는 데이터 표현 → <String>
            Stack<String> st = new Stack<String>();

            // st 라는 Stack 자료구조에 데이터 담기
            //st = colors;  (X)

            for(String color : colors)
            {
                st.push(color);
            }

            st.push("보라");

            //st.push(10);  //->넣는걸 String이라고 정해놔서 못넣는다
            //st.push(10.0); 
            //--==>> 에러 발생(컴파일 에러)
            //-- 제네릭 표현식을 통해 선언하고 있는
            //   String 이 아닌 다른 자료형(int 나 double) 을
            //     스택에 push()하려고 했기 때문...




            // 출력 메소드 호출
            popStack(st);
        }

        //출력 메소드
        private void popStack(Stack<String> st)
        {
            System.out.print("pop : ");
            while (!st.empty())  //add 랑 push랑 같은거처럼 empty랑 isempty 같음!
                System.out.print(st.pop() + " ");
            System.out.println();
        }


    public static void main(String[] args)
    { 
        new Test151();
    }
}

/*
pop : 보라 연두 빨강 파랑 초록 노랑 검정
계속하려면 아무 키나 누르십시오 . . .

*/

Test140~Test151

◼ 예외(Exception) 처리

//자바의 정석 p.414 //어려워도 당황하지마! 원래그래

▪ 프로그램에서 발생하는 오류는

① 잘못된 문법을 사용하거나 변수 등을 정의하지 않은 상태에서 사용함으로써 컴파일 단계에서 발생하는 문법적인 오류

② 프로그램을 실행하는 과정에서 발생되는 런타임 오류 로 나눌 수 있다.

• 개발자가 문제 분석을 잘못하거나 실수에 의해 엉뚱한 결과를 가져오게 되는 논리적인 오류와

• 시스템 이상에서 발생되는 시스템 오류, 그리고

• 프로그램 실행 중 발생되는 비정상적인 상황을 의미하는 예외사항(Exception)이 있다.

예를 들어, → 어떤 수를 0으로 나누거나... → 배열 첨자를 벗어나는 상황이 발생하거나... → 존재하지 않은 파일을 오픈하여 읽어들인다거나...

==> 개발자가 이런 예외 사항이 발생할 경우를 미리 예측하여 적절히 대응하기 위한 절차를 구현하도록 문법을 정리해 놓은 것. 예.외.처.리.

※ 정리해 놓은 문법~!!!(→ Exception 클래스)

• 예외는 프로그램 실행 중에 발생할 수 있는 명령어의 정상적인 흐름을 방해하는 이벤트로 자바에서 예외는 하나의 오브젝트(Object, 객체)이다.

• 프로그램 실행 중에 메소드 안에서 오류가 발생하게 될 경우, 메소드는 그 오류에 해당하는 예외 오브젝트를 만들고 그것을 자바 런타임 시스템(Runtime System)에 전달해 준다.

• 자바에서의 모든 예외는 Throwable 클래스나 Throwable 클래스의 하위 클래스를 상속받아 사용한다.

• Throwable 클래스는 예외를 설명하는 문장이나 예외가 발생할 때의 프로그램의 상태에 관한 정보를 포함하고 있다.

• Throwable 클래스에서 파생된 클래스

▪ Exception 클래스 Exception 예외 클래스는 일반적으로 프로그래머에 의해 복원될 수 있는 예외 상황으로 메소드가 실행 중에 던지는 예외를 가리킨다.

▪ Error 클래스 심각한 예외의 형태로 개발자가 복원할 수 없는 형태의 예외이다.

▪ 예외의 종류

• checked exception 메소드 내에서 예외가 발생한 경우 메소드를 정의할 때 『throws』문에 메소드 내에서 발생할 수 있는 예외들을 명시해주거나 또는 그 예외를 『trycatch』해서 처리해주어야만 하는 예외이다. 컴파일러가 컴파일 하는 과정에서 『checked exception』이 『throws』 되는가의 여부 혹은 『trycatch』되는지의 여부를 판단하여 프로그램에서 예외를 어떤 방식으로 처리하지 않으면 컴파일 자체가 불가능하다.

• unchecked excepion 사전에 처리하지 않아도 컴파일러가 체크하지 않은 런타임 시에 발생할 수 있는 예외이다.

▪ java.lang.Trowable 클래스의 주요 메소드

• String toString() : Throwable 각각에 대한 설명을 문자열 형태로 반환한다.

• void printStackTrace(printStream s)

• void printStackTrace(printWriter w) : 표준 출력 스트림에 스택 호출 목록을 마지막 메소드부터 출력한다.

• .getMessage() = 에러 이벤트와 함께 들어오는 메세지를 출력한다.

• .toString() = 에러 이벤트의 toString()을 호출해서 간단한 에러 메시지를 확인한다.

• .printStackTrace() = 에러 메세지의 발생 근원지를 찾아서 단계별로 에러를 출력한다.

▪ 주요 런타임 예외 클래스

• ArithmeticExcepion : 수치 계산상의 오류
• ArrayStoreException : 배열에 잘못된 데이터 형을 저장하려 했을 경우 발생하는 오류
• IndexOutOfBoundsException : 배열, 문자열, 벡터 등에서 인덱스 범위가 벗어난 경우 발생하는 오류
• ClassCastException : 클래스 변환을 잘못한 경우 발생하는 오류
• NullPointerException : 빈 객체를 참조하는 경우(초기화 되지 않은 변수 사용 등)

   발생하는 오류

• SecurityException : 자바의 내부 보안 사항을 위반하였을 경우 발생하는 오류

▪ 예외(Exception) 처리 코드 설명📝

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test143_1
{                                        //---------[예외 처리하는 방법 ①]: throws IOException로 던지기
    public static void main(String[] args) throws IOException
    {
        //BufferdReader 인스턴스 생성
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 주요 변수 선언
        int a, b, c;


        //-----------------[예외 처리하는 방법 ②] : try-catch 구문에 문제될 부분 넣기
        /*
        try
        {
            System.out.print("첫 번째 정수 입력 : ");
            a = Integer.parseInt(br.readLine());
            System.out.print("두 번째 정수 입력 : ");
            b = Integer.parseInt(br.readLine());
            //error: unreported exception IOException; must be caught or declared to be thrown 
            //                  ---------------------

            c = a + b;

            System.out.println("결과 : " + c);


        }
        catch (IOException e)  //IOException을 이름붙여서(e)
        {
            // IOExcepiton → checked exception
            //-- 메소드를 정의하는 과정에서 throws 한 예외
            // 잡아내거나 던지지 않을 경우 컴파일 에러 발생.
            System.out.println(e.toString());   //별도로 처리하겠다! 여기선 toString 함
        }
        */


        //----------------- [예외 처리하는 방법 ③] : 숫자형태 이외에 값 입력
        /*
        try
        {
            System.out.print("첫 번째 정수 입력 : ");
            a = Integer.parseInt(br.readLine());
            System.out.print("두 번째 정수 입력 : ");
            b = Integer.parseInt(br.readLine());

            c = a + b;

            System.out.println("결과 : " + c);


        }
        catch (IOException e1)  //IOException을 이름붙여서(e)
        {
            // IOExcepiton → checked exception
            //-- 메소드를 정의하는 과정에서 throws 한 예외
            // 잡아내거나 던지지 않을 경우 컴파일 에러 발생.
            System.out.println(e1.toString());   //별도로 처리하겠다! 여기선 toString 함
        }
        catch(NumberFormatException e2)
        {
            System.out.println(e2.toString());
            System.out.println("숫자 형태의 데이터를 입력해야 합니다~!!!");
        }

        // catch 되서 처리되고 있음!
        //첫 번째 정수 입력 : abc
        //java.lang.NumberFormatException: For input string: "abc"
        //숫자 형태의 데이터를 입력해야 합니다~!!!
        //계속하려면 아무 키나 누르십시오 . . .
        */

        //----------------- [예외 처리하는 방법 ④] : catch 안에 한번에 처리 e.printStackTrace()사용
        /*
        try
        {
            System.out.print("첫 번째 정수 입력 : ");
            a = Integer.parseInt(br.readLine());
            System.out.print("두 번째 정수 입력 : ");
            b = Integer.parseInt(br.readLine());
            //error: unreported exception IOException; must be caught or declared to be thrown 
            //                  ---------------------

            c = a + b;

            System.out.println("결과 : " + c);


        }
        catch (IOException e)  //IOException을 이름붙여서(e)
        {
            System.out.println(e.toString());   //별도로 처리하겠다! 여기선 toString 함
            System.out.println(e.getMessage());

            System.out.println("pringStackTrace...");
            e.printStackTrace();
        }
        */

        //----------------- [예외 처리하는 방법 etc...]s : finally사용
        try
        {
            System.out.print("첫 번째 정수 입력 : ");
            a = Integer.parseInt(br.readLine());
            System.out.print("두 번째 정수 입력 : ");
            b = Integer.parseInt(br.readLine());
            //error: unreported exception IOException; must be caught or declared to be thrown 
            //                  ---------------------

            c = a + b;

            System.out.println("결과 : " + c);


        }
        catch (IOException e)  //IOException을 이름붙여서(e)
        {
            // IOExcepiton → checked exception
            //-- 메소드를 정의하는 과정에서 throws 한 예외
            // 잡아내거나 던지지 않을 경우 컴파일 에러 발생.
            System.out.println(e.toString());   //별도로 처리하겠다! 여기선 toString 함
        }

        finally  //check~!!!
        {
            // 예외가 발생하거나 발생하지 않거나...
            // 언제나 실행되는 영역~!!!

            System.out.println("고생 많으셨습니다. 점심 맛있게 먹읍시다.");
        }



    }
}

▪ 이름 입력[종료:Ctrl+z] 예외(Exception) 처리 코드 설명📝

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;


public class Test144 
{

    private String[] date = new String[3];


    public void proc() throws IOException  //-- readLine() 때문에 throws 입력!
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String str;
        int n = 0;

        System.out.print("이름 입력(종류:ctrl+z) : ");


        //   원래는 오른쪽부터인데 괄호로 묶은것 먼저
        while ((str = br.readLine()) != null)         //-- readLine() 때문에 throws 안해주면 에러 발생!
        {                         //-------- == ctrl+z 
            date[n++] = str;
            System.out.print("이름 입력(종류:ctrl+z) : ");
        }

        System.out.println("입력된 내용...");
        for(String s : date)
        {
            if(s != null)
            {
                System.out.println(s);
            }
        }
    }

    public static void main(String[] args) throws IOException
    {
        Test144 ob = new Test144();
        ob.proc();
    }
}


// 배열이 3갠데 4개 넣으려고하니까 에러발생 -> 이건 unchecked excepion

▪ 이름 입력[종료:Ctrl+z] try-catch 예외 처리 사용 코드 설명📝

//Test144같은데 try-catch사용 -> 내부적으로 예외를 잡아버려서 throws IOException을 메인에 안해도 됨!!

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;


public class Test145
{

    private String[] date = new String[3];


    public void proc() //throws IOException  //-- readLine() 때문에 throws 입력!
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String str;
        int n = 0;

        try
        {
            System.out.print("이름 입력(종류:ctrl+z) : ");


            //   원래는 오른쪽부터인데 괄호로 묶은것 먼저
            while ((str = br.readLine()) != null)         //-- readLine() 때문에 throws 안해주면 에러 발생!
            {                         //-------- == ctrl+z 
                date[n++] = str;
                System.out.print("이름 입력(종류:ctrl+z) : ");
            }

            System.out.println("입력된 내용...");
            for(String s : date)
            {
                if(s != null)
                {
                    System.out.println(s);
                }
            }
        }
        catch (IOException e)
        {
            System.out.println(e.toString());
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            System.out.println("예외 발생~!!!");
            System.out.println("getMessage : " + e.getMessage());
            System.out.println("toString   : " + e.toString());
            System.out.println("printStackTrace...........");
            System.out.println();

            //이름 입력(종류:ctrl+z) : 정효진
            //이름 입력(종류:ctrl+z) : 김효진
            //이름 입력(종류:ctrl+z) : 박효짐
            //이름 입력(종류:ctrl+z) : 마효진
            //예외 발생~!!!
            //getMessage : 3
            //toString   : java.lang.ArrayIndexOutOfBoundsException: 3
            //printStackTrace...........

            //계속하려면 아무 키나 누르십시오 . . .
        }


    }

    public static void main(String[] args) //throws IOException
    {
        Test145 ob = new Test145();
        ob.proc();
    }
}

▪ Test147 / Test148 파일과 비교📝

Test147

class Demo
{
    private int value; //기본적으로 0으로 초기화 되니까 -3 넣어도 0나옴

    public void setValue(int value)
    {
        if(value<=0)

            return;    //-- 종료 → 메소드 종료

        this.value = value;
    }



    public int getValue()
    {
        return value;
    }
}

public class Test146
{
    public static void main(String[] args)
    {
        Demo ob = new Demo();
        ob.setValue(-3);
        int result = ob.getValue();
        System.out.println(result);
    }
}

Test148

class Demo2
{
    private int value;

    public void setValue(int value) throws Exception   //check~!!!   Exception 은 lang패키지에 있어서 import생략 가능한~!
    {
        if(value<=0)
        {
            // 예외 생성(발생) - 폭발물 제작을 여기서 한 것!
            throw new Exception("value 는 0보다 작거나 같을 수 없습니다.");
            // throw 예외를 발생시킬때 사용하는 키워드!!   ==> 이렇게 실행하면 에러! throws Exception 작성해줘야함!!
        }

        this.value = value;
    }

    public int getValue()
    {
        return value;
    }
}

public class Test147
{
    public static void main(String[] args) //throws Exception   //check~!!!  이렇게 해주던지 아니면 try-catch로 잡아내!
    {
        Demo2 ob = new Demo2();

        try
        {
            ob.setValue(-3);
            int result = ob.getValue();
            System.out.println(result);
        }
        catch (Exception e)  // checked Exception
        {
            System.out.println(e.toString());
        }

    }
}
/*
java.lang.Exception: value 는 0보다 작거나 같을 수 없습니다.
계속하려면 아무 키나 누르십시오 . . .
*/

▪ 예외 다시 던지기 코드📝

public class Test148
{
    public static void main(String[] args)
    {
        Test148 ob = new Test148();

        try
        {
            int a = ob.getValue(-2);     // ⑥ 예외 발생
            System.out.println("a : " + a);
        }
        catch (Exception e)              // ⑦ 예외 잡아내기
        {
            System.out.println("ⓑ printStackTrace.......");
            e.printStackTrace();
        }

    }

    public int getData(int data) throws Exception
    {
        if (data<0)
            throw new Exception("date 가 0보다 작습니다.");
            // ① 예외 발생  --> 그래서 던지기로 함(throws Exception) -> 이러면 getValue 로 떨어짐

        return data + 10;
    }

    public int getValue(int value) throws Exception
    {
        int a = 0;

        try
        {
            a = getData(-2);  // ② 예외발생 -> 그래서 예외를 catch로 잡음 근데 왜?? throws Exception을 썼나?
        }
        catch (Exception e)   // ③ 예외 잡아내기
        {
            // ④ 잡아낸 예외에 대한 처리
            System.out.println("ⓐ printStackTrace............");
            e.printStackTrace();

            // ⑤ 잡아낸 예외를 다시 던지기
            throw e;  //이거 주석하면 throws Exception 없어도됨
            //-- 주석 처리 시(즉, 잡아낸 예외를 다시 던지지 않을 경우)
            //   main() 메소드의 예외 처리 구문은 수행되지 않게 된다.
        }

        return a;
    }
}

/*
ⓐ printStackTrace............
java.lang.Exception: date 가 0보다 작습니다.
        at Test148.getData(Test148.java:29)
        at Test148.getValue(Test148.java:41)
        at Test148.main(Test148.java:15)
ⓑ printStackTrace.......
java.lang.Exception: date 가 0보다 작습니다.
        at Test148.getData(Test148.java:29)
        at Test148.getValue(Test148.java:41)
        at Test148.main(Test148.java:15)
계속하려면 아무 키나 누르십시오 . . .

*/

▪ 다른 예외 다시 던지는 예외처리 코드(빨간폭발물/파란폭발물)📝

public class Test149
{
    public int getValue(int value)  throws Exception            // ⑦ 예외 던지기(파란 폭발물)
    {
        int a = 0;

        try
        {
            a = getData(-2);                                    //③ 예외 발생    
        }                                                        //   빨간 폭발물
        catch (Exception e)                                        //④ 예외 잡아내기
        {                                                        //   빨간 폭발물
            // ⑤ 예외 처리(빨간 폭발물)
            System.out.println("printStackTrace..............");
            e.printStackTrace();

            // ⑥예외 생성
            throw new Exception("value 가 음수입니다.");        
            // 아까는 같은 e던지는 거였는데 지금은 새로운 예외 발생!
            // (파란 폭발물)
        }

        return a;
    }

    public int getData(int data) throws Exception                //② 예외 던지기
    {                                                             //   빨간 폭발물
        if(data<0)
            throw new Exception("date 가 0 보다 작습니다.");     //① 예외 발생
                                                                 //   빨간 폭발물
        return data + 10;
    }

    public static void main(String[] args)      // ⑨
    {
        Test149 ob = new Test149();

        try
        {
            int a = ob.getValue(-1);                                //⑧ 예외 발생 //파란 폭발물
            System.out.println("a: " + a);
        }
        catch (Exception e)                                             // ⑨ 예외 잡아내기  //파란 폭발물
        {
            // ⑩ 예외 처리(파란 폭발물)
            System.out.println("printStackTrace..............");
            e.printStackTrace();
        }

    }
}