public class DBUtil {

    private static Connection conn;

    /**
     * 데이터 베이스 연결 메소드입니다.
     * @return 연결된 Connection 객체를 반환합니다.
     */
    public static Connection open() {
        String url="jdbc:oracle:thin:@localhost:1521:xe";
        String id="hr";
        String pw="*******";

        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");
            conn = DriverManager.getConnection(url, id, pw);
            return conn; // 성공하면 접속된 Connection 반환
        } catch (Exception e) {
            System.out.println("DBUtil.open()");
            e.printStackTrace();
        }

        return null; // 실패하면 null 반환
    }

    /**
     * 데이터 베이스 연결 메소드입니다.
     * @param server 접속할 서버 주소입니다.
     * @param id 접속할 계정명입니다.
     * @param pw 접속할 비밀번호입니다.
     * @return 연결된 Connection 객체를 반환합니다.
     */
    public static Connection open(String server, String id, String pw) {
        String url="jdbc:oracle:thin:@"+server+":1521:xe";

        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");
            conn = DriverManager.getConnection(url, id, pw);
            return conn; // 성공하면 접속된 Connection 반환
        } catch (Exception e) {
            System.out.println("DBUtil.open()");
            e.printStackTrace();
        }

        return null; // 실패하면 null 반환
    }

}

Statement 클래스

• SQL 구문을 실행해주는 역할(대리자)
• 모든 SQL을 실행할 수 있다.

  Statement 클래스 종류

  1. Statement
• 기본 클래스

  stat=conn.createStatement();
  // statement는 쿼리를 날릴 수 있는 기능만 가지고 있고,
  // 어떤 서버에 어떤 계정으로 연결해서 실행할지는 모른다.
  // 그래서 connection에다가 붙여서 실행.
  // stat -(의존)-> connection
  

// *** SQL 종류 -> 반환값 O, X 미리 구분해야 함! // 반환값이 있느냐 없느냐에 따라 메서드가 달라지기 때문 // 1. 반환값 없는 쿼리 실행 // stat.executeUpdate(sql)

// 2. 반환값 있는 쿼리 실행 // stat.executeQuery(sql)

int result=stat.executeUpdate(sql); // SQL Developer에서 Ctrl + Enter한 것과 동일 // executeUpdate의 반환값 int(result값)는 적용된 행의 숫자를 돌려준 것. 결과셋 X

if (result==1) { System.out.println("등록 성공"); }else { System.out.println("등록 실패"); }

// 열었던 순서의 반대로 닫기 // 자원 해제 필수(**) stat.close(); conn.close();

```java
private static void m9() {

    Connection conn = null;
    Statement stat = null;
    ResultSet rs = null;

    try {
        conn = DBUtil.open();
        stat = conn.createStatement();

        // 요구사항) 영업부 직원수와 영업부 직원 명단을 출력하시오.
        // 1. select count(*) as cnt from tblInsa where buseo='영업부';
        // 2. select * from tblInsa where buseo='영업부';

        String sql = "select count(*) as cnt from tblInsa where buseo='영업부'";
        rs = stat.executeQuery(sql);

        if (rs.next()) {
            System.out.println("영업부 직원수 : "+rs.getString("cnt"));
        }
        rs.close();

        sql = "select * from tblInsa where buseo='영업부'";
        rs = stat.executeQuery(sql);

        // 커서 탐색 방식 -> 자신이 탐색해야 하는 레코드의 개수를 알 수 없다.
        // -> 한칸씩 접근을 해야지만 레코드가 존재하는지 인식

        int n=0;
        // count 구하려고 쿼리날리는 방법도 있지만 이렇게 누적변수로 구하는 방법도 있음.
        // 하지만 별로 추천하고 싶지는 않다고 하셨음.
        /*
        while (rs.next()) {
            System.out.println(rs.getString("name"));
            n++;
        }

        System.out.println(n);
        */
        rs.close();
        stat.close();
        conn.close();

    } catch (Exception e) {
        System.out.println("Ex05_select.m9()");
        e.printStackTrace();
    }
}

2. PreparedStatement

   • Statement 개량 클래스 -> 매개 변수 처리에 특화

   • 안정성 높음 + 가독성 높음

   • 코드량 많음

     public static void main(String[] args) {
     // Ex06_PreparedStatement.java
     
     // 1. Statement
     // - 매개변수가 없는 SQL -> 정적 쿼리
     
     // 2. Prepared Statement
     // - 매개변수가 있는 SQL -> 동적 쿼리
     
     // 3. CallableStatement
     
     // PreparedStatement
     // - 매개변수가 있는 SQL 실행 용도
     
     // insert + 사용자 입력
     
     String name="하하하";
     String age="20";
     String gender="m";
     String tel="010-1111-2222";
     String address="서울시 동대문구 이문'동"; // '를 넣고 싶으면 '' 이렇게 두 번 적어야 함.
     address = address.replace("'", "''");
     
     Connection conn = null;
     Statement stat = null;
        PreparedStatement pstat = null;
     ResultSet rs = null;
     
     try {
        conn = DBUtil.open();
     
     

    // 1. Statement 사용
    // - SQL을 문자열 취급 + 매개변수 문자열 취급
    // - String.format()을 사용


    String sql = String.format("insert into tblAddress (seq, name, age, gender, tel, address, regdate) values (seqAddress.nextVal, '%s', %s, '%s', '%s', '%s', default)", name, age, gender, tel, address);
    stat = conn.createStatement();
    System.out.println(stat.executeUpdate(sql));

    // 2. PreparedStatement 사용
    // - ? : 오라클 매개변수
    // - String.format() 불필요
    // - 매개변수를 손쉽게 전달 가능
    // - 매개변수 값으로 부적절한 값이 있어도 자동으로 이스케이프를 시켜준다.(***)
    sql = "insert into tblAddress (seq, name, age, gender, tel, address, regdate) values (seqAddress.nextVal, ?, ?, ?, ?, ?, default)";
    pstat=conn.prepareStatement(sql);

    pstat.setString(1, name); // 매개변수에 값 전달
    pstat.setString(2, age); // 2번째 물음표에 age를 넣어주세요.
    pstat.setString(3, gender);
    pstat.setString(4, tel);
    pstat.setString(5, address);

    System.out.println(pstat.executeUpdate());

    stat.close();
    conn.close();
} catch (Exception e) {
    System.out.println("Ex06_PreparedStatement.main()");
    e.printStackTrace();
}

}

3. CallableStatement
 - Statement 개량 클래스 -> **프로시저 호출**
 - 프로시저 전용
 - PreparedStatement와 유사
```java
private static void m5() {
    Connection conn = null;
    CallableStatement stat = null;
    ResultSet rs = null;

    try {
        conn = DBUtil.open();

        String sql = "{ call procM5(?, ?) }";
        stat=conn.prepareCall(sql);
        stat.setString(1,  "개발부");
        stat.registerOutParameter(2, OracleTypes.CURSOR);
        stat.executeQuery();

        // Oracle(cursor) -> JDBC(ResultSet)
        rs=(ResultSet)stat.getObject(2);

        while(rs.next()) {
            System.out.println(rs.getString("name"));
            System.out.println(rs.getString("jikwi"));
            System.out.println(rs.getString("city"));
            System.out.println();
        }

        rs.close();
        stat.close();
        conn.close();
    } catch (Exception e) {
        System.out.println("Ex07_CallableStatement.m5()");
        e.printStackTrace();
    }
}

제일 처음 수업을 들을 때 왜 그랬는지 모르겠는데 난 homebrew를 통해서 OpenJDK를 설치했었다. 그렇게 수업 잘 듣고 있었는데... 문제는 데이터베이스과목으로 넘어가면서 시작. 오라클 설치도 문제없었고, 오히려 자바 때처럼 다른 사람들보다 설치를 먼저 끝내서 기다리고 있었는데 sql Developer를 실행하면 자꾸 아래와 같은 오류가 뜨는 것이었다.

problem initializing the javafx runtime openjdk

원래는 접속하면 아래처럼 시작페이지가 보여야 정상인데, 저렇게 오류만 뜨고 시작페이지는 안 뜨니... 찾아보니 문제는 OpenJDK 설치였다. 오라클 홈페이지에서 JDK1.8을 설치했다면 정상적으로 나왔을텐데 OpenJDK를 이용하고 있기 때문에 JavaFX가 지원되지 않아서 생기는 문제였다. 이 문제가 사소한 문제일 수도 있지만 나중에 JDBC로 이클립스와 오라클을 연결할 때 문제가 생기면 곤란하므로 OpenJDK를 삭제하고 오라클 홈페이지에서 JDK1.8을 설치했다. 이제는 잘 됨!

관계형 데이터베이스 관리 시스템 종류

1. Oracle
   • Oracle
   • 기업용
2. MS-SQL
   • Microsoft
   • 기업용
3. MySQL
   • Oracle
   • 개인용 + 기업용
4. MariaDB
   • MySQL 기반
   • 무료
   • 개인용 + 기업용
5. PostgreSQL
   • 무료
   • 개인용 + 기업용
6. DB2
   • IBM
   • 메인프레임
7. Access
   • Microsoft
   • 개인용 + 소규모
8. 티베로(DBMS) -> Oracle
   • 티맥스(TMax)
   • 제우스(웹서버) -> Apache Tomcat

클라이언트 툴

1. SQL Developer
   • 무료
   • Oracle
2. Toad(*****)
3. SQLGate
4. DataGrip(JetBrain) - 대학교 이메일 등록(id@*.ac.kr)
5. SQL*Plus
   • 오라클 설치 시 같이 설치되는 클라이언트 프로그램
   • CLI

오라클 버전

• Oracle 1.0 : 1977년
• Oracle 9i : internet
• Oracle 10g : Grid
• Oracle 11g : Grid (*)
• Oracle 12c : Cloud
• Oracle 18c : Cloud (*)
• Oracle 19c : Cloud

오라클 에디션

1. Oracle Enterprise Edition
   • 상용
   • CPU 무제한
   • Unit -> 5천만원 등...
2. Oracle Standard Edition
   • 상용
   • CPU 최대 4개 지원
3. Oracle Standard Edition One
   • 상용
   • CPU 최대 2개 지원
4. Oracle Personal Edition
   • 상용
5. Oracle Express Edition
   • 무료
   • 개발용, 상용 등..
   • CPU 1개
   • 데이터베이스 크기 11GB 까지
   • 메모리 점유율 최대 1GB 까지(***)
   • 소규모 회사, 학습용
   • 개발자 입장에서 상용버전과 별 차이 없음

서비스 동작 유무 확인

• OracleServiceXE(실행 중)
  • 데이터베이스
• OracleXETNSListener(실행 중)
  • 오라클과 클라이언트 프로그램을 연결해 주는 서비스

127.0.0.1 : Ping Address(예약 주소). 본인 컴퓨터를 가르키는 IP

관계형 데이터베이스

• 데이터를 표형태로 저장/관리한다.
• 데이터끼리의 관계를 표시한다.

1. 데이터

   • 단편적인 정보

2. 테이블

   • 데이터의 입출력을 위한 데이터 구조
   • 표

3. 스키마(Scheme)

   • 테이블, 뷰 등이 저장된 데이터의 집합 저장소
   • 오라클(사용자 계정)
   • 사용자 계정을 새로 만들면, 오라클은 사용자가 취급할 자원들이 저장될 공간을 할당한다.(=스키마)

4. 데이터베이스

   • 여러개의 스키마의 집합 저장소
   • Oracle XE는 1개의 데이터베이스만 생성 가능

5. 열, Column

   • 컬럼, 필드(Filed), 속성(Attribute), 특성(Property)
   • 테이블의 열로 구성된다.(=구조)

6. 행, Row

   • 행, 로우, 레코드(Record), 튜플(Tuple)
   • 테이블에 저장된 데이터 1건
   • 객체(Object)

클라이언트 툴 > 서버 접속

1. 접속명
   • 자유롭게..
   • 서버주소.계정명
2. 사용자 이름
   • 접속할 계정명(아이디)
   • 관리자 계정: sys, system, 우리가 만들 계정들..
   • 사용자 계정: scott(tiger), hr(human resources), 우리가 만들 계정들..
3. 비밀번호
   • 주기적으로 변경
4. 호스트 이름
   • 오라클 서버 IP주소 or 도메인명
   • localhost(127.0.0.1) or 팀 서버 IP(211.63.89.31)
5. 포트번호
   • 1521
   • 네트워크 프로그램이 외부와의 데이터 입출력을 위해서 사용하는 통로 번호
   • 65535
   • 독점
6. SID
   • Service ID
   • 오라클 서버 프로그램의 식별자
   • xe
   • orcl

SQL, Structured Query Language

• 구조화된 질의 언어
• 사용자(클라이언트 툴)가 관계형 데이터베이스와 대화할 때 사용하는 언어
• 자바에 비해 자연어에 가깝다.

1. DBMS 제작사와 독립적이다.

   • SQL은 모든 DBMS 제작사와 독립적으로 개발된다.

2. 표준 SQL(ANSI SQL)

   • 표준 SQL 발표 -> 각 DBMS 제작사에서 자기 제품에 적용
   • SQL은 모든 DBMS에 호환된다.
   • SQL-86... SQ-92... SQL2011

3. 대화식 언어이다.

   • 질문 > 답변 > 질문 > 답변 ... 반복

     ANSI SQL

   • 표준 SQL

     PL/SQL

   • 자체 SQL
   • 오라클에서만 적용되는 명령어

ANSI SQL 종류

