[Item17] - 변경 가능성을 최소화하라.

public class SupplierTest {
    @Test
    void supplierTest() {
        Supplier<Integer> randomSupplier = () -> {
            int num = 100;
            return new Random().nextInt(num + 1);
        };

        for (int i = 0; i < 3; i++) {
            int random = randomSupplier.get();
            System.out.println("random = " + random);
        }
    }
}

public class StreamFunctionalTest {

    @Test
    void integerToStringMap() {
        int[][] arr = {
                {1, 0, 0, 0},
                {1, 1, 0, 0},
                {0, 1, 0, 0},
                {0, 1, 1, 1}
        };
        
        Arrays.stream(arr)
                .map(Arrays::toString)
                .forEach(System.out::println);
    }
    
}

public interface Stream ... {
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

public class FunctionalTest {
    @Test
    void supplierTest() {
        // 문자열 Set 생성
        Set<String> stringSet = new HashSet<>();
        
        // Set에 string 1 ~ string 100까지 저장
        for (int i = 1; i <= 100; i++) {
            stringSet.add("string " + i);
        }
        
        // 함수 팩토리에 구현한 findIdx를 통해 "string 20"이 저장된 위치를 찾음
        // findIdx(set, data)
        final int idx = CustomFunctionalFactory.findIdx(stringSet, () -> "string 20");

        // 실제 저장된 위치가 맞는지 확인
        int i = 0;
        for (String s : stringSet) {
            if (i == idx) {
                assertTrue("string 20".equals(s));
            }
            i++;
        }
    }
}

public class CustomFunctionalFactory {
    /** Set에 포함된 특정 값의 저장 순서를 반환하는 함수
     * @param set       특정 데이터가 포함되어 있는지 탐색할 Set
     * @param supplier  전달받은 "string 20"이 들어있음
     * @return          특정 데이터가 저장된 순서 반환, 데이터가 없을 경우 -1 반환
     * @param <T>       매개변수로 제네릭 타입을 받기 위함
     */
    public static <T> int findIdx(Set<T> set, Supplier<T> supplier) {
        int i = 0;
        // 넘겨 받은 set에 저장된 데이터를 순회하면서 "string 20"의 저장 순서 탐색
        for (T t : set) {
            if (t.equals(supplier.get())) {
                // 순서 반환
                return i;
            }
            i++;
        }
        return -1;
    }
}

public class FunctionalTest {
    @Test
    void consumerFunctionalTest() {
        // 문자열 리스트 생성
        List<String> stringList = new ArrayList<>();
        
        // string 1 ~ 100까지 리스트에 저장
        for (int i = 1; i <= 100; i++) {
            stringList.add("string " + i);
        }
        
        // 함수 팩토리에 리스트와 주어진 리스트로 처리할 기능을 넘겨줌 -> 1 ~ 100까지 출력
        CustomFunctionalFactory.forEachRemaining(stringList, (item) -> System.out.println(item));
    }
}

public class CustomFunctionalFactory {
    /** List에 남아있는 값에 대해서 무언가를 처리하는 메소드
     * @param list      forEach를 돌 리스트
     * @param consumer  forEach를 돌면서 수행할 일
     * @param <T>       매개변수로 제네릭 타입을 받기 위함
    */ 
    public static <T> void forEachRemaining(List<T> list, Consumer<T> consumer) {
        for (T t : list) {
            consumer.accept(t);
        }
    }
}

public class FunctionalTest {
    @Test
    void predicateFunctionalTest() {
        // 문자열 리스트 생성
        List<String> stringList = new ArrayList<>();

        // string 1 ~ 100까지 리스트에 저장
        for (int i = 1; i <= 100; i++) {
            stringList.add("string " + i);
        }

        // 함수 팩토리에 리스트와 해당 리스트에서 걸러줄 조건식을 넘겨줌 -> 1이 포함된 데이터만 돌려 받음
        final List<String> filteredList = CustomFunctionalFactory
                .filter(stringList, (item) -> item.contains("1"));

        // 1이 포함된 데이터만 출력
        for (String s : filteredList) {
            System.out.println(s);
        }

    }
}

public class CustomFunctionalFactory {
    /** 주어진 리스트에서 조건식에 맞는 데이터만 새로운 리스트에 담아서 반환하는 메소드
     * @param list          기존 데이터 리스트
     * @param predicate     리스트에서 검사할 조건식
     * @return              조건식을 통해 걸러진 데이터 리스트
     * @param <T>           매개변수로 제네릭 타입을 받기 위함
     */
    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        // 조건식에 해당되는 데이터를 담을 새로운 리스트
        List<T> result = new ArrayList<>();
        
