ks_velog

기술 면접 - java 1편

Tue, 13 Aug 2024 15:34:04 GMT

1. Java 의 장단점에 대해 설명해주세요.

장점
- JVM에서 동작하기 때문에 운영체제에 독립적
- 객체지향 언어이기 때문에 이해하기 쉽다.
- 오픈소스로 사용할 수 있고 커뮤니티가 잘 발달되어 있다.
- 멀티쓰레드를 쉽게 구현할 수 있다.
- 가비지 컬렉터에 의해 메모리 관리를 자동으로 해준다.
단점
- 컴파일되고 번역하는 과정을 거치기 때문에 비교적 느리다.
- 가비지 컬렉터로 인해 메모리 공간 필요

2. Java 의 데이터 타입에 대해 설명해주세요.

자바의 데이터 타입은 기본 데이터 타입과 참조 타입으로 나뉩니다. 기본 데이터 타입으로는 byte, short, int, long, float, double, boolean, char 가 있으며 Stack 영역에 저장됩니다. 참조 타입은 기본형은 제외한 모든 타입이며, Heap 영역에 저장됩니다.

기본 데이터 타입(Primitive Data Type)
- 정수형 : byte, short, int, long
- 실수형 : float, double
- 논리형 : boolean(ture/false)
- 문자형 : char
- 기본 타입의 크기가 작고 고정적이기 때문에 메모리의 Stack 영역에 저장된다.
참조 타입(Reference Data Type)
- 참조 타입 종류: class, array, interface, Enumeration
- 기본형을 제외하고는 모두 참조형
- new 키워드를 이용하여 객체를 생성하여 데이터가 생성된 주소를 참조하는 타입이다.
- String과 배열은 참조 타입과 달리 new 없이 생성이 가능하지만 기본 타입이 아닌 참조 타입이다.
- 참조 타입의 데이터의 크기가 가변적, 동적이기 때문에 동적으로 관리되는 Heap 영역에 저장된다.
- 더 이상 참조하는 변수가 없을 때 가비지 컬렉션에 의해 파괴된다.
- 참조 타입은 값이 저장된 곳의 주소를 저장하는 공간으로 객체의 주소를 저장한다. (Call-By-Value)

3. Wrapper 클래스와 Boxing, Unboxing 에 대해서 설명해주세요.

Wrapper 클래스는 프로그램에 따라 기본 데이터 타입을 객체로 취급해야 하는 경우, 기본 타입들의 데이터를 객체로 포장한 클래스입니다. 기본 타입의 데이터를 Wrapper 클래스의 값으로 변환하면 Boxing, 반대의 경우를 Unboxing이라고 합니다.

Wrapper Class
- 프로그램에 따라 기본 데이터 타입을 객체로 취급해야 하는 경우, 기본 타입들의 데이터를 객체로 포장한 클래스
- java.lang 패키지에 존재

기본 타입	래퍼 클래스
`byte`	`Byte`
`short`	`Short`
`int`	`Integer`
`long`	`Long`
`float`	`Float`
`double`	`Double`
`char`	`Character`
`boolean`	`Boolean`

Boxing
- 기본 타입의 데이터를 Wapper 클래스의 인스턴스로 변환하는 과정
Unboxing
- Wrapper 클래스의 인스턴스에 저장된 값을 기본 타입의 데이터로 꺼내는 과정

4. Java는 Call by Value인가요 Call by Reference인가요?

자바는 Call by Value 를 따릅니다. 기본 자료형의 경우 해당 값이 복사되어 전달되고, 참조 자료형의 경우 힙 메모리의 참조값이 복사되어 전달됩니다.

자바에서 파라미터는 항상 값으로 전달됩니다. (파라미터의 복사본이 메서드에 전달)
기본 자료형의 경우 값의 복사본이 전달됩니다.

참조 자료형의 경우 힙 메모리의 주소값이 복사되어 전달됩니다.

아래 예시의 경우 User 의 메모리가 복사되어 전달된다. b 의 경우 새로운 주소를 할당하는데 메서드가 종료되면 원본 b 에는 반영되지 않는다.
```
class User {
public int age;

public User(int age) {
    this.age = age;
}
}
```

public class ReferenceTypeTest {

void test() {
    User a = new User(10);
    User b = new User(20);

    System.out.println(a); // age: 10
    System.out.println(b); // age: 20
    modify(a, b);

    System.out.println(a); // age: 11 
    System.out.println(b); // age: 20
}

private void modify(User a, User b) {
    a.age++;

    b = new User(30);
    b.age++;
}

}

5. Java 의 접근제어자는 어떤 것이 있나요?

자바의 접근 제어자로는 제약 없이 접근 가능한 public, 동일 패키지 또는 상속 관계에서 접근 가능한 protected, 동일 패키지에서만 접근 가능한 package-private, 선언한 객체에서만 사용 가능한 private 이 있습니다.

접근 제어자	설명
`public`	`해당 객체를 사용하는 프로그램 어디에서나 접근 가능`
`protect`	`동일 패키지 또는 상속 관계의 객체에서 접근 가능`
`package-private`	`동일 패키지에서 접근 가능`
`private`	`해당 객체에서만 사용 가능`

6. 클래스, 객체, 인스턴스를 비교해주세요.

클래스는 객체를 만들어 내기 위한 틀로서 객체가 가질 수 있는 속성과 메서드를 정의하며, 이를 실체화한 것이 객체입니다. 인스턴스는 객체의 구체적인 사례입니다.

클래스(Class)
- 객체를 만들어 내기 위한 설계도 혹은 틀
- 연관되어 있는 변수와 메서드의 집합
객체(Object)
- 소프트웨어 세계에 구현할 대상
- 클래스에 선언된 모양 그대로 생성된 실체
- '클래스의 인스턴스(instance)' 라고도 부른다.
인스턴스(Instance)
- 설계도를 바탕으로 소프트웨어 세계에 구현된 구체적인 실체
  - 즉, 객체를 소프트웨어에 실체화 하면 그것을 '인스턴스'라고 부른다.
  - 실체화된 인스턴스는 메모리에 할당된다.

7. static 키워드에 대해 설명해주세요.

클래스 멤버를 정의할 때 사용되며, 객체가 생성되기 전에 초기화 되며, 모든 인스턴스에서 공유되어 사용됩니다.

클래스 멤버를 정의할 때 사용
객체가 생성되기 전에 클래스의 로딩 과정에서 메모리에 할당되므로, 객체 생성 없이 클래스 이름만으로 접근할 수 있다.
static 키워드를 적절히 사용하면, 메모리를 효율적으로 사용하거나 객체 생성 없이도 편리하게 접근할 수 있는 장점이 있다.

8. 클래스 멤버와 인스턴스 멤버

클래스 멤버: 클래스에 존재하는 변수와 메서드.
인스턴스 멤버: 객체(인스턴스)에 존재하는 변수와 메서드. static 키워드를 사용하지 않고 정의한다.
클래스 멤버에서는 인스턴스 멤버가 접근 가능하지만, 인스턴스 멤버에서는 클래스 멤버로 접근이 불가능하다.

9. static 멤버와 non-static 멤버는 무슨 차이가 있나요?

static 멤버는 클래스가 로딩될 때 메모리에 할당되며, 모든 인스턴스에서 공유됩니다. 반면에 non-static 멤버는 각 인스턴스가 생성될 때 메모리에 할당되고, 인스턴스마다 고유한 값을 가집니다.

다음과 3가지의 차이점이 존재한다.

항목	메모리 할당 시기	접근 방법	공유 여부
`static`	클래스가 로딩될 때	인스턴스를 생성하지 않고 클래스 이름으로 접근	모든 인스턴스가 동일한 값 공유
`non-static`	인스턴스가 생성될 때	인스턴스를 생성한 후 접근	인스턴스마다 고유한 값 존재

10. main 메서드는 왜 static 메서드인가요?

main 메서드는 프로그램이 실행될 때 가장 먼저 호출됩니다. 인스턴스가 생성되기 전에 호출되어야 하기 때문에 static으로 정의되어야 합니다.

main 메서드는 프로그램이 시작할 때 JVM에 의해 호출됩니다. 만약 non-static 메서드라면, main 메서드를 호출하기위해 클래스를 인스턴스화 시켜야 하기 때문에 JVM 에서 직접 호출이 불가능합니다. 따라서 main 메서드는 static 메서드여야 합니다.

11. 자바 프로그램 실행 시 static 이 붙은 변수는 어떻게 처리되나요?

static 이 붙은 변수는 해당 클래스가 로딩될 때 Method Area에 한번 초기화되고 값 변경이 일어나지 않습니다. 이후에 인스턴스를 초기화하지 않고 사용할 수 있습니다.

자바 프로그램이 실행되고 JVM이 프로그램에서 사용되는 클래스를 로드하고, 해당 static 변수를 초기화합니다.
JVM은 Method Area 에 static 변수에 메모리를 할당합니다.

12. 오버로딩과 오버라이딩을 비교해주세요.

오버로딩은 메서드의 이름은 같고 파라미터를 다르게 한 것이고, 오버라이딩은 부모 클래스의 메서드를 자식 클래스에서 재정의하는 것을 의미합니다.

오버로딩
- 이름은 같고 매개변수의 수, 타입 또는 순서가 다른 여러 메서드 정의
- 반환하는 타입은 달라도 된다.
오버라이딩
- 메서드 이름과 매개변수가 동일한 부모 클래스의 메서드를 자식 클래스에서 재정의하는 것
- 오버라이딩된 메서드가 자식클래스의 인스턴스에서 호출되면 부모 클래스의 메서드는 무시된다.

13. 인터페이스와 추상클래스를 비교해주세요.

둘의 차이는 목적에 있어 차이가 있습니다. 추상클래스는 abstract 키워드로 선언된 클래스로서 기능을 이용하고 확장하도록 의도합니다. 반면, 인터페이스는 추상메서드로만 이루어진 것으로 기능의 구현을 강제하도록 의도합니다. 이때문에 추상클래스는 공통 기능을 가지는 기반 클래스로 적합하며, 인터페이스는 다형성이 필요한 경우에 적합합니다.

추상클래스
- abstract 키워드로 선언된 클래스
- 자식 클래스가 추상클래스의 기능을 이용하고 확장하는데 초점을 둔다.
- 클래스이기 때문에 다중상속은 지원하지 않는다.
- 기능의 확장에 초점을 두기 때문에 공통 기능을 가지는 베이스 클래스에 적합하다.
인터페이스
- 추상 메서드와 상수로만 이루어진 것
- 인터페이스는 선언된 기능을 구현하도록 강제한다.
- 기능의 구현을 강제하기 때문에 같은 기능을 다르게 구현하는 다형성이 필요한 경우에 적합하다.
- 다중 상속이 가능하다.
  - 다중 상속을 할 때 메서드 충돌은 어떻게 해결할까?
    - 다중 상속을 하더라도 인터페이스에는 구현부가 없고, 구현 부분이 하나이기 때문에 컴파일 에러는 나타나지 않는다.
    - 다만, default 메서드를 통해 인터페이스에서 구현하는 경우 컴파일러는 오류를 내보낸다. (모두 구현된 경우)
    - 이 경우 2가지 해결 방법이 존재한다.
      1. 인터페이스에서 구현하지 않고 상속한 클래스에서 구현한다.
      2. 하나의 인터페이스로 구현을 위임한다.
추상 메서드
- abstract 키워드와 함께 구현부는 작성되지 않고 선언부만 작성된 메서드
- final 키워드가 붙은 메서드는 추상 메서드로 만들 수 없다.
- 물론 static 메서드도 추상 메서드로 만들 수 없다.

14. 클래스는 왜 다중 상속을 허용하지 않을까요?

다중 상속을 허용하지 않는 이유는 모호성때문입니다. 다중 상속하는 클래스에서 이름이 같은 메서드가 있다면 어떤 메서드를 컴파일러가 호출할지 모호하기 때문에 자바에서는 다중 상속을 지원하지 않습니다.
자바에서는 모호성때문에 다중 상속을 지원하지 않는다.
부모 클래스들에서 같은 이름을 가진 메서드나 변수가 있다면, 자식 클래스에서 어떤 메서드를 컴파일러가 호출할지 모호하기 때문이다.

15. Java의 Error, Exception 구조에 대해 설명해주세요.

자바의 Error 와 Exception 은 모두 Throwable 객체를 상속받습니다. Error 는 주로 시스템 레벨의 심각한 에러로서 개발자가 처리할 수 없는 에러입니다. 반면, Exception 은 크게 RuntimeException 과 다른 Exception 으로 구분되며, 주로 개발자가 작성한 프로그램에서 발생하는 에러입니다.
Error
- 시스템에 발생하는 심각한 예외 상황을 나타냄
- OutOfMemoryError, StackOverflowError 등
- 시스템 자체에서 발생하여 개발자가 대응할 수 없다. -> 따로 처리하지 않아도 된다.
Exception
- 개발자가 작성한 프로그램에서 발생하는 예외 상황을 나타냄
- RuntimeException, IOException 등
- 일반적으로 RuntimeException 과 나머지 Exception 으로 구분되어 구조화한다.
- try-catch-finally 구문을 사용하여 예외 처리를 해야한다.

16. CheckedException 과 UncheckedException 은 무슨 차이인가요?

UncheckedException 와 CheckedException 의 차이는 예외 처리의 강제성에 있습니다. CheckedException 은 컴파일 과정에서 발생하여 예외를 강제하는 반면, UncheckedException 은 런타입 과정에서 발생하는 예외이기 때문에 컴파일 과정에서 예외 처리를 강제하지 않습니다.

UncheckedException
- RuntimeException 과 이를 상속한 예외
- 런타임 과정에서 발생하는 예외
- 예외 처리를 강제받지 않음
  - 다만 예외가 런타임 과정에서 발생하기 때문에 예상하지 못한 에러가 발생할 수 있다.
  - 따라서 예외 상황이 발생할 것을 대비하여 예외 처리를 하는 것이 좋다.
CheckedException
- RuntimeException 을 제외한 Exception 예외
- 컴파일 과정에서 발생하는 예외
- 컴파일러에 의해 예외 처리가 강제됨

17. 예외처리의 세 가지 방법을 설명해주세요.

예외 처리 방법으로 예외 상황을 정상 상태로 돌려놓는 예외 복구, 호출한 메서드로 예외 처리를 넘기는 예외 회피, 다른 예외로 전환하는 예외 전환이 있습니다.
예외 복구
- 예외가 발생하더라도 애플리케이션이 정상적인 흐름으로 동작하도록 진행
예외 회피
- 예외가 발생하면 throws 를 통해 호출한 메서드로 예외 처리를 위임하는 것
예외 전환
- 다른 예외로 전환.
- 호출한 메서드에서 예외를 처리할 때 더 명확하게 예외 상황을 인지할 수 있도록 돕는다.
- throw 를 통해 실행

18. final 키워드는 왜 사용할까요? 어떤 이점이 있을까요?

final 키워드는 변수와 메서드, 클래스에 붙어 변하지 않도록 하는 역할을 수행합니다. 의도치 않은 변경을 줄여 코드 안정성을 보장하고 final 변수는 상수이기 때문에 컴파일 과정에서 성능 향상을 가져올 수 있습니다. 또한, 코드 가독성을 높일 수 있습니다.
코드 안정성
- 의도치 않은 코드 변경을 줄일 수 있기 때문에 코드 안정성이 높아진다.
성능 향상
- final 변수는 상수로 취급하여 컴파일 과정에서 변수를 계산하는 과정이 준다. 이만큼 성능 향상을 불러올 수 있다.
코드 가독성
- 변수, 메서드, 클래스에 final 키워드를 붙이면 변경되지 않는다는 의미를 명확하게 전달할 수 있다.

19. final, finally, finalize 에 대해 설명해주세요

final 키워드는 변수, 메서드, 클래스를 변경 불가능하도록 만드는 것이고, finally 는 try-catch 구문 마지막에 항상 실행될 코드 블록을 정의하기 위해 사용됩니다. 마지막으로 finalize 는 GC 가 더이상의 참조가 존재하지 않는 객체를 메모리에서 삭제할 때 사용되는 메서드입니다.
final
- 기본 데이터 타입에 적용: 변수에 저장된 값의 변경이 불가능
- 참조 데이터 타입에 적용: 참조 변수의 힙 메모리를 재할당 불가능
- 메서드에 적용: 오버라이드 불가능
- 클래스에 적용: 상속 불가능
finally
- try-catch 구문이 종료될 때 항상 실행될 코드 블록을 정의하기 위해 사용
- JVM 이 종료되거나 해당 프로세스가 종료되지 않는 이상 무조건 실행된다.
  - return 문이 try 에 있어도 finally 코드 블록이 실행됨
  - try-with-resources 구문을 사용할 수 있으면 try-catch-finally 대신 사용할 것
    - 예외가 중복될 경우 디버깅이 힘듦
    - 가독성이 나빠짐
finalize
- Garbage Collector 가 더이상 참조가 존재하지 않는 객체를 메모리에서 삭제할 때 호출하는 메서드
- Object 클래스의 finalize 메서드를 오버라이딩하여 커스텀할 수 있다.

20. final 키워드는 컴파일 과정에서 다르게 실행될까요?

final 키워드가 붙은 변수는 상수와 같이 취급이 됩니다. 메서드는 오버라이딩이 안되기 때문에 오버라이딩한 메서드를 찾는 과정이 생략됩니다. 클래스는 상속이 불가능하기 때문에 자식 클래스를 찾는 과정이 생략됩니다.

21. 제네릭에 대해 설명해주세요.

제네릭은 클래스 내부에서 사용하는 타입을 외부에서 지정할 수 있는 방법입니다. 장점으로는 컴파일 시점에 타입 체크를 진행해 타입 안정성을 보장하고 코드 중복을 줄여줍니다. 반면 단점으로는 문법이 생소하여 가독성이 떨어지고 공변성 때문에 배열과의 호환성이 좋지 않습니다.

클래스 내부에서 사용하는 타입을 외부에서 지정하는 방법
장점
- 컴파일 시점에 타입 체크를 통해 타입 안정성을 보장
- 코드 중복을 줄여줌
단점
- 문법이 생소하여 가독성이 떨어짐.
- 배열의 공변성으로 인해 배열과의 호환성이 떨어짐

22. 리플렉션이 무엇이고, 언제 활용 가능한지 설명해주세요.

리플렉션은 동적으로 클래스의 정보를 얻어 사용할 수 있는 기법입니다. 주로 런타임에 클래스에 접근하여 정보를 얻어야 할 때 사용됩니다. 예시로는 Spring 의 애노테이션, Jackson 등이 있습니다.
런타임에 클래스의 이름, 메서드, 필드 등을 동적으로 가져오는 API
클래스 정보가 런타임 시점에 필요할 때 이용
Spring 의 애노테이션, IDE 의 자동완성, Jackson 등이 있다.

23. 리플렉션의 장단점에 대해 설명해주세요.

리플렉션의 장점으로는 클래스의 정보를 동적으로 로딩할 수 있다는 장점이 있습니다. 또한 객체를 런타임에 생성하여 유연성을 높일 수 있습니다. 반면 단점으로는 private 메서드에 접근할 수 있는 보안문제와 타입이 정해지지 않는 클래스의 정보를 동적으로 가져오기 때문에 성능 저하가 있습니다.
장점
- 클래스의 정보를 동적으로 로딩
- 객체를 런타임에 생성
단점
- 타입이 정해지지 않는 클래스의 정보를 가져오기 때문에 컴파일러의 최적화를 받지 못한다. 이 때문에 성능 저하가 발생한다.
- 동적으로 클래스 정보를 가져오기 때문에 가독성이 떨어진다.
- private 메서드에 접근할 수 있기 때문에 보안문제가 생긴다.

24. 자바의 직렬화와 역직렬화에 대해 설명해주세요.

자바에서 직렬화는 시스템 내부에서 사용되는 객체 또는 데이터를 외부 시스템에서도 사용할 수 있도록 바이트 형태로 변환하는 기술입니다. 반면, 역직렬화는 바이트로 변환된 데이터를 객체로 변환하는 기술입니다.

직렬화
- 시스템 내부에서 사용되는 객체 또는 데이터를 외부 시스템에서도 사용할 수 있도록 바이트 형태로 변환하는 기술
- JVM 의 메모리(힙 또는 스택)에 있는 객체 데이터를 변환
- 조건
  - 기본 타입 (primitive)
  - java.util.Serializable 인터페이스를 상속받은 객체
- 방법
  - java.io.ObjectOutputStream 객체 이용
역직렬화
- 바이트로 변환된 데이터를 객체로 변환하는 기술
- JVM 의 메모리에 저장
- 조건
  - 직렬화 대상이 된 객체의 클래스가 클래스 패스에 존재해야 하며, import 되어 있어야 한다.
    - 직렬화와 역직렬화를 진행하는 과정이 다른 시스템에서 일어날 수 있다.
  - 자바 직렬화 대상 객체는 동일한 serialVersionUID 를 가지고 있어야 한다.
- 방법
  - java.io.ObjectInputStream 객체 이용

25. 자바의 직렬화는 언제, 어디서 사용되나요?

