I/O(Input/Output)는 프로그램과 외부 세계 간의 데이터 이동을 의미한다.

• 키보드 입력
• 파일 읽기/쓰기
• 네트워크 통신

Java에서는 이 모든 작업을 스트림(Stream) 기반으로 처리한다.

1. 스트림(Stream)이란?

스트림은 데이터가 흐르는 통로다.

Java I/O는 데이터를 한 방향으로 흐르게 처리한다.

• 입력 스트림 → 외부 → 프로그램
• 출력 스트림 → 프로그램 → 외부

2. 바이트 스트림 vs. 문자 스트림

Java I/O는 크게 두 계열로 나뉜다.

바이트 스트림 (1 byte 단위)
문자 스트림 (2 byte, 문자 단위)

1) 바이트 스트림

• 모든 종류의 파일 처리 가능
• 이미지, 동영상, 바이너리 파일 등

대표 클래스

• InputStream
• OutputStream
• FileInputStream
• FileOutputStream

예시

FileInputStream fis = new FileInputStream("a.txt");
int data = fis.read();
fis.close();

2) 문자 스트림

• 텍스트 파일 처리에 적합
• 내부적으로 문자 인코딩 처리

대표 클래스

• Reader
• Writer
• FileReader
• FileWriter

예시

FileReader fr = new FileReader("a.txt");
int ch = fr.read();
fr.close();

3. 버퍼 스트림

기본 스트림은 한 글자씩 처리하므로 비효율적이다.

버퍼를 사용하면 성능이 크게 향상된다.

대표 클래스

• BufferedInputStream
• BufferedOutputStream
• BufferedReader
• BufferedWriter

예시

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

버퍼는 내부에 메모리 공간을 두고 한 번에 묶어서 처리한다.

4. try-with-resources

입출력에서는 자원 해제가 중요하다.

try (BufferedReader br = new BufferedReader(new FileReader("a.txt"))) {
    String line = br.readLine();
}

자동으로 close() 호출된다.

5. 파일 클래스 

파일 정보 관리

File file = new File("a.txt");
file.exists();
file.length();
file.delete();

파일 생성, 삭제, 경로 확인 등에 사용된다.

6. 입출력 흐름 구조 정리

File → FileInputStream → BufferedInputStream

또는

File → FileReader → BufferedReader

입출력 클래스는 계층적으로 연결해서 사용한다.

이를 스트림 체인(Stream Chain)이라고 한다.

7. NIO(New I/O) 간단 정리

Java 1.4 이후 도입

• Channel 기반
• Buffer 기반
• 비동기 처리 가능
• 성능 향상

대표 클래스

• Path
• Files
• ByteBuffer
• FileChannel

8. I/O에서 중요한 개념

• 스트림은 단방향
• 반드시 close() 필요
• 버퍼 사용이 성능에 중요
• 예외 처리 필수(IOException)
• 문자 인코딩 고려 필요

프로그램은 항상 정상적으로만 동작하지 않는다.

파일이 없을 수도 있고, 입력 값이 잘못될 수도 있으며, 네트워크 연결이 끊길 수도 있다.

이처럼 프로그램 실행 중 발생하는 오류 상황을 예외(Exception)라고 한다.

Java는 예외를 클래스 형태로 관리한다.

1. 예외와 오류의 차이

Java의 최상위 클래스는 Throwable이다.

Throwable
 ├── Error
 └── Exception

1) Error

• 시스템 레벨 오류
• 복구 불가
• 개발자가 처리하지 않음

ex. OutOfMemoryError

2) Exception

• 프로그램 실행 중 발생 가능
• 개발자가 처리 가능
• 우리가 다루는 대상

2. 체크 예외 vs. 언체크 예외

Exception은 두 종류로 나뉜다.

1) 체크 예외(Checked Exception)

• 컴파일 단계에서 확인
• 반드시 처리해야 함

ex.

• IOException
• SQLException