1. DDL

   • Data Definition Language
   • 데이터 정의어
   • 테이블, 뷰, 사용자, 인덱스 등의 객체를 생성/수정/삭제하는 명령어 a. create : 생성 b. drop : 삭제 c. alter : 수정
   • 데이터베이스 관리자
   • 데이터베이스 담당자
   • 프로그래머(일부)

2. DML(****)

   • Data Manipulation Lanugage
   • 데이터 조작어
   • 데이터베이스의 데이터를 추가/수정/삭제/조회하는 명령어
   • 가장 많이 사용 > CURD(Create, Update, Read, Delete)
   1. select : 읽기
   2. insert : 추가
   3. update : 수정
   4. delete : 삭제
   • 데이터베이스 관리자
   • 데이터베이스 담당자
   • 프로그래머(****)

3. DCL

   • Data Control Language
   • 데이터 제어어
   • 계정, 보안, 트랜잭션 등을 제어
   1. commit
   2. rollback
   3. grant
   4. revoke
   • 데이터베이스 관리자
   • 데이터베이스 담당자
   • 프로그래머(일부)

4. DQL

   • Data Query Language
   • 데이터 질의어
   • DML 중에 select만을 이렇게 부른다.

5. TCL

   • Transaction Control Language
   • DCL 중에 commit, rollback만을 이렇게 부른다.

오라클 기본 인코딩

• ~ 8i : EUR-KR
• 9i ~ : UTF-8

관습화 패턴 -> 프로젝트 내 결정

• 1. 키워드 대문자
• 2. 식별자 소문자

사용자 식별자 생성 시 주의점! 최대 30바이트 이하!

ANSI-SQL 자료형

• 오라클 자료형
• 데이터베이스에서 취급하는 데이터 -> 자료형 존재

1. 숫자형 a. number

   • 정수 + 실수
   • (유효자리)38자리 이하의 숫자를 표현하는 자료형
   • ex) 1234567890123456789012345678
   • 5~22byte
   • 1x10-130 ~ 9.9999x10+125
   • number(precision, scale)
     1. precision : 소수 이하를 포함한 전체 자릿수(1~38)
     2. scale : 소수점 이하 자릿수(0~127자리)
     • ex) number : 유효자리 38자리까지 표현 가능 모든 숫자(정수, 실수)
     • ex) number(3) : 3자리까지 표현 가능 숫자(정수, -999 ~ 999)
     • ex) number(4,2) : 4자리까지 표현 가능 숫자(실수, -99.99 ~ 99.99)
     • ex) number(10,3) : -9999999.999 ~ 9999999.999
   • 숫자형 상수(리터럴)
     1. 정수 : 10
     2. 실수 : 3.14

2. 문자형

   • 문자형 + 문자열

   • 자바의 String과 유사 a. char

     • 차
     • 고정 자릿수 문자열
     • char(n) : n자리 문자열. n(바이트)
     • 최소크기 : 1바이트
     • 최대크기 : 2000바이트
     • ex) char(3) : 최대 3바이트짜리 문자열을 저장
     • ex) char(10) : 최대 10바이트짜리 문자열을 저장
     • ex) char(2000) : 영어(2000자), 한글(666자) -> UTF-8
     • 데이터 길이가 고정 : 사람이름, 성별

     b. varchar2

     • variable charactor
     • 바차2
     • 가변 자릿수 문자열
     • varchar2(n) : n자리 문자열. n(바이트)
     • 최소크기 : 1바이트
     • 최대크기 : 4000바이트
     • ex) varchar2(3) : 최대 3바이트짜리 문자열을 저장
     • ex) varchar2(10) : 최대 10바이트짜리 문자열을 저장
     • ex) varchar2(2000) : 영어(2000자), 한글(666자) -> UTF-8
     • 데이터 길이가 가변 : 주소, 인삿말...

     c. nchar

     • N : National > 유니코드 지원 > UTF-16 동작
     • nchar(n) : n자리 문자열, n(문자수)
     • 최소 크기: 1글자(2바이트)
     • 최대 크기: 1000글자(2000바이트)
     • ex) nchar(3) : 영어(3글자), 한글(3글자)

     d. nvarchar2

     • varchar2와 동일
     • 바이트(X) -> 문자수(O)

     e. clob, nclob

     • 롭
     • large Object
     • 대용량 텍스트 저장
     • 128TB
     • 참조형

3. 날짜/시간형

   • 자바 Calendar, Date a. date(***)

     • 년월일시분초
     • 7byte
     • 기원전 4712년 1월 1일 ~ 기원후 9999년 12월 31일

     b. timestamp

     • 년월일시분초+밀리초(나노초)

     c. interval -> number 사용

     • 시간
     • 틱값

4. 이진 데이터형

   • 비텍스트형 데이터
   • 이미지, 영상, 음악 등.. a. blob
     • 최대 128TB

   • 해당 파일을 특정 폴더에 저장 + 데이터베이스에는 파일명만 저장

테이블 구조 확인

• 1. SQL Developer 기능 사용
• 2. desc 테이블명
• 3. 스크립트(SQL)

1. 사용자 정보
   • 현재 오라클에 만들어져있는 모든 계정 목록

     select * from sys.dba_users;
     select * from sys.dba_users where username = 'HR';

오라클은 식별자를 DB에 저장할 때 모두 대문자로 변환해서 저장한다. 계정명, 테이블명, 컬럼명 등... 2. 스키마(계정)내의 테이블 정보

select * from sys.dba_tables; -- 오라클 내의 모든 테이블
select * from sys.dba_tables where owner = 'HR'; -- 해당 계정이 소유하고 있는 모든 테이블
select * from tabs; -- 본인이 본인꺼 확인

3. 테이블 컬럼 정보

   select * from sys.dba_tab_columns where owner = 'HR' and table_name = 'TBLCOUNTRY';
   

desc tblCountry; ```

// ArrayList vs LinkedList
// - List : List 인터페이스 사용(사용법 동일)
// - Array : 배열구조
// Linked : 링크구조

// HashMap vs TreeMap
// - Map : Map 인터페이스 사용(사용법 동일)
// - Hash : Hash알고리즘 사용
// - Tree : 이진트리 사용

// TreeMap
// 이진 트리 구조
// 자동 정렬(키), 범위 검색 용이
// 키만 이진 트리로 관리!
// 값은 리스트로 관리

TreeMap<String, String> map=new TreeMap<String, String>();

map.put("red", "빨강");
map.put("blue", "파랑");
map.put("yellow", "노랑");
map.put("green", "초록");
map.put("white", "흰색");

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

System.out.println(map.get("yellow"));

// 부분검색(키를 대상으로) == TreeSet메서드와 유사
System.out.println(map.firstKey());
System.out.println(map.lastKey());
System.out.println(map.firstEntry());
System.out.println(map.lastEntry());

System.out.println(map.headMap("m"));
System.out.println(map.tailMap("m"));
System.out.println(map.subMap("m", "x"));


// 1순위
// - ArrayList, HashMap, HashSet

// 2순위
// - LinkedList, Queue, Stack, TreeSet

// 3순위
// - TreeMap, Properties, (Vector), (HashTable)

람다(Lambda)

// 람다, 람다식(Lambda Expression)
// - 함수형 프로그래밍 스타일 지원
// - JDK 1.8 도입
// - 람다식을 사용하면 코드가 간결해지고, 컬렉션을 다루기 쉬워진다.
// - 람다식은 자바의 메서드와 유사
// - 매개변수를 가지는 코드블럭
// - 자바의 람다식을 인터페이스를 통해서 만들어진다.(**** 자바에서만 볼 수 있는 특징)

// 람다식 기본 표현(문법)
// - (자료형 매개변수) -> { 실행코드; }
// a. 매개변수 : 메소드의 매개변수와 동일
// b. -> : 화살표(Arrow). 코드 블럭을 호출하는 역할
// c. 실행코드 : 메서드의 구현부와 동일한 역할

// 이 자체가 문법!!! 람다식!
// (int n) -> { System.out.println(n); }

MyClass m1=new MyClass();
m1.test();

// *** 인터페이스를 구현한 클래스 객체는
// 되도록 인터페이스 변수를 만들어서 저장하는 것이 좋다.
MyInterface m2=new MyClass();
m2.test();

// 익명객체
MyInterface m3=new MyInterface() {

    @Override
    public void test() {
        System.out.println("익명 객체에서 구현한 메서드");

    }

};
m3.test();

// 람다식
// - 자바의 람다식은 익명 객체 표현을 대신한다.(익명객체를 보다 편하게 쓰라고 만든)
MyInterface m4=()->{
    System.out.println("람다식에서 구현한 메서드"); // 함수형프로그래밍
};

m4.test();

// 람다식코드
// - 인터페이스 변수 = 람다식;
//  ex) MyInterface m4=()->{};
// - 자바는 메서드를 독립선언하거나, 저장소에 저장을 하지 못한다.
// - 결국 자바에서 람다식을 다루기 위해서 반드시 인터페이스를 사용해야 한다.

// 람다식에 사용하는 인터페이스
// 1. 반드시 추상 메서드를 1개만 가져야 한다. ( 이름이 없어서 구별을 못함!)
// 2. 람다식을 저장하는 인터페이스를 '람다식의 타겟 타입(Target Type)'이라고 부른다.
// 3. 람다식을 저장하는 인터페이스는 추상 메서드를 단 1개만 가지는데,
// 이런 인터페이스들을 '함수형 인터페이스(Functional Interface)'라고 부른다.
// The target type of this expression must be a functional interface

// 람다식 패턴(=메서드 패턴)
// 1. 매개변수 O, X
// 2. 반환값 O, X

// (1) 매개변수X, 반환값X
NoParameterNoReturn pr1=new NoParameterNoReturn() {
    @Override
    public void call() {
        System.out.println("pr1");
    };
};

NoParameterNoReturn pr2=()->{
    System.out.println("pr2");
};

pr1.call();
pr2.call();

// (2) 매개변수O, 반환값X
parameterNoReturn pr3=(int num)->{System.out.println(num);};

pr3.call(100);
pr3.call(200);

parameterNoReturn pr4=num->{System.out.println(num);};

pr4.call(300);
pr4.call(400);

parameterNoReturn pr5=num->{System.out.println(num);};

pr4.call(500);
pr4.call(600);

// (3) 매개변수X, 반환값O
NoParameterReturn pr6=()->{return 10;};
System.out.println(pr6.call());

NoParameterReturn pr7=()->{return (int)(Math.random()*10);};
System.out.println(pr7.call());

NoParameterReturn pr8=()->20; // 이렇게 return 키워드와 블럭 생략도 가능
System.out.println(pr8.call());

// (4) 매개변수O, 반환값O
parameterReturn pr9=(int a, int b)->{return a+b;};
System.out.println(pr9.call(10, 20));
parameterReturn pr10=(a, b)->a+b; // 생략의 최종 형태
System.out.println(pr10.call(10, 20));

ArrayList<Integer> nums=new ArrayList<Integer>();

nums.add(100);
nums.add(500);
nums.add(300);
nums.add(400);
nums.add(200);

System.out.println(nums);

코드를 입력하세요

// 익명객체를 사용했던 방법
// nums.sort(new Comparator<Integer>() {
//    @Override
//    public int compare(Integer o1, Integer o2) {
//        return o1-o2;
//    }
// });

// 익명객체를 사용했던 방법을 람다식을 이용한 방법으로 바꿈(******)
nums.sort((o1, o2)->o1-o2);
System.out.println(nums);

JDK와 Lambda

Ex84 : 람다식 이해. 내가 람다식을 직접 만들어서 직접 사용 Ex85 : JDK에서 제공하는 여러 람다식과 관련된 기능을 사용하고 싶으면... Ex85는 자바에서 미리 만든 JDK를 사용하는 방법! 우리가 람다식을 사용하려면 인터페이스를 만들어야 하는데, JDK 이용하면 람다식만 작성하면 됨

함수형 인터페이스, Functional Interface JDK 1.8부터 제공되는 인터페이스 람다식 저장용

표준 API 함수형 인터페이스

1. Consumer : 매개변수O, 반환값X
2. Supplier : 매개변수X, 반환값O
3. Function : 매개변수O, 반환값O. 자유도 높음. 4(3-1). Operator : 매개변수O, 반환값O. 매개변수를 연산 후 결과 반환 5(3-2). Predicate : 매개변수O, 반환값O. 매개변수를 논리 판단한 후 반환

   // Consumer
   // - 매개변수를 받아서 소비하는 일을 구현(소비하니까 반환값 없음)
   // - acceptXXX() 추상 메서드
   

Consumer c1=name->System.out.println(name); c1.accept("홍길동"); c1.accept("아무개");

Consumer c2=n->{ for(int i=0;i<n;i++) { System.out.println(i); } }; c2.accept(10);

BiConsumer<String, Integer> c3=(name, age)->{ System.out.println("이름 : "+name); System.out.println("나이 : "+age); };

c3.accept("홍길동", 20);

// Supplier // - 반환값만 제공하는 메서드 // - getXXX()

Supplier s1=()->{ return "홍길동";}; Supplier s2=()->100;

System.out.println(s1.get()); System.out.println(s2.get());

// Function // - 함수 역할의 메서드 제공 // - applyXXX()

// Function<T, R> // - T : 매개변수 // - R : 반환값 Function<String, Integer> f1=name->name.length(); System.out.println(f1.apply("홍길동")); System.out.println(f1.apply("대한민국"));

Function<Integer, String> f2=num->num>0?"양수":"음수"; System.out.println(f2.apply(100)); System.out.println(f2.apply(-50));

// Operator // - Function의 서브셋 // - 주로 매개변수값을 연산 처리 후 반환하는 역할 // - 매개변수의 타입과 반환값 타입이 동일하다.(연산자 특징) BiFunction<Integer, Integer, Integer> bf1 = (a, b) -> a + b;
BinaryOperator bo1 = (a, b) -> a - b;

System.out.println(bf1.apply(10, 20)); System.out.println(bo1.apply(100, 50));

// Predicate // - Function의 서브셋 // - 주로 매개변수값을 조사해서 논리값을 반환하는 역할

Function<Integer, Boolean> f1=n->n>0; Predicate p1=n->n>0;

if (f1.apply(10)) {
    System.out.println("양수");
}else {
    System.out.println("음수");
}

if(p1.test(-10)) { System.out.println("양수"); }else { System.out.println("음수"); } ```