JVM 의 메모리에서만 저장된 객체 데이터를 영속화할 때 사용합니다. 장점으로는 시스템이 종료되더라도 사라지지 않는 점이 있습니다. 예시로는 파일로 저장하는 서블릿 세션, 캐시 등이 있습니다.
언제?
- JVM 메모리에서만 있는 객체 데이터를 영속화할 때 사용
장점
- 시스템이 종료되더라도 없어지지 않음
예시
1. 서블릿 세션
  - 서블릿 기반의 WAS 들은 대부분 세션의 자바 직렬화를 지원하고 있다.
  - 세션을 통해 파일로 저장하거나 세션 클러스터링, DB 를 저장하는 등에서 세션 자체가 직렬화가 되어 저장되고 전달됨
2. 캐시
  - 퍼포먼스를 위한 캐시 라이브러리(Ehcache, Redis, Memcached 등)에서 주로 이용
3. 자바 RMI(Remote Method Invocation)
  - 자바 RMI: 원격 시스템 간의 메시지 교환을 위해서 사용하는 기술
    - 소켓 통신을 하지 않고 추상화하여 메서드를 통해 호출
  - 원격에 있는 메서드를 호출할 때 전달하는 메시지(주로 객체)를 직렬화

26. 자바의 Synchronized 키워드를 설명해주세요.

Synchronized 키워드를 통하여 메서드나 코드 블록에 Lock 을 걸어 스레드 간 상호 배제를 할 수 있습니다. 메서드에 작성할 경우 해당 클래스 인스턴스에 Lock 을 걸고, 코드 블록에 작성할 경우 블록으로 작성된 부분만 Lock 이 걸리게 됩니다.
Lock 을 걸어 스레드 간의 상호배제를 할 수 있는 키워드.
적용 위치: 메서드, 코드 블록
메서드에 적용
- 클래스 인스턴스에 Lock
static 메서드에 적용
- 클래스에 Lock
- static synchronized 메서드와 synchronized 메서드의 Lock 은 공유하지 않는다.
메서드의 코드 블록에 적용
- 인스턴스의 블록 단위에 Lock
- 동기화 전후에는 Lock 이 적용되지 않기 때문에, 효율적 사용 가능
- block 에 this 를 명시할 경우 메서드에 붙은 것과 같은 효과
```
public class Test {
public void run() {
    // ...

    synchronized (this) {
        // ...
    }

    // ...
}
}
```
block 에는 객체 인스턴스를 지정하거나 클래스를 지정할 수 있다.
static 메서드의 코드 블록에 적용
- 클래스에 Lock
- 코드 블록에 this 를 지정할 수 없다.
동기화 순서
- Thread 의 동기화 순서를 보장하지 않는다.

27. 동기화와 비동기화의 차이를 설명해주세요.

동기화와 비동기화의 차이는 호출되는 함수의 반환을 신경쓰는지 여부와 연관이 있습니다. 호출되는 함수의 반환값을 기다리면 동기화, 기다리지 않으면 비동기화입니다. 자바에서 동기화는 synchronized 키워드를 통해 구현 가능하고, 비동기화는 Thread 클래스를 통해 구현할 수 있습니다.
동기화
- 호출되는 함수의 반환값을 기다린다. 반환이 되었으면 다음 흐름을 진행한다.
- synchronized 키워드
- Atomic 클래스
  - CAS(Compare-And-Swap) 알고리즘을 사용하여 lock 없이 동기화 처리 가능
  - lock 없이 동기화
- volatile
  - Main Memory 에 저장
  - 모든 스레드에서 Main Memory 에 읽기, 쓰기를 하기 때문에 값이 일치함
비동기화
- 호출되는 함수의 반환값을 기다리지 않고 다음 흐름을 진행한다.
- Thread 를 통해 구현

28. 동시성 문제가 무엇인가요? 자바에서 동시성 문제를 해결할 수 있는 방법이 있을까요?

동시성 문제란 동일한 자원에 대해 여러 스레드가 동시에 접근하면서 발생하는 문제입니다. 자바에서는 해당 쓰레드만 접근할수 있는 ThreadLocal 를 통해 해결할 수 있습니다. 하지만 ThreadLocal 의 사용이 끝나면 반드시 저장된 값을 제거하는 과정을 거쳐야합니다.
동일한 자원에 대해 여러 스레드가 동시에 접근하면서 발생하는 문제
지역 변수에서는 발생하지 거의 발생하지 않고, 싱글톤, static 과 같은 공용 필드에서 주로 발생
읽기와 쓰기를 동시에 하는 경우에 발생

29. Thread Local에 대해 설명해주세요.

스레드마다 접근할 수 있는 개인 저장소를 의미합니다. ThreadLocal 의 데이터는 사용이 끝나면 반드시 삭제해야합니다. 스레드 풀 환경에서 사용이 완료된 데이터를 지워주지 않으면 재사용되는 스레드가 올바르지 않는 데이터를 참조할 수 있기 때문입니다.

30. 자바의 어노테이션에 대해 설명해주세요.

인터페이스를 기반으로 한 문법으로 주석처럼 코드에 달아 특별한 의미를 부여하거나 기능을 주입할 수 있습니다. 어노테이션에는 크게 세가지 종류가 있습니다. JDK 에 포함되어 있는 build-in 어노테이션과 어노테이션의 정보를 나타내기 위한 Meta 어노테이션, 개발자가 직접 정의한 Custom 어노테이션이 있습니다.
인터페이스를 기반으로 한 문법
사용
- 컴파일러에게 필요한 정보 제공
- 컴파일/배포 시 필요한 처리 기능
- 런타임 처리 제공
build-in 어노테이션
- @Override
- @Deprecated
- @SuppressWarnings
- @FunctionalInterface
- ...
메타 어노테이션
- @Target: 어노테이션이 적용 가능한 대상 지정
- @Retention: 어노테이션이 유지되는 기간 지정
- @Documented: javadoc 포함 여부 지정
- @Inherited: 어노테이션의 상속 가능 여부 지정
- @Repeatable: 어노테이션을 반복하여 적용 가능하도록 지정
주의 사항
- @AllArgsConstructor, @RequiredArgsConstructor
  - 인스턴스 멤버의 순서가 변경되면 생성자의 순서도 변경되기 때문에 타입이 같은 경우 개발자가 인지하지 못할 수도 있다.
- @ToString
  - 양방향 관계에서 해당 어노테이션을 통해 순환참조가 일어날 수 있다.
- @Data
  - 위의 모든 문제가 일어날 수 있다.

31. 자바 8에 추가된 기능들에 대해 간단히 설명해주세요.

자바 8에는 익명 함수를 단순하게 표기한 람다 표현식, 하나의 추상 메서드만 갖고 있는 함수형 인터페이스, 인터페이스의 default 메서드, 연속된 정보를 처리하는 Stream 클래스, null 처리를 간편하게 하기 위한 Optional 클래스 등이 있습니다.
주요하게 추가된 것
- Lambda
- Functional Interface
  - 하나의 추상 메서드만 가지는 인터페이스
- Stream
- Optional
- 인터페이스의 Default Method
- 날짜 관련 클래스 추가
  - ZoneDataTime, LocalDate, DateTimeFormatter, DayOfWeek
- 병렬 배열 정렬
  - parallelSort() 메서드 추가
- StringJoiner
  - 순차적으로 나열되는 문자열 사이에 특정 문자열을 넣어줄 때 사용

32. Stream에 대해 설명해주세요.

자바 8에 추가된 Collection 타입의 데이터를 처리하는 API 입니다. 주요 특징으로는 병렬 처리 용이하고 원본 데이터를 변경하지 못하며 재사용 불가능하고 최종 연산을 할 때 중간 연산이 실행된다는 점이 있습니다.
특징
- 병렬 처리 용이
  - parallel() 메서드 제공. (cf. common fork join pool)
  - 코어 수가 많을수록, 처리할 데이터가 많을수록, 데이터당 처리 시간이 길수록 병렬 처리 성능 향상
- Immutable
  - 원본 데이터에 대한 변경 불가능
- Lazy
  - 중간 연산은 최종 연산에 이용될 때 값 계산
  - 중간 연산: filter, map, flatMat, limit, sorted, peek, ...
  - 최종 연산: foreach, reduce, findFirst, anyMatch, count, collect, ...
- 재사용 불가능
  - 최종 연산 완료 후 Stream 이 닫히므로 재사용 불가능

33. Stream과 반복문 for문의 성능차이가 있을까요?

for 문은 단순 인덱스 기반으로 접근하고, 컴파일러가 최적화를 하기 때문에 성능이 더 빠릅니다. 특히 for 문은 기본 데이터 타입을 통해 접근하면 wrapper 타입에 비해 Heap 메모리에 접근하지 않아도 되서 성능이 더 올라가게 됩니다.

34. Stream에서 사용할 수 있는 함수형 인터페이스에 대해 설명해주세요.

사용할 수 있는 함수형 인터페이스로는 인자를 받지 않고 반환만 하는 Supplier, 인자를 받고 반환은 하지 않는 Consumer, 인자를 받고 반환을 하는 Function, 인자를 받아서 참 거짓을 판단하는 Predicate 등이 있습니다.

35. Lambda에 대해 설명해주세요.

Lambda 는 자바 8에서 추가되어 메서드를 하나의 식으로 표현할 수 있는 익명 함수입니다. 함수형 인터페이스를 통해 정의할 수 있으며 기존 익명 함수로 작성하던 코드를 줄일 수 있다는 장점이 있습니다.
자바 8에서 추가되어 메서드를 하나의 식으로 표현하는 익명 함수
함수형 인터페이스를 통해서 사용 가능
장점
- 기존 익명 함수로 작성하던 코드를 줄일 수 있다.
- 가독성이 증가된다.
- 병렬 프로그래밍에 용이하다.
단점
- 남용시 코드 이해가 어렵다.
- 재귀 활용과 디버깅이 어렵다.

36. 익명 클래스(Anonymous Inner Class)와 Lambda의 차이점을 알고계신가요?

익명 클래스는 클래스를 의미하고 여러 메서드를 포함할 수 있지만, Lambda 는 익명 메서드를 의미합니다. 또한 익명 클래스의 this 는 새로 생성된 클래스 객체를 의미하고 Lambda 의 this 는 Lambda 를 정의한 클래스를 의미합니다.
익명 클래스
- 이름 없는 클래스
- 추상 및 구체 클래스 확장 O
- 여러 추상 메서드를 포함하는 인터페이스 구현 O
- 익명 클래스 생성 시 인스턴스 변수 선언 O
- 익명 내부 클래스 인스턴스화 O
- this 키워드가 생성된 익명 클래스 객체를 의미
Lambda
- 이름 없는 메서드
- 추상 및 구체 클래스 확장 X
- 여러 추상 메서드를 포함하는 인터페이스 구현 X
- 익명 클래스 생성 시 인스턴스 변수 선언 X
- 익명 내부 클래스 인스턴스화 X
- this 키워드가 생성된 Lambda 가 정의된 클래스를 의미

37. 람다식에서, 외부 변수를 사용할 때 final 키워드를 붙여서 사용하는 이유가 무엇일까요? final을 안 붙여도 되지 않을까요?

외부 지역 변수를 제어하는 스레드와 람다식을 제어하는 스레드가 다를 수 있기 때문입니다. 이 경우 각 스레드간 스택 영역이 다르기 때문에 값을 공유할 수 없고, 동기화할 수 없기 때문에 외부 변수가 최신 값으로 변경이 되었는지 확신할 수 없습니다. 따라서 매번 다른 결과가 도출될 수 있기 때문에 final 키워드를 붙여야 합니다.

기술 면접 - java 2편

Tue, 13 Aug 2024 15:24:23 GMT

1. Optional에 대해 설명해주세요. Optional을 사용하면 무슨 이점이 있을까요?

Optional 은 Null 이 될 수 있는 값을 감싸는 Wrapper 클래스입니다.
명시적으로 Null 가능성을 표현할 수 있고, Null 체크를 직접 하지 않아도 되고, NPE 가 발생할 가능성이 있는 값을 직접 다룰 필요가 없다는 점이 장점입니다.
Null 이 될 수 있는 값을 감싸는 Wrapper 클래스
장점
- 명시적으로 변수에 대한 Null 가능성을 표현할 수 있다.
- Null 체크를 직접 하지 않아도 된다.
- Null Pointer Exception 이 발생할 가능성이 있는 값을 직접 다룰 필요가 없다.
단점
- Wrapper 클래스이기 때문에 생성 비용이 비싸다.
- 직렬화가 불가능하기 때문에 클래스의 인스턴스 필드로 사용하면 안된다.
- 필드로 사용하기 위해 고안된 것이 아니므로 값을 반환하는 용도로 사용해야 한다.

2. Optional을 사용하면서 주의해야할 점이 있을까요?

Optional 은 직렬화를 구현하지 않았기 때문에 필드로 사용하는 것을 주의해야 합니다. 또한 생성자나 메서드 인자로 사용하는 것을 주의해야 합니다. 생성 비용이 비싼 Optional 대신 일반 객체를 넘겨 null 체크를 하는 것이 좋습니다.
필드로 사용하지 말자
- Optional 은 Serializable 을 구현하지 않았기 때문에 직렬화가 되지 않는다.
생성자나 메서드 인자로 사용하지 말자
- 생성비용이 비싼 Optional 대신 일반 객체를 넘겨 호출받는 쪽에서 null 체크를 하자. Optional 이 오더라도 Optional 에 null 이 할당되어 있을 수도 있다.
orElse 대신 orElseGet 을 사용하자
- null 일 경우에만 반환하는 코드가 호출되므로 더 효율적이다.
컬렉션을 Optional 로 감싸지 말자

3. Object 클래스의 equals()와 hashcode()는 무슨 역할을 하나요?

equals 는 객체의 내부 요소를 비교하여 객체의 동등성을 확인할 떄 사용합니다.
hashcode 는 런타임 시점에 객체의 유일한 값을 반환하는 것입니다.
이는 HashMap, HashTable 등 여러 Collection 클래스에서 객체끼리 구분할 때 사용합니다.

4. equals()와 hashcode()는 언제 재정의해야할까요? 또, 왜 같이 오버라이딩 하는게 좋을까요?

equals 를 재정의하지 않으면 객체의 주소값만 비교하는 것이 기본 구현입니다.
하지만 객체가 같은 값을 가질 때 같은 객체로 인식하기 위해서는 클래스의 필드에 맞게 재정의가 필요합니다.
hashcode 는 객체간의 구분을 위해 사용하므로 유일하게 객체를 식별할 때 재정의해야 합니다. - Object 의 명세에 의하면 equals 가 동일하면 동일한 해시코드를 반환해야 합니다. 이 때문에 같이 오버라이드 해야합니다.
equals 만 구현했을 때 문제점
- 만약 equals 만 구현하여 동등한 객체로 인식되는데 다른 해시 값이 나온다면, Object 명세에도 어긋나지만, 의미상으로도 이상하다. 동등한 객체인데 HashMap 이나 다른 Collection 객체에서는 다른 객체로 인식되는 문제가 생긴다.
hashcode 만 구현했을 때 문제점
- 만약 hashcode 만 구현하여 동일한 해시코드가 나오는데 동등성이 보장되지 않는다면, 마찬가지로 Collection 객체에서 같은 객체로 인식했는데 equals 메서드를 통해 비교할 때는 다르다는 결과가 나오게 된다. 이는 프로그램의 잠재적인 위험이 된다.
hashcode 를 구현할 때 주의할 점
- 핵심 필드를 꼭 포함해서 구현하자
  - 성능보다는 핵심필드를 포함하자
- 자세한 구현 사항을 API 사용자는 모르는 것이 좋다.
  - 사용자가 구현에 의존하지 않을 수 있다.

5. 서로 다른 인스턴스가 같은 hashcode값을 가질 수 있을까요?

서로 다른 인스턴스더라도 해시코드 값을 가질 수 있습니다. 이때문에 해시 충돌을 해결하는 것이 중요해졌습니다. 해시 충돌을 완화하는 방법에는 크게 Open Addressing 과 Separate Chaining 방식이 존재합니다. 자바의 HashMap 에서는 Separate Chaining 방식을 사용하며, 이는 해시 버킷에 들어갈 수 있는 엔트리의 제한을 두지 않는 방식입니다.
Open Addressing
- 한 버킷당 들어갈 수 있는 엔트리가 하나
- 해시 충돌이 일어난 경우, 다른 버킷에 저장
- 이를 위해 빈 버킷을 찾는 여러 알고리즘이 존재한다.
  - Linear probing
  - Quadratic probing
  - Dobule hasing
- 특징
  - 전체 버킷 중 사용중인 버킷의 비율이 커지면 탐사 비용이 비약적으로 상승한다.
  - 데이터를 삭제할 때 비효율적이다.
Separate Chaining
- 한 버킷에 여러 엔트리가 들어갈 수 있음
- 버킷은 주로 LinkedList 또는 Tree 를 사용
- 특징
  - 위의 방식과 비교하여 추가적인 메모리 공간 필요
  - 적재율에 따라 선형적으로 성능이 저하됨
자바에서의 hash 충돌 발생 해결 방법 (HashMap)
- Separate Chaining
- Java 7 까지는 LinkedList 를 고정적으로 사용
- Java 8 부터 데이터의 개수에 따라 적으면 LinkedList, 많으면 Tree 사용

6. String 클래스는 final로 선언되어있습니다. 왜 그런걸까요?

String 클래스가 final 로 선언되면서 불변성을 가지게 되었습니다.
이 이유로는 String Pool 을 통한 메모리 절약, 다수의 클래스에 매개변수로 사용되기 때문에 보완 관련 문제, 해시 기반 Collection 의 키 값으로 사용하기 위함 등이 있습니다.
String Pool
- String 은 자바를 설계할 때 가장 많이 사용할 것으로 예상된 데이터 타입이다.
- 이를 최적화하기 위해 String Pool 에 String 리터럴을 포함하는 방법을 이용했다.
- String 객체를 공유하여 잉여 객체 생산을 막는 것이 목표이다.
- 이를 위해서는 final 또는 불변이어야 가능하다.
Security
- String 은 다수의 자바 클래스의 매개 변수로 쓰이고 있다.
- 만약 String 이 불변이지 않으면, String 의 조작을 통해 시스템의 특점 파일에 대한 액세스 권한을 얻는 등 심각한 보안 문제가 발생한다.
Multithreading
- 자바에서 멀티 스레드를 지원하기 위해 String 객체는 thread safe 를 보장해야 한다.
Optimization and Performance
- String 을 불변 클래스로 만들면서 성능 최적화를 할 수 있게 되었다.
- 값이 변경되지 않는 것을 이용해서 해시 코드 값을 lazy 하게 계산하고 일단 생성 되면 String Pool 에 캐싱한다.
- 이를 통해 한번 계산된 해시 코드 값을 계속 사용하는 등 성능 개선을 할 수 있다.
- HashMap 등 해시 관련 함수에 이용할 시 성능 향상의 원인이 된다.

7. String을 new 또는 "" 로 생성했을 때의 차이점을 설명해주세요.

String 을 "" 와 같이 리터럴로 생성했을 때는 String Pool 에 캐시됩니다. 따라서 객체를 재활용하는 특징이 있습니다.
반면, new 키워드로 생성했을 때는 다른 객체와 똑같이 Heap 메모리에 생성되고 객체를 공유하지 못하는 특징이 있습니다.
String Pool 도 GC 가 될까?
- Java 7 이전
  - String Pool 은 PermGen 이라는 곳에 저장되어 있었습니다.
  - 이 공간은 런타임에 확장할 수 없고, GC 에 적합하지 않습니다.
  - 그리고 일반 Heap 메모리에 비해 공간이 작아서 문자열을 많이 생성할 경우 메모리 부족 에러가 발생했습니다.
- Java 7 이후
  - String Pool 은 이후 일반 Heap 공간에 저장되고 이는 GC 대상이 되는 공간입니다.
  - 이 방식을 통해 참조되지 않은 문자열을 풀에서 제거해 메모리 부족 위험이 줄어들었습니다.

8. String, StringBuilder, StringBuffer 를 각각 비교해주세요.

String 은 다른 두 클래스와 다르게 새로운 값을 할당할 때마다 새로운 클래스에 대한 객체가 생성됩니다.
또한 + 연산을 통해 String 객체를 합치는 경우 GC 되기 전까지 메모리에 부하를 주게 됩니다.
이와 반대로 StringBuilder, StringBuffer 는 메모리에 append 하는 방식으로 클래스에 대한 객체를 생성하지 않습니다.
다만 이 둘의 차이는 StringBuilder 는 thread safe 하지 않고, StringBuffer 는 thread safe 하다는 점이 있습니다.
JDK 1.5 이전 버전
- 문자열 연산을 할 때 각 리터럴마다 새로운 메모리를 할당
JDK 1.5 이후 버전
- 문자열 연산을 할 때 컴파일 과정에서 StringBuilder 로 컴파일 되도록 변경
- 단 반복문을 사용하여 문자열 연산을 할 경우 이전과 똑같이 새로운 메모리 할당
성능
- StringBuilder > StringBuffer >>> String

9. 컬렉션 프레임워크에 대해 설명해주세요.