2) 언체크 예외(Unchecked Exception)

• RuntimeException 하위 클래스
• 컴파일 시 강제하지 않음

ex.

• NullPointerException
• ArrayIndexOutOfBoundsException
• IllegalArgumentException

3. try-catch문

예외를 직접 처리하는 구조

try {
	int result = 10 / 0;
} catch (ArithmeticException e) {
	System.out.printIn("0으로 나눌 수 없음");
}

동작

• try 블록 실행
• 예외 발생 시 catch로 이동
• 해당 타입과 일치하는 catch 실행

4. finally

항상 실행되는 블록

try {
	// 실행
} catch (Exception e) {
	//예외 처리
} finally {
	//항상 실행
}

주로

• 자원 해제
• 파일 닫기
• DB 연결 종료

5. throws

예외를 직접 처리하지 않고 호출한 곳으로 넘긴다.

void readFile() throws IOException{
	// 파일 처리
}

예외 책임을 상위 호출자에게 위임한다.

6. throw

직접 예외를 발생시킨다.

if (age < 0) {
	throw new IllegalArgumentException("나이는 음수 불가");
}

7. 사용자 정의 예외

필요에 따라 직접 예외 클래스를 만들 수 있다.

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

사용

throw new InvalidAgeException("잘못된 나이");

8. try-with-resources

Java 7부터 도입된 자원 자동 해제 문법

try (BufferedReader br = new BufferedReader(new FileReader("a.txt"))) {
    // 사용
}

AutoCloseable 구현 객체는 자동으로 close() 호출된다.

9. 예외 처리 전략

실무에서 중요한 것은 "어디서 처리할 것인가"이다.

1) 낮은 레벨

• 예외를 throws로 던짐

2) 상위 레벨

• 공통 처리(로깅, 사용자 메세지)

3) RuntimeException 활용

• 비즈니스 로직 예외는 언체크 예외로 처리하는 경우 많음

Java는 원래 클래스 중심 언어지만, Java 8 이후 함수형 프로그래밍 요소가 강화되었다.

이 흐름을 이해하려면 내부 클래스 → 람다식 → 스트림 순서로 보는 것이 좋다.

1. 내부 클래스(Inner Class)

클래스 내부에 정의된 클래스를 내부 클래스라고 한다.

class Outer {
	class Inner {
    	void print() {
        	System.out.printIn("Inner Class");
        }
    }
}

1) 내부 클래스 종류

1. 인스턴스 내부 클래스
2. static 내부 클래스
3. 지역 내부 클래스
4. 익명 클래스

2) 인스턴스 내부 클래스

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

• 외부 클래스의 인스턴스 필요
• 외부 멤버 접근 가능

2) static 내부 클래스

static class Inner {}

• 외부 객체 없이 생성 가능
• static 멤버만 접근 가능

3) 지역 내부 클래스

메서드 내부에서 정의

void method() {
	class Local{}
}

4) 익명 클래스

이름 없는 클래스

Runnable r = new Runnable() {
	@Override
    public void run() {
    	System.out.printIn("실행");
    }
}

한 번만 사용할 클래스에 적합하다.

2. 람다식(Lambda Expression)

익명 클래스를 더 간결하게 표현한 문법이다.

1) 람다식 기본 구조

(매개 변수) → { 실행문 }

ex.

(int a, int b) → a + b

3. 함수형 인터페이스

람다는 반드시 함수형 인터페이스와 함께 사용된다.

함수형 인터페이스란, 추상 메서드가 하나만 있는 인터페이스다.

@FunctionalInterface
interface MyFunctino {
	void run();
}

람다는 이 한 개의 메서드를 구현한다.

1) 자주 쓰이는 함수형 인터페이스

4. 스트림(Stream)

스트림은 데이터를 함수형 방식으로 처리하는 API다.

List<String> list = Arrays.asList("A", "B", "C");

