신비한 비

특정 메서드 실행 시간 ,종료 시간을 측정하고 싶을때 우리는 일반적으로 아래와 같은 식으로 작성했었다.

@Around("webLog()")
public Object 실행시간측정해보기(ProceedingJoinPoint joinPoint) throws Throwable {
    long 시작시간 = System.currentTimeMillis();
    long 종료시간 = System.currentTimeMillis();
    webLog.setSpendTime((int) (종료시간 - 시작시간));
}

하지만 spring 에는 더 좋은 객체가 있어서 소개해본다. 바로 StopWatch 라는 요놈...

// StopWatch 하나 만들고 
StopWatch sw = new StopWatch(" 샘플입니다.");
// 시간계산 시작
sw.start("임수수행1");

Thread.sleep(1000);

// 멈추고...
sw.stop();
System.out.printf("임수수행1-->소요시간：%d%s.\n", sw.getLastTaskTimeMillis(), "ms");

sw.start("임수수행2");
Thread.sleep(1100);
sw.stop();

System.out.printf("임수수행2-->소요시간：%d%s.\n", sw.getLastTaskTimeMillis(), "ms");
System.out.printf("임수수행건수：%s，소용총시간：%ss.\n", sw.getTaskCount(), sw.getTotalTimeSeconds());

sw.stop() 함수가 어떻게 되었는지 확인해보면

public void stop() throws IllegalStateException {
	if (null == this.currentTaskName) {
		throw new IllegalStateException("Can't stop StopWatch: it's not running");
	}

	final long lastTime = System.nanoTime() - this.startTimeNanos;
	this.totalTimeNanos += lastTime;
	this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime);
	if (null != this.taskList) {
		this.taskList.add(this.lastTaskInfo);
	}
	++this.taskCount;
	this.currentTaskName = null;
}

내부코드는 그냥 System.nanoTime() 함수를 사용한것. 사실 System.currentTimeMillis() 와 별다른 차이는 없어보인다.

찾아보니 Apache commons-lang3 의 StopWatch 라는 비슷한 놈도 있었다.

사용방식은 ...

StopWatch sw = StopWatch.createStarted();
Thread.sleep(1000);
System.out.printf("소용시간：%dms.\n", sw.getTime());

getTime() 외 아래 함수들도 있으니 참고 바란다.

// 시간계산 일시 멈춤
sw.suspend();
System.out.printf("시간계산 일시 멈춤：%dms.\n", sw.getTime());

// 시간계산 복구
sw.resume();
System.out.printf("시간계산 복구：%dms.\n", sw.getTime());

// 시간계산 종료
sw.stop();
System.out.printf("시간계산 종료：%dms.\n", sw.getTime());

// 시간계산 리셋
sw.reset();
System.out.printf("시간계산 리셋：%dms.\n", sw.getTime());

// 시간계산 시작
sw.start();
System.out.printf("시간계산 시작：%dms.\n", sw.getTime());

https://blakes-organization.gitbook.io/java/

직접 내용들을 아는것만큼 정리하고 있습니다.

도움이 되셨다면 좋댓구알!

일반적인 수단

// 변경불가Set
Set<String> set = new HashSet<>();
set.add("a");
set.add("b");
set.add("c");
set = Collections.unmodifiableSet(set);

// 변경불가 List
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list = Collections.unmodifiableList(list);

자바 8
stream api 로 쉽게 작성 가능.

Set<String> set = Collections.unmodifiableSet(Stream.of("a", "b", "c").collect(toSet()));
List<Integer> list = Collections.unmodifiableList(Stream.of(1, 2, 3).collect(toList()));

자바9
조금더 간단해졌다.

Set<String> set = Set.of("a", "b", "c");
List<Integer> list = List.of(1, 2, 3);

마찬가지로 아래와 같은 map 타입은 아래와 같이 작성 가능하다.

Map<String, String> map = Map.of("a", "1", "b", "2", "c", "3");

주의 ! key ,value 가 쌍으로 나타나므로 파라미터는 무조건 짝수 이다.

Map.of()
Map.of(k1, v1)
Map.of(k1, v1, k2, v2)
Map.of(k1, v1, k2, v2, k3, v3)
...

그리고 갑자기 asXxx() 등 함수들이 자주 등장하는데 차이가 면지 궁금하지 않는가?
List.of vs Arrays.asList 를 예로 들면

1. List.of -> 변경불가
2. Arrays.asList -> 변경가능 ( 주의 , 사실 요놈은 애매한 놈임. 변경불가능이긴 하지만 set을 이용하 변경가능함.헷갈리지? 하지만 List.of는 아예 안됨. set을 호출시 java.lang.UnsupportedOperationException 이 나온다!)
3. List.of null 허용하지않음 ,Arrays.asList null 허용

아래 코드를 보자

public class StreamTest {

    @Test
    void test() {
        List<String> list = List.of("rainsister.tistory.com", "rainsisters.tistory.com", "rainsister.com", "www.rainsisters.com");

        List<String> result = list.stream()
                .filter(e -> e.contains("rainsisters.tistory.com"))
                .filter(e -> e.length() > 17)
                .toList();

        System.out.println(result);
    }

}

혹시 toList() 에 대해서 궁금하지 않은가 ? 요놈은 java 16에서 등장하는 놈이다. 바로 Stream -> List 로 직접 전환해주는 놈이다. java 8 을 사용한 친구라면 안될껄? 그래서 아래 코드들을 테스트 해보려면 아무래도 java 16 이상은 되어야 겠지?
만일 java8 에서는 어떻게 쓸가?

List<String> result = list.stream()
    .filter(e -> e.contains("rainsisters.tistory.com"))
    .filter(e -> e.length() > 17)
    .collect(Collectors.toList());

Stream.toList() 와 Stream.collect(Collectors.toList()) 의 차이점
Stream.toList() 의 내부 코드를 확인 해보면

default List<T> toList() {
    return (List<T>) Collections.unmodifiableList(new ArrayList<>(Arrays.asList(this.toArray())));
}

Stream.toList()는 불변의 List를 만든다. 하지만 Stream.collect(Collectors.toList()) 는 일반 List를 만들어낸다. 때문에 추가,삭제작업이 가능하다.
그러면 Collectors 로 불변의 List를 만들려면 어떻게 쓰면 될깡?????
바로 Collectors.toUnmodifiableList() 를 쓰면 된다.
아래와 같이

List<String> result = list.stream()
    .filter(e -> e.contains("rainsisters.tistory.com"))
    .filter(e -> e.length() > 17)
    .collect(Collectors.toUnmodifiableList());

그리고 아쉽게도 Collectors.toUnmodifiableList() 는 java 10 부터 지원하는 함수다 ㅜ.ㅜ
어서 빨리들 java 버전을 업그레이드 하라!

끝!