JAVA 정리

JAVA 정리

JAVA에 대한 전체적인 정리입니다.

JVM

Java Program

Edit → Compile → Load → Verify → Execute 크게 4 부분으로 이루어짐

Edit

• 자바 소스코드를 작성하는 것 (.java 파일)

Compile

• javac를 사용하여 소스코드를 컴파일해 바이트코드로 만듬 (.class 파일)
• eg) javac welcome.java

Load

• JVM(Java Virtual Machine)이 바이트코드를 메모리에 올림
• 디스크나 네트워크의 .class 파일 로드 가능

Verify

• Load 후 Bytecode varifier가 바이트코드 검사
• 네트워크에서 온 코드의 안전을 위해 강하게 검사

Execute

• JVM이 바이트코드를 실행
• Interpretation + JIT(Just-in-time) compilation 수행
• 바이트코드를 기계언어로 변환

메인 함수

public static void main(String[] args);

• args는 Command-Line arguments

Javadoc

/** */

전체 실행 순서

// source.java 작성
source.java
// source.class 생성
javac source.java
// source.class 실행
java source

표준 출력

• 한 줄 출력 System.out.println()
• 형식을 가진 출력 (C의 printf 같이) System.out.printf()

표준 입력

import java.util.Scanner;
public class Main {
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int k = scan.nextInt();
  }
}

3항 연산자

C와 동일 a > b ? a : b;

메소드

type methodName(parameters)

변수 초기화

지역 변수 말고는 다 초기값 가짐, String의 경우 null, boolean은 false가 초기값 나머지는 0

get, set 메소드

Primitive Type

int, char, boolean, short, long, float, double

Reference Type

Primitive를 Reference로 가지는 타입 다

Floating Point

• float : Single precision (소수점 아래 7자리)
• double : Double precision (소수점 아래 15자리)

Control Statements

if, if-else, while, for, switch, do-while, break, continue

Static 키워드

정적 메소드 선언

• static 변수 : 클래스 객체들이 모두 공유함
• static 변수나 함수는 클래스 생성을 안하고도 접근 가능
• static 함수는 static이 아닌 클래스 멤버를 부를 수 없음

Static Import

static import로 클래스의 Static 멤버들 가져올 수 있음

import static package.class.member;

Math 클래스

수학 연산 관련 클래스

import java.lang.Math;

Math.abs(x); // 절대값
Math.ceil(x); // 올림
Math.floor(x); // 내림
Math.cos(x); // Cos
Math.sin(x); // Sin
Math.tan(x); // Tan
Math.exp(x); // e^x
Math.log(x); // Log
Math.max(x, y); // 큰 값
Math.min(x, y); // 작은 값
Math.pow(x, y); // x^y
Math.sqrt(x); // 루트

Final 키워드

값 변경 불가

• 처음 선언 시 값 할당해야함
• 값 바꾸려하면 컴파일 에러
• 초기화 되기 전에 접근해도
• final class : 다른 클래스에서 상속 불가
• fianl method : 다른 메소드에서 오버라이딩 불가
• final variable : 변하지 않는 상수값이 되어 새로운 값 할당이 불가

Promotion (형 변환)

연산 시 높은 형으로 자동 변환되어서 계산됨

Type	Valid promotions
double	None
float	double
long	float, double
int	long, float, double
char	int, long, float, double
short	int, long, float, double (char X)
byte	short, int, long, float, double (char X)
boolean	None

랜덤

import java.util.Random;

Random rand = new Random();
int randomInteger = rand.nextInt(); // Random
int randomInteger = rand.nextInt(5); // 0 ~ 5
int randomInteger = 5 + rand.nextInt(5); // 5 ~ 10

Overloading

이름은 같고 인자는 다른 함수 정의 가능

void sum(int a, int b) {
  return a + b;
}
void sum(int a, int b, int c) {
  return a + b + c;
}

Java.awt.Graphics

간단하게 그래픽 객체를 그리는 클래스

Javax.swing.JPanel

그릴 수 있는 공간 제공

Javax.swing.JFrame

GUI를 띄울 수 있는 창

import java.awt.Graphics;
import javax.swing.JPanel;

public class DrawPanel extends JPanel {
  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    int width = getWidth();
    int height = getHeight();

    g.drawLine(0, 0, width, height);
    g.drawLine(0, height, width, 0);
  }
}

import javax.swing.JFrame;