list.stream()
	.forEach(System.out::printIn);

1) 스트림의 특징

• 원본 데이터 변경 없음
• 중간 연산 + 최종 연산 구조
• 내부 반복 방식

2) 스트림 처리 단계

1. 생성
2. 중간 연산(filter, map 등)
3. 최종 연산(forEach, collect 등)

list.stream()
	.filter(s -> s.equals("A"))
    .map(String::toLowerCase)
    .collect(Collectors.toList());

5. 주요 스트림 연산

1) 중간 연산

2) 최종 연산

6. 내부 동작 개념

기존 반복문

for (String s : list) {}

스트림

• 내부 반복
• 지연 연산(Lazy Ealuation)
• 병렬 처리 가능

list.parallelStream();

7. 전체 흐름 정리

내부 클래스 → 익명 클래스 → 람다식 → 스트림

• 내부 클래스 : 클래스 안의 클래스
• 익명 클래스 : 일회성 구현
• 람다식 : 익명 클래스의 간결화
• 스트림 : 람다 기반 데이터 처리 API

컬렉션 프레임워크는 여러 개의 데이터를 효율적으로 저장하고 관리하기 위한 구조다.

배열의 한계를 보완하기 위해 등장했으며, Java에서는 java.util 패키지에 포함되어 있다.

1. 컬렉션 프레임워크 구조

컬렉션은 크게 세 가지 계열로 나뉜다.

Collection
 ├── List
 ├── Set
Map (Collection과 별도 구조)

• List → 순서 O, 중복 O
• Set → 순서 X, 중복 X
• Map → Key-Value 구조

2. List

순서가 있고, 중복이 허용된다.

1) 주요 구현체

2) ArrayList

• 조회 빠름(O(1))
• 중간 삽입/삭제 느림
• 가장 많이 사용

List<String> list = new ArrayList<>();

3) LinkedList

• 삽입/삭제 빠름
• 조회는 상대적으로 느림

3. Set

중복을 허용하지 않는다.

1) 주요 구현체

2) HashSet

• 가장 많이 사용
• 순서 보장 안 됨
• 내부적으로 HashMap 기반

3) TreeSet

• 자동 정렬
• Red-Black Tree 기반
• 성능 O(log n)

4. Map

Key-Value 구조

key → value

• key는 중복 불가
• Value는 중복 가능

1) 주요 구현체

2) HashMap

가장 많이 사용되는 Map

Map<String, Integer> map = new HashMap<>();
map.put("A", 10);
map.get("A");

• 평균 검색 O(1)
• 내부적으로 배열 + 해시 + 트리 구조

5. 내부 동작 원리 간단 정리

1) ArrayList

• 배열 기반
• 용량 초과 시 배열 복사

2) HashSet

• HashMap 기반
• hashCode + equals로 중복 판단

3) HashMap

1. hashCode 계산
2. 배열 index 결정
3. equals로 동일성 판단
4. 충돌 시 체이닝 또는 트리 구조 사용

6. 언제 무엇을 써야 할까?

실무에서는

• 대부분 ArrayList
• Key-Value는 거의 HashMap

7. 인터페이스 타입으로 선언하는 이유

List<String> list = new ArrayList<>();

왼쪽은 인터페이스, 우측은 구현체 구조로 작성하면,

• 구현체 교체 가능
• 유연성 확보
• 느슨한 결합

Java는 대부분의 기능을 클래스 형태로 제공한다.

그 중에서도 가장 기본이 되는 핵심 클래스들이 있다.

1. Object 클래스

Object는 모든 클래스의 최상위 부모 클래스다.

class Student {}

위 코드는 실제로 다음과 같다.

class Student extends Object {}

모든 클래스는 자동으로 Object를 상속받는다.

1) 주요 메서드

2) toString()

객체를 출력할 때 호출된다.

System.out.printIn(student);

기본적으로는 클래스명@해시값 형태로 출력된다.

