Java Demo ['sort', 'sleep', 'StopWatch']

import com.google.common.collect.Lists;
import java.util.concurrent.Callable;
import lombok.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.StopWatch;
import org.junit.jupiter.api.Test;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.TimeUnit;

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.testcontainers.shaded.org.awaitility.Awaitility.await;

/**
 * @author demo
 * @date 2022-07-23
 */
@Slf4j
class SortTest {

    private static final List<Bean> list = Lists.newArrayList(
            new Bean("1", "abc"),
            new Bean("3", "zzz"),
            new Bean("2", "ddd"),
            new Bean("2", "aaa"),
            new Bean("8", "ccc"),
            new Bean("6", "bbc"));

    @Test
    void sort1() {
        //noinspection Java8ListSort
        Collections.sort(list, new Comparator<>() {
            @Override
            public int compare(Bean a, Bean b) {
                return a.getId().compareTo(b.getId());
            }
        });
        for (Bean bean : list) {
            log.debug("id={}", bean.getId());
        }
        assertTrue(true);
    }

    @Test
    void sort2() {
        // list.sort((Bean a, Bean b) -> a.getId().compareTo(b.getId()));
        list.sort(Comparator.comparing(Bean::getId));
        list.forEach(bean -> log.debug("id={}", bean.getId()));
        assertTrue(true);
    }

    @Test
    void sort2_1() {
        list.sort(Comparator.comparing(Bean::getId).reversed());
        list.forEach(bean -> log.debug("id={}", bean.getId()));
        assertTrue(true);
    }

    @Test
    void sort3() {
        list.sort(Bean::compareById);
        list.forEach(bean -> log.debug("id={}", bean.getId()));
        assertTrue(true);
    }

    @Test
    void sort3_1() {
        //noinspection Java8ListSort
        Collections.sort(list, Bean::compareById);
        list.forEach(bean -> log.debug("id={},name={}", bean.getId(), bean.getName()));
        assertTrue(true);
    }

    @Test
    void sort4() {
        list.sort(Bean.getInstance()::compare);
        list.forEach(bean -> log.debug("id={}", bean.getId()));
        assertTrue(true);
    }

    @Test
    void sort5() {
        list.sort(Comparator.comparing(Bean::getId).thenComparing(Bean::getName));
        list.forEach(bean -> log.debug("id={},name={}", bean.getId(), bean.getName()));
        assertTrue(true);
    }

    @Test
    void sort6() {
        List<Bean> list1 = list.stream().sorted(Comparator.comparing(Bean::getId)).toList();
        list1.forEach(bean -> log.debug("id={},name={}", bean.getId(), bean.getName()));
        assertTrue(true);
    }

    @Test
    void sort7() {
        List<Bean> list1 = list.parallelStream().sorted(Comparator.comparing(Bean::getId)).toList();
        list1.forEach(bean -> log.debug("id={},name={}", bean.getId(), bean.getName()));
        assertTrue(true);
    }

    /**
     * 统计程序执行时间
     *
     * @throws InterruptedException 异常
     */
    @Test
    void stopWatch() throws InterruptedException {
        StopWatch sw1 = new StopWatch();
        sw1.start();
        StopWatch sw2 = StopWatch.create();
        sw2.start();
        StopWatch sw3 = StopWatch.createStarted();

        // 优雅的sleep
        TimeUnit.SECONDS.sleep(1L);
        await().atMost(2L, TimeUnit.SECONDS).until(didTheThing());
        log.info("time={}", sw3.getTime());
        // TimeUnit.MILLISECONDS.sleep(200L);
        await().atMost(400L, TimeUnit.MILLISECONDS).until(didTheThing());
        log.info("time={}", sw3.getTime());
        // 暂停
        sw3.suspend();
        // TimeUnit.MILLISECONDS.sleep(500L);
        await().atMost(500L, TimeUnit.MILLISECONDS).until(didTheThing());
        log.info("time={}", sw3.getTime());
        // 恢复
        sw3.resume();
        // TimeUnit.MILLISECONDS.sleep(500L);
        await().atMost(500L, TimeUnit.MILLISECONDS).until(didTheThing());
        log.info("time={}", sw3.getTime());
        assertTrue(true);
    }

    @Test
    void stopWatchSpring() throws InterruptedException {
        org.springframework.util.StopWatch sw1 = new org.springframework.util.StopWatch("test task times");

        sw1.start("task a");
        // TimeUnit.SECONDS.sleep(1L);
        await().atMost(2L, TimeUnit.SECONDS).until(didTheThing());
        sw1.stop();
        log.info("time={}", sw1.getLastTaskTimeMillis());

        sw1.start("task b");
        // TimeUnit.MILLISECONDS.sleep(500L);
        await().atMost(500L, TimeUnit.MILLISECONDS).until(didTheThing());
        sw1.stop();
        log.info("time={}", sw1.getLastTaskTimeMillis());

        log.info("count={}, total time={}", sw1.getTaskCount(), sw1.getTotalTimeMillis());
        log.debug(sw1.prettyPrint());
        assertTrue(true);
    }


    private Callable<Boolean> didTheThing() {
        return () -> {
            // check the condition that must be fulfilled...
            return true;
        };
    }


    @Getter
    @Setter
    @NoArgsConstructor
    @AllArgsConstructor
    @ToString
    static class Bean {

        private static final Bean BEAN = new Bean();
        private String id;
        private String name;

        public static Bean getInstance() {
            return BEAN;
        }

        public static int compareById(Bean a, Bean b) {
            return a.getId().compareTo(b.getId());
        }

        public int compare(Bean a, Bean b) {
            return a.getId().compareTo(b.getId());
        }
    }
}