순서가 없는 배열. 방번호(index)가 없음. 중복값을 가질 수 없음. HashSet, TreeSet.

HashSet<String> set=new HashSet<String>();
// 요소 추가하기
System.out.println(set.add("사과"));
set.add("딸기");
set.add("바나나");
System.out.println(set.add("사과")); // 사과는 이미 들어가있기 때문에 false 반환.
set.add("바나나");

// 요소 개수
System.out.println(set.size());

// toString()
System.out.println(set);

// 개별 요소 탐색 -> 불가능! (******) 방번호가 없기 때문에!
//        System.out.println(set.get(0));
// 그래서 요소 탐색을 사용하려면 iterator를 사용할 것!

Iterator<String> iter=set.iterator();

while(iter.hasNext()) {
    System.out.println(iter.next());
}

// 로또 번호 6개(1~45)
Random rnd=new Random();

ArrayList<Integer> lotto=new ArrayList<Integer>();
for (int i=0; i<6;i++) {
    int n=rnd.nextInt(45)+1;

    // 검증
    boolean flag=false;
    for(int j=0;j<i;j++) {
        if (n==lotto.get(j)) {
            flag=true;
            break;
        }else {
            flag=false;
        }
    }
    if (flag) {
        i--;
    }else {
        lotto.add(n);
    }

}
Collections.sort(lotto);
System.out.println(lotto);

// Set 구현
HashSet<Integer> lotto2=new HashSet<Integer>();
while(lotto2.size()<6) {
    lotto2.add(rnd.nextInt(45)+1);
}
System.out.println(lotto2);


//행사 -> 경품
//1. 중복 당첨 가능 > List
//2. 중복 당첨 불가능 > Set

ArrayList<String> box = new ArrayList<String>(); //응모권 상자

box.add("홍길동");
box.add("아무개");
box.add("유재석");
box.add("강호동");
box.add("박명수");
box.add("정준하");
box.add("하하");
box.add("김영철");

//추첨 명단(3명)
ArrayList<String> result1 = new ArrayList<String>();
HashSet<String> result2 = new HashSet<String>();


while (result1.size() < 3) {
    result1.add(box.get(rnd.nextInt(box.size())));
}

while (result2.size() < 3) {
    result2.add(box.get(rnd.nextInt(box.size())));
}

System.out.println();
System.out.println(result1);
System.out.println(result2);

// 단일값 집합(값형, 문자열)
HashSet<Integer> set1=new HashSet<Integer>();

set1.add(100);
set1.add(200);
set1.add(300);
set1.add(100);

System.out.println(set1);
// 복합값 집합(객체)
// Set이 객체를 저장하는 용도로 사용될 때는
// 동일 객체 비교를 hashCode()를 사용해서 비교

// 객체가 들어가는 Set에서 객체의 상태가 동일하면 같은 객체로 취급하고 싶다.
// -> 해당 객체의 클래스에서 hashCode()를 재정의한다.
HashSet<Person> set2=new HashSet<Person>();
set2.add(new Person("홍길동", 20));
set2.add(new Person("아무개", 22));
set2.add(new Person("하하하", 25));

set2.add(new Person("홍길동", 20));
// HashSet은 단일값일 경우 중복을 제외하지만,
// 객체인 경우 주소값 비교를 하기 때문에 중복값을 넣을 수 있다. 동명이인으로 처리.
// 실제 출력결과 : [{name=아무개, age=22}, {name=홍길동, age=20}, {name=홍길동, age=20}, {name=하하하, age=25}]

System.out.println(set2);

// 같은 객체를 찾아내기! -> 해시코드로!
Person p1=new Person("홍길동", 20);
Person p2=new Person("아무개", 22);

// com.test.collection2.Person@3039 -> 3039는 해시코드(12345, 10진수)의 return값(16진수)
// 자료형@해시코드(메모리주소값)
// p1 주소값 : com.test.collection2.Person@5c647e05 // 실제 존재하는 곳
// p2 주소값 : com.test.collection2.Person@33909752
// 실제 존재하는 곳은 5c647e05와 33909752.
// 주소값을 적절히 조절하면 다른 값을 같다고 할 수도 있고,
// 같은 값을 다르다고 할 수도 있다.
// 객체 비교할 때 HashCode 이용.
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
System.out.println(p1==p2);
System.out.println(p1.equals(p2));

// 사실 문자열은 재사용! 메모리 낭비를 막기 위해.
// "홍길동"이라는 공간이 s1, s2에 재사용되는 것
// 문자열은 불변이다. (Immutable) -> 고칠 수 없다
// "홍길동"+"님" -> "홍길동님"으로 보이지만
// 사실 메모리를 늘리거나 줄일 수 없다.

// Stack : 질서정연 <-> Heap : 자유분방
// 이렇게 생각할 것.
// 크기가 가변이면 Heap영역에 생긴다.

String s1="홍길동";
String s2="홍길동";
String s3="홍";
s3=s3+"길동";

System.out.println(s1==s2);
System.out.println(s1.equals(s2));
System.out.println(s1==s3);
System.out.println(s1.equals(s3));

System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
// 둘다 54150062

Person p3=new Person("호호호", 28);
Person p4=new Person("호호호", 28);

// 해시코드를 재정의하고, equals도 오버라이딩하면
// 아래의 결과는 true가 나온다.
System.out.println(p3.equals(p4));

class Person{

    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "{name=" + name + ", age=" + age + "}";
    }

    @Override
    public int hashCode() {
        // "홍길동20" -> 12345
        // "아무개22" -> 23423
        // "홍길동20" -> 12345
        return (this.name+this.age).hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        // 참조 주소값의 비교 -> 상태값 비교
        Person p=(Person)obj;
        return this.name.equals(p.name) && this.age==p.age;
    }
}

TreeSet

Tree구조를 가지는 Set. 중복값X, 순서X, 정렬X. 이진트리구조를 기반으로 자동 정렬이 되는 Set. 정렬된 상태에서의 Set이 필요할 때 사용. 검색에 장점!

TreeSet<Integer> set=new TreeSet<Integer>();

set.add(5);
set.add(3);
set.add(1);
set.add(2);
set.add(7);
set.add(9);
set.add(6);
set.add(4);
set.add(8);

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

Iterator iter=set.iterator();

while(iter.hasNext()) {
    System.out.println(iter.next());
}

// TreeSet 목적
// 1. 정렬(중복값 없는)
// 2. 부분 검색 능함(*****)

System.out.println(set.first());
System.out.println(set.last());
System.out.println(set.headSet(5)); // 5는 방번호 아님!!! "5"를 만날 때까지 가져오는 것.
System.out.println(set.tailSet(5));
System.out.println(set.subSet(3, 7)); // "3" 등장에서부터 "7" 등장까지.("7"은 미포함)

// 중복값 없는 집합 -> Set -> HashSet vs TreeSet?
// 1. 뭐가 뭔지 잘 모름 -> HashSet
// 2. 범위 검색 필요 -> TreeSet
// 3. 나머지 -> HashSet

// 중복값 있는 집합 -> List vs Map?
// 1. 뭐가 뭔지 잘 모름 -> ArrayList
// 2. 첨자(index) O -> List
//  2-1. 조작이 심하다 -> LinkedList
//  2-2. 조작이 덜하다 -> ArrayList
//  2-3. 선입선출 -> Queue(LinkedList)
//  2-4. 후입선출 -> Stack
// 3. 키 사용 -> HashMap
//  3-1. 범위 검색 -> TreeMap
//  3-2. 나머지 -> HashMap

// List -> ArrayList
// Map -> HashMap
// Set -> HashSet

이름이 없는 클래스(객체) 반드시 인터페이스를 사용해서 생성(상속 관계 이용)

public class Ex76_Anonymous {

    public static void main(String[] args) {

        // 요구사항) 좌표를 저장할 객체 생성

        // Case.1
        // - 장점 : 간단
        // - 단점 : 관리가 힘듬
        int x1=100;
        int y1=200;

        // Case.2
        // - 장점 : 집합
        // - 단점 : 가독성 낮음
        int[] p2=new int[2];

        p2[0]=100;
        p2[1]=200;

        // Case.3
        // - 장점 : 집합, 가독성 높음, 동일한 틀 사용으로 모든 좌표 객체의 성질과 사용법이 동일.
        // - 단점 : 고비용
        // - 가장 추천하는 방법
        Point p3=new Point();

        p3.x=100; // 어떻게 써야할지 모를 때 .찍으면 인텔리센스로 어떤 변수가 있는지 확인 가능하고,
        p3.y=200; // 사용해본 경험이 있을 때 똑같이 사용 가능. 비유하자면 객관식!

        // Case.4
        // - 장점 : 클래스 사용과 동일한 효과
        // - 단점 : 틀이 없음
        // 동일한 구조를 가진 객체를 여러 개 만들어내야하면 클래스를 쓰고,
        // 아니면 해시맵 사용하는 게 이득.
        HashMap<String, Integer> p4=new HashMap<String, Integer>();

        p4.put("x", 100); // p4의 규칙
        p4.put("y", 200); // 규칙이 해시맵에 넣을 때 만들어지기 때문에 사용경험을 적용하기 어려움. 비유하자면 주관식!

        // Case.5
        // 익명 객체 사용
        // - 데이터 저장용 객체(X)
        // - 메서드 호출용 객체(O)

        // AAA a=new AAA(); 불가능! 인터페이스니까.
        BBB b=new BBB(); // 변수 앞에 붙은 타입을 보고 어떤 객체가 들어있구나하고 유추 가능.
        AAA c=new BBB(); // 업캐스팅
        // 위의 경우는 AAA라고 써있으니까 AAA가 들어있을거라고 생각.
        // c에는 BBB클래스의 메서드 두 개가 있는데,
        // 인텔리센스에서는 AAA라고 써있으니까 AAA에 있는 메서드 하나만 보여줌.
        // 그럼에도 많이 쓰는 이유는 구조화를 위해서.

        // 익명객체 스타일로 다시 만들기
        AAA d=new AAA() { //The type new AAA(){} must implement the inherited abstract method AAA.test()

            @Override
            public void test() {
                System.out.println("구현");

            }
        }; // 이 문법은 아래의 class BBB implements AAA...를 구현해놓은 것.
        // 위의 예와 아래의 예를 비교해보면 확연하게 보인다.
//        AAA d=class BBB implements AAA{ // 위의 예에서는 클래스 이름을 붙이지 않고(익명), AAA 이름을 빌려다쓴다.
//            
//            @Override
//            public void test() {
//                System.out.println("인터페이스를 구현한 객체의 test() 메서드");
//                
//            }
//        }
        d.test();

        // 결론!!!
        // 인터페이스 AAA클래스를 만들고, 상속받을 클래스를 만들어서 써도 되고,
        // 아니면 만든 AAA클래스를 가져다가 쓰고, 클래스를 만들지 말고 구현부를 추가하여 (익명으로) 사용할 수 있다.
        // 들어가는 비용은 비슷.
        // 장점 : 익명으로 하는 건 클래스를 따로 만들지 않아도 됨!
        // 단점 : 재사용이 불가능! 이름이 없으니까.
        // 붕어빵먹자고 붕어빵 틀을 사올 수 없는 것처럼!

    }

}

class Point{ // p3의 규칙
    public int x;
    public int y;
}

interface AAA{ // 구현부가 없어서 실행 불가 -> 인스턴스 생성 불가!
    void test();
}

class BBB implements AAA{

    @Override
    public void test() {
        System.out.println("인터페이스를 구현한 객체의 test() 메서드");

    }

    public void ouput() {
        System.out.println("본인이 직접 구현한 output() 메서드");
    }
}

익명 객체를 활용한 컬렉션 정렬

public class Ex77_Anonymous {

