Tech Log 🛠️

0. 스프링 컨테이너란? or IOC Container

- DI 을 이용하여 애플리케이션을 구성하는 여러 빈(Bean)들의 생명주기(Lifecycle)와 애플리케이션의 서비스 실행 등을 관리하며

  생성된 인스턴스들에게 기능을 제공

- Bean 생성, 관리, 제거 등의 역할을 담당

- BeanFactory와 ApplicationContext라는 2개의 컨테이너로 제어하고 관리한다.

1. Bean Factory란?

Bean Factory는 스프링 컨테이너의 최상위 인터페이스이며  빈을 관리하고 조회한다.

getBean 메소드를 통해서 빈을 인스턴스화 할 수 있다.

스프링에서 빈을 관리하기 위한 기본 컨테이너이다.

- 스프링 컨테이너의 최상위 인터페이스다.
- 스프링 빈을 관리하고 조회하는 역할을 담당한다.
- getBean() 을 제공한다.
- IoC의 기본 기능에 초점

2. Application Context 란?

Application Context는 Bean Factory의 모든 기능 상속하면서 여러 부가 기능을 제공하는 컨테이너이다.

- BeanFactory 기능을 모두 상속받아서 제공한다.
- 여러 부가 기능들을 제공한다.

- 빈의 생성, 관계 설정 등의 제어를 총괄하는 것에 초점

3. 공통점

- 제공된 Bean 정의 및 구성을 기반으로 Bean 인스턴스를 생성하고 관리

- 빈의 생성 , 초기화 및 소멸을 포함하여 빈의 수명 주기를 처리

4. 차이점

A. 기능의 차이

애플리케이션을 개발할 때는 빈을 관리하고 조회하는 기능은 물론이고, 수 많은 부가기능들을 제공한다.

MessageSouce

- 메시지소스를 활용한 국제화 기능

EnvinromentalCapable

- 로컬, 개발, 운영등을 구분해서 처리

ApplicationPublisher

- 애플리케이션 이벤트 프로그래밍에 필요한 기능을 제공

ResouceLoader

- 편리한 리소스 조회 기능 제공

B. 빈 로딩시점의 차이

Bean Factory : Lazy Loading 

- 필요 시에 빈을 로딩한다.

Application Context : Eager Loading

- 런타임 실행 시에 모든 빈을 로딩한다.

C. 구성의 차이

BeanFactory는 주로 XML 을 통해 구현된다.

Application Context는 XML 외에도 자바 코드나 어노테이션 등으로 설정을 구성할 수 있다.

5. 결론

Normally when building most applications in a J2EE-environment, the best option is to use the ApplicationContext
, since it offers all the features of the BeanFactory and adds on to it in terms of features, while also allowing a more declarative approach to use of some functionality, which is generally desirable. 

- 스프링 공식 문서

ApplicationContext를 사용하는 것입니다. ApplicationContext는 BeanFactory의 모든 기능을 제공하고 기능 측면에서 추가하고 일부 기능을 사용하는 데 더 선언적인 접근을 허용하기 때문입니다. 일반적으로 바람직한 기능입니다. 

다만 ApplicationContext의 모든 기능이 필요하지 않거나 메모리 관리 적인 측면이 중요할 때는 Bean Factory가 선호될 수 있다.

참고자료

https://velog.io/@sangwoo0727/BeanFactory%EC%99%80-Application-Context-%EB%B9%88-%EB%A1%9C%EB%94%A9%EC%8B%9C%EC%A0%90%EC%9D%98-%EC%B0%A8%EC%9D%B4

https://www.geeksforgeeks.org/spring-difference-between-beanfactory-and-applicationcontext/

https://docs.spring.io/spring-framework/docs/1.2.x/reference/beans.html

추상 팩토리 패턴이란?

구체적인 클래스의 의존하지 않고도 서로 연관 된 객체들의 조합을 만들어주는 인터페이스를 제공하는 패턴이다.

예를 들어서, 어떤 GUI 환경에서 클릭과 스크롤 기능을 제공한다고 생각해보자

운영체제는 크게 3가지가 있다 (윈도우 , 맥 , 리눅스)

그리고 운영체제의 종류에 상관 없이 각각의 기능은 동일한 역할을 한다

추상 팩토리는 동일한 OS에 대해 일관된 객체를 생성하여 준다.

추상 팩토리의 요소들을 각각 다음과 같은 역할을 한다.

AbstractFactory
- 실제 팩토리 클래스의 공통 인터페이스

- GUI로 치면 모든 OS 버전을 담는 인터페이스이다.

ConcreteFactory
- 구체적인 팩토리 클래스로 AbstractFactory 클래스의 추상 메서드를 오버라이드함으로써 구체적인 제품을 생성한다.