컬렉션 프레임워크는 다수의 데이터를 쉽고 효과적으로 처리할 수 있는 클래스의 집합입니다.
주요 인터페이스로는 List, Set, Map, Queue 등이 있습니다.
이중 Map 은 다른 것들과 특징이 달라 Collection 을 상속하지 않고 나머지는 Collection 을 상속합니다. 장점으로는 효율적이고 빠른 코드 작성을 할 수 있습니다.
정의: 다수의 데이터를 쉽고 효과적으로 처리할 수 있는 클래스 집합
특징
- 가변적
- 데이터 삽입, 탐색, 정렬 등 편리한 API 다수 제공
- JDK 1.2 버전부터 지원
  - 초기에는 Vector, Properties, Stack, HashTable, Dictionary 등이 제공되고, 통일성있고 표준화된 인터페이스가 존재하지 않았다.
장점
- 다수의 데이터 처리를 직접 구현하지 않고 사용하면 되서 편리하다.
- 효율적인 데이터 처리로 인해 성능 향상이 있다.

10. List 인터페이스의 구현체에 대해 설명해주세요.

List 의 구현체로는 ArrayList, LinkedList, Vector, Stack 이 존재합니다.
ArrayList 는 배열처럼 연속된 메모리에 저장되어 검색은 용이하나 삽입, 삭제에는 부적절합니다.
LinkedList 는 양방향 포인터 구조로 데이터 검색보다는 삽입과 삭제가 빈번하게 일어나는 경우에 유용합니다.
Vector 는 ArrayList 와 동일하게 배열로 구현되어있고 내부에서 동기 처리가 일어나는 것이 특징입니다.
마지막으로 Stack 은 Vector 를 상속받아 동기 처리가 일어납니다.
ArrayList
- 내부적으로 배열을 사용하여 메모리가 연속적으로 저장된다.
- 배열과 달리 메모리가 동적이다.
- 데이터 삽입, 삭제 시 해당 데이터 이후 모든 데이터의 복사가 이루어지므로 빈번한 삽입, 삭제는 비효울적이다.
- 인덱스를 통해 검색하므로 검색에 효율적이다.
LinkedList
- 양방향 포인터 구조로 저장된다.
- 데이터의 삽입, 삭제 시 포인터의 위치만 바꾸면 되기 때문에 효율적이다.
- 데이터 검색 시 포인터를 타면서 순회하기 때문에 비효율적이다.
Vector
- 내부적으로 배열을 사용한다.
- 동기화 처리를 하여 Thread Safe 하다.
- 성능이 좋지 않고 무거워 잘 쓰이지 않는다.
- 멀티 스레드 환경에서도 ArrayList 를 활용하는 것이 좋다.
```
class MyList {
ArrayList list = new ArrayList<>(Collections.synchronizedList());
}
```
Stack
- Vector 를 상속받아 구현하였다.
- 동기화 처리를 하여 Thread-safe 하다.

11. Array와 ArrayList는 어떤 차이점이 있을까요?

Array 와 ArrayList 의 차이는 길이의 가변성, 제네릭 지원, 기본 데이터 타입 저장 유무에 차이가 있습니다.
배열은 길이가 불변에 제네릭을 지원하지 않고 기본 데이터 타입을 저장할 수 있고, ArrayList 는 길이가 가변이고 제네릭을 지원합니다. 기본 데이터 타입은 저장할 수 없습니다.

12. ArrayList 와 LinkedList를 비교해주세요.

ArrayList 는 배열로 구현되어 메모리에 순차적으로 데이터가 저장되게 됩니다.
이러한 특성 때문에 데이터를 검색할 때 인덱스를 통해 찾을 수 있어 효율적입니다.
하지만 삽입 또는 삭제 시 해당 데이터의 이후 데이터들을 모두 복사하는 과정이 필요하므로 빈번한 삽입, 삭제에는 비효율적입니다.
반면, LinkedList 는 양방향 포인터 구조로 되어있어 데이터가 메모리에 불연속적으로 저장됩니다. 데이터와 데이터 사이의 포인터를 통해 연결되어 삽입, 삭제 시 포인터만 바꾸면 되서 효율적이지만 검색 시 데이터들을 순회해야 하기 때문에 비효율적입니다.

13. Map 인터페이스의 구현체에 대해 설명해주세요.

Map 의 구현체로는 엔트리가 배열로 저장되고 해시 값을 인덱스로 사용하는 HashMap, 엔트리가 Linked List 를 사용하는 LinkedHashMap, 레드 블랙 트리로 저장되는 TreeMap, 다중 락을 지원하는 ConCurrentHashMap, 싱글 락을 지원하는 HashTable 이 있습니다.
HashMap
- Entry 가 배열의 형태로 저장
- 배열의 인덱스로 Key 객체의 해시코드 값 이용
  - 입력과 무관하게 출력.
  - 정렬 제공 X
- Key, Value 모두 null 값을 허용
- Thread-safe 하지 않음
- 검색 및 삽입 시간 복잡도: O(1)
- Fail-Fast Iterators
LinkedHashMap
- Entry 가 LinkedList 형태로 저장
- 입력 받은 순서대로 저장
  - 입력한 순서대로 출력.
- Key, Value 모두 null 값을 허용
- Thread-safe 하지 않음
- 검색 및 삽입 시간 복잡도: O(1)
TreeMap
- Red Black 자료구조로 저장
- 키 값을 기준으로 오름차순으로 정렬
  - 입력받은 순서 보장 X
- Key null 값을 허용안함
- Thread-safe 하지 않음
- 검색 및 삽입 시간 복잡도: O(logn)
ConCurrentHashMap
- Key, Value 모두 null 값을 허용 X
- Thread-safe 보장
  - 버킷 단위로 lock
  - 버킷의 수 == 동시작업 가능한 쓰레드 수
  - 수정 작업시 동기 처리
HashTable
- Key, Value 모두 null 값을 허용 X
- Thread-safe 보장
  - 모든 작업에 동기 처리
- Fail-Safe Iterators

14. HashTable에 대해 설명해주세요.

키 벨류 형태로 데이터를 저장하는 자료구조로 배열을 이용합니다.
모든 메서드에 synchronized 키워드가 붙어있어 thread-safe 하다는 특징이 있습니다. 다만 이때문에 성능 저하가 존재할 수 있습니다.

15. HashMap과 HashTable을 비교해주세요.

HashMap 과 HashTable 모두 배열의 형태로 저장되는 점에서 동일합니다. 다만 키 값에 null 을 허용하는지, 동기 처리를 하는지에 차이가 존재합니다.
16. HashMap과 ConcurrentHashMap은 어떤 차이가 있나요?
HashMap과 ConcurrentHashMap은 키 값에 null 허용 유무, 동기 처리 유무에 차이가 있습니다.
ConcurrentHashMap 은 버킷에 lock 을 걸어 버킷의 수만큼 스레드를 동작시킬 수 있습니다. 또한 읽기 작업에는 락을 걸지 않고 수정 시에만 적용한다는 특징이 있습니다.

17. Set 인터페이스의 구현체에 대해 설명해주세요.

Set 의 구현체로는 해시 값을 사용하는 HashSet, 저장된 순서를 유지하는 LinkedHashSet, 레드 블랙 트리의 형태로 저장되는 TreeSet 등이 있습니다.
HashSet
- 저장된 순서 유지 X
- null 입력 가능
- 해시 값으로 저장
  - 검색 속도가 빠르다.
- 내부적으로 HashMap 을 사용함
LinkedHashSet
- 저장된 순서 유지 O
- null 입력 가능
- 내부적으로 LinkedHashMap 을 사용함
TreeSet
- 데이터가 정렬된 형태로 저장
  - Red Black 트리 자료구조 이용
- null 입력 가능 X
- 내부적으로 TreeMap 을 사용함

18. List와 Set을 비교해주세요.

List 와 Set 은 인덱스를 통해 접근하는지, 동일한 요소를 저장할 수 있는지에 차이가 있습니다.
구현체에 따라 다르지만 List 는 인덱스를 통해 접근할 수 있고 동일한 요소를 저장할 수 있습니다. 반면, Set 은 인덱스를 통해 접근할 수 없고 동일한 요소를 저장할 수 없습니다.

List	Set
indexed sequence	non-indexed sequence
중복 허용	중복 허용 X

19. Java의 컴파일(실행) 과정을 설명해주세요.

먼저 JVM 이 OS 로부터 메모리를 할당받습니다.
이후 컴파일러에 의해 소스코드가 바이트코드로 변환됩니다. 다음 Class Loader 를 통해 Class 파일들을 JVM 으로 로딩시킨 후 이 파일들을 Execution Engine 이 해석한 후 실행하게됩니다.

자바로 개발된 프로그램을 실행하면 JVM은 OS로부터 메모리를 할당합니다.
자바 컴파일러(javac)가 자바 소스코드(.java)를 자바 바이트코드(.class)로 컴파일합니다.
Class Loader를 통해 JVM Runtime Data Area로 로딩합니다.
Runtime Data Area에 로딩 된 .class들은 Execution Engine을 통해 해석합니다.
해석된 바이트 코드는 Runtime Data Area의 각 영역에 배치되어 수행하며 이 과정에서 Execution Engine에 의해 GC의 작동과 스레드 동기화가 이루어집니다.

20. JDK, JRE, JVM에 대해 설명해주세요.

JVM 은 자바 가상머신으로 바이트 코드를 실행시킬 수 있습니다. JRE 는 자바 실행 환경으로 실행하는데 필요한 도구들이 들어있습니다. JVM 이 이 안에 포함됩니다. JDK 는 개발을 위한 도구입니다. 컴파일러와 JRE 가 포함됩니다.
JVM
- 바이트 코드(.class)를 돌리는 자바 가상머신
- 운영체제 별 제공
  - 플랫폼에 독립적
JRE
- 실행 환경을 제공하는 도구들
- JVM 과 Java Class 라이브러리들, Class Loader 로 구성
  - Class Loader: 프로그램을 실행하는데 필요한 클래스를 JVM 에 로딩하는 역할 수행
JDK
- 프로그램을 개발하기 위해 필요한 도구 모음
- JRE 와 컴파일러, 디버깅 툴 등으로 구성

21. JVM의 메모리 구조에 대해 설명해주세요.

JVM 의 Runtime Data 영역에는 클래스의 정보를 저장하는 메서드 영역, 참조타입이 저장되는 힙 영역, 스레드 별 지역 변수, 매개변수 등이 저장되는 스택 영역, 스레드가 실행중인 스택 프레임 주소를 저장하는 PC 레지스터, 자바가 아닌 다른 언어로 작성된 코드를 저장하는 Native 메서드 스택가 있습니다.
Method Area
- Class Area, Static Area
- 클래스 정보가 저장됨
  - 멤버변수, 메서드 정보(이름, 타입, 접근제어자 등)
  - class 인지 interface 인지, static 변수, final 변수
- 상수 자료형을 위한 Runtime Constant Pool 존재
- 모든 스레드에서 공유
- GC 대상
Heap Area
- 레퍼런스 타입이 저장됨
  - new 연산자로 생성된 객체와 배열 저장
  - String Pool
- 모든 스레드에서 공유
- 런타임 시 동적으로 할당되어 사용
- 참조가 없는 객체는 GC 대상이 됨
Stack Area
- 프로그램 실행 과정에서 임시로 할당되거나 메서드 영역에서만 존재하는 데이터 저장
  - 지역변수, 매개변수, 임시 데이터 등
- 스레드마다 스택 하나씩 할당
PC register
- 스레드에서 실행할 명령어 주소값 저장
- 스레드가 시작될 때 생성됨
Native Method Stack
- .class 의 바이트 코드가 아닌 기계어로 작성된 프로그램을 실행시키는 영역
- JAVA 가 아닌 다른 언어로 작성된 코드를 위한 영역

22. 정적 바인딩, 동적 바인딩

바인딩
- 값이 할당되어 변경할 수 없는 상태
정적 바인딩
- 값이 컴파일 시점에 확정되는 것
- static, private, final 메서드 및 변수
  - override 가 불가능
- 성능상으로 이점이 있음
동적 바인딩
- 값이 런타임 시점에 확정되는 것
- method overriding
- 다형성에 유리
- 힙 영역에 vtable(가상 메서드 테이블) 생성
  - vtable 은 클래스가 자신이 상속받은 메서드를 포함한 모든 메서드의 주소값을 저장하는 곳이다.
  - vtable -> 4byte
  - 메서드를 오버라이딩 했을 경우 오버라이딩한 메서드의 주소값을 가지기 때문에 부모 클래스 타입으로 선언되어도 오버라이딩한 메서드가 호출된다.
예상 질문
- 정적 바인딩과 동적 바인딩의 차이점에 대해 설명해주세요.

23. 가비지 컬렉터

가비지 컬렉터란?
- Heap 메모리에 있는 사용하지 않는 객체를 제거하는 역할을 수행합니다.
- Weak Generational Hypothesis: Heap 영역 설계 시 고려한 전제
  - 대부분의 객체는 금방 접근 불가능한 상태가 된다.
  - 오래된 객체에서 새로운 객체로의 참조는 아주 적게 존재한다.
- Heap 메모리 영역은 객체의 생존 기간에 따라 Young, Old 2가지 영역으로 설계되었다.
- 장점
  - 메모리를 수동으로 관리하던 것에서 비롯된 에러를 예방할 수 있다.
- 단점
  - GC 의 메모리 해제 타이밍을 개발자가 정확히 알기 어렵다.
  - 삭제될 객체를 탐색하고 삭제하는 과정에서 오버헤드가 발생한다.

24. 객체 지향 프로그래밍(캡상추다)

객체지향 프로그래밍이란?
- 프로그래밍에서 필요한 데이터를 추상화시켜 상태와 행위를 가진 객체를 만들고 그 객체들 간의 유기적인 상호작용을 통해 로직을 구성하는 프로그래밍 방법
  - 장점
- 코드 재사용 용이
- 유지보수 용이
- 대형 프로젝트에 적합
  - 단점
- 처리 속도 느림
- 설계가 어려움
객체지향의 특징
- 캡슐화
  - 클래스 안에 서로 연관있는 속성과 기능들을 하나의 캡슐로 만들어 데이터를 외부로부터 보호하는 것
  - 목적
    - 데이터 보호: 외부로부터 클래스에 정의된 속성과 기능들을 보호
    - 데이터 은닉: 내부의 동작을 감추고 외부에는 필요한 부분만 노출 (각 객체 고유의 독립성과 책임 영역을 안전하게 지킬 수 있다.)
  - 접근제어자와 getter/setter 를 통해 구현
- 상속
  - 기존의 클래스를 재활용하여 새로운 클래스를 작성하는 자바의 문법요소
  - 코드의 재사용을 통해 반복적인 코드를 최소화하고 공유하는 속성과 기능에 간편하게 접근할 수 있다.
  - 상속과 구현
    - 상속: 상위 클래스의 속성과 기능들을 하위 클래스에서 그대로 받아 사용하거나 오버라이딩을 통해 선택적으로 재정의해서 사용
    - 구현: 반드시 인터페이스에 정의된 추상 메서드의 내용이 하위 클래스에서 정의
- 추상화
  - 객체의 공통적인 속성과 기능을 추출하여 정의하는 것
  - 추상클래스와 인테페이스로 구현
  - 제어 추상화
    - 메서드의 작동방식과 같은 내부 로직을 숨기는 것
    - 프로그래밍을 빠르게 설계하고 구현할 수 있다.
  - 데이터 추상화
    - 객체를 간단한 개념으로 일반화 시키는 것
    - 공통 기능을 미리 개발함으로써, 구조를 빠르게 확장시킬 수 있다.
- 다형성
  - 객체의 속성이나 기능이 상황에 따라 여러 가지 형태를 가질 수 있는 성질
  - 메서드 오버라이딩과 오버로딩을 통해 구현
  - 가능한 것 예시
    - 여러 종류의 객체를 배열로 다룰 수 있다.
    - 하나의 타입만으로 여러 가지 타입의 객체를 참조할 수 있다.

25. SOLID 원칙

SRP(Single Responsibility Principle): 단일 책임 원칙
- 어떤 클래스를 변경해야 하는 이유는 오직 하나뿐이어야 한다.
  - 클래스는 하나의 책임만 가진다.
OCP(Open Closed Priciple): 개방 폐쇄 원칙
- 확장에는 열려있으나 변경에는 닫혀있어야 한다.
- 다형성과 연관이 있다.
LSP(Listov Substitution Priciple): 리스코프 치환 원칙
- 하위 타입은 상위 타입으로 대체할 수 있다.
ISP(Interface Segregation Principle): 인터페이스 분리 원칙
- 클라이언트의 목적과 용도에 적합한 인터페이스만 제공하는 것
- 불필요한 간섭을 최소화할 수 있다.
DIP(Dependency Inversion Principle): 의존 역전 원칙
- 고수준의 모듈은 저수준의 모듈에 의존하면 안된다.
- 추상화된 것은 구체적인 것에 의존하면 안된다.
- 변하기 쉬운 것에 의존하는 것보다 변하지 않는 것에 의존해야 한다.

26. 객체 지향 프로그래밍 vs 절차 지향 프로그래밍

설계 방식
- 객체지향
  - 자료구조와 이를 중심으로한 모듈들을 설계한 후 이들의 실행 순서와 흐름을 조합하는 방식
- 절차지향
  - 프로그램의 순서와 흐름을 먼저 세우고 필요한 자료구조와 함수들을 설계하는 방식
목적
- 객체지향
  - 필요한 객체들의 종류과 속성등이 중심
- 절차지향
  - 실행 순서, 절차 중심
장단점
- 객체지향
  - 장점
- 코드의 재사용성이 높다.
- 디버깅이 쉽다.
  - 단점
- 설계가 어렵다.
- 처리 속도가 느리다.
절차지향
- 장점
  - 컴퓨터의 처리구조와 유사해 실행 속도가 빠르다.
- 단점
  - 유지보수가 어렵다.
  - 실행 순서가 정해져 있어 순서가 바뀌면 결과가 바뀐다.
  - 디버깅이 어렵다.

jenkins를 이용하여 배포하기

Tue, 18 Jun 2024 04:07:51 GMT

실수로 다른 계정에서 작성해버려서..^^ 아래 참고하기

jemkims를 이용하여 배포하기

1장 - 요구사항 확인

Fri, 12 Apr 2024 04:35:57 GMT

내가 볼려고 만든 정리본 -- 수제비를 참고하였다.

소프트웨어 전통적 방법론

종류
- 폭포수 모델
  - 가장 오래된 모델
- 프로토타이핑 모델
  - 피드백
- 나선형 모델
  - 점진적 개선해서 완벽하게 만드는 것
  - 위험 감소 및 변경에 유연
  - 계획 및 정의 -> 위험 분석 -> 개발 -> 고객 평가 (계위개고)

소프트웨어 개발 방법론

애자일 방법론
- 절차보다는 사람이 중심
- 문서보다 코드를 강조
- 종류
  - XP
    - 1-3주의 반복
    - TDD
    - 리팩토링
  - 스크럼
    - 스프린트 : 2-4주 개발

객체지향 설계 원칙(SOLID)

단일 책임의 원칙(SRP : Single Responibility Priciple)
- 하나의 클래스는 하나의 목적을 위해서 생성
개방 폐쇄 원칙(OCP : Open Close)
- 확장은 오픈, 변경은 클로즈
리스코프 치환의 법칙(LSP : Liskov Subsititution)
- 상속받은 자식클래스는 어디서나 부모클래스로 교체할 수 있어야 함
인터페이스 분리의 원칙(ISP : Interface Segregation)
- 특정 기능에 대한 인터페이스는 다른 기능이 변해도 영향 받지 않아야 함
의존성 역전의 법칙(DIP : Dependency Inversion)
- 클래스를 참조할 때, 클래스의 상위인 추상클래스, 인터페이스를 사용할 것

객체지향이란

속성과 메서드가 결합한 상태
캡슐화, 상속성, 다형성, 추상화, 정보 은닉, 관계성

객체지향 분석 방법론 종류

OMT
- 럼바우가 만듦
- 종류 : 객체, 동적, 기능 모델링
  - 객체 모델링
    - ER다이어그램
  - 동적모델링
    - 상태 다이어그램
  - 기능모델링
    - DFD 자료흐름도 사용
- 부치, 야콥슨(Jscobson) 이라는 사람들이 만든 방법도 있음

비용 산정 모델

Loc 모형
- S/W 각 기능의 원시코드 라인 수의 낙관치, 중간치, 비관치를 측정하여 예측치를 구해서 비용 산정
Man Month
- 한 사람이 1개월 동안 할 수 있는 일의 양을 기준으로 비용 산정
- Man Month : LOC / 월간 생산량
- 프로젝트 기간 : man month / 인력
COCOMO
- 보헴이 제안
- 프로그램 규모에 따라 비용 산정
- 비용 산정 결과는 프로젝트를 완성하는데 필요한 노력으로 산정(Man-Month)
- 종류
  - 조직형(Organic)
    - 5만
  - 반 분리형(Semi-Organic)
    - 30만 이하
  - 임베디드형(Embedded)
    - 30만 이상
- 기능점수 (FP)
  - 가중치를 부여
- 푸트남 모형
  - 소프트웨어 개발주기의 단계별로 요구할 인력의 분포를 가정하는 방식
  - 생명주기 예측 모형

현행 시스템 분석

소프트웨어 아키텍처 4+1 뷰

1은 유스케이스
4는 논리 뷰, 구현 뷰, 프로세스 뷰, 배포 뷰

유스케이스 뷰

다른 뷰를 검증
사용자, 설계자, 개발자 관점

논리 뷰

기능적인 요구사항
설계자, 개발자 관점

프로세스 뷰

