기록하며 성장하기

선언된 변수나 클래스 멤버 변수는 선언과 동시에 초깃값 할당 해야함

val data1: Int // 오류
val data2 = 10 // 성공

class User {
	
    val data3: Int  // 오류
    val data5: Int = 10 // 성공
}

함수의 경우 선언과 동시에 할당하지 않아도 되지만, 이용시 에는 값을 할당해야함

fun someFun() {
	
    val data1: Int
    println("data1 : $data1") // 오류
    data1 = 10
    println("Data1 : $data1") // 성공
}

초기화 미루기 ( lateinit , lazy)

lateinit 

•  lateinit은 var 키워드로 선언한 변수에만 사용할 수 있습니다.
• Int, Long, Short, Double, Float, Boolean, Byte 타입에는 사용할 수 없습니다.

lateinit var data1: Int  // 오류
lateinit val data2: String // 오류
lateinit var data3: String // 성공

선언한 변수는 선언과 동시에 초깃값을 할당하지 않아도 됩니다. 

lazy

• 변수 선언문 뒤에 by lazy {} 형식으로 선언
• 변수가 최초로 이용되는 순간 {} 부분이 자동 실행  초깃값으로 할당 

val data4: Int by lazy {
	
    println("in lazy.....")
    10
}

fun main(){
	
    println("in main...")
    println(data4 + 10)
    println(data4 + 10)
}

실행결과 

중괄호 부분을 여러 줄로 작성한다면 마지막 줄의 실행 결과가 변수의 초깃값이 됩니다.

val (=value)

초기값이 할당되면 바꿀 수  없는 변수

var (=variable)

초기값이 할당된 후에도 값을 바꿀 수 있는 변수

RandomStringUtils.randomNumeric(int count)

- count 만큼 랜덤한 숫자를 생성

isNotEmpty

public static boolean isNotEmpty(Collection<?> coll)

Parameters:
coll - the collection to check, may be null

Returns:

true if non-null and non-empty

1. 기본정렬
2. 역순정렬
3. null포함(nullLast)
4. null포함(nullFirst)

1.기본 정렬

List<Member> list = List.of(Member.of(10), Member.of(20), Member.of(30));

List<Member> result = list.stream()
    .sorted(Comparator.comparing(Member::getAge))
    .collect(Collectors.toList());

System.out.println(result);

결과

[Member{age=10}, Member{age=20}, Member{age=30}]

2.역순 정렬

List<Member> list = List.of(Member.of(10), Member.of(20), Member.of(30));

List<Member> result = list.stream()
     .sorted(Comparator.comparing(Member::getAge, Comparator.reverseOrder()))
     .collect(Collectors.toList());

System.out.println(result);

결과

[Member{age=30}, Member{age=20}, Member{age=10}]

3.null 포함 nullLast

List<Member> list = List.of(Member.of(10), Member.of(null), Member.of(30));

List<Member> result = list.stream()
    .sorted(Comparator.comparing(Member::getAge, Comparator.nullsLast(Comparator.naturalOrder())))
    .collect(Collectors.toList());

System.out.println(result);

결과

[Member{age=10}, Member{age=30}, Member{age=null}]

4.null 포함 nullFirst

List<Member> list = List.of(Member.of(10), Member.of(null), Member.of(30));

List<Member> result = list.stream()
    .sorted(Comparator.comparing(Member::getAge, Comparator.nullsFirst(Comparator.naturalOrder())))
    .collect(Collectors.toList());

System.out.println(result);

결과

[Member{age=null}, Member{age=10}, Member{age=30}]

예제 Member class

class Member{

    Integer age;

    public Member(Integer age){
        this.age = age;
    }

    public static Member of(Integer age){
        return new Member(age);
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Member{" +
                "age=" + age +
                '}';
    }
}

public class SomeService {

	private String action(String param){
    		return param + "test";
    	}

}

Test 작성시 private 메서드의 경우 직접 접근을 할 수가 없다.
invoke를 통해서 접근 가능하다. 

@Test
public void 문자열_테스트(){
	
    SomeService someService = new SomeService();
    
    Method testMethod = SomeService.class.getDeclaredMethod("action", String.class);
    testMethod.setAccessible(true);
    testMethod.invoke(someService, "Hello");
    
}

parallel 를 이용하면 병렬처리를 할 수 있다 하지만 기본적으로 서버의 CPU 코어 수에 따라 종속적이라고 한다.
커스텀하게 이용하기 위해서는 ForkJoinPool 을 이용하면 된다. 

List<String> list = Collections.synchronizedList(new ArrayList<>());

ForkJoinPool forkJoinPool = new ForkJoinPool(3);
forkJoinPool.submit(() -> 
	return IntStream.range(1, 100000)
	.parallel()
	.mapToObj(i -> list.add(new Integer(i).toString()))
    .collect(Collectors.toList())
).get();

System.out.println(list);
System.out.println(list.size());

첫번째 줄에 Collections.synchronizedList(new ArrayList<>()); 사용한 이유는 담는 리스트에 여러 쓰레드가 접근할 경우 동시에 접근하기 때문에 갯수가 다르거나 ArrayIndexOutOfBoundsException 가 발생한다.
단순한 예제로 속도에는 별 차이가 없었다.   병렬처리는 주의깊게 사용해야함을 느껴진다. 

Junit4 

import static org.assertj.core.api.Assertions.assertThatThrownBy;
...
assertThatThrownBy(()->Integer.parseInt("One")).isInstanceOf(NumberFormatException.class);

Junit5

import org.junit.jupiter.api.Assertions;
...
Assertions.assertThrows(NumberFormatException.class, () -> {
      Integer.parseInt("One");
    });