public class DrawPanelTest {
  public static void main(String[] args) {
    DrawPanel panel = new DrawPanel();

    JFrame application = new JFrame();
    application.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    application.add(panel);
    application.setSize(250, 250);
    application.setVisible(true);
  }
}

Array

같은 타입으로 이루어진 변수들의 모음. 한 번 만들어지면 크기는 고정된다

• Array는 Reference type이다
• Array의 Element들은 Primitive type 이거나 Reference type이 될 수 있다
• index로 접근 array[0]
• index는 0부터
• length 변수를 가지고 있어 크기를 알 수 있음 array.length

int c[] = new int[12];
int a[];
a[] = new int[12];
int[] n = { 10, 20, 30, 40, 50 }; // Initializer list

Arrays Class

import java.util.Arrays;

double[] doubleArray = { 8.3, 1.5, 4.6, 7.5 };
Arrays.sort(doubleArray); // 정렬
Arrays.binarySearch(doubleArray); // 이진 검색
Arrays.equals(doubleArray, doubleArray2); // ==
Arrays.fill(doubleArray, 7.0); // 채워넣기

System.arraycopy(srcArray, 0, dstArray, 0, srcArray.length); // 두 번째 네 번째 인자는 시작 위치를 나타냄

Enhanced for

간단한 문법으로 Array나 Collection의 아이템에 순차적 반복적으로 접근 가능함

• 값을 쉽게 가져오기 위해 사용 가능하지만 Array의 값을 바꿀 수는 없음

for (parameter : arrayName)
  statement;

Pass-by-value (Call-by-value)

자바 모든 Argument들은 다 Pass-by-value (값 복사)

Variable-Length Argument Lists

메소드가 정해지지 않은 개수의 인자를 받을 수 있게 해줌

• ellipsis(…)는 인자 리스트 제일 마지막에만 넣을 수 있음

public static double average(double... numbers) {
  double total = 0.0;
  for (double d : numbers)
    total += d;
  return total / numbers.length;
}

Collections

자바에서 지원하는 미리 선언된 자료구조들

ArrayList

Array와 유사하지만 유동적으로 사이즈 변경이 가능하다 (Dynamic Resizing)

• Generic class : 여러 형을 받을 수 있는 클래스

import java.util.ArrayList;

ArrayList<String> strs = new ArrayList<String>();
strs.add("Hello"); // Item 추가
strs.add("World");
strs.size(); // Size 반환
strs.get(0); // index의 Item 가져옴
strs.remove(0); // index의 Item 삭제
strs.remove("World"); // index의 Item 삭제
strs.contains("Hello"); // Item이 있는지 확인

Predicate method

Condition이 true인지 false인지 나타내는 메소드 eg) ArrayList.isEmpty()

Class

• 이름 : 대문자로 시작해서 카멜케이스 (eg) JavaClassOne
• Case sensitive (대소문자 구분함)
• this : 현재 오브젝트 멤버 접근
• 생성자가 없으면 Default 생성자 자동으로 만들어짐
• 생성자가 하나라도 있으면 Default 생성자 생성 안됨
• 생성자는 Overloading 가능

public class ClassName {
  public ClassName() {}
}

Class 접근 제어자

• private : 외부에서 접근 불가, 접근 시 컴파일 에러
• default : 해당 패키지 내에서 접근 가능
• protected : 자식과, 같은 패키지내의 클래스에서 접근 가능
• public : 어떤 클래스라도 접근 가능

Wrapper Class

Primitive data type들에 대한 클래스 표현을 Wrapper class 라고 한다. Integer, Float, Boolean 등이 있다. Generic에서 타입을 지정할 때는 Wrapper class를 사용해야한다. 일반 클래스의 경우 비교 연산 ==, != 등이 자유롭지만 Wrapper class의 경우 .intValue() 메소드 등을 통해 Wrapper class의 값을 가져와 비교해야한다.

Composition

클래스는 다른 클래스 오브젝트를 멤버로 가질 수 있음

• has-a relationship 이라고도 함

Enumerations

• enum 도 Reference type
• enum constant 들은 묵시적으로 final 이자 static 이다
• new enum 은 컴파일 에러
• switch 구문이나 Enhanced for 구문에서 사용 가능
• enum.values()는 enum의 constant들의 collection을 반환함

import java.util.EnumSet;
public enum Book {
  JHTP("Java How to Program", "2010"),
  CHTP("C How to Program", "2007"),
  IW3HTP("Internet & World Wide Web How to Program", "2008");

  private final String title;
  private final String copyrightYear;

  Book (String bookTitle, String year) {
    title = bookTitle;
    copyrightYear = year;
  }