        // 기존 데이터 리스트 순회
        for (T item : list) {
            // 주어진 조건식에 맞을 경우 결과 리스트에 추가
            if (predicate.test(item)) {
                result.add(item);
            }
        }
        
        // 결과 리스트 반환
        return result;
    }
}

public class FunctionalTest {
    @Test
    void functionFunctionalTest() {
        // 문자열 리스트 생성
        List<String> stringList = new ArrayList<>();

        // string 1 ~ 100까지 리스트에 저장
        for (int i = 1; i <= 100; i++) {
            stringList.add("string " + i);
        }

        // 함수 팩토리에 리스트와 mapping할 값을 넘겨줌 -> 모든 데이터 뒤에 "^_^"가 붙은 값을 반환함
        final List<String> filteredList = CustomFunctionalFactory
                .map(stringList, (item) -> item.concat("^_^"));

        // 기존 데이터에 "^_^"가 붙은 값들 출력
        for (String s : filteredList) {
            System.out.println(s);
        }
    }
}

public class CustomFunctionalFactory {
    /** 주어진 리스트에서 특정 함수를 전달 받고, 해당 함수를 적용하는 함수
     * @param list          기존 데이터 리스트
     * @param function      리스트를 순회하면서 실행할 함수
     * @return              함수대로 진행한 결과 리스트 반환
     * @param <T>           기존 함수의 데이터 타입
     * @param <R>           반환할 리스트의 데이터 타입(주어진 함수의 반환타입 ex) item.concat() -> String 타입)
     */
    public static <T, R> List<R> map(List<T> list, Function<T, R> function) {
        // 조건식에 해당되는 데이터를 담을 새로운 리스트
        List<T> result = new ArrayList<>();

        // 기존 데이터 리스트 순회
        for (T item : list) {
            // 전달 받은 함수에 기존 데이터 요소를 넣고, 결과 배열에 추가
            result.add(function.apply(item));
        }
        
        // 결과 리스트 반환
        return result;
    }
}

public class Post {
    ...

    public PostDto of() {
        return new PostDto(...);
    }
}

public class PostService {
    public List<PostDto> findAllPostDto() {
        List<PostDto> postDtoList = postRepository.findAll().stream()
                .map(Post::of)
                .toList();
    }
}

public static final Complex ZERO = new Complex(0, 0);
public static final Complex ONE = new Complex(1, 0);
public static final Complex I = new Complex(0, 1);

@Native public static final int   MIN_VALUE = 0x80000000;
@Native public static final int   MAX_VALUE = 0x7fffffff;

@Test
void bigIntegerTest() {
    try {
        BigInteger bi = new BigInteger("-1000000");
        int signum = bi.signum();
        Field field = bi.getClass().getDeclaredField("mag");
        field.setAccessible(true);

        System.out.println(field);
        System.out.println(signum);

    } catch (NoSuchFieldException e) {
        throw new RuntimeException(e);
    }
}

@Test
void bigIntegerTest() {
    BigInteger moby = new BigInteger("1000000");

    moby = moby.flipBit(0);

    // 1000001 출력
    System.out.println(moby);
}

String str = "abc";
str = "bcd";

String str = "abc";
str += "bcd";

public class Complex {
    private final double re;
    private final double im;
    
    private Complex(double re, double im) {
        this.re = re;
        this.im = im;
    }

    public static Complex valueOf(double re, double im) {
        return new Complex(re, im);
    }
}