비기능적인 속성

구현 뷰

정적인 소프트웨어 모듈의 구성
컴포넌트 구조와 의존성

배포 뷰

배치되는지 매핑햇 보여줌

소프트웨어 아키텍처 패턴 유형

파이프-필터 패턴
- 테이터 스트림을 생성
브로커 패턴
- 분리된 컴포넌트들로 이루어진 분산 시스템에서 사용
모델뷰컨트롤러 패턴
- 모델 : 핵심 기능과 데이터 보관
- 뷰 : 사용자에게 보여줌
- 컨트롤러 : 사용자로부터 요청받아 처리
- 컨트롤러 -> 모델 -> 컨트롤러 -> 뷰

디자인패턴

생성 패턴 (생빌 프로 팩앱싱)

Builder = 조립하는거야
- 복잡한 인스턴스를 조립하여 만드는 구조
Prototype- 어떤 type으로 만들래? -> 원형
- 일반적인 원형을 만들고 복사한 후 필요한 부분만 수정하여 사용
Factory Method - 엄마 팩 좀 줘. => 엄마라는 상위클래스가 있고 그 안에 어떤 행위를 할 수 있는 함수가 정의되어 있고 자식클래스(나)는 그 행위함수를 오버라이딩해서 팩을 요청하도록 수정하여 엄마한테 요청
- 상위클래스에서 인터페이스를 정의하고 하위클래스에서 인스턴스를 생성
- 상위클래스에서는 인스턴스를 만드는 방법만 정의하고 하위클래스에서 그 데이터의 생성과 조작하는 함수를 오버라이딩해서 분리하는 것
Abstact Factory = >abstract가 추상클래스를 상속받는 메서드니깐 말 그대로 비슷한 객체들의 조합인 인터페이스를 만든다고 생각
- 구체적 클래스에 의존하지 않고 서로 연관되거나 의존적인 객체들의 조합을 만드는 인터페이스 제공
Singleton
- 객체를 하나만 생성, 어디에서든 참조 가능하도록

구조패턴 (구 브데 퍼플 프록 컴 어)

Bridge
- 기능의 클래스 계층과 구현의 클래스 계층을 연결
Decorator
- 기존에 구현된 클래스에 필요한 기능을 추가해 나가는 패턴으로 객체의 결합을 통해 기능을 동적으로 확장
Facade
- 복잡한 인터페이스에 대해 단순한 인터페이스를 제공함으로써 단순한(통합된) 인터페이스 제공
Flyweight
- 클래스의 경량화를 목적으로 다수의 객체가 생성될 경우 모두가 갖는 본질적인 요소를 클래스화하여 공유하는 여러개의 가상 인스턴스 제공하여 메모리 절감
Proxy
- 실체 객체에 대한 대리 객체로 정보은닉의 역할
Composit
- 객체들의 관계를 트리 구조로 구성하여 복합 객체와 단일 객체를 동일하게 취급
Adapter
- 기존에 생성된 클래스를 재사용할 수 있도록 중간에서 맞춰주기

행위패턴(행 미인이 탬옵 스테 비커 스트 메체)

Mediator
- 객체의 수가 많아지면 복잡하기 때문에 중재자를 두어 상호 작용의 유연한 변경을 지원
Interpreter
- 여러 형태의 언어 구문을 해석할 수 있도록 문법 자체를 캡슐화하여 사용
Iterator
- 컬렉션 구현 방법을 노출시키지 않으면서 그 집합체 안에 들어있는 모든 항목에 반복자를 사용하여 내부구조를 노출하지 않고 복잡 객체의 원소를 순차적으로 접근 가능하게 해줌
Template Method => 탬플릿 안에 특정 내용만 세부처리를 할 수 있게 도와줄게
- 어떤 작업을 처리하는 일부분을 서브 클래스로 캡술화해 전체 일을 수행하는 구조는 바꾸지 않으면서 특정 단계에서 수행하는 내역을 바꾸는 것 즉, 상위 작업의 구조를 바꾸지 않으면서 서브 클래스로 작업의 일부분을 수행
Observer => 오저거바뀜
- 객체의 상태가 바뀌면 의존하는 객체들에게 연락이 가고 자동의 내용 갱신
State => 상태
- 객체의 상태에 따라 행위 내용을 변경
Visitor => 방문만 할게
- 객체의 구조를 변경하지 않고 기능만 따로 추가하거나 확장할 때 사용
Command
- 실행될 기능을 캡슐화하여 재사용성이 높은 클래스를 설계하는 요구사항을 캡슐화
Strategy
- 춧상 클래스 같은 알고리즘을 각각 하나의 클래스로 캡슐화한 다음 필요할 때 서로 교환해서 사용할 수 있게 하는 패턴으로 행위 객체를 클래스로 캡슐화해 동적으로 행위를 자유롭게 변환
Memento
- 갹채를 이전상태로 복구, 작업 취소(Undo)의 요청 가능
Chain of Responsibirity
- 한 요청을 2개 이상의 객체에서 처리

8장 - 서버 프로그램 구현

Fri, 12 Apr 2024 04:15:58 GMT

개발환경 구축

웹서버
- HTTP를 통해 웹 브라우저에서 요청하는 문서를 전송해주는 프로그램
- 정적 컨텐츠
- 아파치, NginX
WAS (웹어플리케이션 서버)
- 동적 콘텐츠
- 톰캣

형상 관리 도구

RCS
CVS
GIT
SVN

소프트웨어 모듈 응집도

우논시절 통순기
응집도가 높아야 좋은 모델
- 우연적 (젤 낮음)
- 논리적
- 시간적
- 절차적
- 통신적
- 순차적
- 기능적 (젤 높음)

소프트웨어 모듈 결합도

내공 외제 스자
결합도가 낮아야 좋은 모델
- 내용 (젤 낮음)
- 공통
- 외부
- 제어
- 스템프
- 자료 (젤 높음)

모듈 테스트

XUnit
- 화이트박스 기법
- Jaca, C++ 등 다양한 언어를 지원해주는 프레임워크
- 종류
  - JUnit
    - 자바 언어용

5장 - 인터페이스 구현

Thu, 11 Apr 2024 10:57:49 GMT

인터페이스 기능 구현

JSON

키-쌍 값으로 이루어짐
인간이 읽을 수 있는 텍스트 사용
AJAX에서 사용
XML 대체

XML

HTML의 단점을 보안한 인터넷 언어
직접 문서의 태그를 정의

AJAX

자바스크립트 사용
웹서버와 클라이언트 간 비동기적 XML 데이터를 주고 받음

REST

웹과 같은 분산하이퍼미디어 환경에서 HTTP 메서드를 사용하여 주고받음

4장 - 통합 구현

Thu, 11 Apr 2024 09:57:42 GMT

내외부 연계 모듈 구현

EAI 방식

기업에서 운영되는 서로 다른 플랫폼 간의 정보를 전달이 가능하도록 하는 솔루션
유형
- 포인트 투 포인트
  - 1:1
- 허브 앤 스코프
  - 중앙 집중형
- 메시지 박스
  - 미들웨어
- 하이브리드
  ESB 방식
기업에서 운영되는 서로 다른 플랫폼 간을 하나의 시스템으로 관리
미들웨어 중심의 느슨한 결합

웹서비스 방식

WSDL
- 웹 서비스명, 위치정보를 XML 형식으로 구현되어 있는 언어

2장- 화면 설계

Thu, 11 Apr 2024 09:51:06 GMT

UI 요구사항

UI 요구사항 확인

사용자와 시스템 사이에서 의사소통 할 수 있도록 고안된 매개체
UI, UX

UI 유형

CLI
- 정적인, 명령어
GUI
- 그래픽
NUI
- 신체부위
OUI
- 유기적, 입출력 장치

UI 설계 원칙 (직유학유)

직관성
- 쉽게 이해하고 사용
유효성
- 목표 달성
학습성
- 쉽게 배우기
유연성
- 최대한 수용

UI 화면 설계 구분

와이어프레임
- 화면 단위의 레이아웃
스토리보드
- 서비스 구축을 위한 정보가 담긴 산출물
프로토타입
- 동적 효과
- 시물레이션 가능한 모형
UI 설계

UML
모델링 기술과 방법론을 통합해서 만든 표준화 범용 모델링 언어

구성요소

사물
관계
다이어그램

UML 다이어그램

구조적 다이어그램 = 정적

클래스
- 클래스의 속성 및 연산과 클래스
- 연관, 의존, 일반화, 실체화, 포함 관계
객체
- 연관된 모든 인스턴스
컴포넌트
- 의존 관계
배치
- 컴포넌트 사이의 종속성
복합체 구조
- 복합 구조를 갖는 경우 표현
패키지
- 클래스들을 그룹화
- 의존관계에는 <>, <>가 있음

행위적 다이어그램 = 동적

유스케이스
- 사용자의 관점에서 표현
시퀀스
- 시간적 개념을 중심으로 메시지 흐름으로 표현
- 객체는 사각형 안에 밑줄로 표시
- 생명선은 점선
커뮤니케이션
- 주고받는 메시지를 표현
- 객체명 : 클래스명으로 기제
상태
- 상태변화
활동
- 어떤 기능을 수행하는지 표현
타이밍
- 객체 상태 변화와 시간 제약을 명시적 표현

UML 스트레오 타입

<>
- 반드시 포함
<>
- 있고, 않을 수도
<>
- 모든 메서드가 추상메서드
<>
- 정보나 연관된 행위를 형상화라는 클래스

3장 - 데이터 입출력 구현

Thu, 11 Apr 2024 09:44:52 GMT

데이터 저장소

데이터 모델

데이터 모델 절차 (요개논물)

요구사항 분석
개념적 설계
- 트랜잭션을 모델링
- ERD
논리적 설계
- 트랜잭션의 인터페이스 설계
- 스키마의 평가 및 정제
물리적 설계
- 반 정규화
- 접근경로 설계

관계 데이터 모델

관계 데이터 모델의 구성요소

릴레이션
- 행과 열로 구성된 테이블
튜플
- 릴레이션의 행
- 튜플의 개수 : 카디널리티
속성
- 릴레이션의 열
- 속성의 개수 : 차수, 애트리뷰트
스키마 = 릴레이션 스키마
- 데이터베이스의 구조 등의 정보를 담고있는 기본적인 구조
인스턴스 = 릴레이션 인스턴스
- 실제 저장된 데이터의 집합

관계 대수

관계형 데이터베이스에서 원하는 정보와 그 정보를 어떻게 유도하는가를 기술
일반 집합 연산자
- 합집합
  - U
- 교집합
  - 거꾸로 U
- 차집합
  - -
- 카티션 프로덕트
  - X
순수 관계 연산자
- 셀렉트 (σ) = SQL에서 SELECT 담당
  - 릴레이션에서 조건을 만족하는 튜플 반환
- 프로젝트 (π) = SQL에서 WHERE 조건 담당
  - 주어진 속성들의 값으로만 구성된 튜플 반환
- 조인 (▷◁)
  - 공통 속성을 이용해 연결
- 디비전 (÷)
  - 관련있는 튜플 반환

ERD

피터챈 모델
현실 세계에 존재하는 데이터와 그들 간의 관계를 사람이 이해할 수 있는 형태로 명확하게 표현하기 위한 모델
개체, 속성, 관계

ERD 기호

정규화

단계 (원부 이걸 다조)
- 1정규형(1NF)
  - 원자값으로 구성
- 2정규형
  - 부분 함수 종속 제거
- 3정규형
  - 이행함수 종속 제거
- BCNF
  - 결정자 후보 키가 아닌 함수 종속 제거
- 4정규형
  - 다치(다중값) 종속 제거
- 5정규형
  - 조인 종속 제거

이상현상

데이터의 중복성으로 인해 릴레이션을 조작할 때 발생하는 현상 <테이블> 학번 이름 교수번호 교수이름 2010 홍길동 1 김 교수 2011 김영희 2 이 교수 2012 이철수 ? ?
- 삽입이상
  - 2012학번을 가진 이철수라는 학생이름을 등록할 경우 교수가 지정되어 있지않으면 삽입 불가
- 삭제이상
  - '이교수'라는 교수가 퇴사할 경우 김영희의 정보도 같이 삭제
- 갱신이상
  - 홍길동의 지도교수를 이 교수로 변경할 경우 중복이 되어 모순이 일어난다.

함수 종속

부분함수 종속(Partial)
완전함수 종속(Full)
이행함수 종속(Transitive)

반정규화

정규화된 엔티티 등에 대해 성능 향상과 개발 운영의 단순화를 위해 중복, 통합 등을 수행

물리 데이터 모델

데이터베이스 무결성

데이터베이스에 저장된 데이터 값과 그것이 표현하는 현실 세계 값이 일치하는 성질
무결성 종류 (개참속시키)
- 개체 무결성
  - 기본키는 널값이 안됨
- 참조 무결성
  - 외래키가 참조하는 키는 기본키값이거나 널값
- 속성 무결성
  - 규칙에 준수
- 사용자 정의 무결성
- 키 무결성

키

유일성
- 유일하게 구분
최소성
- 최소한의 속성으로 구별
종류
- 기본 키
- 후보 키
- 슈퍼 키
  - 유일성은 만족, 최소성은 불만족
- 외래 키
  - 기본 키로 이용되는 키
  - 무결성

파티셔닝

레인지 파티셔닝
- 연속적인 숫자나 날짜를 기준
해시 파티셔닝
- 해시함수 값
리스트 파티셔닝
- 특정 파티션에 저장될 데이터
라운드로빈
- 라운드로빈 회전

10장 - 애플리케이션 테스트 관리

Wed, 10 Apr 2024 15:42:42 GMT

소프트웨어 테스트의 이해

소프트웨어 테스트의 기본원칙

소프트웨어 테스트 원리
- 결함 존재 증명
- 완벽 테스팅은 불가능
- 초기 집중
- 결함 집중
- 살충제 패러독스
  - 동일한 테스트에 대한 반복적 테스트는 새로운 버그를 찾지 못한다.
- 정황 의존성
- 오류-부재의 원인
소프트웨어 테스트 산출물
- 테스트 계획서
- 테스트 베이시스
  - 테스트 설계를 위한 기준이 되는 문서
- 테스트 케이스
  - 테스트를 위한 설계 산출물
- 테스트 슈트
  - 실행환경에 따라 구분
- 테스트 시나리오
  - 테스트가 필요한 상황을 작성한 문서
- 테스트 스크립트
  - 테스트 실행 순서를 작성
- 테스트 결과서

소프트웨어 테스트 유형

테스트 기법에 따른 분류

정적 테스트
- 실행하지 않고 구조를 분석
- 리뷰
  - 동료검토
    - 2~3명이 0진행
  - 인스펙션
    - 전문가가 검사
  - 워크스루
    - 회의 전에 배포하여 사전 검토
동적 테스트
- 실행하여 검출
- 화이트박스, 블랙박스 테스트
2-1) 화이트박스 테스트 = 구조기반 테스트
- 응용프로그램의 내부 구조와 동작을 검사
- 소스 코드의 모든 문장을 한 번 이상 수행
  
  a. 구문 커버리지 (Statement)
  - 프로그램 내 모든 명령문을 적어도 한 번 이상 수행
  - 조건문 결과와 관계없이 구문 실행 개수로 수행
  b. 결정 커버리지 = 선택/분기 커버리지 (Decision/Branch)
  - 각 분기의 결정 포인트 내의 전체 조건식이 적어도 한 번은 참과 거짓의 결과를 수행
  c. 조건 커버리지 (Condition)
  - 각 분기의 결정 포인트 내의 개별 조건식이 참 한번, 거짓 한번의 결과가 되도록 수행
  d. 기본경로 커버리지 (Base 0Path)
  - 수행 가능한 모든 경로를 다 테스트
  - 맥케이브의 순환복잡도
2-2) 블랙박스 테스트
- 외부 사용자의 요구사항 명세를 보면서 수행
  
  a. 동등분할 테스트 = 동치/균둥 분할 테스트 (Equivalence Partitioninh)
  - 도메인 별로 유효값/무효값을 그룹핑하여 대푯값 테스트 케이스를 도출
  b. 경곗값 분석 테스트 (Boundary Value Analysis)
  - 최솟값 바로 위, 최대치 바로 아래 등 경곗값을 포함하여 설계
  c. 결정 테이블 테스트 (Decision Table)
  - 테이블 형태로 나열 후 조합하여 테스트
  d. 상태전이 테스트 (State Transition)
  - 객체의 상태를 구분
  - 다른 상태로 전이되는 경우의 수를 테스트
  e. 유스케이스 테스트 (Use Case)
  - 유스케이스로 모델링
  f. 분류트리 테스트 (Classification Tree Method)
  - 트리구조로 분석 및 표현
  g. 페어와이즈 테스트 (Pairwise)
  - 테스트 데이터값들을 최소 한번씩 조합
  - 커버해야 할 범위를 적은 양의 테스트로 구성하기 위함
  h. 원인-결과 그래프 테스트 (Cause-Effect Graph)
  - 그래프를 활용하여 효용성이 높은 테스트 케이스 선정
  i. 비교 테스트 (Comparison)
  - 동일한 결과가 나오는지 비교하여 테스트
  j. 오류추정 테스트 (Error guessing)
  - 실수를 추정하여 결함이 검출되도록 설계

테스트 시각에 따른 분류

검증
- 개발 과정을 테스트
- 개발자 혹은 시험자의 시각
확인
- 사용자 시각
- 결과를 테스트하여 제대로 동작하는지 확인

테스트 목적에 따른 분류

회복 테스트
- 고의로 실패를 유도하여 정상적 복귀 여부를 테스트
안전 테스트
- 보안적인 결함을미리 점검
성능 테스트
- 반응하는 속도 등 테스트
구조 테스트
- 복잡도를 평가
회귀 테스트
- 일종의 반복 테스트
병행 테스트
- 변경된 시스템과 기존 시스템에 동일한 데이터 입력 후 결과 비교

테스트 오라클

결과가 참인지 거짓인지를 판단하기 위해 사전에 정의된 참값을 입력하여 비교
종류 (참샘휴일) -> 참새가 휴일에 쉰다.
- 참 오라클
  - 모든 입력 값에 대하여 기대하는 결과를 생성함
  - 발생된 오류를 모두 검출 가능
- 샘플링 오라클
  - 특정한 몇개의 입력값에 대해서만 기대하는 결과 제공
- 휴리스틱 오라클
  - 샘플링 오라클을 개선
    - 특정 입력값에 대해 올바른 결과 제공
    - 나머지 값들은 휴라스틱(추정) 값 처리

애플리케이션 테스트 시나리오 작성

테스트 레벨

V모델
- 개발자 관점 + 사용자 관점에서의 최종 산출물에 대한 확인을 지원하기 위한 모델
테스트 레벨
- 단위테스트
  - 사용자 요구사항에 대한 모듈, 컴포넌트에 초점
- 통합테스트
  - 단위테스트를 통과후 테스트
  - 인터페이스 관련 오류
- 시스템테스트
  - 통합된 시스템의 기능 점검
- 인수테스트
  - 알파테스트
    - 개발자 환경에서 통제된 환경
  - 베타테스트
    - 실제환경에서 일정 수의 사용자에게 피드백

9장 - SW 개발 보안 구축 - 2장

Wed, 10 Apr 2024 09:06:19 GMT

입력 데이터 검증 및 표현

입력 데이터 검증 및 표현 취약점

XSS
- 검증되지 않은 웹페이지가 전송되는 경우, 부적절한 스크립트가 실행
사이트 간 요청 위조 (CSRF)
- 사용자 의지와 상관없이 공격자가 의도한 행위를 요청하게 되는 공격
SQL 삽입
- 응용 프로그램의 취약점을 이용
  - 악의적인 SQL 구문을 삽입

시스템 보안 구현

리눅스 주요 로그 파일

wtmp
- 사용자 로그인/로그아웃 정보
- last 명령어

보안 솔루션

방화벽
- 기업 내/외부 간 트래픽을 모니터링
웹 방화벽 (WAF)
- XSS, SQL인젝션을 탐지하고 방지
네트워크 접근 제어 (NAC)
- 바이러스나 웜으로부터 방지
가상사설망 (VPN)
- 마치 전용망을 사용하는 효과
- SSL 방식과 IPSec 방식
SIEM
- 위협에 대응하는 보안 관제 솔루션
- 머신러닝 기술을 이용하여 대량의 로그분석
ESM
- 각종 이벤트 및 로그를 통합해서 관리
- 서로 다른 기종의 보안 장비들을 모니터링하여 통합 관리

SW 개발 보안 테스트와 결함 관리

정적 분석
- SW를 실행하지 않고 보안 약점 분석
동적 분석
- 실행 단계

비즈니스 연속성 계획(BCP)

각종 재해, 재난으로부터 위기관리를 기반으로 재해복구, 비상계획을 통해 비스니스 연속성을 보장하는 체계

비즈니스 연속성 계획 관련 주요 용어

BIA
- BCP를 구축하기 위한 비즈니스 영향 분석
RTO
- 다시 가동될 때까지의 시간
RPO
- 데이터 손실 허용 시점
DRS
- 재해복구센터

보안 용어

보안 공격 관련 용어

