Java Collections Framework: List, Set, Map

💡 Java Collections Framework: List, Set, Map — Executive Summary

Technical architectural analysis, practical configuration manifests, and deployment instructions for Java Collections Framework: List, Set, Map.

Subpage

Spring

Roadmap

Java Collection

Map

Object → Map (Jackson.ObjectMapper)

java

ObjectMapper objectMapper = new ObjectMapper();
Person person = new Person(12, "kim");
Map<String, Object> map = objectMapper.convertValue(person, Map.class);

Map → String for Logging (Collection.Stream)

java

String resultSet =
        {{ map_var }}.entrySet()
                .stream()
                .map(e -> e.getKey() + "=" + String.join(", ", e.getValue()))
                .collect(Collectors.joining(" "));
log.debug(resultSet);
...

List

Array Parse with List (Lists or Arrays)

java

// List to Array
long[] longArr = Longs.toArray(longList);

// List to Array (Object)
String[] strArr = StringList.toArray(new String[0]);

// Array to List
Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
List<Integer> targetList = Lists.newArrayList(sourceArray);
List<String> targetList2 = Arrays.asList(new String[] {""});

JSON

Object → JsonString (Jackson.ObjectMapper)

The Object -> Json conversion process is called serialization. In addition to String, Jackson can also write to files or streams.

java

ObjectMapper objectMapper = new ObjectMapper();
Person person = new Person("Nicole", 20);

String personJson = objectMapper.writeValueAsString(person);

System.out.println(personJson);

JsonString → Object (Jackson.ObjectMapper)

The Json -> Object conversion process is called Deserialization. Like serialization, it is also possible to write to a file or stream.

java

String personJson = "{isJsonString}"
Person jsonToPerson = objectMapper.readValue(personJson, Person.class);

Reactive Streams

Comparison items	Java Stream API	WebFlux (Project Reactor)
How it works	Pull-based (synchronous)	Push-based (asynchronous)
Blocking	Blocking. The thread waits until all data has been collected.	Non-blocking. Schedule to be notified when the data is ready.
Data Source	Collections already in memory (List, Set, etc.)	Data flow that does not know when it will arrive (network, DB, etc.)
Purpose of use	Quickly calculate large amounts of data (parallel processing, etc.)	Efficiently handle many concurrent requests with fewer threads
Reusability	Consume it once and it’s over (closed)	Multiple subscription possible

Java Stream

java

/* Stream.map() */
List<?> baseList = new ArrayList<>();
List<?> rtnList = baseList.stream().map(obj->{
	return obj.value
}).collect(Collectors.toList());

/** Map 내 모든 리스트 병합 */
((HashMap<String,List<String>>) obj).values().stream().flatMap(List::stream).collect(Collectors.toList()));

/** 표현식 설명 아래 모두 기능 동일*/
// .A(B::C) 종류 (.A(D->{})를 가정)
// 1. .A(D->D.C())
.map(Map.Entry::getValue) == .map(entry -> entry.getValue())
// 2. Consumer<T(D)> void : .A(D->B.C(D))
.forEach(System.out::println) == .forEach(item -> System.out.println(item))
// 3. Supplier<T(new)> retrun T : .A(()->B.C())
(Math::random) == (()->Math.random())
// 4. Function<T(D),T(B)> ? : .A(D->B.C(D))
(Interger::parseInt) == (str->Integer.parseInt(str));
// 5. Predicate<T(B)> return Boolean : .A(D->D.C())
(String::isEmpty)
// 이것을 단순화하려 해보았지만, 분석결과 사실 Functional Interface의 정의에 따라 모두 다른 결과일것으로 보임

WebFlux (Project Reactor)

java

//ClientRequest

//ClientResponse
response.bodyToMono()

//Body and Mono
Publisher.subscribe(
	value -> { //when then (Published value)
	},
	error -> { //when throwed
	},
	() -> { //when completed
	}
)

Failed

java

//ClientResponse를 Publisher(bodyToMono(), bodyToFlux())를 사용하여 로깅
//외부 웹클라이언트의 이벤트에 의해 다중실행되는 메서드이므로 subscribe()-비동기-를 하게되면 에러발생.

/** 에러 예시 */
            clientResponse.bodyToMono(String.class)
                    .doOnNext(responseBody -> {
                        sb.append("\tBody: \n");
                        sb.append("\t\tContents: " + responseBody + " \n");
                    })
                    .doOnTerminate(()-> {
                        log.info(sb.toString());
                    })
                    .subscribe();
            return Mono.just(clientResponse);

/** 잘못된 예시 */
            clientResponse.bodyToMono(String.class)
                    .flatMap(responseBody -> {
                        sb.append("\tBody: \n");
                        sb.append("\t\tContents: " + responseBody + " \n");
                        log.info(sb.toString());
                        return Mono.empty();
                    });
            return Mono.just(clientResponse);
/*
java.lang.IllegalStateException: block()/blockFirst()/blockLast() are blocking, which is not supported in thread reactor-http-nio-2
이 메시지는 다음을 나타냅니다:

block(), blockFirst(), 또는 blockLast()와 같은 블로킹 연산을 스레드 "reactor-http-nio-2"에서 사용하고 있다는 것입니다.
Reactor는 비동기 및 논블로킹 스트림 처리를 위해 설계되었으므로 블로킹 연산을 사용하면 문제가 발생할 수 있습니다.
*/

/** 방법 */
            clientResponse.bodyToMono(String.class)
                    .subscribeOn(Schedulers.elastic())
                    .subscribe(responseBody -> {
                        sb.append("\tBody: \n");
                        sb.append("\t\tCount: " + JsonParserFactory.getJsonParser().parseMap(responseBody).size() + " \n");
                        sb.append("\t\tContents: " + responseBody + " \n");
                        log.info(sb.toString());
                    });
//            }
            return Mono.just(clientResponse);

/* Steam을 즉시 종료하고 내용물을 꺼내기 */
Mono<String> mono = Mono.just("Hello, Reactor!");

mono
    .take(1)
    .subscribe(
        value -> {
            // 첫 번째 요소를 처리합니다.
            System.out.println("Received value: " + value);
        },
        error -> {
            // 에러 처리
        },
        () -> {
            // 완료 처리
        }
    );

Method	Input	Output	Reactor processing (Unwrapping)
`map`	`T`	`R` (generic object)	Move on to the next step as received
`flatMap`	`T`	`Mono` or `Flux`	Open the box Take out only the contents `R` and move on to the next step
`flatMapMany`	`T`	`Flux`	Expands `Mono` into `Flux`, which contains multiple particles.
`flatMapIterable`	`T`	`Iterable` (List, etc.)	The list is split one by one and exported sequentially.

Fredric News

Leave a Reply Cancel reply

Java Collections Framework: List, Set, Map

Subpage

Spring

Java Collection

Map

Object → Map (Jackson.ObjectMapper)

Map → String for Logging (Collection.Stream)

List

Array Parse with List (Lists or Arrays)

JSON

Object → JsonString (Jackson.ObjectMapper)

JsonString → Object (Jackson.ObjectMapper)

Reactive Streams

Java Stream

WebFlux (Project Reactor)

Comments

Leave a Reply Cancel reply