public void streamOperator(){

  //중간연산만 단독으로 실행 시, 실행되지 않는다.
  Stream<UserVo> userVoStream = getMockUserList().stream();

  userVoStream.peek(System.out::println);
}

public void parallelStream(){
    IntStream forParallelStream = IntStream.range(1, 10);

    forParallelStream
            .parallel()
            .forEach((n)->System.out.println("parallel numbering : "+n));

  }

public void streamCollect(){

  List<UserVo> userList = getMockUserList();

  //stream -> array
  Stream<UserVo> toArrayStream = userList.stream();
  UserVo[] resultArray = toArrayStream.toArray(UserVo[]::new);
}

public void streamCollect(){
  List<UserVo> userList = getMockUserList();

  Stream<UserVo> toMapStream = userList.stream();

  Map<String, UserVo> resultMap = toMapStream.collect(Collectors.toMap(userVo -> userVo.getName(), userVo -> userVo));
}

public void streamCollect(){
  List<UserVo> userList = getMockUserList();

  Stream<UserVo> toListStream = userList.stream();

  List<UserVo> resultList = toListStream.collect(Collectors.toList());
}

public void streamMap(){
  Stream<String> strArrStream = Stream.of(
    "1_1", "1_2", "1_3", "1_4", "1_5", "1_6"
    , "2_1", "2_2", "2_3", "2_4", "2_5", "2_6"
    , "3_1", "3_2", "3_3", "3_4", "3_5", "3_6"
  );

  strArrStream
    .map((s)->"prefix_"+s))
    .forEach(System.out::println);
}

public void flatStream(){
  Stream<String[]> strArrStream = Stream.of(
    new String[]{"1_1", "1_2", "1_3", "1_4", "1_5", "1_6"}
      , new String[]{"2_1", "2_2", "2_3", "2_4", "2_5", "2_6"}
      , new String[]{"3_1", "3_2", "3_3", "3_4", "3_5", "3_6"}
  );

  strArrStream
    .flatMap(Arrays::stream)
    .forEach(System.out::println);
}

public void streamReduce(){
  Integer[] numberArr = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 10};

  Stream<Integer> numberStream1 = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 10});

  Integer intReuslt = numberStream1.reduce(0, (integer1, integer2) -> integer1 + integer2);

  System.out.println("integer Sum : "+intReuslt);
}

public final class Optional<T> {

    ...

    private final T value;

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
    ...
}

  private void handleOptional1(){
        Optional<Integer> wrapIntVal = Optional.of(new Integer(5));
        Integer intVal = wrapIntVal.get();      //intVal == 5
    }

  private void safeValWithOptional(){

      Map<String, Integer> mockupMap = new HashMap<>();

      final String findKey = "data10"; //찾으려는 키값

      //mock data
      mockupMap.put("data1", 1);
      mockupMap.put("data2", 2);
      mockupMap.put("data3", 3);

      Integer findVal = mockupMap.entrySet().stream()
              .filter(entry -> findKey.equals(entry.getKey()))
              .map(entry -> entry.getValue())
              .findAny()              //Optional 객체가 반환된다.
              .orElse(-1);

      System.out.println("검색된 값 : "+findVal.toString());
  }

public void streamOperator(){

    List<UserVo> mockUserList = getMockUserList();

    Stream<UserVo> userListStream = mockUserList.stream();


    userListStream
      .filter(userVo -> userVo.getAge()>20)
      //.peek(System.out::println)
      .filter(userVo -> userVo.getAuth().contains("master"))
      .forEach(userVo -> System.out.println(userVo.getName()));

    //스트림 연산을 하여도 원본은 변경되지 않는다.
    mockUserList.forEach((userVo)->{System.out.println(userVo.getName());});
}

public void baseStream(){
    //create stream
    Stream<String> strToStream = Stream.of("one", "two", "three", "four");

    strToStream
      .filter(s->s.equals("one"))
      .forEach(System.out::println);


    //strToStream.forEach(System.out::println); ERROR!! 스트림은 소모성
}

public void baseStream(){
    //함수를 저장
    Supplier<Stream<String>> getListStream = () -> list.stream();

    getListStream.get()
        .forEach(System.out::println);

    getListStream.get()
        .forEach(System.out::println);
}

public void streamSort(){
    IntStream intsStream = new Random().ints(30, 0, 100);

    //intsStream.sorted().forEach(System.out::println);
    intsStream.parallel().filter(value -> value>30).sorted().forEach(System.out::println);
}

public void streamSort(){
    Map<String, List<String>> map = new HashMap<>();
    String[] strArr = {"key1","key2","key3","key4","key5","key6","key7"};

    //더미 데이터 입력
    Stream.of(strArr).forEach(key -> map.put(key, Arrays.asList(strArr)));

    List<Set<String>> itemSetList = map.keySet()
        .stream()
        .map(key -> map.get(key))
        .map(itemList ->
                itemList
                    .stream()
                    .map(item -> "update" + item)
                    .collect(Collectors.toSet()))
        .collect(Collectors.toList());
}

public void streamSort(){
    Map<String, List<String>> map = new HashMap<>();
    String[] strArr = {"key1","key2","key3","key4","key5","key6","key7"};

    //더미 데이터 입력
    Stream.of(strArr).forEach(key -> map.put(key, Arrays.asList(strArr)));

    List<Set<String>> itemSetList = map.keySet()
        .stream()
        .map(key -> map.get(key))
        .map(itemList -> handleItemList(itemList).get())
        .collect(Collectors.toList());
}

private Supplier<Set<String>> handleItemList(List<String> itemList){
    return () -> itemList
        .stream()
        .map(item -> "update" + item)
        .collect(Collectors.toSet());
}

Each mapped stream is closed after its contents have been placed into this stream.

When the resulting stream is closed, the close handlers for both input streams are invoked.

    public static String encodeWithEx(String str) throws UnsupportedEncodingException {

        return URLEncoder.encode(str, "utf-8");
    }

        strs.stream()
            .map(WithCheckedEx::encodeWithEx)   //ERROR!
            .collect(Collectors.toList());

    public static String encodeWithoutEx(String str){

        try {
            return URLEncoder.encode(str, "utf-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e.getMessage());
        }
    }

    public static void main(String[] args) {

        List<String> strs = Arrays.asList("첫번째", "두번째", "세번째");

        strs.stream()
                .map(WithCheckedEx::encodeWithoutEx)
                .collect(Collectors.toList());
    }