드라이브 바이 다운로드
- 악성 스크립트를 설치하고 접속시 사용자 동의없이 실행되어 감염
워터링 홀
- 자주 방문하는 페이지에 악성 코드를 심거나, URL로 유인하여 감염
하트블라드
- 하트비트
스피어피싱
- 파일 클릭하도록 유도하여 감염
스미싱
- 문자메시지 피싱
큐싱
- 큐알코드 피싱
봇넷
- 악성 프로그램에 감염되어 다수의 컴퓨터들이 네트워크로 연결된 형태
제로데이 공격
- 대응책이 발표되기 전 공격이 이루어지는 것
바이러스
- 자가 증식 불가
웜
- 자가 증식 가능
악성 봇
- 공격 당해 원격으로 제어 0당하는 프로그램
랜섬웨어
- 몸 값을 요구
이블 트윈
- 무선 와이파이 피싱 기법
사회공학
- 사람들의 심리와 행동을 이용
타이포스쿼팅
- URL 하이재킹
- 네이버를 검색했는데 네이바가 나와서 해킹하는 방법
- 유사한 URL을 사용

주요 시스템 보안 공격 기법

키로거 공격
- 키보드 움직임

보안 공격 대응 관련 용어

ISMS
- 정보 자산을 관리, 보호하기 위한 종합적인 체계
트러스트존
- ARM사에서 개발
- 프로세스 안에 독립적인 보안 구역을 두어 중요한 정보는 따로 보관
TKIP
- 임시 키 무결성 프로토콜

7장 - SQL 응용

Wed, 10 Apr 2024 02:39:16 GMT

데이터베이스 기본

트랜잭션

인가받지 않은 사용자로부터 데이터를 보장받기 위해 DBMS가 가져야 할 특성

트랜잭션 특성

원자성
- 연산 전체가 성공 또는 실패가 되어야 함
일관성
- 수행 전후 상태가 같아야 함
격리성
- 서로 영향을 미쳐서는 안됨
영속성
- 영속적으로 저장되어야 함

병행제어

다수 사용자 환경에서 여러 트랜잭션을 수행 할때 일관성 유지를 위해 상호작용을 제어하는 기법

병행제어 기법 종류

로킹
- 하나의 트랜잭션이 실행되는 동안 다른 트랜잭션이 접근하지 못하도록 상호배제 기능
타임스탬프 순서
- 타임스탬프를 부여하여 부여된 시간에 따라 수행

회복기법

트랜잭션 도중 장애로 인해 손상된부분을 정상 상태로 복구
REDO
- 트랜잭션 시작과 완료에 대한 기록이 있음
UNDO
- 트랜잭션 시작만 있고 완료에 대한 기록이 없음

DDL

데이터 정의어
생성, 변경, 삭제, 이름 변경

DDL 대상

스키마
- 데이터베이스의 구조, 제약조건을 담고 있음
- 외부스키마
  - 사용자, 개발자 관점
- 개념스키마
  - 전체적인 논리적 구조
- 내부스키마
  - 물리적 저장 장치의 관점
테이블
- 데이터를 저장하는 필드로 구성된 집합 = 릴레이션, 엔티티
- 튜플/ 행
  - 테이블 내의 행
  - 테이블에서 동일 값 가질 수 없음
  - 튜플의 개수 : 카디널리티(특정 데이터 집단의 유니크한 값의 개수)
- 속성/ 열
  - 열의 개수 : 차수, 디그리
- 도메인
  - 하나의 속성이 취할 수 있는 같은 타입의 원자값들의 집합
뷰
- 논리 테이블
- 사용자 관점에서는 테이블과 동일
인덱스
- 검색 연산을 최적화
- 기본키는 자동으로 인덱스 생성

TABLE 관련 DDL 명령어

 CREATE    생성
 ALTER     수정
 DROP      삭제
 TRUNCATE  내용삭제

CREATE TABLE
- 테이블을 생성하는 명령어
```
CREATE TABLE 사원
(
사번 VARCHARE(10) NOT NULL,
부서번호 VARCHARE(20),
생년월일 DATE NOT NULL,
성별 CHAR(1),
PRIMARY KEY(사번),
FOREIGN KEY(부서번호) REFERENCES 부서(부서코드),
CONSTRAINT 성별제약 CHECK 성별 IN('M','F')
);
```
  - 사원테이블의 VARCHARE(10)타입인 사번컬럼은 NULL이 아니고,
  - VARCHARE(20)타입인 부서번호칼럼이 있고,
  - DATE 타입인 생년월일칼럼은 NULL이 아니어야 하고,
  - 그 중 사번컬럼은 기본키이고,
  - 부서번호칼럼은 부서테이블의 부서코드칼럼을 참조하고,
  - 성별컬럼은 M과 F값만 허용.

ALTER TABLE

테이블을 수정

칼럼 추가 문법

ALTER TABLE 테이블명 ADD 칼럼명 데이터타입 [제약조건];

칼럼 수정 문법

ALTER TABLE 테이블명 ALTER 칼럼명 데이터타입 [제약조건];

칼럼 삭제 문법

ALTER TABLE 테이블명 DROP COLUMN 칼럼명;

DROP TABLE
- 테이블을 삭제
```
DROP TABLE 테이블명 [CASCADE | RESTRICT];
```
- CASCADE
  - 참조하는 테이블까지 제거
- RESTRICT
  - 다른 테이블이 삭제할 테이블을 참조 중이면 제거하지 않기
TRUNCATE TABLE
- 테이블 내의 데이터들을 모두 삭제
```
TRUNCATE TABLE 테이블명;
```

VIEW 관련 DDL 명령어

CREATE VIEW
- 뷰를 생성
```
CREATE VIEW 뷰이름 AS
```
DROP VIEW
- 뷰를 삭제
```
DROP VIEW 뷰이름;
```

INDEX 관련 DDL 명령어

CREATE INDEX

인덱스를 생성

CREATE [UNIQUE] INDEX 인덱스명 ON 테이블명(칼럼명1, 칼럼명2);

ALTER INDEX
- 인덱스를 수정
DROP INDEX
- 인덱스를 삭제
```
DROP INDEX 인덱스명;
```

DML

데이터 조작어

SELECT  조회
 INSERT  삽입
 UPDATE  갱신
 DELETE  삭제

SELECT 명령어

SELECT 명령어
- 데이터의 내용을 조회
```
SELECT [ALL | DISTINCT] 속성명1, 속성명2,
FROM 테이블명
WHERE 조건
GROUP BY 속성명1
HAVING 그룹조건
ORDER BY 속성 [ASC | DESC];
```
- SELECT 조건
  - ALL = *
    - 모든 튜플을 검색
  - DISTINCT
    - 증복된 속성이 있는 경우 그 중 첫 번째 한개만 검색
- WHERE 조건
  - LIKE 연산자
    - %
      - 글자수 제한 없음
      - '박%'이면 박으로 시작하는 글자수 제한없이 와야 함
    - _
      - 특정위치에 있어야 함
      - '박_' 이면 박 뒤에 무조건 1글자가 있어야 함

조인

두개 이상의 테이블을 연결하여 테이터 검색

내부조인

조인조건에 맞는것끼리 묶어줌

SELECT A.칼럼1, A.칼럼2,
    B.칼럼1, B.칼럼2
FROM 테이블1 A [Inner] JOIN 테이블2 B
ON 조인조건
WHERE 검색조건;

왼쪽 외부 조인

왼쪽에 위치한 테이블을 기준으로 조인

SELECT A.칼럼1, A.칼럼2,
    B.칼럼1, B.칼럼2
FROM 테이블1 A LEFT [OUTER] JOIN 테이블2 B
ON 조인조건
WHERE 검색조건;

오른쪽 외부 조인

오른쪽에 위치한 테이블을 기준으로 조인

SELECT A.칼럼1, A.칼럼2,
    B.칼럼1, B.칼럼2
FROM 테이블1 A RIGHT [OUTER] JOIN 테이블2 B
ON 조인조건
WHERE 검색조건;

교차 조인

각 테이블의 칼럼끼리 다 조인

SELECT A.칼럼1, A.칼럼2,
    B.칼럼1, B.칼럼2
FROM 테이블1 A CROSS JOIN 테이블2 B;

집합 연산자

UNION
- 중복 행 제거
UNION ALL
- 중복 행 제거 X
INTERSERT
- 중복 레코드만 포함
MINUS
- 첫 쿼리에만 있는 것

INSERT 명령어

데이터의 내용을 삽입

INSERT INTO VALUES

INSERT INTO 테이블명(속성명1, 속성명2, ..)
VALUES(데이터1, 데이터2, ..);

UPDATE 명령어

데이터의 내용을 변경

UPDATE SET WHERE

UPDATE 테이블명
SET 속성명1 = 데이터1, 속성명2 = 데이터2.. 
WHERE 조건;

DELETE 명령어

데이터의 내용을 삭제
- DELETE FROM WHERE
```
DELETE FROM 테이블명
WHERE 조건;
```

DCL

데이터 제어어
```
GRANT 권한부여
REVOKE 권한취소
```

GRANT

사용자에게 데이터베이스의 권한 부여

GRANT 권한 [UPDATE | DELETE] ON 테이블명 TO 사용자;

REVOKE

사용자에게 데이터베이스의 권한 회수

REVOKE 권한 [UPDATE | DELETE] ON 테이블명 FROM 사용자;

9장 - SW 개발 보안 구축 - 1장

Tue, 09 Apr 2024 16:04:16 GMT

소프트웨어 개발 보안 설계

SW 개발 보안의 구성요소

3대 구성요소 (기무가)

기밀성
- 인가된 사용자만 접근 가능
무결성
- 데이터가 훼손, 파괴 되지 않음을 보장
가용성
- 언제든 접근 가능

SW 개발 보안을 위한 공격기법의 이해

DoS 공격

SYN 플러딩
- TCP 프로토콜의 구조적인 문제를 이용한 공격
UDP 플러딩
- 대량의 UDP 패킷을 만들어 자원 고갈
스머프/ 스머핑
- ICMP Echo 패킷을 직접 브로드캐스팅하여 마비
죽음의 핑
- ICMP 패킷을 정상보다 크게 만들어 전송하여 마비
랜드 어택
- 수신자가 자기 자신에게 응답하여 가용성 침해
티어 드롭
- IP 패킷 재조합 과정에서 수신시스템 문제를 발생시키도록

DDoS 공격

여러 대의 공격자를 배치하여 공격

DRDos

DDoS보다 공격의 근원지 파악 어려움

세션 하이재킹

TCP의 세션 관리의 취약점을 이용
비동기화 상태 탐지
ACK 패킷 비율 모니터링

네트워크 공격

스니핑
- 데이터만 몰래 들여다보는 수동적 공격, 직접 공격X
네트워크 스캐너/스니퍼
- 네트워크의 취약점 파악을 위해 탐색하는 공격 도규
패스워드 크래킹
- 사전 크래킹
  - 가능성이 될 단어를 파일로 만들어 대입
- 무차별 크래킹
  - 무작위로 대입
- 패스워드 하이브리드
트로이 목마
- 악성 루틴이 몰래 숨어있는 프로그램

시스템 보안 위협

버퍼 오버플로
- 스택 버퍼 오버플로
- 힙 버퍼 오버플로
백도어
- 인증 절차를 우회하는 기법

서버 인증 및 접근 통제

서버인증

사용자의 정보를 확인하는 보안 절차

서버인증의 유형

지식기반 인증
- ID, 패스워드
소지기반 인증
- 공인인증서
생체기반 인증
- 홍채, 정맥, 얼굴, 지문
특징(행위)기반 인증
- 서명, 발걸음, 몸짓

서버 접근 통제의 유형

임의적 접근 통제 (DAC)
- 주체나 그룹의 신분에 근거
- 신분 기반 접근통제
강제적 접근통제 (MAC)
- 허용등급, 주체가 갖고있는 접근허가 권한에 근거
- 규칙기반 접근통제
역할 기반 접근 통제(RBAC)
- 맡은 역할에 근거

접근 통제 보호 모델

벨-라파둘라 모델
- 미 국방부
- 기밀성 강조
비바 모델
- 무결성 강조

3A

인증
- 신분 검증
권한 부여
- 접근 허용
계정 관리
- 정보 수집, 관리, 접근 추적, 행동 기록

인증 관련 기술

SSO
- 커버로스에서 사용
- 한 번의 인증 과정으로 여러 컴퓨터 이용 가능
커버로스
- 대칭 키 암호 기법의 티켓 기반의 프로토콜
- 2004년 2개 회사가 합심해 만듦
OAuth
- 다른 웹 사이트에 대한 접근 권한 부여 가능 (구글, 네이버, 카카오)

Sw 개발 보안을 위한 암호화 알고리즘

암호 알고리즘

양방향
- 대칭키
  - 블록 암호
    - DES, AES, SEED
  - 스트림 암호
    - RC4
- 비대칭키
  - RSA, 디피-헬만, ECC
일방향
- 해시함수
  - 고정된 길이의 암호문(해시값) 출력
  - MAC
    - 키를 사용하는 메시지 인증 코드
  - MDC
    - 키를 사용하지 않는 변경 감지 코드

대칭키 암호화 기법 - 양방향

DES
- 16라운드, 64비트
SEED
- 16라운드, 128비트
AES
- 전사적 공격 가능, 128비트, DES 성능 개선으로 갭발
Skipjack
- 칩이 내장
IDEA
- 8라운드, 64비트
ARIA
- 128비트, 키 길이에 따라 128, 192, 256으로 분류
- 2004년 2개가 합심해 개발

비대칭키 암호화 기법 - 양방향

RSA
- 소인수 분해
ECC
- 이산 대수
디피-헬만
- 최초

해시함수 암호화 기법 - 일방향

MD5
- MD4를 개선
- 128비트의 해시값 생성
SHA-1
- 160비트의 해시 생성

데이터베이스 암호화 기법

VPN
- 인터넷 공중망에 기술을 활용하여 마치 전용망을 사용하는 효과를 갖음
- IPSec
  - IP계층(3계층 네트워크)에서 사용하는 무결성, 인증 보장 보안 프로토콜
- SSL/TLS
  - 전송계층(4계층), 응용계층(7계층) 사이에서 무결성 보장 보안 프로토콜
L2TP
- 데이터 링크 계층(2계층)에서 사용하는 보안 프로토콜
- UDP 포트 사용

11장 - 응용 SW 기초 기술 활용

Tue, 09 Apr 2024 09:56:53 GMT

네트워크 계층 구조

OSI 계층

7계층 응용계층          (Application) - HTTP/HTTPS
6계층 표현계층        (Presentation)
5계층 세션계층        (Session)
4계층 전송계층        (Transport)   - TCP/UDP
3계층 네트워크계층        (Network)     - IP/ICMP
2계층 데이터링크계층    (Data Link)   - HDLC/PPP
1계층 물리계층        (Physical)

외우는 방법
- 아파서 티내다, 피나다

네트워크 장비

1계층 장비

허브 : 하나의 네트워크로 여러 대의 컴퓨터로 송신하기 위한 장비
리피터 : 디지털 신호를 증폭

2계층 장비

브리지 : 두 개의 근거리 통신망(LAN)을 연결

3계층 장비

라우터 : LAN과 LAN을 연결 or LAN과 WAN을 연결
게이트웨이 : 서로 다른 통신망에 접속

프로토콜

개념

서로 다른 시스템이나 기기들 간의 데이터 교환을 원활히 하기 위함
3요소
- 구문, 의미, 타이밍 (구의타)

데이터 링크 계층 - 2계층

프로토콜

HDLC
- 동기식 비트 중심
ATM
- 정보전달 기본 단위를 53바이트 셀 단위로 전달
- 비동기식 시분할 다중화 방식의 패킷형 전송기술
- 광대역 전송
PPP
- 두 통신 노드 간의 직접적인 연결을 위해 사용
프레임 릴레이
- 중계 기능, 다중화 기능만 수행

오류 제어

전진 순방향 오류수정 (FEC : Foward Error Correction)
- 데이터 전송 과정에서 오류 발생시 재전송 요구없이 스스로 수정
- 해밍코드방식
  - 수신측에서 오류가 발생한 비트를 찾아 재전송을 요구하지 않고 자신이 직접 오류를 수정
  - 1비트의 오류 수정이 가능
후진 역방향 오류수정(BEC : Backward Error Correction)
- 오류 발생시 송신 측에 재전송 요구
- 패리티 검사
  - 패리티 비트를 추가
- CRC
  - 다향식을 통해 산출된 값으로 오류 검사
- 블록합 검사
- 자동반복 요청방식(ARQ)
## 네트워크 계층 - 3계층 ### 네트워크 계층 프로토콜
IP
- 패킷 단위로 데이터를 교환
ARP
- IP 주소 -> MAC 주소로 변환
RARP
- MAC 주소 -> IP 주소로 변환
ICMP
- IP 과정 중 오류 발생 시 오류 정보를 메시지 형태로 전송
IGMP
- 인터넷 그룹 관리, 화상회의
NAT
- 사설 네트워크 IP 주소 -> 공인 IP 주소로 변환
라우팅 프로토콜

IPv4 / IPv6

IPv4
- 32비트
- 유니캐스트, 멀티캐스트, 브로드캐스트
- 서브네팅
  - IP 주소 고갈 문제를 해결하기 위해 분리
IPv6
- 128 비트
- 16비트씩 8부분
- 40바이트의 고정길이
- 유니캐스트, 멀티캐스트, 애니캐스트

라우팅 프로토콜

최적의 경로를 설정
- IGP (내부 라우팅 프로토콜)
  - 동일한 AS 내
  - RIP
    - 거리벡터 알고리즘
      - 벨만-포드 알고리즘
  - OSPF
    - RIP의 단점 개선
    - 링크 상태 알고리즘
      - 다익스트라 알고리즘
- EGP (외부 라우팅 프로토콜)
  - 서로 다른 AS 간
  - BGP
    - 경로 벡터 알고리즘

전송 계층 - 4계층

TCP
- 안정적으로, 패킷손실 없이, 에러 없이, 순서대로 교환 가능, 흐름제어 기능
- TCP 헤더 20바이트
UDP
- 비연결성, 비신뢰성, 순서화X
  ## 세션계층 - 5계층
응용 프로그램 간의 대화를 유지하기 위한 구조 제공, 논리적인 연결 담당
## 표현계층 - 6계층
JPEG
- 이미지
MPEG
- 멀티미디어, 비디오, 오디오
  ## 응용계층 - 7계층 ### 프로토콜
- HTTP
- 하이퍼텍스트
- 80번 포트
- HTTPS
- HTTP의 보안이 강화된
- 443번 포트
- SMTP
- 이메일 전송
- TCP 포트번호 25번
- IMAP
- 원격서버로 부터 이메일 가져오는
- 143번 포트
- Telnet
- 네트워크 연결에 사용
- 23번 포트
- SSH
- Telnet보다 강화된 보안
- 원격접속
- 22번 포트
- DNS
- 도메인 이름
- 53번 포트
- FTP
- 데이터 전송 채널 - 20번 포트
- 데이터 전송 제어 채널 - 21번 포트

네트워크 전달 방식

패킷 교환 방식

종류

데이터그램
- 연결경로를 확립X
- 순서 무관하게 독립적 전송
가상회선
- 통신 경로를 미리 설정

네트워크 구조

`애드 혹 네트워크`

노드 들에 의해 자율적으로 구성되는 구조가 없음
종류
- 버스형 구조
  - 하나의 네트워크에 여러대의 노드가 연결
- 트리형 구조
- 링형 구조
- 성형 구조
  - 중앙 허브, 스위치, 리피터 등 허브에 점대점 연결

네트워크 용어

SDN
- 제어부 / 전달부로 분리
NFV
- 범용 하드웨어에 가상화 기술 적용
NFC
- 주파수 사용
- RFID의 확장 기술
블루투스
- 근거리 디바이스 간 통신
- 피코넷, 스캐터넷
Zing
- 기기를 키오스크에 갖다 대면 데이터 가져올 수 있는 기술
메시 네트워크
- 기존 랜의 한계 극복 등장
- 차세대 이동통신
- 그물모양 네트워크
사물인터넷
- 각종 사물에 센서와 통신 기능 내장
MQTT
- IOT 장치 등에서 최적화되어 사용될 수 있도록 개발
- 브로커를 사용한 발행/구독 방식의 경량 메시징 전송
Zigbee
- 근거리 통신 지원
- 저전력, 저비용, 저속

TIL - 3월 21일 : 알고리즘 기초3

Mon, 25 Mar 2024 00:25:23 GMT

스택

1. 스택이란?

스택(Stack)은 컴퓨터 과학에서 자주 사용되는 기본적인 데이터 구조 중 하나로, 마지막에 추가된 요소가 가장 먼저 제거되는 후입선출(Last In First Out, LIFO) 방식을 따른다.
스택 구현의 중요 키워드
- push : 값을 넣음(스택의 가장 위에 새로운 요소를 추가한다.)
- pop : 값을 꺼냄(스택의 가장 위에 있는 요소를 제거하고 그 값을 반환한다.)
- peek : 빼지는 않고 값만 알려줌
- top : 현재 가리키고 있는 인덱스
- isEmpty : 배열이 비어있는지 확인
- isFull : 배열이 꽉 차있는지 확인

웹 브라우저의 뒤로 가기 기능 / 함수 호출 시의 반환 주소 저장 / 괄호의 짝 맞춤 검사 등 다양한 알고리즘과 프로그램에서 사용된다.

2. 스택 만들기