보통 오버라이딩해서 사용한다.

3) equals()

기본 equals는 주소값 비교다.

a.equals(b);

논리적 등등 비교를 하려면 오버라이딩해야 한다.

2. String 클래스

문자열을 다루는 클래스다.

String str = "Java";

String은 참조형이며, 불변(immutable) 객체다.

1) 불변 객체란?

값이 한 번 생성되면 변경되지 않는다.

String s = "Java";
s += " Programming";

실제로는 새로운 객체가 생성된다.

2) 주요 메서드

3. Wrapper 클래스

기본형을 객체로 감싸는 클래스다.

1) 왜 필요할까?

• 컬렉션은 객체만 저장 가능
• 객체 메서드 사용 가능

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

2) 오토 박싱 / 언박싱

Integer num = 10; //오토 박싱
int value = num; //언박싱

컴파일러가 자동 변환한다.

4. Math 클래스

수학 관련 유틸리티 클래스다.

Math.abs(-10);
Math.max(3, 5);
Math.random();

• static 메서드로 구성
• 객체 생성 불필요

5. System 클래스

시스템 관련 기능 제공

System.out.printIn();
System.currentTimeMillis();
System.exit(0);

• 표준 출력
• 시간 측정
• 프로그램 종료

인터페이스는 객체가 반드시 구현해야 할 기능의 규약(계약)을 정의하는 구조다.

클래스가 설계도라면, 인터페이스는 기능 명세서에 가깝다.

1. 인터페이스란?

interface Animal {
	void sound();
}

특징

• interface 키워드 사용
• 메서드는 기본적으로 public abstract
• 객체 생성 불가

2. 구현(implements)

인터페이스는 상속이 아니라 구현한다.

class Dog implements Animal {
	@Override
    public void sound() {
    	System.out.printIn("멍멍");
    }
}

• implements 키워드 사용
• 모든 추상 메서드를 반드시 구현해야 함

3. 인터페이스와 다형성

인터페이스도 다형성을 제공한다.

Animal a = new Dog();
a.sound();

• 참조 타입 → 인터페이스
• 실제 객체 → 구현 클래스

인터페이스는 다형성을 위한 가장 강력한 도구다.

4. 다중 구현 가능

클래스는 단일 상속만 가능하지만, 인터페이스는 여러 개 구현할 수 있다.

interface Flyable {
	void fly();
}

interface Swimable {
	void swim();
}

class Duck implements Flyable, Swimable {
	public void fly() {}
    public void swim() {}
}

5. default 메서드

interface Animal {
	default void breathe() {
    	System.out.printIn("숨 쉰다.");
    }
}

• default 키워드 사용
• 구현 클래스에서 재정의 가능

6. static 메서드

interface Animal {
	static void info() {
    	Systme.out.printIn("동물 인터페이스");
    }
}

인터페이스 이름으로 직접 호출한다.

Animal.info();

7. 필드

인터페이스의 변수는 자동으로 다음 속성을 가진다.

• public
• static
• final

즉, 상수만 정의 가능하다.

int MAX = 10;

8. 추상 클래스 vs. 인터페이스

9. 설계 관점에서의 차이

1) 추상 클래스

• "~이다(is-a)" 관계
• 강한 결합
• 공통 상태 공유

2) 인터페이스

• "~할 수 있다(can-do)" 관계
• 느슨한 결합
• 역할 중심 설계

3) 예시

• Dog is an Animal → 상속
• Dog can Fly → 인터페이스

10. 왜 인터페이스가 중요한가?

실무에서는 인터페이스 기반 설계를 가장 많이 사용한다.

이유

• 구현과 분리
• 교체 가능성 확보
• 테스트 용이
• 유지보수 편리

ex.

List<String> list = new ArrayList<>();

왼쪽은 인터페이스, 우측은 구현체

이 구조가 Java 설계의 기본 패턴이다.

