import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class MyCollection<T> {
    private List<T> list;

    public MyCollection(List<T> list) {
        this.list = list;
    }

    //map 구현
    public <U> MyCollection<U> map(Function<T, U> function) {
        List<U> newList = new ArrayList<>();
        foreach(d -> newList.add(function.apply(d)));
        return new MyCollection<>(newList);
    }

    //filter 구현
    public MyCollection<T> filter(Predicate<T> predicate) {
        List<T> newList = new ArrayList<>();
        foreach(d -> {
            if (predicate.test(d)) newList.add(d);
        });
        return new MyCollection<>(newList);
    }

    //foreach 구현
    public void foreach(Consumer<T> consumer) {
        for (T data : list) {
            consumer.accept(data);
        }
    }
}

package com.programmers.java.collection;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        new MyCollection<>(Arrays.asList("A", "AB", "ABC", "ABCD", "ABCDE"))
                .map(String::length)
                .filter(i -> i % 2 == 1)
                .foreach(System.out::println);
    }
}

public class User {
    private int age;
    private String name;

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    //getter를 쓰지 않고 나이에 관한 정보는 User만 알고 있도록 User에서 구현
    public boolean isOver19() {
        return age >= 19;
    }

    //toString 오버라이딩
    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        new MyCollection<User>(
                Arrays.asList(
                        new User(15, "A"),
                        new User(16, "B"),
                        new User(17, "C"),
                        new User(18, "D"),
                        new User(19, "E"),
                        new User(20, "F"),
                        new User(21, "G"),
                        new User(22, "H"),
                        new User(23, "I")
                )
        )
                .filter(User::isOver19)
                .foreach(System.out::println);
    }
}

public interface MyIterator<T> {
    boolean hasNext();
    T next();
}

public MyIterator<T> iterator() {
    return new MyIterator<T>() {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < list.size();
        }

        @Override
        public T next() {
            return list.get(index++);
        }
    };
}

Random r = new Random();
Stream.generate(r::nextInt)
        .limit(10)
        .forEach(System.out::println);

Stream.iterate(0, (i) -> i + 1) //초기값(seed), 어떤 값을 결과로 만들어낼지
        .limit(10)
        .forEach(System.out::println);

Stream<Integer> s1 = Arrays.asList(1, 2, 3).stream();
Stream<Integer> s1 = Stream.of(1, 2, 3);
Stream<Integer> s1 = Arrays.stream(new int[]{1, 2, 3}).mapToObj(i -> Integer.valueOf(i));


IntStream s3 = Arrays.stream(new int[]{1, 2, 3});

// stream으로 List<Integer> 생성
List<Integer> list = Arrays.stream(new int[]{1, 2, 3}).boxed().collect(Collectors.toList());

// stream으로 Integer[] arr 생성
Integer[] arr = Arrays.stream(new int[]{1, 2, 3}).boxed().toArray(Integer[]::new);

import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.stream.Stream;

//주사위를 100번 던져서 6 나올 확률 구하기
Random r = new Random();
long count = Stream.generate(() -> r.nextInt(6) + 1)
        .limit(100)
        .filter(n -> n == 6)
        .count();

System.out.println(count);

//1 ~ 9 사이 겹치지 않게 3개를 배열로 출력
Random r = new Random();
int[] arr = Stream.generate(() -> r.nextInt(9) + 1)
        .distinct()
        .limit(3)
        .mapToInt(i -> i)
        .toArray();

System.out.println(Arrays.toString(arr));

//0 ~ 200 사이 랜덥값 5개를 뽑아 큰 순서대로 표시
Random r = new Random();
int[] arr = Stream.generate(() -> r.nextInt(200))
        .limit(5)
        .sorted(Comparator.reverseOrder())
        .mapToInt(i -> i)
        .toArray();

System.out.println(Arrays.toString(arr));

private BallCount ballcount(Numbers answer, Numbers inputNumbers) {
    int strike = 0; // 동기화 기능을 추가하기
    int ball = 0;
    answer.indexedForEach((a, i) -> {
        inputNumbers.indexedForEach((n, j) -> {
            if (!a.equals(n)) return;
            if (i.equals(j)) strike += 1; //scope 밖에 있는 변수 읽기는 가능하지만 사용은 X -> 멀티 쓰레드 환경에서 
            else ball += 1;
        });
    });
    return new BallCount(strike, ball);
}