    public static void main(String[] args) {

        // 익명 객체 활용 -> 컬렉션 정렬
        ArrayList<Integer> nums=new ArrayList<Integer>();
        nums.add(10);
        nums.add(30);
        nums.add(50);
        nums.add(20);
        nums.add(40);

        System.out.println(nums);
        Collections.sort(nums); // 컬렉션 정렬
        System.out.println(nums);
        Collections.reverse(nums);
        System.out.println(nums);

        ArrayList<String> names=new ArrayList<String>();
        names.add("홍길동");
        names.add("아무개");
        names.add("이순신");
        names.add("강호동");
        names.add("유재석");

        System.out.println(names);
        Collections.sort(names);
        System.out.println(names);


        names.add("이훈");
        names.add("김진");
        names.add("남궁창민");

        System.out.println(names); // 문자 코드값에 의한 오름차순

        // 익명객체를 만들어서
        // 글자수로 정렬해보자!
        names.sort(new Comparator<String>(){

            @Override
            public int compare(String o1, String o2) {
//                return o1.length()-o2.length(); // 단순히 글자수 비교라서 사전처럼 정렬 안됨
                int result=o1.length()-o2.length();

                if(result==0) { // 글자수가 같을 때 2차 정렬
                    result=o2.compareTo(o1); // 사전정렬의 역정렬
                }

                return result;
            }

        });

        System.out.println(names);

        ArrayList<Calendar> dates=new ArrayList<Calendar>();

        Calendar c1 = Calendar.getInstance();
        c1.set(2020, 10, 1);
        dates.add(c1);

        Calendar c2 = Calendar.getInstance();
        c2.set(2020, 10, 25);
        dates.add(c2);

        Calendar c3 = Calendar.getInstance();
        c3.set(2020, 10, 3);
        dates.add(c3);

        Calendar c4 = Calendar.getInstance();
        c4.set(2020, 10, 19);
        dates.add(c4);

        Calendar c5 = Calendar.getInstance();
        c5.set(2020, 10, 30);
        dates.add(c5);

        Collections.sort(dates);
//        System.out.println(dates);
        for(Calendar c:dates) {
            System.out.printf("%tF %tA\n", c, c);
        }

        // 요일에 따라 정렬
        dates.sort(new Comparator<Calendar>() {

            @Override
            public int compare(Calendar o1, Calendar o2) {
                return o1.get(Calendar.DAY_OF_WEEK)-o2.get(Calendar.DAY_OF_WEEK);
            }

        });

        for(Calendar c:dates) {
            System.out.printf("%tF %tA\n", c, c);
        }


        ArrayList<Book> books = new ArrayList<Book>();
        books.add(new Book("자바의 정석", 999, "프로그래밍"));
        books.add(new Book("오라클 데이터베이스", 555, "데이터베이스"));
        books.add(new Book("HTML5 기초", 345, "웹프로그래밍"));
        books.add(new Book("CSS 디자인", 543, "웹프로그래밍"));
        books.add(new Book("JavaScript 프로그래밍", 819, "웹프로그래밍"));


        System.out.println(books);
//        Collections.sort(books); // 객체들 자체를 정렬하지는 못함!
//        System.out.println(books);

        // JDK 구현된 정렬 기능
        // 1. 있으면.. 사용(완제품)
        // 2. 없으면.. 직접 구현
        //  2-1. 모든걸 직접 구현(주문제작) - 지난번에 배운 버블정렬.
        //  2-2. 틀을 제공+구현(반제품) - 오늘 배울 것.

        // interface Comparator
        // interface Comparable

        // 1. interface Comparator 상속해서 정렬 -> 객체들을 비교하는 데에만 쓰기엔 고비용
//        MyComparator mc=new MyComparator(); // Book끼리 비교하는 능력이 있음
//        books.sort(mc);
//        System.out.println(books); // 오름차순 정렬

        // 2. interface Comparator를 익명객체로 만들어서 정렬 -> 일회용!
        // 객체 정렬은 대부분 이렇게 한다!
        // Comparator
        // 정렬알고리즘 -> 퀵정렬 이용!
        books.sort(new Comparator<Book>() {

            @Override
            public int compare(Book o1, Book o2) {
                return o1.category.compareTo(o2.category);
            }

        });

        System.out.println(books);
    }

}

class MyComparator implements Comparator<Book>{ // interface Comparator를 MyComparator에 상속

    @Override
    public int compare(Book o1, Book o2) { // 반환값 int!

        // 두 매개변수의 우위 비교(오름차순기준)
        // 1. o1 크면 > 양수 반환
        // 2. o2 크면 > 음수 반환
        // 3. 같으면 > 0 반환

//        if(o1.pages>o2.pages) {
//            return 1;
//        }else if (o1.pages<o2.pages) {
//            return -1;
//        }else {
//            return 0;
//        }

        // if문 쓸 것도 없이 이렇게 가능!
        // 페이지수 정렬
//        return o1.pages-o2.pages;

        // 제목 정렬
        // return o1.title.compareTo(o2.title);

        // 카테고리 정렬
        return o1.category.compareTo(o2.category);

    }

}

class Book {
    public String title;
    public int pages;
    public String category;

    public Book(String title, int pages, String category) {
        this.title = title;
        this.pages = pages;
        this.category = category;
    }

    @Override
    public String toString() {
        return "{title=" + title + ", pages=" + pages + ", category=" + category + "}\n";
    }

}

자바 컬렉션 인터페이스

public static void main(String[] args) {
    // 자바 컬렉션 인터페이스(*** 면접용 질문 준비할 것!!!)

    // 1. Collection 인터페이스
    // - List와 Set의 부모

    // 2. List 인터페이스
    // - ArrayList, Stack, LinkedList, Vector, Queue
    // - 순서가 있는 집합 (*** 리스트를 한줄로 나타낼 때 이렇게 말하면 됨!)
    // - 방번호(첨자)가 있다. -> 요소 접근!
    // - 데이터 중복을 허용 (*****) -> 같은 데이터도 첨자를 이용해서 구분할 수 있음

    // 3. Set 인터페이스
    // - HashSet, TreeSet
    // - 순서가 없는 집합 (*** 셋을 한줄로 나타낼 때 이렇게 말하면 됨!)
    // - 방번호(첨자)가 없다.
    // - 데이터 중복을 허용XXX (*****)

    // 4. Map 인터페이스
    // - HashMap, TreeMap, HashTable, Properties
    // - 순서가 없는 집합(***)
    // - 키와 값을 사용하는 컬렉션 -> 연관 배열, Dictionary구조
    // - 키(key) : 식별자역할 -> 유일해야함!(중복XXX) -> Set으로 구성되어있음
    // - 값(value) :  데이터역할(최종목적) -> 중복 허용 > List로 구성되어있음

    // Vector, HashTable, Properties
    // 사용안함. Legary Class. 예전 시스템의 호환성을 위해 남겨놓은 문법.
    // 언젠가 버전업이 되면서 사라질 수도 있는 문법
    // 되도록이면 쓰지 말 것! (있는거야 고쳐서 써야겠지만)

    // Vector -> ArrayList로 대체.
    // HashTable -> HashMap으로 대체.
    // Properties -> 폐기 -> XML, JSON 기술로 대체.

    // List 계열
    // 1. Vector : 동기화 지원
    // 2. ArrayList : 동기화 지원안함
    // 동일하다고 생각하면 됨!

    ArrayList<String> list1=new ArrayList<String>();
    Vector<String> list2=new Vector<String>();

    list1.add("홍길동");
    list1.add("아무개");
    list1.add("하하하");

    list2.add("빨강");
    list2.add("파랑");
    list2.add("노랑");

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

    System.out.println(list1.get(0));
    System.out.println(list1.get(0));
}

LinkedList

// ArrayList, HashMap, LinkedList, Stack, HashSet : 연습 많이

// LinkedList
// - List 계열(List 인터페이스를 상속받았다는 것)
//  -> ArrayList와 사용법 비슷 but 구현 내부는 서로 다름!

// LinkedList 종류
// 1. LinkedList
// 2. Double LinkedList
// 3. Double Circular LinkedList

// ArrayList vs LinkedList
// - 순서를 가지는 집합
// ArrayList 장점 : 마지막에 데이터를 삽입하는 경우 속도가 탁월하게 빠름!
// LinkedList 장점 : 중간에 데이터를 삽입하는 경우 속도가 탁월하게 빠름!

ArrayList<Integer> nums1=new ArrayList<Integer>();
LinkedList<Integer> nums2=new LinkedList<Integer>();

nums1.add(10);
nums1.add(20);
nums1.add(30);

nums2.add(10);
nums2.add(20);
nums2.add(30);

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

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

long begin=0, end=0; // 시간을 재기 위한 변수


// 1. 순차적으로 데이터 추가하기(Append)
System.out.println("1. 순차적으로 데이터 추가하기(Append)");
begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=0;i<1000000;i++) {
    nums1.add(i);
}

end=System.nanoTime();

System.out.printf("ArrayList 작업시간 : %,dns\n", end-begin);

begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=0;i<1000000;i++) {
    nums2.add(i);
}

end=System.nanoTime();

System.out.printf("LinkedList 작업시간 : %,dns\n", end-begin);


// 2. 배열 중간에 데이터 추가하기(Insert)
System.out.println("2. 배열 중간에 데이터 추가하기(Insert)");
begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=0;i<100000;i++) {
    nums1.add(0, i);
}

end=System.nanoTime();

System.out.printf("ArrayList 작업시간 : %,dns\n", end-begin);

begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=0;i<100000;i++) {
    nums2.add(0, i);
}

end=System.nanoTime();

System.out.printf("LinkedList 작업시간 : %,dns\n", end-begin);

// 3. 배열 중간에 데이터 삭제하기(Delete)
System.out.println("3. 배열 중간에 데이터 삭제하기(Delete)");
begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=0;i<100000;i++) {
    nums1.remove(0);
}

end=System.nanoTime();

System.out.printf("ArrayList 작업시간 : %,dns\n", end-begin);

begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=0;i<100000;i++) {
    nums2.remove(0);
}

end=System.nanoTime();

System.out.printf("LinkedList 작업시간 : %,dns\n", end-begin);

// 4. 순차적으로 데이터 삭제하기(Delete)
// 끝에서 처음으로 가면서 삭제
System.out.println("4. 순차적으로 데이터 삭제하기(Delete)");
begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=nums1.size()-1;i>=0;i--) {
    nums1.remove(i);
}

end=System.nanoTime();

System.out.printf("ArrayList 작업시간 : %,dns\n", end-begin);

begin=System.nanoTime(); // 10의 -9승까지의 초도 가능

// 작업
for(int i=nums2.size()-1;i>=0;i--) {
    nums2.remove(i);
}

end=System.nanoTime();

System.out.printf("LinkedList 작업시간 : %,dns\n", end-begin);

// ArrayList
// - 순차적인 추가/제거 양호
// - 중간 추가/제거 불량
// - 한번 넣어두고 순차적으로 탐색하는 용도 -> 목록

// LinkedList
// - 순차적인 추가/제거 보통
// - 중간 추가/제거 양호
// - 집합의 요소를 수시로 넣었다뺐다 하는 용도

자바 프로그램 <- (데이터) -> 파일(HDD) - 콘솔 입출력 방식과 인터페이스 유사 - 주기억장치(휘발성) - 보조기억장치(반영구적)

텍스트 입출력

문자데이터 입출력.

바이너리 입출력

이미지, 동영상, 압축파일, 실행파일 등. 비문자 데이터 입출력.

인코딩과 디코딩

인코딩(내보내기, 쓰기)

문자 코드를 부호화(0, 1)하는 작업

디코딩(가져오기, 읽기, 복호화)

부호 데이터를 문자 코드화하는 작업

인코딩/디코딩 규칙

ISO-8859-1, EUC-KR, ANSI, UTF-8(표준인코딩! 영어 : 1byte, 한글 : 3byte), UTF-16(영어 : 2byte, 한글 : 2byte), MS949 **ANSI(ISO-8859-1, EUC-KR, MS949) : 영어 : 1byte, 한글 : 2byte

네트워크의 인코딩/디코딩

네이버 웹서버(UTF-8) -> 인코딩 + 디코딩 -> (UTF-8)브라우저

파일 쓰기 : FileOutputStream(바이트 단위, 한글X)

// 파일 입출력
// - 외부 환경과의 교류
// - 사용 메서드 -> 예외 미루기 설정 -> try catch

// 쓰기
// 바이트 단위 쓰기
// 1바이트씩 저장

// 파일에 데이터 저장하기(쓰기)
// 1. 스트림 객체 생성하기(열기)
// 2. 스트림 객체 사용하기(쓰기)
// 3. 스트림 객체 닫기

try {
    // 쓰기 전용 스트림(빨대)
    // - 스트림 모드
    // 1. 생성모드(Create Mode)
    //  - 기본방식
    //  - 파일이 없으면 새로 만든다.
    //  - 파일이 있으면 무조건 덮어쓰기를 한다.
    // 2. 추가모드(Append Mode)
    //  - 파일이 없으면 새로 만든다.
    //  - 파일이 있으면 기존 내용을 이어쓰기를 한다.

    // 1. 스트림 객체 생성
    File file=new File("/Users/ara/class/java/file/data.txt");
    FileOutputStream stream=new FileOutputStream(file, true); // true는 이어쓰기 모드.

    // 2. 쓰기
    stream.write(97);
    stream.write(98);
    stream.write(99);

    // 자동 형변환
    stream.write('\r');
    stream.write('\n');
    stream.write('J');
    stream.write('a');
    stream.write('v');
    stream.write('a');

    // 3. 닫기!!!
    stream.close();
    System.out.println("완료");
    } catch (Exception e) {
        System.out.println("Ex75_File.m1()");
        e.printStackTrace();
    }

try {
    FileOutputStream stream = new FileOutputStream("/Users/ara/class/java/file/diary.txt", true);
    Scanner scan=new Scanner(System.in);
    String input= scan.nextLine();
    for(int i=0;i<input.length();i++) {
        char c=input.charAt(i);
        stream.write(c);
    }
    stream.write('\r');
    stream.write('\n');
    stream.close();
} catch (Exception e) {
    System.out.println("Ex75_File.m2()");
    e.printStackTrace();
}

팁

데이터의 종류에는 아래와 같은 두 가지가 있다.

1. 고정폭 : 이름, 나이, 성별, 연락처
2. 가변폭 : 주소

javaw.exe

콘솔에서 종료버튼 안 누르면 계속 실행중이어서 실행중으로 javaw.exe가 계속 뜬다. 그러니까 종료버튼 꼭 누르기.

파일 읽기 : FileInputStream(바이트 단위, 한글X)