- GUI로 치면 OS에 맞는 기능을 수행하는 클래스이다.

AbstractProduct
- 제품의 공통 인터페이스

- GUI로 치면 공통 기능(추상적으로)을 가지고 있는 인터페이스이다. 

ConcreteProduct
- 구체적인 팩토리 클래스에서 생성되는 구체적인 기능

- 여기서 각각의 OS에 맞는 기능을 구현한다.

이렇게 함으로써 사용자는 GUI에 접속할 때 OS 에 맞는 기능들을 수행할 수 있다.

구현 코드

추상 팩토리 패턴에는 인터페이스가 크게 두가지가 있다.

먼저 AbstractFactory 와 AbstractProduct 를 구현해보자 - 기능은 클릭과 스크롤이 있다고 가정한다.

GuiFac(AbstractFactory)

public interface GuiFactory {
    public Click runClick();
    public Scroll scroll();
}

Click(AbstractProduct)

public interface Click {
    public void click();
}

Scroll(AbstractProduct)

public interface Click {
    public void click();
}

기능 두 개를 인터페이스화 함으로써 각각의 OS는 이 기능들을 구체화하면 된다.

만약 리눅스 환경에서의 기능을 구현한다고 하자

LinuxClick(ConcreteProduct)

public class LinuxClick implements Click{
    @Override
    public void click() {
        System.out.println("리눅스 환경에서 클릭합니다.");
    }
}

LinuxScroll(ConcreteProduct)

public class LinuxScroll implements Scroll {
    @Override
    public void scroll() {
        System.out.println("리눅스 환경에서 스크롤합니다.");
    }
}

이렇게 두 가지의 기능을 구현했다.

각각 미리 작성해놓은 Click , Scroll 인터페이스를 구체화한다.

구현된 기능들을 사용자에게 제공하려면 ConcreteFactory 가 필요하다.

LinuxGuiFac(ConcreteFactory)

public class LinuxGuiFac implements GuiFactory {

    @Override
    public Click runClick() {
        return new LinuxClick();
    }

    @Override
    public Scroll scroll() {
        return new LinuxScroll();
    }
}

이제 기능을 사용할 준비가 끝났다

메인에서 기능을 실행시켜보자

public class main {
    public static void main(String[] args) {
        GuiFactory gui = new LinuxGuiFac();
        Click click = gui.runClick();
        Scroll scroll = gui.scroll();

        click.click();
        scroll.scroll();
    }
}

이 코드를 실행시키면,

다음과 같이 리눅스에서 실행한 결과 값이 나온다.

만약 리눅스가 아니라 다른 환경(윈도우 , 맥) 에서의 기능을 구현하고 싶다면 위에서 했던 방식과 동일하게 진행하면 된다.

(과정생략)

public class main {
    public static void main(String[] args) {
        GuiFactory gui = new WindowGuiFac();
        Click click = gui.runClick();
        Scroll scroll = gui.scroll();

        click.click();
        scroll.scroll();
    }
}

윈도우로 구현 팩토리를 변경해주었다.

이렇게 추상 팩토리 패턴을 사용하면 의존성을 주입해주는 것만으로도 구현 코드의 변경없이 기능 구현을 변경할 수 있다.

참고한 사이트

https://www.youtube.com/watch?v=soV1C6j9kkg 

https://gmlwjd9405.github.io/2018/08/08/abstract-factory-pattern.html

문자열을 추가할 때 흔히 StringBuilder 와 StringBuffer 를 주로 사용한다.

그 동안은 멀티 쓰레드의 차이라고만 알고 있었는데 이번에 구체적으로 어떻게 다른 지 코드를 통해 살펴보았다.

StringBuilder VS StringBuffer

기본적으로 스트링 버퍼와 스트링 빌더 모두 AbstractStringBuilder 라는 추상클래스를 상속받는다.

대표적으로 사용하는 append 함수의 구현 코드를 보면 둘다 super() 메소드를 통해 AbstractStringBuilder 의 함수를 호출한다.

근데 스트링 버퍼에만 있는 것들이 몇가지 있다.

1. synchronize 

2. toStringCache

각각이 어떤 역할을 하는 지 알아보자

synchronize

- 이 키워드는 멀티 스레드 환경에서의 동기화를 지원한다.  

- 공유 데이터에 lock을 걸어 작업중이던 쓰레드가 마칠때까지 다른 쓰레드에게 제어권이 넘어가지 않게 보호한다.

이 키워드를 통해 스트링 버퍼를 멀티 스레드 환경에서 지원해준다.

toStringCache

- 이름 그대로 toString() 함수의 캐시 같은 변수이다.

   toString() 함수 호출 시에 이 value 배열의 변경이 없다면,  toStringCache을 이용해서 String을 만든다.