  public String getTitle() {
    return title;
  }

  public String getCopyrightYear() {
    return copyightYear;
  }

System.out.println(Book.JHTP.getTitle());
for (Book book : Book.values())
  System.out.println(book.getTitle() + book.getCopyrightYear());

EnumSet.range(Book.JHTP, Book.CHTP); // EnmSet으로 일정 범위 볼 수 있음

Garbage Collector

JVM의 Garbage collector가 Garbage collection을 통해서 Object들이 필요없을 시 메모리를 자동으로 해제함

• Object.finalize()로 Garbage collector에 Object 할당을 해제해 달라고 할 수는 있음, 하지만 함수가 호출되자마나 처리해준다고 보장 못함 (안쓰는게 좋음)
• 객체를 다 쓰고나서 object = null로 명시해 주는 것도 좋음

Inheritance (상속)

부모 클래스의 속성을 자식 클래스가 받을 수 있음

• Superclass : 부모
• Subclass : 자식
• 자바는 Single inheritance (하나만 상속 가능)
• 자바의 Class hierarchy는 Object로 부터 시작
• is-a relationship
• Override : 자식 클래스가 부모 클래스의 함수를 재정의 @Override 어노테이션 붙여야함
• super.method() 형식으로 부모 클래스 함수 접근 가능
• super(arguments) 형태로 자식 클래스 생성자에서 부모 클래스 생성자 호출 해야함

Protected

부모 클래스의 멤버, 부모 클래스와 같은 패키지의 클래스들, 자식 클래스가 접근 가능한 멤버

Polymorphism

프로그램을 일반화 시켜줌

• 자식 클래스들을 모두 부모 클래스로 볼 수 있음
• 부모 클래스를 자식 클래스로 볼 수는 없음 (컴파일 에러)
• Dynamic binding : execution time에 객체가 참조해서 사용하는 매소드가 뭔지 판별

Abstract class

객체를 만들 수는 없지만 hierarcy를 위해 만듬

• 자식 클래스는 abstract 메소드 모두 구현 필요
• abstract 메소드가 하나라도 있으면 Abstract class
• public abstract void method() 형태로 함수 정의

Concrete class

객체를 만들 수 있는 모든 멤버가 구현된 클래스

Final class

다른 클래스의 부모가 될 수 없음

• 멤버 함수들도 묵시적으로 final

Finalize

종료자라고도 한다. Object클래스의 Protected 메소드이며 GC에 의해 소멸되기 직전에 실행된다.

Volatile

Volatile이 붙은 변수는 메인 메모리에서 바로 읽고/쓰기를 진행. 하나의 Write 하는 스레드와 여러 Read 스레드들이 있을 경우 값을 보장한다. 하지만, Write를 하는 스레드가 여러 개일 경우 값이 제대로 되지 않을 수 있다.

Annotations

Built-in-Annotations

자바 내장 어노테이션, 컴파일러에게 유용한 정보 제공을 목표로 한다.

• @Override : 부모 클래스의 함수를 자식 클래스에서 재정의한 Overriding을 명시하는 것, 따로 명시하지 않아도 작동하지만, @Override가 붙지 않았을 때 Overriding 시 사용자의 실수가 있을 때 컴파일러가 알려주지 못한다.
• @Deprecated : 차후 버젼에서 지원되지 않기 때문에 더 이상 사용하지 말아야할 메소드 명시
• @SuppressWarning : 프로그래머 의도를 컴파일러에 전달하여 경고 제거
• @FuncionalInterface : 다음 인터페이스가 함수형 인터페이스라는 것을 알림

Meta-Annotations

어노테이션에 사용되는 어노테이션으로 해당 어노테이션의 동작 대상을 결정한다. 주로 새로운 어노테이션 정의 시 사용된다.

• @Target : 어노테이션 적용 가능한 대상을 적용할 때 사용한다. {}를 사용해 여러 개의 값을 지정한다.
• @Retention : 어노테이션이 유지되는 기간을 지정하는데 사용한다.
  • SOURCE : 소스 파일에만 존재하며, 클래스 파일에는 존재하지 않는다. (@Override, @SupressWarning 등)
  • CLASS : 클래스 파일에 존재하지만, 런타임 시에 사용이 불가능하다. (default 값)
  • RUNTIME : 클래스 파일이 존재하며 런타임 시에도 사용 가능하다. (@FuncionalInterface의 경우)
• @Documented : 어노테이션 정보가 Javadoc으로 작성한 문서에 포함되도록 할 때 사용하는 어노테이션이다. Built-in-annotation 중 @Override, @SuppressWarning을 제외하고는 모두 이 메타 어노테이션이 붙어있다.
• @Inherited : 어노테이션이 자손 클래스에도 상속되도록 하는 어노테이션이다.
• @Native : 네이티브 메소드에 의해 참조되는 상수 필드에 붙는 어노테이션이다. 여기서 네이티브 메소드는 JVM이 설치된 OS의 메소드를 말한다.

Custom-Annotations

사용자가 정의할 수 있는 어노테이션은 인터페이스 타입의 한 케이스이다. interface 예약어 앞에 @을 붙여 어노테이션을 선언할 수 있다.

• 어노테이션 타입은 암묵적으로 java.lang.annotation.Annotation을 상속 받기 때문에 extends절을 가질 수 없다.
• 메타 데이터 저장을 위해 클래스처럼 멤버를 가질 수 있다.
• Marker, Single-value, Full Annotation 들이 있다.

Marker Annotation

멤버를 하나도 가지지 않으며, 컴파일러에 표식을 주기 위해 사용된다.

public @interface MarkerAnnotation {}

Single-value Annotation

단일 변수만 갖는 어노테이션이다. 값만을 명시하여 데이터 전달이 가능하다.

public @interface MyAnnotation {
  String value ();
}

@MyAnnotation(value="Passed")
class ClassName(...)

Full Annotation

둘 이상의 변수를 갖는 어노테이션으로 데이터를 배열 안에 key-value 형태로 전달한다.

• 변수의 타입은 Primitive, String, Enum, Annotation, Class 만 허용된다.
• 변수의 ()안에 매개변수 선언은 불가능하다.
• 예외 선언은 불가능하다.
• 변수를 타입 매개변수로 정의할 수 없다.
• 어노테이션 각 변수는 기본 값을 가질 수 있다.

public @interface MyAnnotation {
  int count() default 1;
  String name() default "Name";
}

@MyAnnotation(count=10, name="Pass")
class ClassName(...)

Generic

클래스가 다룰 객체형을 미리 명시해주어 사용하는 방식이다.

• class ClassName<T> {} 를 이용해 제네릭 클래스라는 것을 명시해줄 수 있다.
• ? 키워드를 사용해 하나의 클래스의 자식클래스에 대한 제네릭 객체를 만들 수 있다.

ArrayList<? extends Object> list;

DAT (Data Access Object)

DB의 Data에 접근하기 위한 객체이다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TestDao {

    public void add(TestDto dto) throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost/test", "root", "root");

        PreparedStatement preparedStatement = connection.prepareStatement("insert into users(id,name,password) value(?,?,?)");


        preparedStatement.setString(1, dto.getName());
        preparedStatement.setInt(2, dto.getValue());
        preparedStatement.setString(3, dto.getData());
        preparedStatement.executeUpdate();
        preparedStatement.close();

        connection.close();

    }
}