상속을 공부했다면 자연스럽게 등장하는 개념이 추상 클래스다.

추상 클래스는 완전하지 않은 설계도다.

즉, 일부 기능은 구현되지 않은 상태로 남겨두는 클래스다.

1. 추상 클래스란?

추상 클래스란 abstract 키워드를 사용해 정의한다.

abstract class Animal {
	abstract void sound();
}

특징

• 객체 생성 불가
• 추상 메서드를 가질 수 있음
• 일반 메서드도 가질 수 있음

2. 추상 메서드

구현이 없는 메서드다.

abstract void sound();

• 메서드 선언만 존재
• 중괄호 {} 없음
• 자식 클래스에서 반드시 구현해야 함

3. 왜 추상 클래스를 사용할까?

공통 구조는 제공하지만 구체적인 동작은 자식에게 맡기기 위해 사용한다.

abstract class Animal {
	void breathe() {
    	System.out.printIn("숨을 쉰다.");
    }
    
    abstract void sound();
}

• 숨쉬는 기능은 공통
• 소리는 동물마다 다름

4. 자식 클래스에서 구현

class Dog extends Animal {
	@Override
    void sound() {
    	System.out.printIn("멍멍");
    }
}

추상 클래스를 구현하지 않으면 해당 클래스도 abstract가 되어야 한다.

5. 객체 생성 불가

Animal a = new Animal(); //오류

추상 클래스는 설계 개념이기 때문에 직접 인스턴스 생성이 불가능하다.

하지만 다형성은 가능하다.

Animal a = new Dog();

6. 추상 클래스와 다형성

추상 클래스는 다형성을 위한 기반 구조다.

• 공통 타입 제공
• 자식 객체를 부모 타입으로 관리
• 동적 바인딩 발생

즉, 추상 클래스는 "상위 개념"을 표현하기 위해 존재한다.

7. 일반 클래스와의 차이

8. 인터페이스와의 차이(간단 비교)

추상 클래스는 "부분 구현"

인터페이스는 "행동의 규약"에 가깝다.

9. 언제 사용해야 할까?

추상 클래스는 다음 상황에 적합하다.

• 공통 기능을 일부 구현하고 싶을 때
• 자식 클래스 간 강한 연관 관계가 있을 때
• 상태(필드)를 공유해야 할 때

Java는 객체지향 언어다.

객체지향의 핵심 개념 중 가장 중요한 두 가지가 상속(Inheritance)과 다형성(Polymorphism)이다.

이 두 개념은 함께 이해해야 한다.

1. 상속(Inheritance)

상속은 기존 클래스의 속성과 기능을 물려 받아 새로운 클래스를 만드는 것이다.

class Animal {
	void sound() {
    	System.out.printIn("소리를 낸다");
    }
}

class Dog extends Animal{
}

• Animal → 부모 클래스(Super Class)
• Dog → 자식 클래스(Sub Class)
• extends → 상속 키워드

Dog는 Animal의 메서드를 그대로 사용할 수 있다.

1) 상속의 목적

• 코드 재사용
• 계층 구조 표현
• 유지보수 용이

2. 메서드 오버라이딩(Overriding)

자식 클래스에서 부모의 메서드를 재정의하는 것

class Dog extends Animal {
	@Override
    void sound() {
    	System.out.printIn("멍멍");
    }
}

조건

• 메서드 이름 동일
• 매개 변수 동일
• 반환 타입 동일

3. 다형성(Polymorphism)

다형성은 하나의 타입으로 여러 객체를 다룰 수 있는 성질이다.

Animal a = new Dog();

• 참조 타입 → Animal
• 실제 객체 → Dog

이게 다형성의 핵심이다.

4. 업캐스팅(Upcasting)

자식 객체를 부모 타입으로 참조하는 것

Animal a = new Dog();

자동으로 이루어진다.

특징

• 부모 타입의 메서드만 접근 가능
• 실제 실행은 자식 메서드