스트링 버퍼는 함수를 호출할 때마다 toStringCache 멤버 변수를 초기화 해준다.

그 상태에서 toString()을 호출하면 toStringCache 는 null 이기때문에 새로운 value 값으로 String 을 만드는 것이다 !

@HotSpotIntrinsicCandidate
    public synchronized String toString() {
        return this.toStringCache == null ? (this.toStringCache = this.isLatin1() ? StringLatin1.newString(this.value, 0, this.count) : StringUTF16.newString(this.value, 0, this.count)) : new String(this.toStringCache);
    }

이미 저장된 값이 있을 경우 기존 값을 이용해 String 을 만든다. 

그게 아니라면 새로운 값으로 String 을 만든다.

근데 왜 toStringCache 변수는 스트링 버퍼에만 있을까 ?

그 이유는 스트링 빌더는 단일 쓰레드 환경에서만 사용되는 것으로 간주하기 때문이다.

이게 무슨 의미냐면, 스트링 버퍼는 멀티 쓰레드에서 실행되기 때문에 변하지 않은 상태에서 여러번 불릴 수 있지만

단일 쓰레드에서 실행되는 스트링 빌더는 상대적으로 이런 경우가 적다.

결국 최적화의 차이이다.

결론

공통점

스트링 빌더와 스트링 버퍼 모두 같은 추상 클래스를 상속 받는다.

차이점

스트링 빌더 : 단일 스레드이거나 동기화를 신경 쓰지않아도 되는 곳

스트링 버퍼 : 멀티 스레드 환경에서 사용

참고한 사이트

https://woooongs.tistory.com/98?category=798806 

https://stackoverflow.com/questions/46294579/why-stringbuffer-has-a-tostringcache-while-stringbuilder-not

인증과 인가

인증 :  유저 확인 절차

           ex) 로그인 , 회원가입

인가 : 해당 유저가 적절한 권한을 가지고 있는 지 확인

           ex) 글 수정 , 삭제 등 권한이 필요한 작업들

HTTP의 특성

HTTP는 기본적으로 상태를 저장하지 않는 stateless 특성을 가진다.

그렇기 때문에 유저의 로그인 정보 또한 기억할  수 없다.

이렇게 되면 매번 요청마다 로그인을 요구해야하는데 이는 비효율 적이다.

이를 보완하기 위해서 유저의 인증 정보를 저장하는 방식으로 세션 인증과 토큰 인증이 있다.

세션 인증

유저가 로그인을 하면 서버에서 세션을 생성해 해당 세션에 맞는 세션ID를 유저의 쿠키로 저장한다.

다음 요청이 들어오면 유저의 세션ID와 서버의 세션ID를 비교해서 권한을 확인하고 인가한다.

장점

1.  서버에 세션을 저장하기 때문에 세션 관리가 용이하다.

2.  서버에 저장 된 세션은 아무나 열람할 수 없기 때문에 보안이 안전하다.

단점

1. 유저의 요청이 많아질수록 서버의 부담이 커진다.

2. 서버 확장 시 세션 불일치 문제가 발생할 수 있으므로 확장성이 떨어진다.

토큰 인증

유저의 정보가 담긴 페이로드와 시크릿 키를 이용해서 암호화 한 토큰을 유저에게 발급한다.

유저는 발급받은 토큰을 보관해놨다가 다음 요청 시 함께 보낸다.

세션은 서버에서 저장되지만 토큰은 유저가 저장한다는 차이가 있다.

토큰은 세가지로 나뉜다.

1. 헤더  : 토큰을 어떻게 검증하는 가에 대한 내용

2. 페이로드 : 토큰에 담긴 사용자 정보

3. 시크릿 키 : 암호화 키

장점

1. 토큰을 유저가 저장하므로 상대적으로 서버에 부담이 적다. 

2. 세션 방식보다 확장성이 좋다.

단점

1. 긴 문자열을 보내야하므로 네트워크 트래픽을 많이 사용한다.

2. 클라이언트가 토큰을 저장하다 보니 세션보다 보안상 취약하다.

참고 사이트

https://velog.io/@chickenrun/%EC%84%B8%EC%85%98-%EC%9D%B8%EC%A6%9D-%EB%B0%A9%EC%8B%9D-VS-Token-%EC%9D%B8%EC%A6%9D%EB%B0%A9%EC%8B%9D%EC%9D%B8%EC%A6%9D%EA%B3%BC-%EC%9D%B8%EA%B0%80

https://hudi.blog/session-based-auth-vs-token-based-auth/

제네릭이란?

어떤 클래스에 아직 형태가 정해지지 않은 필드를 선언한다고 가정해보자이 필드를 어떻게 선언해줘야할까?
 
쉽게 생각해보면 모든 클래스의 최상위 부모 클래스인 Object 로 선언할 수 있다.하지만 이럴 경우 타입을 모르기 때문에 필드값을 얻을 때 문제가 발생한다.
 