public class MyStack {
  private int maxSize;        // 스택을 저장할 배열
  private int[] stackArray;   // 스택의 최대 크기
  private int top;            // 스택 포인터, 초기값은 -1

  // 스택의 크기를 받아들이는 생성자
  public MyStack(int maxSize) {
      this.maxSize = maxSize;
      this.stackArray = new int[maxSize];
      this.top = -1;
  }

  // 스택에 데이터 추가
  public void push(int num) {
      if (top < maxSize - 1) {
          System.out.println(num);
          stackArray[++top] = num;
      } else {
          System.out.println("스택이 가득 찼습니다.");
      }
  }

  // 스택에서 데이터 제거
  public int pop() {
      if (isEmpty()) {
          System.out.println("스택이 비었습니다.");
          return -1;
      } else {
          return stackArray[top--];
      }
  }

  // 스택의 최상단 데이터 확인
  public int peek() {
      if(isEmpty()){
          System.out.println("스택이 비었습니다.");
          return -1;
      } else {
          return stackArray[top];
      }
  }

  // 스택이 비어 있는지 확인
  public boolean isEmpty() {
      return top == -1;
  }

  // 스택이 가득 찼는지 확인
  public boolean isFull(){
      return top == maxSize - 1;
  }

  public static void main(String[] args) {
      MyStack stack = new MyStack(5);
      stack.push(1);
      stack.push(2);
      stack.push(3);
      System.out.println(stack.pop());
      System.out.println(stack.peek());
      System.out.println(stack.pop());
      System.out.println(stack.pop());
      System.out.println(stack.isEmpty());
  }
}

예외처리가 추가된 스택

public class FixedLengthStack {
  private int[] stackArray; // 스택을 저장할 배열
  private int stackCapacity; // 스택의 최대 크기
  private int stackPointer; // 스택 포인터

  // 스택이 비었을 때 발생하는 예외
  public static class StackEmptyException extends RuntimeException {
      public StackEmptyException() {
      }
  }

  // 스택이 가득 찼을 때 발생하는 예외
  public static class StackFullException extends RuntimeException {
      public StackFullException() {
      }
  }

  // 생성자
  public FixedLengthStack(int maxSize) {
      stackPointer = 0;
      stackCapacity = maxSize;
      stackArray = new int[stackCapacity];
  }

  // 스택에 데이터 추가
  public int push(int item) {
      if (stackPointer >= stackCapacity)
          throw new StackFullException();
      return stackArray[stackPointer++] = item;
  }

  // 스택에서 데이터 제거
  public int pop() {
      if (stackPointer <= 0)
          throw new StackEmptyException();
      return stackArray[--stackPointer];
  }

  // 스택의 최상단 데이터 확인
  public int peek() {
      if (stackPointer <= 0)
          throw new StackEmptyException();
      return stackArray[stackPointer - 1];
  }

  // 스택 초기화
  public void clear() {
      stackPointer = 0;
  }

  // 스택에서 특정 데이터 찾기
  public int indexOf(int item) {
      for (int i = stackPointer - 1; i >= 0; i--) {
          if (stackArray[i] == item)
              return i;
      }
      return -1;
  }

  // 스택 최대 크기 반환
  public int getCapacity() {
      return stackCapacity;
  }

  // 스택에 저장된 데이터 개수 반환
  public int size() {
      return stackPointer;
  }

  // 스택이 비어 있는지 확인
  public boolean isEmpty() {
      return stackPointer == 0;
  }

  // 스택이 가득 찼는지 확인
  public boolean isFull() {
      return stackPointer == stackCapacity;
  }

  // 스택 내용 출력
  public void dump() {
      if (stackPointer <= 0)
          System.out.println("스택이 비어 있습니다.");
      else {
          for (int i = 0; i < stackPointer; i++)
              System.out.print(stackArray[i] + " ");
          System.out.println();
      }
  }

  public static void main(String[] args) {
      FixedLengthStack stack = new FixedLengthStack(5); // 크기가 5인 스택 생성

      // 스택에 데이터를 푸시합니다.
      try {
          stack.push(1);
          stack.push(2);
          stack.push(3);
          stack.push(4);
          stack.push(5);
          // 스택이 가득 찼으므로, 다음 줄에서 예외가 발생합니다.
          stack.push(6);
      } catch (FixedLengthStack.StackFullException e) {
          System.out.println("스택이 가득 찼습니다.");
      }

      // 스택의 내용을 출력합니다.
      stack.dump();

      // 스택에서 데이터를 팝합니다.
      try {
          System.out.println("팝한 데이터: " + stack.pop());
          System.out.println("팝한 데이터: " + stack.pop());
          System.out.println("팝한 데이터: " + stack.pop());
          // 스택이 비었으므로, 다음 줄에서 예외가 발생합니다.
          System.out.println("팝한 데이터: " + stack.pop());
          System.out.println("팝한 데이터: " + stack.pop());
          System.out.println("팝한 데이터: " + stack.pop());
      } catch (FixedLengthStack.StackEmptyException e) {
          System.out.println("스택이 비어 있습니다.");
      }
  }
}

큐

1. 큐란?

큐(Queue)는 컴퓨터 과학에서 사용되는 중요한 추상 데이터 타입 중 하나로, 선입선출(First In First Out, FIFO)의 원칙을 따른다.
큐의 중요 키워드
- enQueue : 큐의 뒷쪽에 새로운 요소 추가
- deQueue : 큐의 앞쪽에서 요소를 제거하고 반환
- peek : 큐의 앞쪽에서 요소를 제거하지 않고 반환
- front : 현재 반환해야되는 요소을 가르키는 배열의 인덱스
- rear : 마지막 요소의 다음 위치를 가리키는 인덱스
- count : 현재 큐에 저장된 요소의 개수
- IsEmpty : 큐가 비어 있는지 확인한다.
큐는 데이터를 일시적으로 보관해야 할 때 유용하게 사용된다.
프린터의 인쇄 작업 관리 / 운영 체제에서의 작업 스케줄링 / 네트워크 요청의 처리 순서 관리 등

2. 큐 만들기
enqueue 와 dequeue 메소드에서 rear와 front를 하나씩 늘려주기만 하면 선형 큐
capacity 로 나눠주면 원형 큐가 된다.

선형 큐는 인덱스가 증가만 하므로 배열의 끝에 도달하면 포화된 큐가 아니더라도 앞의 빈 공간을 사용하지 못하는 문제점이 있다.

public class MyQueue {
  private int[] queueArray;   // 큐
  private int front;          // 큐의 맨 앞 값의 인덱스
  private int rear;           // 큐 맨 뒤 값의 다음 인덱스
  private int capacity;       // 큐 쵀대 용량
  private int count;          // 큐의 저장된 데이터 수

  // 큐의 크기를 받아들이는 생성자
  public MyQueue(int maxSize) {
      capacity = maxSize;
      queueArray = new int[capacity];
      front = rear = count = 0;
  }

  public void enqueue(int item) {
      if (isFull()) {
          System.out.println("큐가 가득 차서 데이터를 넣을 수 없어요.");
      } else {
          queueArray[rear] = item;
          rear = (rear + 1) % capacity;
          count++;

          System.out.println(item);
      }
  }

  public void dequeue() {
      if (isEmpty()) {
          System.out.println("큐가 비어서 뺄 데이터가 없어요.");
      } else {
          int item = queueArray[front];
          front = (front + 1) % capacity;
          count--;

          System.out.println(item);
      }
  }

  public void peek() {
      if (isEmpty()) {
          System.out.println("큐가 비어 있어요.");
      } else {
          int item = queueArray[front];
          System.out.println(item);
      }
  }

  public boolean isEmpty() {
      return count == 0;
  }

  public boolean isFull() {
      return count == capacity;
  }

  public static void main(String[] args) {
      MyQueue q = new MyQueue(3);
      q.enqueue(1);
      q.enqueue(3);
      q.enqueue(5);
      System.out.println("q.isFull() : " + q.isFull());
      q.enqueue(7);
      q.dequeue();
      q.peek();
      q.dequeue();
      q.dequeue();
      System.out.println("q.isEmpty() : " + q.isEmpty());
      q.dequeue();
  }
}

예외처리가 추가된 큐

public class FixedLengthQueue {
    private int[] queueArray; // 큐를 저장할 배열
    private int queueCapacity; // 큐의 최대 크기
    private int front; // 첫 번째 요소를 가리키는 인덱스
    private int rear; // 마지막 요소의 다음 위치를 가리키는 인덱스
    private int currentSize; // 현재 큐에 저장된 요소의 개수

    public class QueueEmptyException extends RuntimeException {
        public QueueEmptyException() {
        }
    }

    public class QueueFullException extends RuntimeException {
        public QueueFullException() {
        }
    }

    public FixedLengthQueue(int maxSize) {
        currentSize = front = rear = 0;
        queueCapacity = maxSize;
        queueArray = new int[queueCapacity];
    }

    public int enqueue(int item) {
        if (currentSize >= queueCapacity)
            throw new QueueFullException();
        queueArray[rear] = item;
        rear = (rear + 1) % queueCapacity;
        currentSize++;
        return item;
    }

    public int dequeue() {
        if (currentSize <= 0)
            throw new QueueEmptyException();
        int item = queueArray[front];
        front = (front + 1) % queueCapacity;
        currentSize--;

        return item;
    }

    public int peek() {
        if (currentSize <= 0)
            throw new QueueEmptyException();
        return queueArray[front];
    }

    public void clear() {
        currentSize = front = rear = 0;
    }

    public int indexOf(int item) {
        for (int i = 0; i < currentSize; i++) {
            int index = (front + i) % queueCapacity;
            if (queueArray[index] == item)
                return index;
        }

        return -1;
    }

    public int getCapacity() {
        return queueCapacity;
    }

    public int size() {
        return currentSize;
    }

    public boolean isEmpty() {
        return currentSize == 0;
    }

    public boolean isFull() {
        return currentSize == queueCapacity;
    }

    public void dump() {
        if (currentSize <= 0) {
            System.out.println("큐가 비어 있습니다.");
        } else {
            for (int i = 0; i < currentSize; i++) {
                System.out.print(queueArray[(front + i) % queueCapacity] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        FixedLengthQueue queue = new FixedLengthQueue(5); // 크기가 5인 큐 생성

        // 큐에 데이터를 인큐(추가)합니다.
        try {
            queue.enqueue(10);
            queue.enqueue(20);
            queue.enqueue(30);
            queue.enqueue(40);
            queue.enqueue(50);
            // 큐가 가득 찼으므로, 다음 줄에서 OverflowIntQueueException 예외가 발생할 수 있습니다.
            // queue.enqueue(60); // 이 줄의 주석을 해제하면 예외가 발생합니다.

        } catch (FixedLengthQueue.QueueFullException e) {
            System.out.println("큐가 가득 찼습니다. 더 이상 데이터를 추가할 수 없습니다.");
        }

        // 큐의 내용을 출력합니다.
        queue.dump();

        // 큐에서 데이터를 디큐(제거)합니다.
        try {
            while (!queue.isEmpty()) {
                System.out.println("디큐한 데이터: " + queue.dequeue());
            }
            // 큐가 비었으므로, 다음 줄에서 EmptyIntQueueException 예외가 발생할 수 있습니다.
            // System.out.println(queue.dequeue()); // 이 줄의 주석을 해제하면 예외가 발생합니다.

        } catch (FixedLengthQueue.QueueEmptyException e) {
            System.out.println("큐가 비어 있습니다. 더 이상 데이터를 제거할 수 없습니다.");
        }
    }
}

재귀의 기본

1. 재귀란?

재귀(Recursion)는 자신을 정의할 때 자기 자신을 호출하는 방식을 의미한다.
종료조건이 필수적으로 필요하다
재귀 함수는 기본적으로 두 부분으로 구성된다. a. 기저 조건(Base Case) 재귀 호출을 멈추고 함수가 자기 자신을 더 이상 호출하지 않는 조건이다. 기저 조건은 재귀가 무한 루프에 빠지지 않도록 하는 중요한 역할을 한다. b. 재귀적 단계(Recursive Case) 문제의 크기를 줄이고 자기 자신을 호출하는 부분이다.
```
public class RecursiveTest {
  static void recursive(int n){
      if(n > 0){
          recursive(n - 1);
          System.out.println(n);
      }
  }

  public static void main(String[] args) {
      recursive(5);
  }
}
```

2. 팩토리얼 구하기

import java.util.Scanner;

public class FactorialCalculator {
    static int factorial(int n) {
        if (n > 0)
            return n * factorial(n - 1);
        else
            return 1;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("n!, 정수 n을 입력하세요 : ");
        int n = sc.nextInt();

        System.out.println(n + "! = " + factorial(n));
    }
}

3. 유클리드 호제법

유클리드 호제법(Euclidean Algorithm)은 두 양의 정수의 최대공약수(Greatest Common Divisor, GCD)를 찾는 효율적인 방법이다.
기본 아이디어는 두 수의 차이가 그 수들의 최대 공약수에 영향을 미치지 않는다는 것이다.
두 수 a와 b (a > b)의 최대공약수는 a와 a-b의 최대공약수와 같다. 이 원리를 반복하면 최종적으로 최대공약수를 구할 수 있다.
뺄셈을 이용한 방법 가장 단순한 형태로, 두 수 중 큰 수에서 작은 수를 뺀다. 이 과정을 두 수가 같아질 때까지 반복하여, 최종적으로 남은 수가 두 수의 최대공약수가 된다. → 큰 수에 대해서는 계산이 비효율적일 수 있다.
나눗셈을 이용한 방법(모듈로 연산) 두 수 a와 b (a > b)가 있을 때, a를 b로 나눈 나머지를 구한다. 그 다음, b와 이 나머지의 최대공약수를 구한다. 반복하여 나머지가 0이 되었을 때의 b가 두 수의 최대공약수이다. → 뺄셈을 사용하는 방법보다 훨씬 빠르고 효율적이다.
```
import java.util.Scanner;
```

public class GCDCalculator { // 유클리드 호제법을 사용한 반복문 static int gcd(int x, int y) { while (y != 0) { int temp = y; y = x % y; x = temp; } return x; }

// 유클리드 호제법을 사용한 재귀 호출
static int calculateGCD(int x, int y) {
    if (y == 0)
        return x;
    else
        return calculateGCD(y, x % y);
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    System.out.println("두 수의 최대공약수를 계산합니다.");
    System.out.print("첫 번째 정수를 입력하세요: ");
    int x = sc.nextInt();
    System.out.print("두 번째 정수를 입력하세요: ");
    int y = sc.nextInt();

    System.out.println("두 수의 최대공약수는 " + gcd(x, y) + "입니다.");
    System.out.println("두 수의 최대공약수는 " + calculateGCD(x, y) + "입니다.");
}

}

## 꼬리 재귀
- 팩토리얼을 재귀함수와 for문으로 작성한 코드
```java
import java.util.Scanner;

public class FactorialCalculator {
    //재귀함수
    static int factorial(int num) {
        if (num > 0){
            return factorial(num-1) * num;
        } else{
            return 1; //0!은 1이다.
        }
    }

    //for문으로 구현한 함수
    static int factorialForGrammar(int num) {
        int result = 1;
        if (num > 0){
            for(int i = num; i < 0; i--){
                result *= num;
            }
        }else {
            result = 1;
        }
        return result;
    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int num = 0;

        do {
            System.out.print("펙토리얼을 구하고자하는 양의 정수를 입력하세요: ");
            num = sc.nextInt();
        }while(num < 0);

        System.out.println(factorial(num));
        System.out.println(factorialForGrammar(num));
    }
}

꼬리재귀란

위의 팩토리얼 재귀함수 코드를 보면 return뒤에 아래와 같은 형태로 되어있는 것을 볼 수 있다.

factorial(num-1) * num;

꼬리재귀는 재귀함수에 다른 연산을 하는 것이 아닌 모조건 return뒤에 재귀함수 본인만 오는 것을 말한다.
꼬리 재귀(Tail Recursion)는 함수의 마지막 동작이 자기 자신을 호출하는 형태의 재귀이다.
재귀 호출이 함수의 끝부분에서 발생하며, 현재 함수의 실행 상태를 유지할 필요가 없기 때문에, 컴파일러나 인터프리터가 최적화하기가 더 쉽다. → 즉, 새로운 스택 프레임을 추가하지 않고 현재의 스택 프레임을 재사용할 수 있어 메모리 사용량이 줄고, 실행 효율이 높아질 수 있다.
예제 : 팩토리얼 계산
```
import java.util.Scanner;
```

public class TailRecursiveFactorial { // 꼬리 재귀를 사용한 팩토리얼 계산 메서드 static int factorial(int n, int accumulator) { if (n == 1) return accumulator; return factorial(n - 1, n * accumulator); // 꼬리 재귀 호출 }

// 사용자가 입력한 숫자에 대해 팩토리얼을 계산
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    System.out.print("팩토리얼을 계산할 정수를 입력하세요: ");
    int x = sc.nextInt();

    // 초기 누적 변수 값으로 1을 사용
    int result = factorial(x, 1);
    System.out.println(x + "의 팩토리얼은 " + result + "입니다.");
}

}


마지막에 수행하는 작업이 재귀 호출인 점이 중요한 특징이다.
호출 시 전달되는 모든 정보가 매개변수에 포함되어 있어서 현재 실행 컨텍스트를 유지할 필요가 없다는 것이다.
## 정렬
정렬(Sorting)은 데이터를 특정 기준에 따라 순서대로 배열하는 과정이다.
### 1. 버블 정렬(Bubble Sort)
- 방식 
: 인접한 두 요소를 비교하고, 필요한 경우에 위치를 교환한다. 이 과정을 모든 요소가 정렬될 때까지 반복한다.
: 한 턴이 끝나면 마지막 요소는 정렬되어 있는 상태
- 특징 : 구현이 간단하지만, 효율성이 낮아 큰 데이터셋에는 부적합하다.
평균 및 최악의 경우 시간 복잡도는 O(n^2) 이다.
```java
import java.util.Arrays;

public class BubbleSortExam {
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println((i + 1) + "번째 정렬 : " + Arrays.toString(arr));
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 33, 67, 22, 6, 88, 5};
        System.out.println("원래배열 : " + Arrays.toString(arr));

        bubbleSort(arr);

        System.out.println("정렬 후 배열 : " + Arrays.toString(arr));
    }

}

if 문 안의 내용이 보기 복잡하다면 swap 메소드로 구현하면 좀 더 깔끔해지기도 한다.

2. 선택 정렬(Selection Sort)

방식 : 전체 요소 중에서 가장 작은(혹은 큰) 요소를 찾아 첫 번째(혹은 마지막) 위치에 놓고, 나머지 요소에 대해 같은 과정을 반복한다. : 한 턴이 끝나면 가장 앞의 요소는 정렬되어 있는 상태
특징 : 버블 정렬과 마찬가지로 구현이 쉽지만, 큰 데이터셋에는 비효율적이다. 시간 복잡도는 평균과 최악의 경우 모두 O(n^2) 이다.
```
import java.util.Arrays;
```

public class SelectionSortExam { public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; }

public static void selectionSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        int min = i;
        for (int j = i; j < arr.length; j++) {
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        swap(arr, i, min);
        System.out.println((i + 1) + "번째 정렬 : " + Arrays.toString(arr));
    }
}