//읽기
// - 바이트 단위 읽기
// - System.in.read() 동일
try {
    // 읽기 전용 스트림(빨대)
    FileInputStream stream
        = new FileInputStream("/Users/ara/class/java/file/diary.txt");
//    int code=stream.read();
//    System.out.println(code+","+(char)code);
//    code=stream.read();
//    System.out.println(code+","+(char)code);
//    code=stream.read();
//    System.out.println(code+","+(char)code);

    // 하나하나씩 말고 통째로 읽기
    int code=-1;
    while((code=stream.read())!=-1) {
        System.out.print((char)code);
    }

    // 종료
    stream.close();
} catch (Exception e) {
    System.out.println("Ex75_File.m3()");
    e.printStackTrace();
}

파일 쓰기(문자단위, 한글 가능)

// 쓰기
// - 문자 단위 쓰기(2byte)
// - 모든 문자를 기록할 수 있다.(한글 포함)

try {
    FileWriter writer=new FileWriter("/Users/ara/class/java/file/todo.txt");
    writer.write("abc");
    writer.write("\r\n");
    writer.write("안녕하세요. 홍길동입니다.");
    writer.close();
    // 추가작성
    // 닫힌 스트림은 사용이 불가능하다.
    // 정 해야할 경우는 새로 스트림 생성
    writer=new FileWriter("/Users/ara/class/java/file/todo.txt", true);
    writer.write("추가내용입니다.");
    writer.close();
} catch (Exception e) {
    System.out.println("Ex75_File.m4()");
    e.printStackTrace();
}

파일 읽기(문자 단위, 한글 가능)

// 읽기
// - 문자 단위 읽기(한글도 가능!)
try {
    FileReader reader=new FileReader("/Users/ara/class/java/file/message.txt");
//    int code=reader.read();
//    System.out.println((char)code);


    int code=-1;
    while((code=reader.read())!=-1) {
        System.out.print((char)code);
    }


} catch (Exception e) {
    System.out.println("Ex75_File.m6()");
    e.printStackTrace();
}

파일 쓰기 BufferedWriter

// 쓰기

// 알맹이만 바꾸면 콘솔, 네트워크, 파일 입출력 전부 가능.
// BufferedWriter writer=new BufferedWriter(알맹이);
try {
    BufferedWriter writer
    = new BufferedWriter(new FileWriter("/Users/ara/class/java/file/log.txt"));
    writer.write("문자열입니다.");
    writer.write("\r\n");
    writer.write("하하하");
    writer.newLine();
    writer.write("호호호");
    writer.close();
    System.out.println("완료");
} catch (Exception e) {
    System.out.println("Ex75_File.m7()");
    e.printStackTrace();
}

파일 쓰기 : BufferedReader

// BufferedReader
// 1. 키보드 입력
// 2. 파일 입력(읽기)
try {
    BufferedReader reader=new BufferedReader(new FileReader("/Users/ara/class/java/file/log.txt"));
    // BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

//    String line=reader.readLine();
//    System.out.println(line);

    String line=null;
    while((line=reader.readLine())!=null) {
        System.out.println(line);
    }

    reader.close();
} catch (Exception e) {
    System.out.println("Ex75_File.m8()");
    e.printStackTrace();
}

학생 정보 관리 프로그램

private static void m10() {
    // 학생 정보 입출력
    // 데이터 구조
    // - 이름, 나이, 성별, 주소, 연락처
    // - student.dat

    // 절대경로
    // - 드라이브명부터 시작하는 표현
    File file=new File("/Users/ara/class/java/JaveTest/src/data/student.dat");
//    System.out.println(file.exists());
    // 상대경로
    // -.으로부터 시작하는 표현
    // -. : 프로젝트 루트 폴더
//    File file2=new File("./src/data/student.dat"); 이것도 가능
//    File file2=new File("src/data/student.dat");
//    System.out.println(file2.exists());

    System.out.println("====================");
    System.out.println("학생 정보 관리 프로그램");
    System.out.println("====================");

    Scanner scan=new Scanner(System.in);
    boolean loop=true;

    while(loop) {
        System.out.println("1. 학생 정보 보기");
        System.out.println("2. 학생 정보 쓰기");
        System.out.println("3. 종료");
        System.out.print("선택 : ");
        String sel=scan.nextLine();
        if (sel.equals("1")) {
            list();
        }else if(sel.equals("2")) {
            add();
        }else if(sel.equals("3")) {
            loop=false;
        }else {
            System.out.println("잘못된 메뉴 선택입니다.");
            }
        }
        System.out.println("프로그램 종료");
    }

    private static void list() {
        System.out.println("학생 목록");
        System.out.println("[이름]\t[나이]\t[성별]\t[연락처]\t[주소]");
        try {
            BufferedReader reader=new BufferedReader(new FileReader(Data.학생정보));
            String line=null;
            while((line=reader.readLine())!=null) {
//            System.out.println(line);
//            홍길동,20,m,010-1234-5678,서울시 강남구 역삼동
                String[] temp=line.split(",");
                System.out.printf("%s\t%5s\t%s\t%s\t%s\n", temp[0], temp[1], temp[2].equals("m")?"남자":"여자", temp[3], temp[4]);
            }
            reader.close();
            pause();
        } catch (Exception e) {
            System.out.println("Ex75_File.list()");
            e.printStackTrace();
        }

    }

    private static void pause() {
        Scanner scan = new Scanner(System.in);
        System.out.println("엔터 입력...");
        scan.nextLine();

    }
    private static void add() {
        System.out.println("학생 정보 추가");
        try {
            BufferedWriter writer=new BufferedWriter(new FileWriter(Data.학생정보, true));
            Scanner scan=new Scanner(System.in);

            System.out.print("이름 : ");
            String name=scan.nextLine();

            System.out.print("나이 : ");
            String age=scan.nextLine();

            System.out.print("성별(m|f) : ");
            String gender=scan.nextLine();

            System.out.print("연락처 : ");
            String tel=scan.nextLine();

            System.out.print("주소 : ");
            String address=scan.nextLine();

            writer.write(String.format("%s,%s,%s,%s,%s\n", name, age, gender, tel, address));
            writer.close();
            System.out.println("저장 완료");
            pause();

        } catch (Exception e) {
            System.out.println("Ex75_File.add()");
            e.printStackTrace();
        }

    }

객체 메서드 내에서

또 다른 객체 메서드를 호출할 수 있다. 또 다른 정적 메서드를 호출할 수 있다. 객체 멤버 변수도 접근할 수 있다. 객체 정적 변수도 접근할 수 있다.

정적 메서드 내에서

또 다른 객체 메서드를 호출할 수 없다.(X) 또 다른 정적 메서드를 호출할 수 있다. 객체 멤버 변수도 접근할 수 없다.(X) 객체 정적 변수도 접근할 수 있다.

파일 경로는 바뀌면 안되는 경우가 많기 때문에 final(상수)로 선언.

// 1. 파일 접근하기 -> 파일 참조하기 -> 파일 참조 객체 만들기
// 2. 파일 정보 보기

// 경로
final String path="/Users/ara/class/java/file/test.txt";

// 파일 참조 객체 생성
File file=new File(path);
//    System.out.println(file.exists()); // 접근할 파일이 존재하는지 확인
//    System.out.println(file.getAbsolutePath()); // 파일의 경로가 제대로 잡혀있는지 확인

if (file.exists()) {
    // 정보 읽기
    System.out.println(file.getName());
    System.out.println(file.isFile());
    System.out.println(file.isDirectory());
    System.out.printf("%tF %tT\n", file.lastModified(), file.lastModified()); // 2020-11-11 09:19:24 형식으로 출력
//    Calendar c=Calendar.getInstance();
//    c.setTimeInMillis(file.lastModified());
//    System.out.printf("%tF %tT\n", c, c); // 2020-11-11 09:19:24 형식으로 출력
    System.out.println(file.canRead());
    System.out.println(file.canWrite());
    System.out.println(file.isHidden());
    System.out.println(file.length()); // 파일크기! 바이트!
    System.out.println(file.getPath()); // 참조 당시 경로
    System.out.println(file.getAbsolutePath()); // 절대경로
}else {
    System.out.println("파일이 존재하지 않습니다.");
}

// 파일 조작
// - 생성, 복사, 이동, 이름바꾸기, 삭제

// 1. 파일명 수정
// test.txt -> aaa.txt
String path="/Users/ara/class/java/file/test.txt";
File file=new File(path);

String path2="/Users/ara/class/java/file/aaa.txt";
File file2=new File(path2);

if (file.exists()) {
    boolean result=file.renameTo(file2); // 파일의 상태 변화(성공유무가 반환값)
    System.out.println(result);
}else {
    System.out.println("폴더가 존재하지 않습니다.");
}

// 2. 이동
// file > aaa > hong.txt : 이동전
// file > bbb : 여기로 이동! hong.txt 파일 생기도록.
String path="/Users/ara/class/java/file/aaa/hong.txt";
File file=new File(path);

Calendar c=Calendar.getInstance();
String path2=String.format("/Users/ara/class/java/file/bbb/[%tT]hong.txt", c);
File file2=new File(path2);

if (file.exists()) {
    boolean result=file.renameTo(file2); // 파일의 상태 변화(성공유무가 반환값)
    System.out.println(result);
}else {
    System.out.println("폴더가 존재하지 않습니다.");
}

// 3. 삭제(휴지통 거치지 않는 완전삭제!)
String path="/Users/ara/class/java/file/aaa.txt";
File file=new File(path);

if (file.exists()) {
    boolean result=file.delete();
    System.out.println(result?"성공":"실패");
}else {
    System.out.println("폴더가 존재하지 않습니다.");
}

폴더

final String path="/Users/ara/class/java/file";

// 디렉토리 참조 객체 생성
// 디렉토리는 (크기가 없는) 파일의 일종! -> File클래스 이용. 자바는 Directory클래스는 없음.
// class File{
// public String parentDirectory="D:/test";
// }
File dir=new File(path);

if(dir.exists()) {
    System.out.println(dir.getName());
    System.out.println(dir.isFile());
    System.out.println(dir.isDirectory());
    System.out.println(dir.length()); // 파일크기! 바이트! -> 폴더가 소유하고 있는 파일들의 크기의 합
    System.out.println(dir.getPath()); // 참조 당시 경로
    System.out.println(dir.getAbsolutePath()); // 절대경로
}else {
    System.out.println("폴더가 존재하지 않습니다.");
}

// 폴더 조작
// 생성, 이동, 폴더명 수정, 삭제

// 1. 생성
String path="/Users/ara/class/java/file/ccc"; // ccc폴더를 만들 예정.
File dir=new File(path);

if(!dir.exists()) {
    dir.mkdir();
}else {
    System.out.println("같은 이름의 폴더가 이미 있습니다.");
}

// 폴더 여러개 생성
path="/Users/ara/class/java/file/ddd/eee"; // ccc폴더를 만들 예정.
dir=new File(path);
if(!dir.exists()) {
    dir.mkdirs();
}else {
    System.out.println("같은 이름의 폴더가 이미 있습니다.");
}

// 요구사항) 회원 > 회원별 개인 폴더 생성
String[] member={"홍길동", "아무개", "하하하", "호호호"};

for(String name:member) {
    path=String.format("/Users/ara/class/java/file/member/[개인폴더]%s님", name);
    dir=new File(path);
    dir.mkdir();
    System.out.println(name+"님 개인 폴더 생성 완료.");
}

// 요구사항) 자식 폴더 생성
// /Users/ara/class/java/file/todo
// 2020-01-01 ~ 2020-12-31 -> 366개
Calendar c=Calendar.getInstance();
c.set(2020, 0, 1);
for(int i=0;i<366;i++) {
    path=String.format("/Users/ara/class/java/file/todo/%tF", c);
    dir=new File(path);
    dir.mkdir();
    System.out.printf("%tF\n", c);
    c.add(Calendar.DATE, 1);
}

// 2, 3. 폴더명 수정, 이동
String path="/Users/ara/class/java/file/fff";
File dir=new File(path);

String path2="/Users/ara/class/java/file/aaa/fff"; // ccc폴더를 만들 예정.
File dir2=new File(path2);

if(dir.exists()) {
    System.out.println(dir.renameTo(dir2));
}else {
    System.out.println("같은 이름의 폴더가 이미 있습니다.");
}

// 4. 삭제
String path="/Users/ara/class/java/file/aaa/"; // 삭제하고자 하는 폴더 경로 끝에 / 이거 꼭 붙여줘야 함! 아님 삭제 안됨!
File dir=new File(path);
if (dir.exists()) {
    System.out.println(dir.delete()); // 폴더 delete시 하위에 내용물있으면 삭제 안됨.
}else {
    System.out.println("폴더가 존재하지 않습니다.");
}

월이 0부터인 이유? 요일 0(일요일)부터인 이유?

월, 요일 데이터는 숫자가 아니라 배열의 개념으로 시작했기 때문. 시작 1 : 수치로써 사용되는 데이터 시작 0 : 배열, 열거형으로써 사용되는 데이터

디렉토리의 내용 보기

String path="/Applications/Eclipse.app/Contents/Eclipse";
File dir=new File(path);

if (dir.exists()) {
    String[] list=dir.list();
    for(String name:list) {
        System.out.println(name);
    }
}else {
    System.out.println("폴더가 존재하지 않습니다.");
}

재귀구조로 파일 개수, 폴더 개수 세기

private static void m14() {
    // 이 폴더에 들어있는 모든 파일의 개수?
    String path="/Applications/Eclipse.app/Contents/Eclipse"; // ccc폴더를 만들 예정.
    File dir=new File(path);


    // 누적변수
    int count=0;

    // 해당 폴더의 파일 개수 세기
    if (dir.exists()) {
        count+=countFile(dir, count);
    }
    System.out.printf("총 파일 개수 : %,d개\n", count);
}