DTO (Data Transfer Object)

DTO = VO (Value Object)로 계층간 데이터 교환을 위한 자바빈즈이다. 일반 클래스를 생각하면될듯하다.

public class TestDto {

    private String name;
    private int value;
    private String data;

    public String getName() {
        return name;
    }

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

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

Interface

연관 없는 클래스들을 일반적인 메소드로 연결해 줄 수 있음

• 인터페이스를 통해 행동 양식을 표준화할 수 있음

public interface handle {
  public void turnRight();
  public void turnLeft();
}
public class car implements handle {
  public void turnRight() {
    statement;
  }
  public void turnLeft() {
    statement;
  }
}

자바 Common Interface

• Comparable : 비교문구 사용 가능하게
• Serializable : 직렬화 가능하게 (File IO, Object IO에서 사용)
• Runnable : 멀티스레딩시 사용 가능하게

Serialize (직렬화)

자바 시스템 내부에서 사용하는 객체 또는 데이터를 외부의 자바 시스템에서도 사용할 수 있도록 바이트 형태로 변환하는 것을 직렬화, 바이트를 다시 자바 객체로 변환하는 것을 역직렬화라고 한다.

• 자바의 Primitive 타입이나, Serializable 인터페이스를 가진 클래스를 직렬화 가능하다.
• JSON, CSV 등으로도 직렬화가 가능하지만, 자바의 직렬화를 사용하면 개발자가 따로 데이터 형을 지정하는 등 부가적인 작업이 줄어들게되어 편할 수도 있다.

public class car implements Serializable {
}

public class main {
  public static void main(String[] args) {
    try {
      FileOutputStream fo = new FileOutputStream("car.txt");
      ObjectOutputStream oo = new ObjectOutputStream(fo);
      oo.writeObject(new car());
    }
    catch (Exception e) {

    }
    finally {

    }
  }
}

Exception Handling

• Exception : 문제가 있다는 걸 알려주는 표시
• try → catch… → finally 순으로 실행
• Throwable : Exception의 부모 클래스
• Finally 블록은 항상 실행되기 때문에 자원을 해제시킬 때 주로 사용
• Stack unwinding : 현재 Try에서 catch 불가능할 시 상위 Try 블록에서 Catch

Exception	설명
ArrayIndexOutOfBoundsException	배열 바깥의 인덱스 접근 시
ClassCastException	클래스 캐스팅 시
NullPointerException	객체 사용 시 참조가 null 일 경우
ArithmeticException	정수가 0으로 나누어질 경우 [^1]
InputMistmatchException	입력이 잘못 주어질 경우 (Scanner)
IllegalStateException	입력 도 중 파일이 닫혔을 경우
EOFException	파일이 끝났음에도 불구하고 읽으려고 할 경우
ClassNotFoundException	클래스 못 찾을 경우
SecurityException	권한 없는 파일 접근 시
FileNotFoundException	파일 못 찾을 경우

[^1] floating number가 0으로 나뉠 경우 -Infinity 나 Infinity, 0.0 나누기 0.0 은 NaN

• java.lang.Throwable 클래스를 상속 받아 Exception handling 가능
• try 문 후에는 꼭 catch 나 finally가 하나 이상 있어야함
• Exception 처리 안되면 프로그램 종료

import java.util.InputMismatchException;
import java.util.Scanner;

public static int divide(int a, int b) throws ArithmeticException {
  return a / b;
}
public static void main(String[] args) {
  Scanner scanner = new Scanner(System.in);
  try {
    int a = Scanner.nextInt();
    int b = Scanner.nextInt();
    int result = divide(a, b);
  }
  catch (InputMismatchException e) {
    e.printStackTrace();
  }
  finally {
    // Resource deallocation
  }
}

Precondition

메소드가 불려질 때 오류가 없는지

Postcondition

메소드가 값을 반환 할 때 오류가 없는지

Assertions

assert expression;의 expression이 False일 경우 AssertionError 발생

• assert expression : output;으로 AssertionError 발생 시 표시해줄 output 명시 가능

static void method(int a) {
  assert (a >= 0 && a <= 10) : "bad number: " + a;
  return a + 1;
}

• Assert 사용 시 성능이 저하되기 때문에 따로 옵션을 둬서 실행해야함

java -ea AssertTest

String

자바의 String 오브젝트는 immutable (변형 불가능)

• + 나 += 연산은 새로운 String 객체를 만드는 것
• String 객체의 변형이 일어날 때마다 새로운 객체가 만들어짐으로 비효율적
• 하지만 단순히 읽기만을 할 경우 빠르게 읽을 수 있음 (멀티 스레드 환경에서 장점)

StringBuilder

StringBuilder 객체는 mmutable (변형 가능)

• StringBuffer와 동일한 함수 제공
• StringBuffer와는 다르게 멀티 스레드 환경에서 동기화가 되지 않음
• 동기화를 하지 않기 때문에 속도는 StringBuffer 보다 빠름

StringBuffer

StringBuffer 객체는 mmutable (변형 가능)

• StringBuilder와 동일한 함수 제공
• StringBuilder와는 다르게 멀티 스레드 환경에서 동기화 지원

char[] charArray = { 'b', 'i', 'r', 't', 'h', ' ', 'd', 'a', 'y' };
String s= new String("hello");
String s1 = new String(); // ""
String s2 = new String(s); // "hello"
String s3 = new String(charArray); // "birth day"
String s4 = new String(charArray, 6, 3); // "day"

String s = "Hello world!";
char[] charArray = new char[5];
s.length(); // 길이 반환
s.charAt(index); // 인덱스의 캐릭터 반환
s.getChars(start, end, charArray, char start); // String의 문자를 char 배열로 복사, charArray = "Hello"

String s = "Hello";
if (s.equals("Hello")) {} // true, 문자가 같은지 비교
if (s == "Hello") {} // false, 객체가 같은지 비교
if (s.equalsIgnoreCase("hello")) {} // true, 대소문자 구분 없이 비교
if (s.regionMatches(0, "Hell", 0, 4)) {} // true, 0에서 4까지 문자 비교
if (s.regionMatches(true, 0, "hell", 0, 4)) {} // true, 대소문자 구분 없이 비교
if (s.compareTo("go") > 0) {} // true, 사전식 비교

String s = "Hello";
if (s.startsWith("He", 0)) {} // true
if (s.endsWith("lo")) {} // true

String s = "Hello";
s.indexOf('H'); // 0
s.lastIndexOf('l'); // 3
s.indexof("el"); // 1

String s = "Hello";
s.substring(3); // "lo"
s.substring(0, 2); // "He"

String s1 = " world";
s.concat(s1); // "Hello world"

String s = "Hello";
s.toUpperCase();
s.toLowerCase();
s.toCharArray();
s.replace('h', 'o'); // "oello"
String space = "    space  ";
space.trim(); // "space", 앞 뒤 공백 없앰

String.valueOf(10); // "10"
String.valueOf(true); // "true"

StringBuilder buffer = new StringBuilder(10); // "10"
buffer.setLength(1); // "1"
buffer.reverse(); // 역
buffer.append("He"); // "1He"
buffer.setCharAt(0, 'V'); // "VHe"
buffer.insert(1, "K"); // "KVHe"
buffer.isDigit();
buffer.isLetter();

String str = "aa bb ccc ddd";
str.split(" "); // { "aa", "bb", "ccc", "ddd" }

• String regular expression

String str = "Abbab";
str.mathces("[A-Z][a-zA-Z]*"); // true
str.mathces("[^B][a-zA-Z]*"); // true, ^는 not

Files

Java는 File을 byte의 Stream으로 봄

• 마지막은 End-of-file marker
• binary files - byte-based streams
• text files - character-based streams
• java.io. 안에 있음

Stream	설명
FileInputStream	byte-based 입력
FileOutputStream	byte-based 출력
FileReader	Character-based 입력
FileWriter	Character-based 출력
ObjectInputStream	object (byte-based) 입력
ObjectOutputStream	object (byte-based) 출력

File class

File(String path);로 생성

File name = new File(path);
name.exists();
name.getName();
name.isFile();
name.isDirectory();
name.isAbsolute();
name.lastModified();
name.length();
name.getPath();
name.getAbsolutePath();
name.getParent();
if (name.isDirectory())
  name.list(); // Directory 일 경우 폴더의 파일 리스트

try-with-resources

try 구문 안에서 Resource를 생성가능하게 한다. try문이 끝나면 자동으로 Resource 할당을 해제해주는 구문이다. try 구문의 인자에는 AutoCloseable 구현체가 들어가야한다.

try(FileInputStream fi = new FileInputStream("hello.txt")) {

}
castch (Exception e) {

}
finally {

}

Formatter

Text를 파일에 쓰기위해 사용

import java.util.Formatter;

Formatter output = new Formatter("clients.txt");
output.format("%d %d %s\n", 10, 20, "hey"); // 10 20 hey
output.format("%d %d %s\n", 30, 40, "ho"); // 30 40 ho
output.close();

import java.util.Scanner;

Scanner input = new Scanner(new File("clients.txt"));
while(input.hasNext()) {
  input.nextInt();
  input.next();
  input.next();
  input.nextInt();
}
input.close();

Object serialization

객체 자체를 읽고 쓸 수 있게 해줌

• 파일에 쓸 때 Serialize하고, 읽을 때 Deserialize 함
• Seralize 할 객체는 Serializable 인터페이스를 가져야함

ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("Contact.bin"));
os.writeObject(new Human(19, "John"));

ObjectInputStream is = new ObjectInputStream(new FileInputStream("Contact.bin"));
Human h = (Human)is.readObject();
System.out.println(h.getName());

os.close();
is.close();

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
String line = br.readLine();

BufferedWriter br = new BufferedWriter(new FileWriter("file.txt"));
br.write("String");
br.newLine();

Map들

• HashTable : 동기화가 일어남
  • key, value에 null 허용하지 않음
  • 모든 함수에 synchronized 키워드가 선언됨
• HashMap : 비동기적
  • key, value에 null 허용
  • 비동기적이기 때문에 HashTable 보다 속도는 빠름
• ConcurrentHashMap : 동기화가 일어나는 HashMap
  • key, value에 null 허용하지 않음
  • 동일 엔트리에 추가될 경우만 동기화를 진행하기 때문에 멀티 스레드 환경에서 HashTable 보다 빠름