요르딩딩
과외문제 - 답 본문
# [크기가 5인], 1차원 정수형 배열 선언 및 그림 : int[] arr = new int[5];
# 정수형 리스트 선언 : ArrayList<Integer> list = new ArrayList<Integer>();
# [크기: 행2,열3]인 2차원 문자열 배열 선언 및 초기화 및 그림 : String[][]arr = new[2][3];
# 1차원 배열 [인덱스3]에 [10] 삽입 : arr[3] =10
# 2차원 배열 [행:5, 열:10]에 "v" 삽입 : arr[5][10] = "v";
# 접근제어자
| private | 같클 |
| default | 같패 |
| protect | 다패,상속 |
| public | 전체 |
# overload : 메소드명 동일, 매계변수(타입 또는 갯수 다름)
# overriding : 재정의
# 클래스, 생성자, 메소드 선언
class A { // 클래스
public A(){} // 생성자
pulbic A(int a){} // 생성자 (overload)
public int B() {return 5;} //메소드
public void C() {} // 반환값 X
}
# 클래스 객체(인스턴스) 생성
A a = new A();
A a = new A(5); // 생성자 (overload)
# 변수
| 정적변수 (static) | 최초1번 초기화, 공유(유지) | class A { static int num = 10; public A(){ num ++;} public static void main(~) { A a = new A(); // 인스턴스통해 접근 } } |
| 전역변수 (static) | 모든함수 접근가능 | class A { static int num = 10; public static void main(~) { sysout(num); // 직접사용 } } |
| 지역변수 | 블록내에서만 접근가능 | - |
# String, Char
| String | 여러 개의 문자(char)로 구성된 객체 | "Hello, World!" |
| char | 1개의 문자로 구성된 데이터 타입 | 'H' |
* 문자열.charAt(인덱스) : 아스키값
# 정렬 (Arrays, Collection 사용)
| 배열 | Arrays.sort(array) |
| 리스트 | Collections.sort(list) |
| 리스트 (역방향) | Collections.reverse(list) |
# 출력
| 배열 | System.out.println(Arrays.toString(array)); |
| 리스트 | System.out.println(list); |
# 삼항연상자 : String result = (a > b) ? "a승" : "b승";
# 길이
| 배열 | 배열.length |
| 리스트 | 리스트.size() |
* 마지막 인덱스와 길이 구분 : 마지막 인덱스 = 길이 -1
# 복사
| 배열 | int[] copy = Arrays.copyOf(원본배열, 원본배열.length); |
| 리스트 | List<Integer> copy = new ArrayList<>(원본리스트); |
# 형변환
| 정수 <- 문자열 | int number = Integer.parseInt("123"); |
| 실수 <- 문자열 | double number = Double.parseDouble("123.45"); |
| 문자열 <- 정수 | String str = String.valueOf(123); 또는 String str = Integer.toString(123); |
| 문자열 <- 실수 | String str = String.valueOf(123.45); 또는 String str = Double.toString(123.45); |
| 문자열 대문자 | String upperStr = "hello".toUpperCase(); |
| 문자열 소문자 | String lowerStr = "HELLO".toLowerCase(); |
# 비교
| == | 객체의 참조(주소)를 비교 if (a == b) |
| equals() | 객체의 내용(값) 비교 if (a.equals(b)) |
# 실수 출력 : 소수점한자리 : String.format("%.1f", num);
• %s: 문자열
• %d: 정수
• %f: 실수
• %x: 16진수로 변환된 정수
# 인터페이스 그림 및 장점 5가지
# Compareable, Comparator 차이
# iterable(Collection), iterator (map, listiterator) 그림
# List, Set, Map 특징 정리
# Map의 특징을 작성하세요.
1. Map
{ key : value}
map.entrySet() : map의 key와 value를 포함하는 Entry객체의 Set을 반
map.KeySet() : 키를 모아서 Set형태로 반환
map.values() : values를 Collection형태로 반환 -> Collections.max(map.values()) 처럼 사용가능
map.entrySet().iterator() : map.entrySet() 이 리턴하는 Set 객체의 Iterator를 사용
map.getOrDefault(i.0)+1 : map에 key가 i인 값이 없다면 0, 있다면 해당 value 반환 후 +1
# ArrayList를 Iterator로 선언 후 반복문 예시를 들어 보시오.
ArrayList<Integer> list = new ArrayList<Integer>();
: Iterator<Integer> a = list.iterator(); // 선언
: for(iterator.hasNext()){
int n = iterator.next();
}
# ArrayList를 HashSet으로 선언하세요.
: Set<Integer> set = new HashSet<>(list);
# 제네릭 장점
1. 코드의 재사용성
2. 타입의 안정성 : 컴파일 시점에 타입을 검사해서 런타임 오류를 방지
3. 형변환 필요없음
T : 임이의 타입 / Box<T> : 제네릭 타입을 일반적으로 표현 할때 사용
E : 컬렉션의 요소 타입 / List<E>
( 동일한 동작/ 가독성을 위해 구분)
# 람다
1. 함수형 인터페이스(메서드 1개만 존재)에서만 사용가능
2. 간결하게 표현 / 병렬처리에 유용
3. 자바에서 제공하는 함수형 인터페이스 활용가능 ( Suppiler, Consumer, Function, Predicate)
4. 스트림, 컬렉션과 자주 사용.
[예시]
interface MyFunc {
void sayHello();
}
public class Main {
public static void main(String[] args) {
MyFunc func = () -> System.out.println("Hello!");
func.sayHello();
}
}
[함수형 인터페이스 종]
| Runnable | run() | X | X | 아무것도 받지 않고 실행만 함 | () -> System.out.println("작업 시작") |
| Supplier<T> | get() | X | O | 값을 생성해서 반환 | () -> "Hello" |
| Consumer<T> | accept(T t) | O | X | 값을 받아서 사용만 하고 반환 없음 (출력) | (x) -> System.out.println(x) |
| Function<T, R> | apply(T t) | O | O | 값을 받아서 변환한 뒤 반환 (변환) | (x) -> x * x |
| Predicate<T> | test(T t) | O | boolean | 조건 검사해서 true/false 반환 (검사) | (x) -> x > 10 |
| BiFunction<T, U, R> | apply(T t, U u) | 2개 | O | 두 개의 값을 받아서 변환 후 반환 | (a, b) -> a + b |
import java.util.*;
class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return name + "(" + age + ")";
}
}
public class Main {
public static void main(String[] args) {
List<Person> list = Arrays.asList(
new Person("Alice", 25),
new Person("Bob", 20),
new Person("Charlie", 23)
);
list.sort(Comparator.comparing(p -> p.age));
System.out.println(list); // [Bob(20), Charlie(23), Alice(25)]
list.sort(Comparator.comparing(Person::getAge).thenComparing(Person::getName)); // 두번 정렬
list.sort(Comparator.comparing(p -> p.age).reversed()); // 반대방향
}
}
# 스트림 패키지
. 스트림이란 : 일련의 데이터 흐름
. 패키지란 : 클래스의 집합
- 특징 : 가독성 향상/ 병렬처리를 통해 속도 업/ 유지보수성 향상
-> 스트림을 사용하기전에는 테이터를 컬렉션으로 처리했었음. (코드가 길다는 단점)
-> 하나하나 기술하는 '명령형'방식이 X, '선언적' 코딩 가능
-> 멀티 스레드로 병렬로 처리하고, 처리 후에 합침 -> 빠르고 쉽다.
(스트림은 간단하게 Parallel() 또는 ParallelStream() 연산으로 병렬처리 가능.)
-> stream 생성 -> 가공(중간연산) -> 소비(최종연산)
(최종연산은 1번만 가능/ 지연평가 (Lasy Evaluation))
** 생성 **
- 컬렉션은 스트림 메소드 지원, 배열 또한 Arrays.stream(arr)으로 생성 가능
- Stream.generate(() -> "Hello").limit(5) : 무한한값 생성
- Stream.iterate(1, n -> n*2).limit(5); : 다음 요소를 생성하기위해 이전 요소에 의존해서 만듦.
- java.util.stream 패키지의 IntStream클래스 : 정수형 데이터 스트림연산 수행을 위해 사용
- IntStream st = IntStream.rangeClosed(1,100);
Stream<Integer> st2 = Stream.iterate(1, n -> n+1).limit(100);
| 메소드 | 설명 |
|------------------------------------|----------------------------------------------------------------------|
| `Stream.of(T... values)` | 주어진 요소들로 스트림을 생성합니다. (배열, 가변 인자)
| `Stream.empty()` | 비어있는 스트림을 생성합니다.
| `Stream.iterate(T seed, UnaryOperator<T> f)` | 주어진 시드를 시작으로, 지정된 함수를 적용하여 요소를 생성하는 스트림을 생성합니다. |
| `Stream.generate(Supplier<T> s)` | 주어진 `Supplier`를 사용하여 무한한 스트림을 생성합니다.
| `Arrays.stream(T[] array)` | 배열에서 스트림을 생성합니다.
| `IntStream.range(int startInclusive, int endExclusive)` | 주어진 범위의 정수로 스트림을 생성합니다. (끝은 미포함)
| `IntStream.rangeClosed(int startInclusive, int endInclusive)` | 주어진 범위의 정수로 스트림을 생성합니다. (끝 포함)
| `LongStream.range(long startInclusive, long endExclusive)` | 주어진 범위의 long으로 스트림을 생성합니다.
| `LongStream.rangeClosed(long startInclusive, long endInclusive)` | 주어진 범위의 long으로 스트림을 생성합니다. (끝 포함)
| `DoubleStream.range(double startInclusive, double endExclusive)` | 주어진 범위의 double로 스트림을 생성합니다.
| `DoubleStream.rangeClosed(double startInclusive, double endInclusive)` | 주어진 범위의 double로 스트림을 생성합니다. (끝 포함)
** 중간연산 **
| 연산자 | 설명 |
|----------------------------------|--------------------------------------------------------
| filter(Predicate) | 조건에 맞는 요소만 남김
| map(Function) | 각 요소를 다른 값으로 변환
| flatMap(Function) | 중첩된 스트림 평탄화 (2차원 → 1차원)
| mapToInt(ToIntFunction) | 각 요소를 int 스트림으로 변환
| mapToLong(ToLongFunction) | 각 요소를 long 스트림으로 변환
| mapToDouble(ToDoubleFunction) | 각 요소를 double 스트림으로 변환
| mapToObj(Function) | 기본형 스트림 → 객체 스트림 변환
| distinct() | 중복 요소 제거
| sorted() | 자연 순서로 정렬
| sorted(Comparator) | 사용자 정의 기준으로 정렬
| limit(long maxSize) | 결과 개수를 최대 N개로 제한
| skip(long n) | 처음 N개의 요소 건너뜀
| peek(Consumer) | 각 요소를 살펴보고, 디버깅 용도로 사용
| takeWhile(Predicate) | 조건이 참인 동안 요소 추출 (Java 9 이상)
| dropWhile(Predicate) | 조건이 거짓이 될 때까지 요소 건너뜀 (Java 9 이상)
** 최종연산 **
| 메소드 | 설명 |
|--------------------------|--------------------------------------------------------------------------------------------------|
| `reduce()` | 요소들을 결합하여 단일 값으로 축소하는 연산 (누적)
| `collect()` | 스트림의 요소들을 다른 형태로 수집 (예: List, Set 등)
| `forEach()` | 각 요소에 대해 동작을 수행하는 연산
| `forEachOrdered()` | 병렬 스트림에서 요소 순서를 보장하며 동작을 수행
| `toArray()` | 스트림의 모든 요소를 배열로 반환
| `min()`, `max()` | 스트림에서 최소값/최대값을 반환
| `count()` | 스트림의 요소 개수 반환
| `anyMatch()`, `allMatch()`| 조건을 만족하는 요소가 하나라도 있으면 true, 모든 요소가 만족하면 true
| `noneMatch()` | 모든 요소가 조건을 만족하지 않으면 true
| `findFirst()`, `findAny()`| 첫 번째/아무 요소를 반환
| `sum()`, `average()` | 숫자 스트림에서 합계/평균 반환
| collect(Collector) | 스트림 결과를 컬렉션/맵/문자열로 변환
: 수집하여 원하는 형태로 변환
-> Java Collector 인터페이스를 매개변수로 호출하는데, Java에서 제공하는 Collectors클래스에서
이미 존재하는 method를 이용해서 요소 변환
-> Collectors제공 메소드
- toList()
- toSet()
- toColllection() : 원하는 컬렉션으로 변환 예) Collectors.toCollection(ArrayList:new)
- toMap()
- toArray()
- joining(",") : ,로 붙이기
- naturalOrder()
- comparingInt(String::length)
'[코딩테스트] > 팁' 카테고리의 다른 글
| 과외문제 (0) | 2025.01.22 |
|---|---|
| 팁 *** 정렬/변환 (0) | 2022.04.26 |
| 팁 *** (0) | 2022.04.05 |