instanceof 연산자로 타입을 조사할 수는 있지만 모든 종류의 클래스를 대상으로 조사할 수는 없다.
 
따라서 이런 경우에는 아직 타입이 정해지지않은 필드를 선언할 수 있는 기능이 필요하다.
이것이 "제네릭"이다.
 

제네릭이란 결정되지 않은 타입을 파라미터로 처리하고
실제 사용할 때 파라미터를 구체적인 타입으로 대체시키는 기능

 
 
쉽게 생각하면 일단 타입을 선언한 후에 구체적인 타입은 나중에 설정하는 거라고 이해하면 될 것 같다.
 

public class Box<T>{
	public T content;
}
//'T' 대신 다른 알파벳을 써도 무방

여기서 T는 타입 파라미터를 의미하고 클래스 및 인터페이스만 받을 수 있다.
만약 content에 100을 넣고 싶다면 , 타입 파라미터를 Integer로 대체하면되고
content에 '"name"을 넣고싶다면, 타입 파라미터를 String으로 대체하면 된다.
 

제네릭 타입

제네릭타입은 결정되지 않은 타입을 파라미터로 가지는 클래스와 인터페이스이다.

public class 클래스명<A,B,..> {...}
public interface 인터페이스명<A,B,..> {...}
//선언부에 '<>' 부호가 붙는다.

타입을 지정하지 않으면 Object 타입이 기본적으로 사용되며 , object가 가지고 있는 메소드(ex.equals)를 호출할 수 있다.
 

제네릭 메소드

제네릭 메소드는 타입 파라미터를 가지고 있는 메소드이다.

public <A,B,...> 리턴타입 메소드명(매개변수,..){ }

 
제네릭 타입과는 다르게 타입 파라미터가 메소드 선언부에서 정의된다 .

public static <T> Box<T> boxing(T t) {
        Box<T> box = new Box<T>();
        
        box.setT(t);
        return box;
    }
    
    public static void main(String[] args) {
        Box<Integer> box1 = boxing(100);
        // 100이 Integer 타입이므로 T는 Integer로 대체
        int intValue = box1.getT();
        System.out.println(intValue);

        Box<String> box2 = boxing("name");
        // 100이 String 타입이므로 T는 String으로 대체
        String strValue = box2.getT();
        System.out.println(strValue);
        
    }

제한된 타입 파라미터

경우에 따라서는 타입 파라미터를 대체하는 구체적인 타입을 제한할 수 있다.

public <T extends 상위타입> 리턴타입 메소드(매개변수,...) { }

 
상위타입은 클래스 뿐만 아니라 인터페이스도 가능하다.
 
만약 상위타입을 Number로 제한한다면 해당 자식클래스(Byte,Shoret,Long,Integer ...) 만 사용히 가능하며 해당 클래스가 가지고 있는 메소드도 이용할 수 있다.
 

와일드카드 타입 파라미터

제네릭 타입을 매개값이나 리턴 타입으로 사용할 때 타입 파라미터로 '?'(와일드카드)를 사용할 수 있다.
 
ex)
Student 클래스와 자식 클래스만 매개변수로 가능

리턴타입 메소드명(제네릭타입<? extends Students> 변수) {...}

 
Worker 클래스와 부모 클래스만 매개변수로 가능

리턴타입 메소드명(제네릭타입<? super Worker> 변수) {...}

 
어떤 타입이든 매개변수로 가능

리턴타입 메소드명(제네릭타입<?> 변수) {...}

자바8 부터 컬렉션 및 배열의 요소 및 반복 처리를 위해 스트림을 사용할 수 있다.

스트림이란 ?

스트림은 요소들이 하나씩 흘러가면서 처리된다는 의미를 내장

스트림 없이 컬렉션 및 배열에 저장된 요소를 반복 처리하기 위해서는 for 문이나 iterator를 이용했어야했다.

하지만 스트림의 등장으로 매무 빠르고 효율적으로 처리할 수 있게 되었다.

스트림 없이 처리하는 경우

List<String> list = ...;
for(int i=0;i<list.size();i++){
	String item = list.get(i);
}

스트림 사용