public static void main(String[] args) {
    int[] arr = {64, 33, 67, 22, 6, 88, 5};
    System.out.println("원래배열 : " + Arrays.toString(arr));

    selectionSort(arr);

    System.out.println("정렬 후 배열 : " + Arrays.toString(arr));
}

} ```

TIL - 3월 20일 : 알고리즘 기초2

Wed, 20 Mar 2024 12:16:34 GMT

알고리즘

클래스

자바에서 클래스는 객체 지향 프로그래밍의 핵심 구성 요소
객체는 클래스에 정의된 속성과 동작을 가지며, 클래스에서 생성된다.
클래스를 사용하면 코드의 재사용성, 확장성 및 관리 용이성이 향상된다.
정의 방법

class ClassName {
    // 필드(변수)
    // 메서드(함수)
}

ClassName은 클래스의 이름으로, Java의 네이밍 컨벤션에 따라 각 단어의 첫 글자는 대문자로 시작한다.

주요 구성 요소

필드(Fields)
- 클래스 내에서 정의된 변수로, 객체의 상태를 나타낸다. 필드는 객체의 속성, 특성을 저장하기 위해 사용한다.
메서드(Methods)
- 객체가 수행할 수 있는 동작을 정의한 코드 블록이다. 메서드는 특정 작업을 수행하고, 결과를 반환하거나, 단순히 작업을 수행할 수 있다.
생성자(Constructor)
- 클래스 이름과 동일하며, 객체가 생성될 때 자동으로 호출되는 특별한 메서드이다. 생성자는 객체 초기화에 주로 사용된다.
- 명시적으로 생성자를 정의하지 않으면, 자바 컴파일러는 기본 생성자를 제공한다.

ex. 자바 클래스

public class Dog {
    // 필드
    String breed;
    int age;
    String color;

    // 메서드
    // 접근제한자 리턴타입 메소드명 (매개변수들..) {..구현..}
    void bark() {
        System.out.println("Woof!");
    }

    void displayInfo() {
        System.out.println("Breed: " + breed + ", Age: " + age + ", Color: " + color);
    }
}

ex. 객체 생성 및 사용

클래스를 정의한 후, new 키워드를 사용하여 클래스의 인스턴스(객체)를 생성할 수 있다

public class DogTest {
  public static void main(String[] args) {
      Dog myDog = new Dog();
      myDog.breed = "Labrador";
      myDog.age = 5;
      myDog.color = "Brown";
      myDog.bark();
      myDog.displayInfo();
  }
}

소수

입력한 정수까지 모두 체킹을 하며 소수를 찾는 방식

import java.util.Scanner;

public class ListPrimes {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("정수를 입력하세요: ");
        int num = sc.nextInt();
        int cnt = 0;

        for (int i = 2; i <= num; i++){
            boolean isPrime = true;
            for (int j = 2; j < i ; j++){
                cnt++;
                if (i % j == 0){
                    isPrime = false;
                    break;
                }
            }
            if(isPrime == true){
                System.out.println(i);
            }
        }
        System.out.println(cnt);
    }
}

설명

입력한 정수까지의 모든 수를 2부터 체킹하는 수-1까지의 모든 수로 나누어 소수인지 판별을 한다. 이러한 방식은 시간이 오래걸리는 단점이 있음. 입력한 정수까지 홀수만 체킹하며 소수를 찾는 방식

import java.util.Scanner;

public class ListPrimes2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("정수를 입력하세요: ");
        int num = sc.nextInt();
        int cnt = 0;
        int arrCnt = 0;
        int[] primes = new int[500];

        primes[arrCnt++] = 2; // 2를 먼저 소수의 배열에 넣어준다.

        for (int i = 3; i <= num; i+=2){
            boolean isPrime = true;
            for (int j = 3; j < i ; j++){
                cnt++;
                if (i % j == 0){
                    isPrime = false;
                    break;
                }
            }
            if(isPrime == true){
                System.out.println(i);
            }
        }
        System.out.println(cnt);
    }
}

설명

2를 먼저 소수의 배열 primes에 넣어준다. 3부터 입력한 정수까지 홀수만 체킹을 하며 그 사이의 수로 모두 나누며 소수인지 판별한다. 위의 코드와 다르게 prime배열에 3을 먼저 넣어주고 5부터 판별해도 된다. (2, 3 모두 소수이기 때문)

다차원 배열

다차원 배열의 초기화

1번째 방법

int[][] scores = new int[3][4];

2번째 방법

int[][] scores = {
                {90, 80, 77, 60}, // 첫 번째 학생의 점수
                {80, 70, 60, 50}, // 두 번째 학생의 점수
                {70, 60, 50, 40} // 세 번째 학생의 점수
        };

클래스

클래스는 기본적으로 도면이라고 생각하면된다. 클래스를 인스턴스화 하면 객체가 되는 것이다.

클래스 → 자동차를 만드는 도면 객체 → 도면을 가지고 만든 나의 자동차

public class Dog {
    String breed;
    int age;
    String color;

    public Dog() {
        //기본 생성자
    }

    public Dog(String breed, int age, String color) {
        this.breed = breed;
        this.age = age;
        this.color = color;
    }

    public Dog(String breed, String color) {
        this.breed = breed;
        this.color = color;
    }

    //메소드
    //접근제한자 리턴타입 메소드명 (매개변수들...)
    static void bark(){
        System.out.println("Woof!");
    }
    void displayInfo(){
        System.out.println("Breed: " + breed + " Age: " + age + " Color: " + color);
    }

    //getter, settter
    public String getBreed() {
        return breed;
    }

    public int getAge() {
        return age;
    }

    public String getColor() {
        return color;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

설명

강아지 클래스이다. 즉, 강아지를 만들 수 있는 도면을 만든 것이라고 생각하면 된다. 기본적으로 생성자를 만들지 않으면 자바에서는 기본 생성자를 제공해준다. 위의 코드에서는 “기본생성자”, “품종과 나이, 색깔이 모두 들어간 생성자”, “품종과 색깔만 들아간 생성자” 3 종류가 있다. 위의 메소드를 보면 bark()와 displayInfo()가 있다. bark()는 static이 붙은 클래스 메소드이다. displayInfo()는 static이 붙지 않은 인스턴스 메소드이다. static이 붙은 클래스 메소드는 객체를 생성하지 않아도 사용이 가능하다. 하지만 static이 붙지 않은 인스턴스 메소드는 객체를 생성해야만 사용이 가능하다.

ex. 객체 생성 코드

public class DogTest {
    public static void main(String[] args) {
        Dog.bark();

        Dog myDog = new Dog(); //Dog 타입의 myDog를 인스턴스화
        myDog.setAge(3);
        myDog.setBreed("말티즈");
        myDog.setColor("흰색");
        myDog.age=6;
        myDog.displayInfo();

        Dog myDog2 = new Dog("포메", 4, "검정색");
        myDog2.displayInfo();

        Dog myDog3 = new Dog("포메", "흰색");
        myDog3.displayInfo();
    }
}

설명

위의 코드는 Dog클래스의 객체를 생성해서 사용하는 DogTest클래스이다. bark() 메소드를 보면 객체를 생성하지 않고 Dog클래스에 바로 접근해서 사용이 가능하다. 위에서 언급했듯이 static 키워드가 붙은 클래스 메소드이기 때문이다. 하지만 displayInfo() 메소드는 객세를 생성한 후 객체에 접근해서 사용이 가능하다. static이 붙지 않은 인스턴스 메소드이기 때문이다.

선형 검색(Linear Search)

선형검색

원하는 값을 찾기 위해서 배열의 첫번째 요소부터 마지막 요소까지 차례대로 모두 확인하는 방법

import java.util.Scanner;

public class SearchExam {
    static int sequentialSearch(int[] arr, int key){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == key)
                return i; // 키와 일치하는 요소의 인덱스 반환
        }
        return -1; // 검색 실패 시 -1 반환
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("찾고자하는 정수를 입력하세요: ");
        int key = sc.nextInt();
        int[] arr = {1,3,5,33,56,2,44};

        int index = sequentialSearch(arr, key);

        if (index != -1){
            System.out.println("당신이 찾는 데이터는 " +index+"번째 인덱스에 있습니다.");
        }else {
            System.out.println("당신이 찾는 데이터가 존재하지 않습니다.");
        }
    }
}

설명

찾고자 하는 값을 입력하면 sequentialSearch() 메소드에서 배열의 첫번째 요소부터 마지막 요소까지 순차적으로 확인을 한다. 도중에 원하는 값을 찾으면 값이 위치하는 요소의 인덱스를 반환한다.

선형 검색(보초법)

선형 검색 알고리즘을 개선한 방법
보초법(Sentinel Method)은 선형 검색에서 조건 검사의 횟수를 줄이기 위해 배열의 마지막에 검색하고자 하는 값을 “보초”로 추가하는 기법이다.
보초는 검색하고자 하는 키 값과 동일한 값을 배열의 맨 끝에 추가함으로써, 배열을 순회하는 동안 매번 배열의 끝에 도달했는지 확인하는 조건 검사를 생략할 수 있게 해준다.
선형 검색(보초법)의 작동 원리
1. 검색하고자 하는 키 값을 배열의 마지막에 추가한다(보초).
2. 배열의 첫 번째 요소부터 시작하여 키 값과 일치하는 요소를 찾는다.
3. 배열 내에 키 값과 일치하는 요소가 있으면 그 위치를 반환한다.
4. 보초 덕분에, 배열의 끝에 도달했는지 확인할 필요 없이 보초 값에 도달할 때까지 반복할 수 있다.
5. 배열 내에 키 값과 일치하는 원래의 요소가 없는 경우, 반복은 보초에 의해 종료된다. 이 때, 보초의 위치(즉, 배열의 맨 끝)가 반환되므로, 이를 통해 검색 실패를 판단할 수 있다.
장점
- 배열의 끝을 체크하는 조건 검사가 불필요하여, 약간의 성능 향상을 기대할 수 있다.
- 코드가 더 간결해지고 이해하기 쉬워진다.
단점

배열 수정

원래의 배열을 수정해 보초 값을 추가해야 한다.

  → 배열의 크기를 변경하거나 추가적인 메모리 공간을 사용해야 할 수 있다.

검색 대상 제한
- 검색하려는 키 값이 배열 내에 존재하지 않을 때 효율적이다.
- 그러나 배열 내에 키 값과 일치하는 요소가 여러 개 있는 경우, 보초법을 사용해도 첫 번쨰 일치하는 요소를 찾은 후 검색을 멈추므로, 모든 일치하는 요소를 찾는 데에는 추가적인 로직이 필요하다.
특정 상황에서의 성능 이점 부족
보초 값의 선택
- 보초 값을 배열에 추가하기 위해서는 보초 값이 원래 배열 내의 어떤 값과도 중복되지 않아야 한다.
- 찾고자 하는 값(key)를 마지막 배열 요소에 추가
- 배열의 크기를 벗어났는지 체크하지 않다도 됨
- 즉, for문을 사용하지 않고 while문을 사용하여 구현 가능

import java.util.Scanner;

public class LinearSearchSentinel {
    // 배열 arr에서 key와 일치하는 요소를 보초법을 사용하여 선형 검색
    static int linearSearchSentinel(int[] arr, int size, int key) {
        int i = 0;
        arr[size] = key; // 보초 추가

        while (true) {
            if (arr[i] == key)
                break;
            i++;
        }
        return i == size ? -1 : i;
    }

    public static void main(String[] args) {
        Scanner stdIn = new Scanner(System.in);

        System.out.print("요소 개수: ");
        int num = stdIn.nextInt();
        int[] array = new int[num + 1]; // 요소 개수가 num + 1인 배열로, 마지막은 보초용

        for (int i = 0; i < num; i++) {
            System.out.print("array[" + i + "]: ");
            array[i] = stdIn.nextInt();
        }

        System.out.print("찾을 값: "); // 찾고자 하는 값 입력
        int key = stdIn.nextInt();

        int index =linearSearchSentinel(array, num, key); // 배열 array에서 key를 검색

        if (index == -1)
            System.out.println("찾는 값의 요소가 없습니다.");
        else
            System.out.println("찾는 값은 array[" + index + "]에 있습니다.");
    }
}

이진 검색(Binary Search)

이진 검색은 “분할 정복(Divide and Conquer)” 전략을 사용하여, 데이터가 정렬되어 있는 배열에서 중간 지점의 값을 키와 비교하여 검색 범위를 반으로 줄이면서 검색하는 방법이다.
이진 검색은 순차 검색에 비해 훨씬 빠른 검색 속도를 제공하지만, 검색 전에 배열이 정렬되어 있어야 한다.
작동원리
1. 배열의 중간 요소을 기준으로 원하는 키값이랑 같은지 확인한다.
2. 중간 요소보다 키값이 크면 중간 요소와 마지막 요소의 중간 요소를 찾는다.
3. 중간 요소보다 키값이 작으면 처음 요소와 중간 요소의 중간 요소를 찾는다.
4. 이를 start 변수와 end 변수를 이용하여 start 변수가 end보다 커지면 탐색을 종료하고 그 전에 원하는 키값을 찾으면 키값이 들어있는 배열 요소의 인덱스를 반환한다.
5. 이는 순차 탐색보다 빠르며 시간복잡도는logN이다.
6. 이진 탐색은 배열이 무조건 정렬이 되어있어야된다.

import java.util.Arrays;
import java.util.Scanner;

public class BinarySearchExam {
    public static int binarySearch(int[] arr, int key){
        int start = 0;
        int end = arr.length - 1;

        while(start <= end){
            int mid = (start + end) / 2;
            if (key == arr[mid]){
                return mid;
            } else if (key > arr[mid]) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("찾고자하는 정수를 입력하세요: ");
        int key = sc.nextInt();
        int[] arr = {1,3,5,33,56,2,44};
        Arrays.sort(arr); //Arrays의 sort메소드를 사용하여 정렬
        System.out.println(Arrays.toString(arr));

        int index =binarySearch(arr, key);

        if (index != -1){
            System.out.println("당신이 찾는 데이터는 " +index+"번째 인덱스에 있습니다.");
        }else {
            System.out.println("당신이 찾는 데이터가 존재하지 않습니다.");
        }
    }
}

장점
- 효율성
  - O(log n) 의 시간 복잡도를 가지며, 큰 데이터 집합에서도 빠른 검색 속도를 보장한다.
- 정렬된 데이터에 최적화
단점
- 데이터 정렬 필요
- 동적 배열에서 비효율적
  - 배열에 자주 삽입이나 삭제가 발생하는 경우, 배열을 정렬된 상태로 유지하는 데 추가 비용이 발생할 수 있다.

TIL - 3월 19일 : 알고리즘 기초

Wed, 20 Mar 2024 06:55:00 GMT

1. 알고리즘이란?

어떤 문제를 해결하기 위한 명확한 절차나 일련의 단계
컴퓨터 과학에서 알고리즘은 특정 작업을 수행하거나 문제를 해결하기 위해 정의된, 컴퓨터가 따라야 할 명령의 집합이다.

명확성 : 알고리즘의 각 단계는 명확하고 이해하기 쉬워야 한다.
입력 : 하나 이상의 입력이 있어야 한다.
출력 : 하나 이상의 출력이 있으며, 이는 주어진 입력에 대한 해답이다.
유한성 : 유한한 수의 단계를 거쳐서 종료되어야 한다.
효율성 : 실행 시간과 사용하는 자원(메모리 등) 측면에서 효율적이어야 한다.
일반성 : 특정 문제 뿐만 아니라 문제의 범주에 속하는 다양한 문제를 해결할 수 있어야 한다.

알고리즘은 일상 생활의 다양한 문제를 해결하는 데 사용될 수 있으며,
수학적 계산, 데이터 처리, 자동화된 추론, 컴퓨터 프로그래밍 등 다양한 분야에서 중요한 역할을 한다.

세 값의 최댓값 구하기

세 개의 정수 값을 입력받아 그 중 가장 큰 값을 찾아내는 간단한 알고리즘
비교 연산자를 사용하여 각 값을 서로 비교

public class MaxValue {
    // 세 개의 정수 a,b,c 중 최대값을 구하여 반환하는 메소드
    public static int max(int a, int b, int c) {
        int max = (a > b) ? a : b;
        max = (b > c) ? b : c;

        return max;
    }

    // main
    public static void main(String[] args) {
        System.out.println("최대값 : " + max(5, 3, 6));
    }
}

숫자와 문자열 입력하기 1

Scanner를 이용한 숫자와 문자열 입력

Scanner 클래스는 java.util 패키지에 포함되어 있으며, 다양한 형태의 입력(문자열, 정수, 실수 등)을 처리할 수 있다.

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        // Scanner 객체 생성
        Scanner scanner = new Scanner(System.in);

        // 사용자로부터 정수 입력받기
        System.out.print("정수를 입력하세요: ");
        int number = scanner.nextInt();

        // 입력 버퍼 비우기 (줄바꿈 문자 제거)
        scanner.nextLine();

        // 사용자로부터 문자열 입력받기
        System.out.print("문자열을 입력하세요: ");
        String text = scanner.nextLine();

        // 입력받은 정수와 문자열 출력
        System.out.println("입력받은 정수: " + number);
        System.out.println("입력받은 문자열: " + text);

        // Scanner 객체 닫기
        scanner.close();
    }
}

Scanner 클래스의 입력 메소드들

nextInt() : 정수 (int) 타입의 데이터를 읽어들인다.
- 범위: -2,147,483,648 에서 2,147,483,647 까지 ( -2^31 에서 2^31 - 1 )
nextLong() : 긴 정수 (long) 타입의 데이터를 읽어들인다.
- 범위: -9,223,372,036,854,775,808 에서 9,223,372,036,854,775,807 까지 ( -2^63 에서 2^63 - 1 )
nextFloat() : 부동 소수점 (float) 타입의 데이터를 읽어들인다.
- 범위: 대략 -3.4028235E+38 에서 3.4028235E+38 까지
nextDouble() : 더블 정밀도의 부동 소수점 (double) 타입의 데이터를 읽어들인다.
- 범위: 대략 -1.7976931348623157E+308 에서 1.7976931348623157E+308 까지
nextBoolean() : 불리언 (boolean) 타입의 데이터를 읽어들인다.
- 이 메소드는 true 또는 false 문자열에 대해 대소문자를 구분하지 않는다.
nextByte() : 바이트 (byte) 타입의 데이터를 읽어들인다.
- 범위: -128 에서 127 까지 ( -2^7 에서 2^7 - 1 )
nextShort() : 짧은 정수 (short) 타입의 데이터를 읽어들인다.
- 범위: -32,768 에서 32,767 까지 ( -2^15 에서 2^15 - 1 )
next() : 다음 토큰을 문자열로 읽어들인다.
- 이 메소드는 공백으로 구분된 단어를 반환한다.
nextLine() : 줄의 끝까지 문자열을 읽어들인다.
- 이 메소드는 한 줄 전체를 입력으로 받으며, 줄바꿈 문자를 읽은 후에 제거한다.

메서드의 반환값과 메서드의 호출식의 평가

자바 프로그래밍에서 메서드는 특정 작업을 수행하는 코드의 묶음이다.
메서드는 입력(매개변수)을 받아 처리하고, 결과를 반환(return)한다.

메서드의 반환값

메서드가 작업을 완료한 후 결과를 호출한 곳으로 전달할 때 사용하는 값
반환값의 타입은 메서드를 정의할 때 지정하며, 반환값이 없는 경우에는 void 를 사용한다.
반환값이 있는 메서드는 return 키워드를 사용하여 결과값을 반환한다.
```
  접근제한자  반환타입 메서드명(매개변수) {..구현..}