5. 동적 바인딩(Dynamic Binding)

메서드 호출은 참조 타입이 아니라 실제 객체 기준으로 결정된다.

Animal a = new Dog();
a.sound(); //"멍멍" 출력

컴파일 시점 → Animal 타입

실행 시점 → Dog 객체

이것이 다형성의 핵심 원리다.

6. 다운캐스팅(Downcasting)

부모 타입을 다시 자식 타입으로 변환하는 것

Dog a = (Dog) a;

명시적 형변환이 필요하다.

실제 객체가 해당 타입이 아닐 경우 예외가 발생한다.

if (a instanceof Dog) {
	Dog d = (Dog) a;
}

7. 상속과 다형성의 관계

상속이 있어야 다형성이 가능하다.

• 상속 → 타입 계층 형성
• 다형성 → 부모 타입으로 자식 객체를 다룸
• 오버라이딩 → 동적 바인딩 발생

8. 왜 중요한가?

실무에서 가장 많이 쓰이는 구조

List<Animal> animals = new ArrayList<>();

부모 타입으로 컬렉션을 만들고, 여러 자식 객체를 넣는다.

이게 객체 지향 설계의 기본 패턴이다.

프로그램에서 여러 개의 데이터를 다룰 때 하나의 변수로는 부족하다.

같은 타입의 데이터를 묶어서 관리하는 구조가 필요하다.

그 대표적인 것이 배열과 ArrayList다.

1. 배열(Array)

배열은 같은 자료형의 데이터를 연속된 메모리 공간에 저장하는 구조다.

1) 배열 선언

int[] numbers = new int[5];

• int 타입 데이터 5개 저장
• 크기 5로 고정

2) 배열 초기화

int[] numbers = {1, 2, 3, 4, 5};

3) 배열 접근

배열은 인덱스(index)로 접근한다.

인덱스는 0부터 시작한다.

numbers[0]; //첫 번째 값
numbers[2]; //세 번째 값

4) 배열의 특징

• 크기가 고정됨
• 같은 타입만 저장 가능
• 메모리에 연속적으로 저장
• 빠른 인덱스 접근(O(1))

2. 배열의 메모리 구조

int[] arr = new int[3];

• Stack → arr(참조 변수)
• Heap → 실제 배열 객체 생성

배열도 객체이므로 Heap에 저장된다.

3. ArrayList

ArrayList는 Java에서 제공하는 가변 길이 배열 클래스다.

import java.util.ArrayList;
ArrayList<Integer> list = new ArrayList<>();

1) 특징

• 크기가 자동으로 증가/감소
• 객체만 저장 가능
• 내부적으로 배열 기반으로 동작

2) 주요 메서드

list.add(10); //추가
list.get(0); //조회
list.set(0, 20); //수정
list.remove(0); //삭제
list.size; //크기 확인

4. 배열 vs. ArrayList 비교

5. 왜 ArrayList는 기본형을 못 넣을까?

ArrayList는 제너릭(Generic) 기반 클래스다.

ArrayList<int>; //불가능
ArrayList<Integer>; //가능

기본형(int)은 객체가 아니기 때문에 Wrapper Class(Integer)를 사용해야 한다.

이를 오토 박싱(Auto Boxing)이라고 한다.

6. 내부 동작 원리

ArrayList는 내부적으로 배열을 사용한다.

1. 초기 용량 생성
2. 데이터 추가
3. 용량 초과 시 → 더 큰 배열 생성
4. 기존 데이터 복사

그래서 추가 시점에 비용이 발생할 수 있다.

7. 언제 무엇을 써야 할까?

1) 배열을 쓰는 경우

• 크기가 고정
• 성능이 중요
• 메모리 효율 고려

2) ArrayList를 쓰는 경우

• 데이터 개수가 유동적
• 삽입/삭제가 빈번
• 개발 편의성 중요

실무에서는 대부분 ArrayList를 사용한다.