Stream<String> stream = list.stream();
stream.forEach(item -> //item처리);

스트림을 사용하면 뭐가 좋을까?

1. 내부반복자이므로 빠르고 효율적이다. 

2. 람다식으로 다양한 요소 처리를 할 수 있다.

3. 중간 처리와 최종 처리를 수행하도록 파이프 라인을 형성할  수 있다.

내부반복자

스트림의 장점 1번에서 내부반복자이므로 빠르고 효율적이라고 하였다.근데 여기서 '내부 반복자'란 무엇일까?

먼저 for 문을 볼 필요가 있다.

List<String> list = ...;
for(int i=0;i<list.size();i++){
	String item = list.get(i);
}

기존 for문은 외부 반복자이다.

외부반복자란 컬렉션의 요소를 컬렉션 바깥쪽으로 꺼내와서 처리하는 것을 말한다.

예시 코드에서는 컬렉션의 요소들을 item 이라는 변수내에 가져와서 처리하고있다.

하지만,

내부반복자(스트림) 은 컬렉션 내부에서 요소를 반복 처리하기 때문에 컬렉션 요소들을 밖으로 꺼낼 필요가 없어서 더욱 빠르고 효율적이다.

이 외에도 내부 반복자는 멀티코어 CPU를 최대한 활용하기 때문에 요소들을 분배시켜 병렬 작업을 할 수 있다.

중간 처리와 최종처리

스트림은 크게 세가지로 구분된다.

//오리지날 스트림
Stream<Student>  student = list.stream();
//중간처리 스트림(매핑)
IntStream scoreStream = studentStream.mapToInt( student -> student.getScore());
//최종처리 스트릠(집계)
double avg = scoreItem  = scoreStream.average().getAsDouble();

1. 오리지널 스트림

2. 중간 처리 스트림   

- 매핑 중간 스트림이 연결 될 수 있다.   

- 필터링 , 매핑 ,정렬 작업 수행

3. 최종 처리 스트림   

- 중간 처리에서 정제된 요소들을 반복하거나 , 집계 작업(카운팅, 종합 , 평균)을 수행

- 최종 처리 스트림이 없으면 스트림이 실행되지 않는다.

스트림의 종류

BaseStream 에는 모든 스트림에서 사용할 수 있는 공통 메소드들이 정의되어있다.

BaseStream의 자식 인터페이스들은 다음과 같은 상속 관계를 가지고 있다.

1. Stream 

     - 객체 요소를 처리

2. IntStream

    - int 요소를 처리

3. LongStream

    - long 요소를 처리

4. DoubleStream

    - double 요소를 처리

리소스로부터 스트림 얻기

1. 컬렉션으로부터 스트림 얻기     

- List 와 Set 인터페이스를 구현한 모든 컬렉션에서 객체스트림을 얻을 수 있다.

      ex) Product 라는 객체를 저장하는 리스트로부터 스트림을 받는 코드

Stream<Product> stream =  list.stream();

2. 배열로부터 스트림 얻기   

-  java.utils.Arrays 클래스를 이용하면 다양한 종류의 배열로부터 스트림을 얻을 수 있다.

//문자열 배열
String[] strArray = {"홍길동","신용권","김미나"};
//문자열 스트림(strStream) 을 얻을 수 있다.
String<String> strStream = Arrays.stream(strArray);

//정수 배열
int[] intArray = {1,2,3,4,5};
//문자열 스트림(intStream) 을 얻을 수 있다.
IntStream intS1tream  = Arrays.stream(intArray);

이외에도 숫자 범위나 파일 등등 여러 리소스로 부터 스트림을 얻을 수 있다.

함수형 프로그래밍이란,

함수를 정의하고 데이터 처리부로 보내 데이터를 처리하는 기법

함수형 프로그래밍을 위해 자바8부터 람다식을 지원한다.

람다식 :(매개변수, ...) -> {처리내용}

자바는 람다식을 익명 구현 객체로 변환한다.

추상 메소드가 하나이고 두개의 매개변수를 가지는 람다식은 다음과 같다.

(x,y) -> { 처리내용 };

x,y : 매개변수

-> { 처리내용 } : 추상 메소드의 실행 블록

람다식은 인터페이스의 익명 구현 객체이므로 인터페이스 타입의 매개변수에 대입될 수 있다.

public class Main {
    public static void main(String[] args) {
        action((x, y) -> {
            int result = x+y;
            System.out.println("result: "+ result);
        });

        action((x,y) -> {
            int result = x-y;
            System.out.println("result ="+result);
        });
    }

    public static void action(Calculable calculable) {
        int x = 10;
        int y = 4;
        calculable.calculate(x, y);
    }
}

calculable.calculate(x,y) 가 실행되면 람다식의 중괄호 블록이 실행된다.

어떤 람다식을 매개값으로 제공하느냐에 따라 결과는 달라진다.

* 인터페이스의 익명 구현 객체를 람다식으로 표현하려면 인터페이스가 단 하나의 추상메소드를 가져야한다.

( @FuntionalInterface 를 붙이는 것은 본인 마음이지만 정확한 함수형 인터페이스를 작성할 수 있다. )

매개변수가 없는 람다식

//실행문이 두개 이상일 경우
() ->{
	실행문;
        실행문;
}

//실행문이 하나일 경우
() -> 실행문