private static int countFile(File dir, int count) {
    // A. 목록 가져오기
    File[] list=dir.listFiles();

    // B. 파일 개수 누적
    for(File file:list) {
        if(file.isFile()) {
            count++;
        }
    }

    // C. 본인이 했던 행동 -> 자식 폴더 대상으로 다시 실행
    for(File subdir:list) {
        if (subdir.isDirectory()) {
            count=countFile(subdir, count); // 재귀구조
        }
    }
    return count;
}

객체들로 구성된 리스트의 정렬

System.out.println();
System.out.println(Arrays.toString(slist));
// 버블정렬
for(int i=0;i<slist.length-1;i++) {
    for(int j=0; j<slist.length-1-i;j++) {
        // compareTo() : 1(>), 0(=), -1(<) 셋 중 하나 반환.
        if (slist[j].getName().compareTo(slist[j+1].getName())>0) { // 이름에 따라 정렬
//        if (slist[j].getWeight()>slist[j+1].getWeight()) {
            Student temp=slist[j];
            slist[j]=slist[j+1];
            slist[j+1]=temp;
        }
    }
}
System.out.println(Arrays.toString(slist));

rm "/Volumes/Macintosh HD/var/db/auth.db"

이진탐색알고리즘을 이용하여 검색.

HashMap

ArrayList vs HashMap

• ArrayList : List인터페이스를 구현한 배열(Array). 스칼라 배열(Scalar Array) -> 요소들간의 구분이 쉽지 않음. 방번호는 의미를 가지지 않기 때문.

• HashMap : Map인터페이스를 구현 + Hash알고리즘 사용 배열. 사전구조(Dictionary). 맵(Map). 연관배열. 방번호가 없음 -> 요소들의 순서가 없음. 키(Key)와 값(Value)으로 데이터를 관리. 일괄접근 불가능 -> 일괄접근 안하려고 만든 데이터구조. 요소의 의미를 알기 쉬움. 키는 유일해야 함!

  // HashMap 사용법
  
   // 생성
   HashMap<String, Integer> map=new HashMap<String, Integer>();
  
   // 1.요소 추가
   // T put(T key, T value)
   map.put("국어", 100);
   map.put("영어", 90);
   map.put("수학", 80);
  
   // 2. 요소 개수
   System.out.println(map.size());
  
   // 3. 요소 접근
   System.out.println(map.get("국어"));
   System.out.println(map.get("영어"));
   System.out.println(map.get("수학"));
   System.out.println(map.get("과학"));
  
   // 4. 수정하기
   // 수정되기 전 값이 반환값
   map.put("국어", 98);
   System.out.println(map.get("국어"));
   System.out.println(map.getOrDefault("영어", 0));
       // 없으면 Default로 지정한 값 반환
  
   // 5. 검색
   System.out.println(map.containsKey("국어"));
   System.out.println(map.containsValue(100));
  
   // 6. 삭제
   map.remove("국어");
   System.out.println(map.size());
  
   // 7. 초기화
   map.clear();
   System.out.println(map.size());

Queue

Queue<String> queue=new LinkedList<String>();
// =========================
//-> 노랑     파랑     빨강 ->
// =========================
queue.add("빨강");
queue.add("파랑");
queue.add("노랑");

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

System.out.println(queue.poll());
System.out.println(queue.size());

System.out.println(queue.poll());
System.out.println(queue.size());

System.out.println(queue.poll());
System.out.println(queue.size());

System.out.println(queue.poll()); // 꺼내기. 다 뽑고 또 poll하면 null 반환.
System.out.println(queue.size());

queue.add("빨강");
queue.add("주황");
queue.add("노랑");
queue.add("초록");
queue.add("파랑");
queue.add("남색");
queue.add("보라");

System.out.println(queue.peek()); // 보이긴 하지만 size 변화는 없음.

//루프
// 1. for문
int size=queue.size();

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

// 2. while문
while(queue.size()>0) {
    System.out.println(queue.poll());
    System.out.println(queue.size());
}

// 3. 향상된 for문 -> 이 방식은 사용 불가! 이건 큐가 아님! 꺼내면서 사라지지 않기 때문.
for(String color:queue) {
    System.out.println(color);
}

Stack

Stack<String> stack=new Stack<String>();
//  =========================
//<=>  노랑     파랑    빨강   ㅒ <- 막혔음!
//  =========================

stack.push("빨강");
stack.push("파랑");
stack.push("노랑");

System.out.println(stack.pop());
System.out.println(stack.size());

System.out.println(stack.pop());
System.out.println(stack.size());

System.out.println(stack.pop());
System.out.println(stack.size());

System.out.println(stack.pop()); // 빈 stack에 pop하면 java.util.EmptyStackException 발생
System.out.println(stack.size());

if (!stack.isEmpty()) {
    System.out.println(stack.pop());
    System.out.println(stack.size());
}

stack.push("빨강");
stack.push("파랑");
stack.push("노랑");

System.out.println(stack.peek());
System.out.println(stack.size());

// while문
while(!stack.isEmpty()) {
    System.out.println(stack.pop());
}

(향상된)배열. 배열을 감싼 클래스(물리적 구조 상). 배열의 길이가 가변.(실행중 늘리거나 줄이는 게 가능). 배열을 사용 목적에 따라 사용법이나 구조를 특화시켜 미리 제공.

List 인터페이스

ArrayList, LinkedList, Stack, (Queue), (vector)

set 인터페이스

HashSet, TreeSet

Map 인터페이스

HashMap, TreeMap, (Properties)

ArrayList

ArrayList(C)->List(I)->Collection(I) 사용빈도가 가장 높음. 순수 배열과 구조가 가장 유사함(그래서 사용빈도가 높음) 첨자(Index)를 사용해서 요소(element)에 접근/제어 -> 순수배열과 동일

ArrayList(Object버전)

• 일반 객체 생성하는 방법으로 선언. -> 넣을 때도 꺼낼 때도 메서드로.
• 어떤 자료형을 담을지 명시되어있지 않음. (Object로 되어있기 때문에 모든 자료형 가능.)
• 배열의 길이가 안 보임 -> 길이 가변!
• 무조건 마지막에 추가 -> append
• int size() : 컬렉션의 길이(배열의 length)
• 컬렉션에 어떤 자료형을 넣어도 상관없지만 처음 넣은 데이터와 같은 자료형의 데이터만 넣는다. 자료형을 여러 개 넣는 건 절대로 하면 안되는 행동!!!

  // Object 버전
  ArrayList list1=new ArrayList();
  list1.add(100);
  System.out.println((int)list1.get(0)*2);
  

// Generic 버전(다양한 자료형을 담을 수 있고, 끝없이 담을 수 있음) ArrayList list2=new ArrayList(); list2.add(100); System.out.println(list2.get(0)*2);