```

메서드 호출식의 평가

메서드 호출은 메서드가 실행되어야 함을 나타내며, 메서드 호출식은 그 호출이 평가되는 과정을 말한다.
메서드 호출식의 평가 결과 = 메서드의 반환값

반환값과 메서드 호출식의 중요성

코드 재사용성 향상
- 메서드를 통해 코드를 분리함으로써, 같은 코드를 반복해서 작성할 필요 없이 메서드 호출을 통해 재사용할 수 있다.
프로그램의 구조화
- 메서드를 사용하여 프로그램을 작은 단위로 나눔으로써, 코드의 가독성과 관리가 용이해진다.
데이터 흐름의 명확성
- 메서드의 반환값을 통해 데이터가 어떻게 처리되고 전달되는지 명확하게 할 수 있다.

ex) 최댓값 반환 메서드

  public static int max(int x, int y) {
      if (x > y) {
          return x;
      } else {
          return y;
      }
  }

  public static void main(String[] args) {
      int a = 10;
      int b = 20;
      int maxValue = max(a, b);
      System.out.println("최대값: " + maxValue);
  }

결정트리

결정트리는 복잡한 조건과 다양한 경우의 수를 시각적으로 표현하여 이해를 돕는다.
프로그래밍에서 결정트리를 사용하면 코드의 흐름을 명확하게 계획하고, 효율적인 알고리즘을 설계할 수 있다.

세 값의 대소 관계와 중앙값

특정한 데이터 집합 내에서 중앙값(median)을 찾는 것은 중요한 작업 중 하나이다.

알고리즘 설명

a 와 b 를 비교하여, a 가 더 큰 경우 b 와 c 를 비교한다. b 가 더 크면 b 가 중앙값이다. 아니면 a 와 c 를 비교하여 더 작은 값이 중앙값이 된다.

a 가 b 보다 작은 경우 a 와 c 를 비교한다. a 가 더 크면 a 가 중앙값이다. 아니면 b 와 c 를 비교하여 더 작은 값이 중앙값이 된다.

// 3개의 정숫값을 입력하고 중앙값을 구하여 출력
import java.util.Scanner;

public class Median {
 static int med3(int a, int b, int c) {
     if (a >= b)
         if (b >= c)
             return b;
         else if (a <= c)
             return a;
         else
             return c;
     else if (a > c)
         return a;
     else if (b > c)
         return c;
     else
         return b;
 }

 public static void main(String[] args) {
     Scanner stdIn = new Scanner(System.in);

     System.out.println("세 정수의 중앙값을 구합니다.");
     System.out.print("a 값 : ");
     int a = stdIn.nextInt();
     System.out.print("b 값 : ");
     int b = stdIn.nextInt();
     System.out.print("c 값 : ");
     int c = stdIn.nextInt();

     System.out.println("중앙값은 " + med3(a, b, c) + "입니다.");
 }
}

조건 판단과 분기

조건 판단과 분기는 프로그램의 흐름을 제어하는 중요한 요소이다.
사용자의 입력이나 계산 결과에 따라 다른 작업을 실행할 수 있도록 하는 기능을 제공

→ 프로그램은 더 유연하고 다양한 상황에 대응할 수 있게 된다.

조건문을 통해 프로그램의 로직을 세분화하고, 사용자의 입력이나 계산 결과에 따라 다르게 반응하도록 설계할 수 있다.

연산자와 피연산자

프로그램에서 데이터를 처리하고 조작하는 데 사용되는 기본적인 구성 요소
연산자 : 피연산자에 대해 수행될 연산(ex: +, -, > 등)을 나타내는 기호나 키워드
피연산자 : 연산이 수행될 데이터(ex: 변수, 리터럴 값 등)

연산자의 종류

산술 연산자
- + , - , * , / , %
비교 연산자
- == , != , < , > , <= , >=
논리 연산자
- && , || , !
할당 연산자 : 변수에 값을 할당하는 데 사용
- = , += , -= , *= , /=
증감 연산자
- ++ , --
조건 연산자(삼항 연산자)
- ? : (조건식 ? 값1 : 값2)
비트 연산자
- & , | , ^ , ~ , << , >>

순서도의 기호

순서도(flowchart)는 프로그램이나 시스템의 흐름을 도식화하여 나타내는 그래픽 표현이다.

시작/종료 (Terminator)
- 시작과 종료를 나타내는 기호, 타원형 또는 둥근 모서리의 사각형으로 표현된다.
- 프로세스의 시작과 끝을 명확하게 한다.
처리 (Process)
- 일반적인 처리 단계를 나타내며, 사각형으로 표현된다.
- 계산이나 데이터 처리 등의 작업을 나타낼 때 사용한다.
결정 (Decesion)
- 조건 분기를 나타내며, 다이아몬드(마름모) 형태로 표현된다.
입력/출력 (Input/Output)
- 입력 또는 출력을 나타내며, 평행사변형으로 표현된다.
순차적 연결 (Flowline)
- 화살표는 흐름의 방향을 나타낸다. 처리의 순서와 흐름의 방향을 명확하게 표시한다.
- 실선, 점선, 파선(긴 선과 짧은 선을 3:1의 비율로 이은 선)
서브루틴/프로세스 참조 (Predefined Process)
- 하위 프로세스 또는 서브루틴을 나타내며, 더블 사각형으로 표현된다.
- 재사용 가능한 코드 블록이나 함수 호출을 나타낼 때 사용한다.

2. 반복

1부터 n까지 정수의 합 구하기

기본적인 반복문 사용법을 익히는 좋은 예제

import java.util.Scanner;

class SumWhile {
    public static void main(String[] args) {
        Scanner stdIn = new Scanner(System.in);

        System.out.println("1부터 n까지의 합을 구합니다.");
        System.out.print("n값: ");
        int n = stdIn.nextInt();

        int sum = 0; // 합
        int i = 1;

        while (i <= n) { // i가 n 이하면 반복
            sum += i; // sum에 i를 더함
            i++; // i 값을 1 증가(increment)
        }
        System.out.println("1부터 " + n + "까지의 합은 " + sum + "입니다.");
    }
}

연습문제

1 - 1부터 n까지의 정수 중 짝수들의 합 구하기

import java.util.Scanner;

public class SumEven {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n, sum = 0;

        System.out.print("정수 n을 입력하세요 : ");
        n = sc.nextInt();

        for (int i = 1; i <= n; i++) {
            if (i % 2 == 0)
                sum += i;
        }
        System.out.println("n까지의 짝수의 합 : " + sum);
    }
}

2 - 1부터 n까지의 정수 중 3의 배수의 합 구하기

import java.util.Scanner;

public class Sum3Drainage {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n, sum = 0;

        System.out.print("정수 n을 입력하세요 : ");
        n = sc.nextInt();

        for (int i = 1; i <= n; i++) {
            if (i % 3 == 0)
                sum += i;
        }
        System.out.println("n까지의 3의 배수의 합 : " + sum);
    }
}

✔ 구조적 프로그래밍 - 논리연산과 드모르간 법칙

두 자리 양의 정수 입력받기

import java.util.Scanner;

public class TwoDigits {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n;

        System.out.println("두자리 양의 정수를 입력해주세요.");

        do {
            System.out.print("정수값 입력 : ");
            n = sc.nextInt();
        } while (n < 10 || n > 99);

        System.out.println("입력한 숫자는 " + n + "입니다.");
    }
}

논리연산자

주로 boolean 타입의 피연산자를 가지며, 조건문이나 반복문 내에서 조건의 조합을 평가하는 데 사용된다.
논리연산자는 표현식의 진리값을 결정하기 위해 사용되며, 주로 두 조건이나 표현식을 결합할 때 활용된다.
&& , || , ! , ^

드모르간 법칙

NOT (A AND B) = (NOT A) OR (NOT B)
NOT (A OR B) = (NOT A) AND (NOT B)

논리연산의 부정과 결합을 다룰 때, 특히 조건문이나 논리식을 간소화하는 데 유용하게 사용된다.

다중루프 - 구구단

public class Multi99Table {
    public static void main(String[] args) {
        System.out.println("------- 구구단 곱셈표 -------");

        for (int i = 1; i < 10; i++) {
            for (int j = 1; j < 10; j++) {
                System.out.printf("%d * %d =%2d  ", i, j, i * j);
            }
            System.out.println();
        }
    }
}

다중루프 - 직각 이등변 삼각형 출력

import java.util.Scanner;

public class TriangleLB {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n;

        do {
            System.out.print("직각 이등변 삼각형의 단 수를 입력해주세요 : ");
            n = sc.nextInt();
        } while (n <= 0);

        for (int i = 0; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

이등변 삼각형 출력

import java.util.Scanner;

public class TriangleLB2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n;

        do {
            System.out.print("이등변삼각형의 단 수를 입력해주세요 : ");
            n = sc.nextInt();
        } while (n <= 0);

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i; j++)
                System.out.print(" ");
            for (int j = 0; j < (i*2+1); j++)
                System.out.print("*");
            System.out.println();
        }
    }
}

2-1. 배열

유틸리티 메서드

  1. **`toString()`**: 배열의 내용을 문자열로 변환하여 반환 . 주로 디버깅 목적으로 사용
  2. **`sort()`**: 배열을 정렬. 기본적으로는 오름차순으로 정렬, 오브젝트 배열의 경우에는 해당 객체들이 구현한 Comparable 인터페이스의 compareTo() 메서드에 따라 정렬.
  3. **`binarySearch()`**: 지정된 값의 위치를 찾음. 이 메서드를 사용하기 전에 배열이 반드시 정렬되어 있어야 함.
  4. **`copyOf()`**: 지정된 길이로 배열을 복사.
  5. **`copyOfRange()`**: 배열의 지정된 범위를 복사.
  6. **`fill()`**: 배열의 모든 요소를 지정된 값으로 설정.
  7. **`equals()`**: 두 배열이 같은지 비교.
  8. **`asList()`**: 배열을 고정 크기의 리스트로 변환.

배열의 클론(복제)

import java.util.Arrays;

public class DuplicateArray {
    public static void main(String[] args) {
        int[] original = {10, 20, 30, 40, 50};
        int[] copied = original.clone(); // copied는 original의 복제본을 참조

        copied[2] = 0; // copied 배열의 세 번째 요소를 0으로 변경

        System.out.println("original = " + Arrays.toString(original));
        System.out.println("copied = " + Arrays.toString(copied));
    }
}
/* 실행결과
original = [10, 20, 30, 40, 50]
copied = [10, 20, 0, 40, 50]
*/

배열요소의 최댓값 구하기

import java.util.Scanner;

public class MaxOfScores {
    static int maxOf(int[] scores) {
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] > max)
                max = scores[i];
        }
        return max;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("학생 수 입력 : ");
        int n = sc.nextInt();
        int[] scores = new int[n];

        for (int i = 0; i < n; i++) {
            System.out.print((i + 1) + "번째 점수 입력 : ");
            scores[i] = sc.nextInt();
        }

        System.out.println("최댓값 : " + maxOf(scores));
    }
}

난수 사용해 배열의 요솟값 설정하기

import java.util.Random;
import java.util.Scanner;

public class MaxOfWeightsRand {
    static int maxOf(int[] weights) {
        int max = weights[0];
        for (int i = 1; i < weights.length; i++)
            if (weights[i] > max)
                max = weights[i];
        return max;
    }

    public static void main(String[] args) {
        Random rand = new Random();
        Scanner sc = new Scanner(System.in);

        System.out.println("몸무게의 최댓값을 구합니다.");
        System.out.print("사람 수: ");
        int num = sc.nextInt(); // 입력받은 사람 수로 배열의 크기를 결정
        int[] weights = new int[num]; // 사람 수만큼 몸무게를 저장할 배열 생성

        for (int i = 0; i < num; i++) {
            weights[i] = 40 + rand.nextInt(60); // 몸무게를 40kg에서 100kg 사이의 난수로 결정
            System.out.println("weights[" + i + "] : " + weights[i]);
        }
        System.out.println("최댓값은 " + maxOf(weights) + "입니다.");
    }
}

.nextInt() : -2,147,483,648 ~ 2,147,483,647 사이의 값 (min ~ max)
.nextInt(60) : 0~60 의 난수

배열을 역순으로 정렬하기

// 사용자로부터 입력받은 값으로 구성된 배열을 역순으로 정렬
import java.util.Arrays;
import java.util.Scanner;

class InvertArray {
    //--- 배열 요소 a[idx1]과 a[idx2]의 값을 교환 ---//
    static void swap(int[] a, int idx1, int idx2) {
        int temp = a[idx1];
        a[idx1] = a[idx2];
        a[idx2] = temp;
    }

    //--- 배열 a의 요소를 역순으로 정렬 ---//
    static void reverse(int[] a) {
        for (int i = 0; i < a.length / 2; i++)
            swap(a, i, a.length - i - 1);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("점수의 개수: ");
        int num = sc.nextInt(); // 점수의 개수를 입력받음
        int[] scores = new int[num]; // 점수를 저장할 배열 생성

        for (int i = 0; i < num; i++) {
            System.out.print("scores[" + i + "] : ");
            scores[i] = sc.nextInt(); // 점수 입력
        }

        reverse(scores); // 배열 scores의 요소를 역순으로 정렬

        System.out.println("점수를 역순으로 정렬했습니다.");
        System.out.println("scores = " + Arrays.toString(scores));
    }
}

두 배열의 비교

public class CompareArrays {
    static boolean areArraysEqual(int[] arr1, int[] arr2) {
        if (arr1.length != arr2.length)
            return false;

        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i])
                return false;
        }

        return true;
    }

    public static void main(String[] args) {
        // 테스트를 위한 두 배열 선언
        int[] array1 = {1, 2, 3, 4, 5};
        int[] array2 = {1, 2, 3, 4, 5};
        int[] array3 = {1, 2, 3, 4};

        // areArraysEqual 메소드를 사용하여 배열 비교
        System.out.println("array1과 array2는 동일한가? " + areArraysEqual(array1, array2));
        System.out.println("array1과 array3는 동일한가? " + areArraysEqual(array1, array3));
    }
}

기수변환

분할과 나머지를 이용한 방법

10진수 29를 2진수로 변환 후 출력

public class DecimalToBinaryExam {
    public static void main(String[] args) {
        int decimal = 29;
        StringBuilder binary = new StringBuilder();

        while (decimal > 0) {
            binary.append(decimal % 2);
            decimal /= 2;
        }
        System.out.println(binary.reverse().toString());
    }
}

2-2. StringBuilder

StringBuilder / 배열

: 문자열을 동적으로 조작하고 수정하는 데 사용됨. : 문자열의 변경이 필요한 상황

StringBuilder sb = new StringBuilder();

    // 문자열 추가
    sb.append("Hello");

    // 문자열 삽입
    sb.insert(5, " ");

    // 문자열 수정
    sb.replace(6, 10, "World");

    // 문자열 삭제
    sb.delete(5, 6);

    // 문자열 출력
    System.out.println(sb.toString()); // 출력 결과: HelloWorld

TIL - 3월 18일 : TDD

Tue, 19 Mar 2024 01:02:35 GMT

- TDD 사이클

1. 실패하는 테스트 작성 :  아직 구현되지 않은 기능에 대한 테스트를 먼저 작성
이 테스트는 당연히 실패할 것입니다.
2. 테스트를 통과하기 위한 코드 작성 : 테스트를 통과하기 위한 최소한의 코드를 작성
합니다.
3. 리팩토링 : 코드를 개선하고 중복을 제거합니다. 이 과정에서도 모든 테스트가 통과
해야 합니다.

이 사이클을 반복하면서 개발을 진행하게 되며, 이는 코드의 품질을 높이고 버그를 줄이
는 데 도움이 됩니다.

테스트 코드 작성 순서

테스트 케이스 작성

TDD의 핵심은 개발 시작 전에 테스트 케이스를 먼저 작성하는 것

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.time.LocalDate;

public class DateCalculatorTest {

 private DateCalculator dateCalculator;

 @BeforeEach
 void setup() {
     dateCalculator = new DateCalculator();
 }

 @Test
 void testCalculateAge() {
     LocalDate birthDate = LocalDate.of(1990, 5, 15);
     LocalDate currentDate = LocalDate.of(2022, 2, 28);
     int expectAge = 32;
     int actualAge = dateCalculator.calculateAge(birthDate, currentDate);
     assertEquals(expectAge, actualAge);
 }

 @Test
 void testCalculateDaysBetween() {
     LocalDate startDate = LocalDate.of(2022, 2, 15);
     LocalDate endDate = LocalDate.of(2022, 3, 1);
     int expectedDays = 14;
     int actualDays = dateCalculator.calculateDaysBetween(startDate, endDate);
     assertEquals(expectedDays, actualDays);
 }

 @Test
 void testIsLeapYear() {
     int leapYear = 2024;
     boolean isLeap = dateCalculator.isLeapYear(leapYear);
     assertEquals(true,isLeap);
 }

}

실패하는 테스트 실행
- 테스트를 실행하면 DateCalculator 클래스가 존재하지 않기 때문에 실패

구현 코드 작성

import java.time.LocalDate;

public class DateCalculator {
 public int calculateAge(LocalDate birthDate, LocalDate currentDate) {
     return currentDate.getYear() - birthDate.getYear();
 }

 public int calculateDaysBetween(LocalDate startDate, LocalDate endDate) {
     return (int) startDate.until(endDate).getDays();
 }

 public boolean isLeapYear(int year) {
     return LocalDate.ofYearDay(year, 1).isLeapYear();
 }
}

테스트 실행 및 성공 확인
- 테스트를 다시 실행하면 모두 성공
- 실패하지 않는 한 성공한 테스트를 기반으로 다음 단계로 진행
코드 리팩토링
- 필요한 경우 코드를 리팩토링하여 가독성을 높이고 중복을 제거

==============================================

** @어노테이션 **
- 약속을 정의하고 있고, 정해진 곳에 표시를 해주면 프레임워크가 실행할때 동작한다.
- 이미 정의되어 있는 것들이 많다.
- TDD : 개발 방법론 중 하나. 테스트코드를 기반으로 개발하겠다
테스트하는 도구로 JUnit 사용한다.
- JUnit : 자바에서 x유닛을 사용하는 것.
단위테스트는 개발과정에 이루어져야한다.
Assertions 해당 조건에 맞았을 때 판단해줄 수 있는 부분.

TIL - 3월 15일 : Git fork, pull request

Tue, 19 Mar 2024 00:56:05 GMT

Git이랑 GitHub는 다른 개념
1. git은 로컬 저장소에서 가지고 노는 느낌
2. github는 클라우드가 있어서 거기에 저장해서 사용할 수 있는 느낌
Git 명령어 모음
1. git init
  - 현재 폴더를 Git 저장소로 생성
  - .git 폴더가 생성
2. git status
  - 현재 스테이징 영역에 있는 변경사항과 작업 디렉토리의 변경사항을 비교 가능
3. git add .
  - 모든 변경사항 스테이징 영역에 추가하기
  - git add <파일>
    - 특정 파일 스테이징 영역에 추가하기
4. git commit -m "commit message"
  - commit message 메시지 입력 후 커밋하기
5. git pull
  - 원격 저장소의 변경 사항을 작업 브랜치와 병합 : 파일 올리기
6. git push
  - 로컬 브랜치의 변경 사항을 원격 저장소와 병합 : 파일 내려받기
7. git branch
  - 현재 있는 모든 브랜치 나열하기
  1. git branch 브런치 이름
    - 특정 브랜치 생성하기
8. git branch -d 브런치 이름
  - 특정 브랜치 삭제하기

10. ` git branch -m 새브런치 이름` 
    - 현재 브랜치 이름 변경하기


11. `git merge 브런치 이름 ` 
    - 현재 위차한 branch와 지정한 branch를 merge(병합)하기

13.  `git switch 브런치 이름` 
    - 다른 브랜치로 전환하기

8.  `git switch -c 생성할 branch명` 
    - branch 생성 후 해당 branch로 이동

1.  `git switch branch명` 
    - 해당 branch로 이동

12.  `git checkout branch명` (checkout을 사용해서 위와 같은 작업이 가능하다 ) 
    - 다른 브랜치로 전환하기

13. `git checkout -b blog-create`
    - blog-create 생성 후 브랜치 이동

13. `git push origin main` 

    - 로컬 branch의 변경 사항을 원격 저장소에 업로드함


1. ` git pull origin main ` 
    - 원격 저장소의 변경 사항을 현재의 작업 branch와 병합함

16.  `git clone` 
    - 다른 저장소 복제

17. `git diff (비교할 해시코드1) (비교할 해시코드2)` 
    - 해시코드1 과 해시코드 2의 내용을 비교해서 출력

=================================================

기타 명령어
1. ls
  - 현재 디렉토리의 파일 목록 조회
2. ls -la
  - 현재 디렉토리의 히든 파일까지 포함하여 파일 목록 조회
3. pwd
  - 현재 작업 위치 풀력
4. mkdir my_project
  - mkdir 폴더명
  - 해당 폴더명으로 폴더 생성
5. cp Hello.java Hi.java
  - 파일 복사
  - Hello.java 내용을 Hi.java에 복사
6. cd my_project
  - 해당 디렉토리로 이동
7. cd ..
  - 상위 폴더로 이동

vi editer
1. vi [Hello.java](http://Hello.java)
  
  or
2. vim Hello.java
  - Hello.java 편집
  - 해당 파일이 없으면 생성하고 편집
  - ior insert누르고 입력 후 esc로 입력 종료
  - :wq 입력하여 vi or vim 종료

TIL - 3월 14일 : 배열

Tue, 19 Mar 2024 00:45:31 GMT

기본형 배열

선언 여러가지 가능

ex1. 기본형타입[] 변수명;
ex2. 기본형타입 변수명[];

* 초기값 가지고 선언

```java
기본형타입[] 변수명 = new 기본형타입[배열의크기];
변수명[index값] = 값;
기본형타입[] 변수명 = new 기본형타입[]{ 값1, 값2, .... };
기본형타입[] 변수명 = {값1, 값2, 값3.... };

참조형 배열

public class Array05 {
    public static void main(String[] args) {
        ItemForArray[] array1 = new ItemForArray[3];
        array1[0] = new ItemForArray(500, "사과");
        array1[1] = new ItemForArray(300, "바나나");
        array1[2] = new ItemForArray(900, "수박");

        ItemForArray[] array2 = new ItemForArray[]{new ItemForArray(500, "사과"), new ItemForArray(300, "바나나"), new ItemForArray(900, "수박")};
        ItemForArray[] array3 = {new ItemForArray(500, "사과"), new ItemForArray(300, "바나나"), new ItemForArray(900, "수박")};

        System.out.println(array1[0].getName());
        System.out.println(array1[0].getPrice());
        System.out.println(array1[1].getName());
            System.out.println(array1[1].getPrice());
        System.out.println(array1[2].getName());
        System.out.println(array1[2].getPrice());
    }
}

이차열 배열

리스트

    타입[][] 변수명 = new 타입[행의수][열의수];
    변수명[행인덱스][열인덱스] = 값;

public class Array09 {
    public static void main(String[] args) {
        int[][] array = {{0,1,2}, {3,4,5}};

        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

이차원 가변 배열의 선언과 초기화

가변 길이 : 두 개의 길이가 달라도 된다는 것을 의미

    타입[][] 변수명 = new 타입[행의수][];
    변수명[행의인덱스] = new 타입[열의수];

public class Array10 {
    public static void main(String[] args) {
        int[][] array = new int[2][];

        array[0] = new int[2];
        array[1] = new int[3];

        array[0][0] = 0;
        array[0][1] = 1;
        array[1][0] = 2;
        array[1][1] = 3;
        array[1][2] = 4;

        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                System.out.print(array[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

for each 문

public class Array12 {
  public static void main(String[] args) {

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

      for(int i : array){
          System.out.println(i);
      }
  }
}

// i는 index가 아닌 array안의 값

명령 행 아규먼트

리스트

public class EmptyCommandLineArgumentExam {
    public static void main(String[] args){
        System.out.println(args.length);
    }
}

제한 없는 아규먼트

리스트

public class UnlimitiedArgumentsExam {
    public static void main(String[] args){

        System.out.println(sum(5,10));
        System.out.println(sum(1,2,4,2));
        System.out.println(sum(3,1,2,3,4,1));
    }

    public static int sum(int... args){
        System.out.println("print1 메소드 - args 길이 : " + args.length);
        int sum = 0;
        for(int i = 0; i < args.length; i++){
            sum += args[i];
        }
        return sum;
    }
}

//print1 메소드 - args 길이 : 2
//15
//print1 메소드 - args 길이 : 4
//9
//print1 메소드 - args 길이 : 6
//14

생성자

객체가 생성될때 자동으로 호출 되는 특수 목적의 메서드

객체의 초기화를 위해 사용

public class Book {
  String title;
  int price;

  public Book() {    }                   // 기본생성자

  public Book(String title, int price) {    // 매개변수를 가진 생성자
      this.title = title;
      this.price = price;
  }
}

생성자(Constructor)는 객체가 생성될때 자동으로 호출되는 특수 목적의 멤버함수(메소드)로객체의 초기화를 위해 사용