실행문이 두 개 이상일 경우에는 중괄호를 생략할 수 없다.

public static void main(String[] args) {
        Person person = new Person();

        person.action(() -> {
            System.out.println("WORK");
            System.out.println("PROGRAMMING");
        });

        person.action(()->{
            System.out.println("WORK");
        });
    }

매개변수가 있는 람다식

함수형 인터페이스와 추상 메소드에 매개변수가 있을 경우

매개변수타입은 생략하거나 var를 사용할수도 있지만 타입을 생략하는 것이 일반적이다.

리턴값이 있는 람다식

함수형 인터페이스의 추상 메소드에 리턴값이 있을 경우return 문 하나만 있을 경우에는 중괄호와 함께 return 키워드 생략가능리턴값은 연산식 or  리턴값이 있는 메소드 호출로 대체 가능

public static void main(String[] args) {
        Person person = new Person();

        person.action((x, y) -> {
            double result = x+y;
            return result;
        });

        person.action((x,y) -> (x+y));

    }

메소드 참조

public class Computer {
    public static double staticMethod(double x,double y){
        return x+y;
    }public double instanceMethod(double x,double y){
        return x*y;
    }
}

public static void main(String[] args) {
        Person person = new Person();

        person.action(Computer::staticMethod);

        Computer com = new Computer();

        person.action(com::instanceMethod);

    }

매개변수의 메소드 참조

람다식에서 제공되는 a 매개변수의 메소드를 호출해서 b 매개변수를 매개값으로 사용하는 경우가 있다.

(a,b) -> {a.instanceMethod(b);}

이것을 메소드 참조로 표현하면 다음과 같다.

클래스::instanceMethod

a의 클래스 :: 메소드 이름

public class MethodReference {
    public static void main(String[] args) {
        Person person = new Person();
        person.ordering(String :: compareToIgnoreCase);
    }
}

생성자 참조

람다식이 아래와 같이 단순히 객체를 생성하고 리턴하도록 구성된다면 생성자 참조로 대치할 수 있다.

(a,b) -> {return new 클래스(a,b);}

이것은 생성자 참조로 표현하면 다음과 같다.

클래스 :: new

과거에 중첩 선언에 대해 정리한 적이 있지만 람다식을 공부하다가 개념이 헷갈려서 익명 객체와 함께 복습을 진행함

https://cb036133.tistory.com/56

중첩 클래스

- 클래스 내부에 선언한 클래스 

- 클래스의 멤버를 쉽게 사용할 수 있고 코드의 복잡성을 줄일 수 있다.

- 특정 클래스하고만 관계를 맺을 경우 중첩 클래스로 선언하는 것이 유지보수에 용이

멤버 클래스

- 클레스의 멤버로서 선언되는 중첩 클래스

  1. 인스턴스 멤버 클래스 

  2. 정적 멤버 클래스

로컬 클래스

  3. 메소드가 실행할 때만 B객체를 생성할 수 있음

1. 인스턴스 멤버 클래스 

   - 클래스 내부에서 사용되므로 private접근 제한을 갖는 것이 일반적

   - 인스턴스 필드값 , 생성자 , 인스턴스 메소드에서 생성할 수 없다 .( 바깥 객체가 있어야 B객체도 생성할 수 있기 때문)

   - 인스턴스 멤버 클래스를 외부에서 생성하려면  default 또는 public 접근 제한을 가져야한다.

   - 클래스 내부에는 필드 , 생성자 , 메소드 선언이 올수 있다.

   - 정적 필드와 메소드는 자바 17 부터 가능

2. 정적 멤버 클래스

   - 외부에서 사용되는 경우가 많기 때문에 default 또는 public 접근 제한을 가진다.

   - 바깥 객체 내부 어디에서든 정적 멤버 클래스 객체를 생성할 수 있다.

   - 정적 멤버 클래스 내부에는 필드 , 생성자 , 메소드 선언이 올 수 있다.

3. 로컬 클래스

   - 생성자 또는 메소드 내부에서 선언된 클래스이다.

   - 생성자와 메소드가 실행될 동안에만 객체를 생성할 수 있다.

   - 필드 , 생성자 , 메소드 선언이 올 수 있다. 

   - 정적 필드와 정적 메소드는 자바17부터 가능

   - 로컬 변수를 로컬 클래스 내에서 사용할 경우 자동으로 final 특성을 갖게 된다.

바깥 멤버 접근 

정적 멤버 클래스 내부에서는 바깥 클래스의 필드와 메소드를 사용할 때 제한이 따른다.

인스턴스 멤버 클래스 : 바깥 클래스의 모든 필드와 메소드

정적 멤버 클래스 :  바깥 클래스의 정적 필드와 정적 메소드