```java
//ArrayList 사용법
ArrayList<String> list=new ArrayList<String>();

// 1. 요소 추가하기
// boolean add(T value)
// 배열의 맨 마지막에 추가하기(append)
list.add("빨강");
list.add("파랑");
list.add("노랑");
list.add("검정");
list.add("주황");

// 2. 요소의 개수
// int size()
// 배열의 맨 마지막에 추가하기(append)
System.out.println(list.size());

// 3. 요소의 접근
// T get(int index)
System.out.println(list.get(0));
System.out.println(list.get(1));
System.out.println(list.get(2));
System.out.println(list.get(list.size()-1));

// 4. 요소의 수정
// T set(int index, T element) -> 수정되기 전 값을 반
System.out.println(list.get(0));
String temp=list.set(0, "red");
System.out.println(list.get(0));

// 5. 요소의 삭제(주의해야 함!!!)
// 순수 배열은 요소 삭제가 불가능 -> 방 개수를 줄이는 것이 불가능!
// T remove(int index)
// Left Shift 발생!!!(요소 하나가 빠지면 그 칸 채우기 위해 왼쪽으로 이동)
// boolean remove(T element)와 같이 쓰면 지웠는지 안 지웠는지 여부가 boolean으로 반환
System.out.println(list.size());
System.out.println(list.remove(0));
System.out.println(list.size());

// 6. 요소의 추가(주의해야 함!!!)
// boolean add(int index, T element)
// 배열의 넣고 싶은 위치에 추가하기 -> insert 모드
// Light Shift 발생!!!(요소 하나가 더해지면 그 요소가 들어갈 칸 확보하기 위해 오른쪽으로 이동)
for(int i=0;i<list.size();i++) {
    System.out.printf("list[%d]= %s\n", i, list.get(i));
}
list.add(1, "녹색");
for(int i=0;i<list.size();i++) {
    System.out.printf("list[%d]= %s\n", i, list.get(i));
}

// 7. 탐색
// for문
for(int i=0;i<list.size();i++) {
    System.out.printf("list[%d]= %s\n", i, list.get(i));
}
// 향상된 for문
for(String color:list) {
    System.out.println(color);
}

// 8. 검색
// boolean contains(T values)
// int indexOf(T value)
// int lastIndexOf(t value)
System.out.println(list.contains("빨강"));
System.out.println(list.contains("파랑"));
if (list.contains("파랑")){
    list.remove("파랑");
    System.out.println("파랑 삭제");
}else {
    System.out.println("파랑 없음");
}
System.out.println(list.indexOf("노랑"));
System.out.println(list.lastIndexOf("노랑"));

// 9. 덤프(dump) : 개발자용. 고객출력용 아님!
System.out.println(list.toString()); // toString()은 오버라이딩된 것!

// 10. 초기화
// 배열의 내용을 전부 지워버림.
// void clear()
list.clear(); // 아니면 list=new ArrayList<String>으로 변수만 재활용 하거나.(이렇게 되면 새로 ArrayList를 메모리에 만들어서 주소값만 바꿔주는 것. 낭비! 원래 연결되어있던 참조는 끊김.)
System.out.println(list.isEmpty()); // 비워있는지 확인하려면 isEmpty() 이용.

// 11. 정렬
// void sort(List<T> list)
// List<T> list
// List(인터페이스) : 부모 <- ArrayList(클래스) : 자식
Collections.sort(list); // 순차정렬, 순정렬, 오름차순
System.out.println(list);
Collections.reverse(list); // 순차정렬되어있는 것을 뒤집음. 위에서 오름차순으로 정렬했으므로 내림차순으로 정렬되는 결과.
System.out.println(list);

// 12. 부분 집합 추출
// List<T> subList(index fromIndex, index toIndex)
list.subList(fromIndex.toIndex)

순수배열vsArrayList

private static void m1() {
    // 순수배열
    int[] nums1=new int[3]; // 타입과 길이 명시

    // 초기화 or 요소 접근(첨자(index) 사용) -> Indexer(인덱서)
    nums1[0]=100;
    nums1[1]=200;
    nums1[2]=300;

    // 요소 접근(첨자(index) 사용)
    System.out.println(nums1[0]);

    for(int i=0;i<nums1.length;i++) {
        System.out.println(nums1[i]);
    }

    // ArrayList
    ArrayList nums2=new ArrayList();
      nums2.add(100);
    nums2.add(200);
    nums2.add(300);

    System.out.println(nums2.get(0));
    //     System.out.println(nums2.get(0)*2); 이런건 불가능. get되어서 나올 때 자료형이 어떤 것일지 모르기 때문.
    //     System.out.println((int)nums2.get(0)*2); 다운캐스팅하면 가능

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

}

생성자는 또다른 생성자를 호출할 수 있다.

class Student{
    private String name;
    private int kor;
    private int eng;
    private int math;

    public Student() {
        this("", 0, 0, 0);
    }

    public Student(String name, int kor, int eng, int math) {
        this.name=name;
        this.kor=kor;
        this.eng=eng;

        if (math>=0 && math<=100) {
            this.math=math;
        }

    }

    public Student(int kor, int eng, int math) {
        this("", kor, eng, math);

    }
}

ArrayList만들어보기

public class Ex71_ArrayList {
    public static void main(String[] args) {
        // JDK
        ArrayList<Integer> list1=new ArrayList<Integer>();
        // 만든 ArrayList
        MyArrayList list2=new MyArrayList();
    }
}

class MyArrayList{
    private int[] list;
    private int index; // 중요역할! 여태 넣은 데이터 수 & 지금 들어갈 마지막 방번호.

    public MyArrayList() {
        this.list=new int[4];
        this.index=0;
    }

    public void add(int value) {
        // 1. 어느 자리에 넣을 것인가
        // 2. 꽉 찰 경우 어떻게 늘릴 것인가
        this.list[index]=value;
        index++;

        // 더 이상 데이터를 넣을 방이 있는지? 없는지?
         if (list.length==index) { // 넣을 방이 없다면
             int[] temp=new int[this.list.length*2]; // 현재 리스트 길이의 2배 길이가 되는 리스트를 만들고,
             for (int i=0; i<this.list.length;i++) { // 그 리스트에 각 요소를 깊은 복사해준다.
                 temp[i]=this.list[i];
             }
             this.list=temp; // 그리고 리스트를 교체.
         }
    }

    public int get(int index) {
        return this.list[index];
    }

    @Override
    public String toString() {
        String temp="";
        temp+="[";
        for(int i=0;i<this.index;i++) {
            temp+=this.list[i]+", ";
        }

        temp=temp.substring(0, temp.length()-2);
        temp+="]";
        return temp;
    }
}

ArrayList 크기 지정

아래와 같이 크기 지정이 가능하다. 그러나 이 지정된 크기보다 더 넣었을 경우는 크기가 doubling이 된다.

ArrayList<Integer> list3=new ArrayList<Integer>(1000);
for(int i=1;i<=1000;i++) {
    list3.add(i);
}

크기보다 더 넣어서 크기가 doubling되었을 때, 쓸모없는 칸들을 버리는 방법은 아래와 같다. 자주 쓰면 안좋다. 길이가 더 이상 늘어나지 않는다고 확신할 때 사용할 것.

list3.trimToSize();

컴파일에서는 발견되지 않지만(문법 오류가 아니기 때문) 실행 중 오류(런타임오류)가 발견되는 경우.

예외처리

전통적인 방식

제어문 사용(조건문)

private static void m1() {
    int num=0;
    if (num!=0) { // 비즈니스코드(업무코드)
        System.out.printf("100 / %d = %d\n", num, 100/num);
    }else { // 예외처리코드
        System.out.println("0을 입력하면 안됩니다.");
    }
}

예외 처리 구문

try catch finally

private static void m1() {
    int num=5;
    try {
        System.out.printf("100 / %d = %d\n", num, 100/num);
    }catch (Exception e){
        System.out.println("0을 입력하면 안됩니다.");
    }
}

전통적 방식과 예외 처리 구문은 작동방식이 다르다.

가독성 좋은 코드 나쁜 코드

// 가독성 좋은 코드
if (num!=0){
    System.out.printf("100 / %d = %d\n", num, 100/num);
}else{
    System.out.println("0을 입력하면 안됩니다.");
}
// 가독성 나쁜 코드
if (num==0){ // 참의 부분에 예외처리해놔서 나쁜 코드.
    System.out.println("0을 입력하면 안됩니다.");
}else{ // 예외에 비즈니스코드
    System.out.printf("100 / %d = %d\n", num, 100/num);
}

예외 e

예외 객체. 예외와 관련된 정보 제공.

예외 각자 처리 vs 묶어서 처리

private static void m4() {
    try {
        int[] nums= {10, 20, 30};
        nums[5]=100;
        Random rnd=null;
        System.out.println(rnd.nextInt());
        Object o1="문자열";
        System.out.println((int)o1);
    }catch(Exception e) {
        System.out.println("예외발생");
    }

}
private static void m3() {
    try {
        int[] nums= {10, 20, 30};
        nums[5]=100;

    }catch(Exception e) {
        System.out.println("방 번호 오류");
    }
    try {
        Random rnd=null;
        System.out.println(rnd.nextInt());
    } catch (Exception e1) {
        System.out.println("널 참조");
    }

    try {
        Object o1="문자열";
        System.out.println((int)o1);
    } catch (Exception e) {
        System.out.println("형변환오류");
    }

}

다중캐치문

private static void m5() {
    try {
        int[] nums= {10, 20, 30};
        nums[2]=100; // ArrayIndexOutOfBoundsException

        Random rnd=null; //null;
        System.out.println(rnd.nextInt()); //NullPointerException
        Object o1="문자열";
        System.out.println((int)o1); //ClassCastException
        Exception e=new Exception(); // 야구공
        throw e;
    }catch(ArrayIndexOutOfBoundsException e) {
        System.out.println("방번호 오류");
    }catch(NullPointerException e) {
        System.out.println("널참조");
    }catch(ClassCastException e) {
        System.out.println("형변환 오류");
    }catch(Exception e) {
        System.out.println("예외발생");
    }    
}

패턴코드

String data="";
while(scan.hasNext()){
    data=scan.next();
    System.out.println("출력 : " + data);
}

띄어쓰기를 기준으로 한줄씩 출력된다.

Scanner로 쪼개기

Scanner scan=new Scanner(System.in);
    String data=scan.nextLine();
    String[] result=data.split(",");
    for(String str:result) {
        System.out.println(str);
    }

1. 추상클래스와 유사. 객체 생성 불가능. 변수 생성 가능(참조형 형변환). 추상메서드 소유 가능.
2. 추상클래스와 차이
   • 구현 멤버를 가지지 못함
   • 일반 변수, 일반 메서드 가지지 못함 -> 구현부를 가질 수 없음
3. 추상메서드의 집합 -> 규칙! 추상메서드만 올 수 있다!
4. 인터페이스의 멤버는 무조건 공개를 원칙으로 한다.

   interface IMember{
   // 추상메서드만 올 수 있다.
   // 인터페이스의 멤버는 무조건 공개를 원칙으로 한다.
   // 추상메서드는 public abstract void aaa();로 선언해야하는데
   void aaa(); // 인터페이스 내에서는 이렇게 선언할 수 있다.
   }

   추상클래스와 인터페이스의 역할은 클래스의 부모역할!

인터페이스를 상속받을 때는 implements

interface IMember{
    boolean login(String id, String pw);
    void logout();
}

class Member implements IMember{

    @Override
    public boolean login(String id, String pw) {
        return false;
    }

    @Override
    public void logout() {

    }

}

추상멤버

자식들이 종류가 다르면 각자 하고 싶은 걸 구현했으면 한다. 기능이 달라도 사용법은 동일하게 만들었으면 한다. -> 최종 사용자가 편리하게 사용하게 하기 위해서.

상속의 경우의 수

1. 자식이 일반클래스, 부모가 일반클래스 : 상속 가능
2. 자식이 일반클래스, 부모가 추상클래스 : 상속 가능
3. 자식이 일반클래스, 부모가 인터페이스 : 상속 가능
4. 자식이 추상클래스, 부모가 일반클래스 : 상속은 되지만 절대 사용 안하는 경우. 논리적인 이치에 맞지 않기 때문.
5. 자식이 인터페이스, 부모가 일반클래스 : 인터페이스는 추상멤버만 가질 수 있기 때문에 일반클래스(일반변수가지고 있음)는 인터페이스에 상속이 불가능.
6. 자식이 추상클래스, 부모가 인터페이스 : 상속 가능. 추상클래스도 추상메서드를 가질 수 있기 때문에.
7. 자식이 인터페이스, 부모가 추상클래스 : 상속 불가능
8. 자식이 추상클래스, 부모가 추상클래스 : 상속 가능
9. 자식이 인터페이스, 부모가 인터페이스 : 상속 가능
   • 일반클래스 -> 일반클래스 -> 추상클래스 -> 추상클래스 -> 인터페이스 -> 인터페이스

enum(Enumeration)

클래스의 일종 열거값을 가지는 자료형(=제시한 값 중에서 선택해서 사용하는 자료형) 열거형. 객관식에 가깝다.

public class Ex66_enum {
    public static void main(String[] args) {
        Gender g1=Gender.male;
        Gender g2=Gender.female;
    }
}

enum Gender{
    MALE,
    FEMALE
}

Generic

제네릭 클래스 : 제네릭의 타입변수 -> 무조건 참조형만 넣을 수 있다. 제네릭 메서드

// 제네릭 클래스
// T : 타입변수 -> 메서드 내의 지역변수용으로는 지양
class Bag<T>{
    // 멤버구현
    public int a;
    public String b; // 정적타입
    public T c; // 동적타입
}

아래와 같이 선언하는 것도 가능하다.
class Camera<T,U>{
    public T a;
    public U b;
}

Object

장점 : 모든 자료형을 넣을 수 있다. -> 코드 비용 감소 단점 : 데이터를 꺼내서 활용할 때 어떤 자료형의 데이터가 들어 있었는지 알기 힘들다. 잘못된 형변환을 할 수 있다. -> 예외 발생 -> 프로그램 안정감소

메서드 재정의. 기존의 메서드를 무시하고 새로 구현한다. 메서드 헤더는 그대로 두고 메서드 바디를 재정의. 상속에서 발생 > 자식 클래스에서 발생하는 일. 부모가 물려준 메서드를 그대로 명시적 선언하게 되면 부모 메서드를 감추고 부모 메서드와 자식 메서드를 동시에 존재하게 해준다. 기술은 발전하면서 사용자들의 사용경험은 유지하는 기술.

메서드 오버로딩 vs 메서드 오버라이드(면접질문!)

메서드 오버로딩 : 메서드가 인자리스트를 다양하게 가질 수 있는 기술. 개발자의 편의를 위해. 메서드 오버라이드 : 부모로부터 물려받은 메서드를 자식이 수정해서 사용하는 기술.

@Override

어노테이션(Annotation) : 컴파일러가 인식하는 주석.(원래 컴파일러는 주석을 인식 못하지만!) 일종의 명령어. 필수는 아니라서 지워도 되지만 편의상 남겨두는 게 좋음.

동일 클래스내에서 다른 생성자 호출하기

우리가 생성자를 아무 것도 안 만든 상태라면 자동으로 기본생성자가 수행되지만 하나라도 생성자를 만들면 그 생성자에 맞춰 생성해야 한다. 기본생성자에서 초기화하면 0이 들어가는데, 이 경우 인자를 받아쓰는 Time()생성자를 이용하는 방법도 있다. 아래와 같이 코드를 작성하면 된다.

class Time{
    private int hour;
    private int min;
    private int sec;

    public Time() {
        this(0, 0, 0);
    }
    public Time(int hour, int min, int sec) {
        this.hour=hour;
        this.min=min;
        this.sec=sec;
    }
}

흔히 볼 수 있는 오버라이딩의 예

아래와 같이 객체를 있는 그대로 출력하면 com.test.inheritance.Time@6d06d69c와 같이 나온다.

System.out.println(t2); = System.out.println(t2.toString()); // 결과 같음
// 이때 toString()의 클래스는 java.lang.object.

Date d1=new Date();
Calendar c1=Calendar.getInstance();

System.out.println(d1.toString()); // 이때 toString()의 클래스는 각 클래스.
System.out.println(c1.toString()); // 오버라이딩된 것!

위에서 t2를 print한 결과는 com.test.inheritance.Time@6d06d69c로 나온다.(com.test.inheritance.Time : 이 객체가 어떤 자료형인지 알려준다. 6d06d69c : 객체가 위치한 메모리 주소값) 이것은 toString()을 붙인 결과와 같은데, 우리가 만든 Time클래스말고 Date클래스와 Calendar클래스를 이용하여 출력한 것을 보면 시간형식으로 나온다. 이렇게 되는 이유는 object클래스에서 상속받은 toString()을 Date와 Calendar클래스는 오버라이딩해서 바꾸었기 때문. 우리가 만든 클래스에서 toString()을 재정의하고 싶다면 아래와 같이 코드를 적으면 된다. 되도록 해당 개체가 가지고 있는 데이터를 문자열로 반환하도록 고친다.

@Override
public String toString() {
    return String.format("%02d:%02d:%02d", this.hour, this.min, this.sec);
}

이렇게 오버라이딩을 해야 하는 이유는 전세계 개발자가 이 결과가 뭔지 알고 있기 때문. 모르는 클래스를 사용할 때 개발자들이 좀 더 빠르게 그 클래스를 파악할 수 있게 하기 위함.

final

final은 프로그램 안정성을 위해 사용한다.

1. 변수에 적용(final변수) -> 값을 변경할 수 없음. "(이름이 있는) 상수"! 자바말고 다른 언어에서는 final 대신 const라고 쓴다.
   • 상수명 표기는 ALL 대문자로!
2. 메서드에 적용(final메서드) : 상속시 발생하는 안정성 문제때문에 사용.
3. 클래스에 적용(final클래스) : 상속 불가능.

형변환

1. 값형 형변환 : 값형끼리만 가능
2. 참조형 형변환 : 참조형끼리만 가능
   • 클래스끼리 가능
   • 상속 관계를 맺은 클래스끼리만 가능
   • 자식클래스 -> 부모클래스 : 암시적, 업캐스팅(Up Casting) -> 100% 안전
   • 부모클래스 -> 자식클래스 : 명시적, 다운캐스팅(Down Casting) -> 100% 불가능

     package com.test.inheritance;
     

public class Ex62_Casting {

public static void main(String[] args) {
    CastParent p1=new CastParent();
    p1.a=10;
    p1.b=20;

    CastChild c1=new CastChild();
    c1.a=10;
    c1.b=20;
    c1.c=30;
    c1.d=40;

    // 1. 자식 -> 부모 복사
    CastParent p2; // 복사본(부모객체)
    CastChild c2=new CastChild(); // 원본(자식객체)
    p2=c2; // (p2=(CastParent)c2와 같음.)암시적, 업캐스팅
    System.out.println(p2.a);
    System.out.println(p2.b);
    // 실제 객체가 가지는 멤버 c와 d를 접근할 수 없다는 게 단점.

    // 2. 부모 -> 자식 복사
    CastParent p3=new CastParent(); // 원본(부모객체)
    CastChild c3; // 복사본(자식객체)
    c3=(CastChild)p3; // 100% 불가능.
}

}

class CastParent{ public int a; public int b; }

class CastChild extends CastParent{ public int c; public int d; }

```

다운캐스팅이 가능한 경우

자식클래스를 먼저 생성하고, 그 자식클래스를 부모클래스로 업캐스팅하고, 그 부모클래스를 다시 자식클래스로 다운캐스팅하는 경우는 가능하다.

현존하는 모든 클래스의 최상위에는 Object클래스가 있다. 업캐스팅은 세대수와 상관없이 가능하기 때문에 결국 자바에 존재하는 모든 클래스는 Object 참조변수에 넣을 수 있다.(값형도 가능)

클래스 멤버에게 붙이는 키워드.

1. 멤버 변수

2. 멤버 메서드 같은 틀(클래스)에서 찍어낸 인스턴스들이 서로 다른 값을 가지는 경우와 공통된 값을 가지는 경우가 있다.

   class SmartPhone{
   // 개개인이 가지는 데이터(다양)
   // 객체 멤버 변수 역할
   private String model;
   private String color;
   private int price;
   
   // 모든 객체가 가지는 공통된 데이터 -> 정적멤버
   private static String manu; -> 정적 멤버변수
   
   // static변수의 getter, setter는 static메서드로 만든다.
   public static String getManu() {
       return manu;
   }
   public static void setManu(String manu) {
       SmartPhone.manu = manu;
   }
   }
   