중첩 클래스 내부에서 바깥 클래스의 객체를 얻으려면 바깥 클래스 이름에 this 를 붙여주면 된다 !

ex) 바깥클래스이름.this -> 바깥 객체

중첩 인터페이스 

- 클래스의 멤버로 선언된 인터페이스

- 해당 클래스와 긴밀한 관계를 맺는 구현 객체를 만들 수 있다.

class A{
	[public|private] [static] interface B{
    	// 상수 필드
        // 추상 메소드
        // 디폴드 메소드
        // 정적 메소드
    } 
}

익명 객체 

- 이름이 없는 객체

- 명시적으로 클래스를 선언하지 않기 때문에 쉽게 객체를 생성할 수 있다.

- 필드값 , 로컬 변수값, 매개변수 값으로 사용

익명 자식 객체 : 클래스를 상속

익명 구현 객체 : 인터페이스를 구현

익명 자식 객체

익명 자식 객체는 부모클래스를 상속받아 다음과 같이 생성된다.

new 부모생성자(매개값, ...){
 	//필드
    //메소드
}

이렇게 생성된 객체는 부모 타입의 필드, 로컬 변수 , 매개변수의 값으로 대입 가능

익명 구현 객체

익명 구현 객체는 인터페이스를 구현해서 다음과 같이 생성된다.

new 인터페이스(매개값, ...){
 	//필드
      //메소드
}

중괄호 블록안에는 주로 인터페이스의 추상 메소드를 재정의하는 코드가 온다.

컬렉션 프레임워크

- 자료구조를 바탕으로 객체들을 효율적으로 추가,삭제,검색할 수 있는 인터페이스 , 클래스

- 대표적으로 List, Map , Set 이 있다.

* List 와 Map은 Collection 인터페이스로 상속 , Map 은 사용 방법이 이 둘과는 다륻다.

List 컬렉션

- 객체를 인덱스로 관리한다.

- ArrayList , Vector , LinkedList 등이 사용된다.

- 메서드를 통해 객체추가 , 객체 검색 , 삭제를 할 수 있다.

ex) add(), contatains() , clear()

ArrayList 

- 일반 배열은 사이즈를 미리 정해 주어야하지만 , ArrayList는 제한없이 객체를 추가할 수 있다.

- 객체의 번지를 저장한다. (동일한 객체를 저장할 경우 동일한 번지가 저장된다!!)

- null 도 저장가능

- 특정 인덱스의 객체를 제거하면 모두 앞으로 1씩 당겨진다.

- 선언은 다음과 같이 할 수 있다.

List<E> list = new ArrayList<E>(); // E에 지정된 타입의 객체만 저장

List<E> list = new ArrayList<>(); // E에 지정된 타입의 객체만 저장

List list = new ArratList(); // 모든 타입의 객체를 저장

- 삽입 삭제시 자료 전체가 이동하기 때문에 빈번한 수정이 발생하는 곳에서는 적합하지 않다, (LinkedList 사용)

Vector 

- ArrayList와 동일한 내부구조이지만 동기화된 메소드로 구성되어있다. -> 멀티스레드가 동시에 실행 불가 !!

- 선언방식은 다음과 같다.

List<E> list = new Vector<E>(); // E에 지정된 타입의 객체만 저장

List<E> list = new Vector<>(); // E에 지정된 타입의 객체만 저장

List list = new Vector(); // 모든 타입의 객체 저장

LinkedList

- ArrayList와 달리 LinkedList는 인접객체를 체인처럼 연결해서 관리 

- 따라서 객체 삭제와 삽입이 일어나는 곳에서 용이하다.

List<E> list = new LinkedList<E>(); // E에 지정된 타입의 객체만 저장
List<E> list = new LinkedList<>(); // E에 지정된 타입의 객체만 저장
List list = new LinkedList(); // 모든 타입의 객체를 저장

Set 컬렉션

- 저장 순서가 유지되지 않고 중복을 허용하지 않는다 !

- 인덱스를 사용하지 않기 때문에 인덱스를 사용하는 메소드가 없다

HashSet 

- 가장 많이 사용되는 클래스이다.

- 객체를 중복 저장하지 않는다. 

   만약 다른 객체라도 hash 코드 함수의 리턴값이 같고 equals 메소드가 true를 리턴하면 동일한 객체하고 판단하고 중복 저장하       지 않는다.(메소드 재정의를 통해서 구현할 수 있다)

Set 컬렉션은 인덱스가 없기때문에 객체를 한개씩 반복해서 가져와야한다.

1. for문을 통해 가져오기

2. iterator() 메소드로 가져오기 

iterator() 는 다음과 같은 메소드를 제공한다.

- hasnext() : 가져올 객체가 있는 지 알려준다.

- next()  : 컬렉션에서 하나의 객체를 가져온다.