... public static void main(String[] args) { // 핸드폰 3대

SmartPhone.setManu("삼성");
System.out.println(SmartPhone.getManu());

### 메모리상에서 static에의 접근(! 그림그려넣기)
 1. 클래스 로드 : 클래스 선언 코드를 미리 읽고 내용을 파악하는 작업
  - static키워드가진 멤버를 만나면 static영역에 할당
 2. main() 메서드 실행
![](https://images.velog.io/images/ara_velog/post/a2eeec13-0c2b-4a34-8c1a-dc6562b671d0/%EC%9D%B4%EB%A6%84%20%EC%97%86%EB%8A%94%20%EB%85%B8%ED%8A%B8%EB%B6%81-1.jpg)
### static의 활용 : 만든 개수 세기
```java
...
public static void main(String[] args) {
    Robot r1=new Robot();
    Robot r2=new Robot();
    Robot r3=new Robot();
    System.out.printf("총 개수 : %d개\n", Robot.count);

    }
}

// 로봇장난감 클래스
class Robot{
    private String name;
    public static int count; // 편의상 public으로.

    public Robot() {
        Robot.count++;
    }

    public String getName() {
        return name;
    }

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

}

패키지

클래스를 관리하는 집합(물리적인 폴더) 클래스 관리, 클래스 용도 명확하게 알아보게 하기 위함

패키지명명법

1. 모든 문자를 소문자로 작성한다.(규칙)
2. 공백 금지, 숫자 금지, 특수문자 금지 > 모두 영소문자로만!
3. 전세계의 모든 패키지와 비교해도 중복되지 않도록
   • 주로 도메인을 사용(중복되지 않도록 만드는 것이 힘들기 때문)
   • 예를 들어, 네이버에서 개발하는 자바코드의 패키지는 com.naver.xxx 이런식으로 명명한다.(구글이라면 com.google.xxx 이런식으로.)
   • 패키지명이 겹칠 경우 다른 사람이 만든 프로젝트와 꼬일 수가 있다.
   • 최소 3단계 이상을 사용. 예를 들어, test는 1단계 패키지, com.test는 2단계 패키지, com.test.java는 3단계 패키지.

     패키지의 역할

     패키지가 다르면 클래스명이 중복 가능하다.

     다른 패키지의 클래스를 사용하고 싶으면 import해야 한다.

     클래스명이 겹칠 경우, 현재 패키지에 있는 클래스를 먼저 가져온다. 다른 패키지에 있는 클래스명을 사용하고 싶을 때는 클래스 앞에 패키지명 전체를 써주면 된다. 단, import는 반드시 같은 프로젝트 내에 있는 패키지(클래스)만 인식이 가능하다.

     SmartPhone s1=new SmartPhone(); // 같은 패키지 내에
     com.test.aaa.SmartPhone s2=new com.test.aaa.SmartPhone(); // aaa패키지 내에

상속(Inheritance)

클래스와 클래스 간에 해당 클래스가 소유하고 있는 코드(멤버 변수, 멤버 메서드)를 물려주는 행위. 부모 클래스가 가지고 있는 코드를 자식 클래스에게 물려준다.

상속을 왜 하는지?

코드 재사용을 위해서.

난수생성기

Math.random() : 메서드형태

Random() : 클래스형태

private static void m1() {
    Random rnd=new Random();
    System.out.println(rnd.nextInt()); // int범위 내에서 발생
    System.out.println(rnd.nextInt(10)); // 0~9범위 내에서 발생.
}

Object클래스

java.lang(자바 기본 패키지)에 있다. 루트 클래스(모든 클래스의 조상)

추상클래스&추상메서드(Abstract class&Abstract Method)

추상클래스

클래스의 일종. 일반 클래스의 목적이 객체 생성인데 반해 추상 클래스는 객체의 행동을 표준화하는 것이 목적이다.(객체 생성은 불가능) 상속관계에서 클래스 부모 역할은 가능하다. 추상 메서드를 자식들에게 강제로 만들라고 시키려고. 추상 클래스의 하위 클래스들은 모두 사용법이 동일해진다.

abstract class Monitor{ // 추상클래스의 선언
}

추상메서드

추상클래스에서 추상메서드가 선언되면 그 추상클래스를 상속받은 클래스는 반드시 추상메서드를 구현해야 한다.

abstract class Monitor{
    // 멤버 구현
    public String model;
    public int price;

    // 추상메서드 선언
    public abstract void on();
    public abstract void off();
}

class LG100 extends Monitor{
    public void on(){
        System.out.println("전원 On");
    }
    public void off(){
        System.out.println("전원 Off");
    }
}

eclipse TODO

// TODO

위와 같이 주석을 달면 나중에 tasks에서 TODO만 확인할 수 있다. FIXME는 중요태그이다.

값형과 참조형의 차이

값형과 참조형이 매개변수로 사용될 때의 상황에서

1. 값형(값을 복사해서 전달) : 사이드 이펙트 無
2. 참조형(주소값을 복사해서 전달) : 사이드 이펙트 有

** 참조형 타입이 매개변수로 전달될 때는 주소값이 복사**

int weight=40;
String size="A4";
Calendar c=Calendar.getInstance();

Paper p1=new Paper();

p1.setWeight(weight);
p1.setSize(size);
p1.setCreationTime(c);

System.out.println(p1.getWeight());
System.out.println(p1.getSize());
System.out.printf("%tF\n", p1.getCreationTime());

weight=50;
c.add(Calendar.DATE, 7); // 시간을 일주일 뒤로.

System.out.println(p1.getWeight()); // 무게는 40으로 계속 유지된다.
System.out.println(p1.getSize());
System.out.printf("%tF\n", p1.getCreationTime()); // 하지만 시간은 일주일 뒤로 바뀐다.

배열을 매개변수로 할 때

setter측면에서

1. 배열변수만들어서 set
String[] parent= {"홍아빠", "김엄마"};
b1.setParent(parent);

2. 변수없이 set안에서 생성
b1.setParent(new String[]{"홍아빠", "김엄마"});

3. 배열요소들 입력받아서 setter안에서 설정
b1.setParent("홍아빠", "김엄마");
public void setParent(String father, String mother) {
    this.parent=new String[] {father, mother};
}

// 아래의 경우는 안됨!!!
b1.setParent({"홍아빠", "김엄마"});    

getter측면에서

아래와 같은 방법으로 get할 수 있다.

System.out.println(b1.getParent()[0]);
System.out.println(b1.getParent()[1]);

이 때는 부모 전체 다 가져올 때이고, 배열요소 중 일부를 가져오고 싶을 때는 아래와 같이 코드를 작성하면 된다.

1.  메서드 2개
public String getFather() {
    return this.parent[0];
}
public String getMother() {
    return this.parent[1];
}

2. 메서드 1개, 인자로 구분.
// 숫자 이용하는 방법(그 숫자의 의미를 모르면 불편함)
public String getParent(int n) {
    if (n==1) {
        return this.parent[0];
    }else {
        return this.parent[1];
    }
}
// String 이용하는 방법(어떤 단어를 넣어야 결과가 나오는지 모름)
public String getParent(String n) {
    if (n.equals("아빠")) {
        return this.parent[0];
    }else {
        return this.parent[1];
    }
}

생성자(Constructor)

객체의 멤버를 초기화하는 목적을 가지고 있는 메서드. 사용법이 일반 메서드와는 상이함. 반환 타입이 없고 이름이 클래스명과 동일하다.(이름을 마음대로 정할 수 없다.) 객체 생성 직후 객체의 초기 상태를 설정. 호출은 생성할 때 1번만 가능!

// 기본 생성자
// - 개발자가 명시적으로 선언하지 않아도 컴파일러가 만들어주는 생성자
public Person() {
    this.name=null;
    this.age=0;
}

생성자 오버로딩

public Person(String name, int age) {
    this.name=name;
    this.age=age;
}

생성하면서 초기화시킬 값을 미리 인자로 받아서 생성과 동시에 초기화시킨다. 개발하는 개발자를 위해 객체를 생성하고 초기화하는 방법이 다양해졌다.

1. if (owner==null){
}
2. if (owner.equals(""){
}

이렇게 두 가지 경우가 있다. 결론적으로 말하자면 ==는 주소값 비교이고, equals는 실제값 비교이다.

클래스 Point의 인스턴스 p1을 예시로 보면 아래와 같다.

p1.x=100;
p1.y=200;
// 위에서 쓰인 . 을 멤버 접근 연산자라고 한다.

멤버변수(필드라고도 함)에 들어있는 데이터를 객체의 상태라고 한다.

접근 지정자(제어자)(Access Modifier)

public, private, protected, default. 클래스를 경계로 내부의 멤버(변수, 메서드)를 외부에 공개할지를 결정하는 보안 단계

public

클래스(객체)의 울타리를 경계로 외부에 멤버를 100% 공개

private

클래스(객체)의 울타리를 경계로 외부에 멤버를 100% 비공개. 외부에서 접근 불가능. 접근하면 위험한 중요정보를 보호하기 위해.

class Item{
    public int a;
    private int b; // 캡슐화되어 외부에 비공개된 상태
}

변수는 private으로, 변수 설정 메서드는 public으로(인터페이스 메서드)

class Dog{
    public String name;
    public int age;
    public String color;
}

이렇게 멤버변수를 전부 public으로 선언하면 잘못된 상황을 발생시킬 수 있기 때문에 주의를 요한다. 그렇기 때문에 변수는 private로 설정하고, public메서드를 통해 변수에 값을 넣는다. 감춰진 내부와 공개된 외부를 연결해주는 것이 인터페이스. 이 public메서드가 인터페이스역할을 하는 메서드이다. 변수를 설정하는 인터페이스 메서드를 setter라고도 한다. 이 메서드를 통해서 아래와 같이 유효하지 않은 값으로 변수를 설정하려고 할 때, 제어를 해줄 수 있다.

public void setAge(int age) {
    if (age>=0 && age<=25) {
        this.age=age;
    }else {
        System.out.println("강아지 나이로 올바르지 않습니다.");
    }
}

변수를 설정할 때와 마찬가지로 getter를 통해 변수의 값을 가져올 수 있다.

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

public String getColor(){
    return this.color;

this(객체지정연산자)

멤버변수와 매개변수를 구분하기 위해(지역변수와 멤버변수의 충돌을 막기 위해) 사용. 객체 자신을 가리키는 연산자. (같은 식별자가 충돌하면 항상 지역이 좁은 식별자가 우선한다.)

getter와 setter

두 개 모두 구현되어있으면 읽기/쓰기 필드이고, setter만 있으면 쓰기 전용 필드, getter만 있으면 읽기 전용 필드.(getter는 설정은 못하기 때문에 기본값을 가지고 있는 경우 사용)

계산된 프로퍼티

객체의 멤버 변수(데이터)와 setter, getter를 아울러 Property 혹은 Attribute이라고 한다.

System.out.println(Arrays.toString(array));
// [5, 6, 10, 3, 8] 이런식으로 출력

(다차원배열) Arrays.deepToString() - string 반환

System.out.println(Arrays.deepToString(nums));
// [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20], [21, 22, 23, 24, 25]] 이런식으로 출력

편하긴 하지만 위처럼 출력되면 보기 불편하므로 아래와 같이 코드를 써도 된다.

for (int i=0;i<nums.length;i++) {
    for (int j=0;j<nums[0].length;j++) {
        System.out.printf("%3d", nums[i][j]);
    }
    System.out.println();
}

// 아래와 같은 식으로 출력
  1  2  3  4  5
  6  7  8  9 10
 11 12 13 14 15
 16 17 18 19 20
 21 22 23 24 25

중복되지 않는 임의의 수 배열 만들기

for (int i=0;i<array.length;i++) {
    int num=(int)((Math.random()*numRange))+1;
    for(int j=0;j<i;j++) {
        if (num==array[j]) {
            equal=true;
            i--;
            break;
        }
    }
    if (equal) {
        equal=false;
        continue;
    }else {
        array[index]=num;
        index+=1;
    }
}

다차원배열

int[][] num=new int[2][3];

num의 자료형은 int[][](integer 2차원 배열)이다.

다차원배열의 초기화 리스트

 // 2차원 배열
int[][] nums2=new int[][] {{1, 2}, {3, 4}};
 // 3차원 배열
int[][][] num=new int[][][] //new int[3][2][2]
{
    {
        {1, 2}, {3, 4}
    },
    {
        {5, 6}, {7, 8}
    },
    {
        {9, 10}, {11, 12}
    }
};

모든 참조형변수의 주소값을 저장하는 공간의 자료형은 int.

프로그래밍언어

절차 지향 프로그래밍

순서를 중요. C.

객체 지향 프로그래밍

객체를 중심. C++, Java, C#.

함수형 프로그래밍

F#, kotlin, Java(일부).

객체(Object)

• 데이터(Data)
• 행동(Behavior)
• 상태(State)
• 캡슐화(Encapsulation)
• 상속(Inheritance)
• 다형성(Polymorphism)
• 은닉화
• 인터페이스
• 추상화
• 독자성

클래스와 객체

클래스

코드의 집합. 컨테이너 역할(비중 적은 역할). 객체 생성(가장 큰 역할) + 자료형 역할.

객체

인식 가능하고 구별 가능한 사물.

클래스와 객체는 붕어빵틀&붕어빵과 같음.

클래스 구문

class 클래스명 {
    // 설계 내용 -> 클래스멤버(클래스는 변수와 메서드로 구성되어있음)
    1. 멤버 변수 -> 데이터, 상태, 성질 역할
    2. 멤버 메서드 -> 기능, 행동
}