- remove() : next로 가져온 객체를 set 컬렉션에서 제거한다.

iterator 메소드는 다음과 같이 선언할 수 있다.

Iterator<E> iterator = set.iterator();

Map 컬렉션

- Map 컬렉션은 키와 값으로 구성된 엔트리를 저장

- 키는 중복 저장할 수 없지만 값은 중복저장 가능

- 만약 동일한 키가 저장되면 기존 키가 삭제된다.

- 키를 매개값으로 갖는 메소드가 많다.

ex) put(K key , V value) : 주어진 키와 값을 추가 , 저장이 되면 값을 리턴

      boolean  containsKey(Object key) : 주어진 키가 있는지 여부

HashMap 

- Set와 마찬가지로 중복을 허용하지 않는다 . (키값에 한해서만)

- hashcode 의 리턴값이 같고 equals 가 true를 리턴할 경우 중복저장을 허용하지 않는다.

- 다음과 같이 선언할 수 있다.

Map<K,V> map = new HashMap<K,V>();
Map<K,V> map = new HashMap<>();
Map map = new HashMap(); // 모든 타입의 키와 객체를 저장할 수 있지만 거의 안쓴다.

HashTable

- HashMap과 다른 점은 동기화 된 메소드로 구성되어 있다는 점이다.

  따라서 멀티스레드가 동시에 HashTable메소드들을 실행할 수 없다.

- 선언은 HashMap 과 동일한 방식으로 하면 된다.

ArrayList VS LinkedList

같은 Set 컬렉션이지만 이 둘은 정확히 어떻게 다를까 ?

1. 상속받는 클래스가 다르다.

    - ArrayList 는 AbstractList(배열 클래스)라는 클래스를 상속받지만 LinkedList는 Abstarct Sequential List(연결리스트 클래스)        라는 클래스를 상속 받는다.

2. 데이터를 저장하는 방식에 차이가 있다.

     - ArrayList는 쭉 늘어진 배열의 형식을 취하고 있지만 , Linked List는 서로 자료의 주소값으로 연결되어져 있다.

     - 이때문에 Linked List는 데이터의 삽입 , 삭제 시에 몇개의 참조자만 바꾸어주면 되므로 빠르게 연산을 수행할 수 있다.

3. 장단점

    - Linked List는 데이터의 삽입 삭제에 용이하지만 Sequantial access 만을 지원하기 때문에 인덱스를 통한 데이터 접근이 불가        능하다.

      참조자를 위한 추가적인 메모리가 필요하다

      사실 순차 접근도 데이터가 연속적으로 저장되어져 있는 ArrayList가 더 빠르다.

    - Array List는 데이터의 삽입 삭제가 상대적으로 느리지만 random access를 지원하기 때문에 인덱스를 통한 탐색을 할 수 있다.

참고자료

https://www.nextree.co.kr/p6506/

중첩클래스

- 클래스 내부에 선언한 클래스

- 특정 클래스하고만 관계를 맺을 경우 사용

- 생성할 경우 바이트코드 파일 생성

인스턴스 멤버 클래스 

- 주로 클래스 내부에서 사용되므로 private 접근 제한을 가짐

- 인스턴스 필드값, 생성자 , 인스턴스 메소드에서 생성가능

- 외부에서 사용하려면 바깥 클래스를 생성해야 함

- 중첩 클래스 내부에는 필드,생성자,메소드 선언이 가능하다. (자바17부턴 정적 필드, 정적 메소드 선언 가능)

정적 멤버 클래스

- static 키워드로 선언된 중첩 클래스

- 외부에서 사용되는 경우가 많아서 일반적으로 public 혹은 default

- 클래스의 어디에서든 생성 가능

- 중첩 클래스에는 필드, 생성자, 메소드 선언이 올 수 있다.

로컬클래스

- 생성자 혹은 메소드 내부에서 선언된 중첩클래스

- 메소드(생성자) 가 실행 될 경우에만 객체 생성 가능

- 중첩 클래스 내부에는 필드,생성자,메소드 선언이 가능하다. (자바17부턴 정적 필드, 정적 메소드 선언 가능)

- 로컬 클래스 내에서 값을 변경하지 못하기 때문에 로컬 변수는 (자바8 이후부터)자동으로 final 로 선언

바깥멤버 접근

- 인스턴스 멤버 클래스 : 바깥 클래스의 모든 필드와 메소드 사용 가능

- 정적 멤버 클래스 : 정적 클래스와 정적 메소드만 사용 가능

- 바깥 클래스 객체에 접근하기 우해선 this 를 붙여준다. ex) 바깥클래스.this -> 바깥 객체

중첩 인터페이스

- 클래스의 멤버로 선언된 인터페이스

- 해당 클래스와 긴밀한 관계를 맺는 구현 객체를 만들 수 있다.