[Java] Java 8 에서 자주 만나는 것들 2

1
2
3
4
5
6
7
8
9
10
11
private static void streamPractice1() {
  ArrayList<Integer> list = new ArrayList<>();

  list.add(4);
  list.add(2);
  list.add(3);
  list.add(1);

  Stream<Integer> stream = list.stream();
  stream.map(i -> i + " ").forEach(System.out::print);
}

1
2
3
4
5
6
7
8
9
private static void streamPractice2() {
  String[] arr = new String[] {"넷", "둘", "셋", "하나"};

  Stream<String> stream = Arrays.stream(arr);
  stream.forEach(e -> System.out.print(e + " "));
  System.out.println();

  Arrays.stream(arr, 1, 3).forEach(e -> System.out.print(e + " "));
}

1
2
3
4
5
6
7
8
9
private static void streamPractice3() {
  Stream<Double> stream1 = Stream.of(3.14, 1.57, 2.0, 5.55555, 3.11);
  stream1.map(d -> d + " ").forEach(System.out::print);

  System.out.println();

  Stream<Integer> stream2 = Stream.of(100, 200);
  stream2.map(d -> d + " ").forEach(System.out::print);
}

1
2
3
4
private static void streamPractice4() {
  IntStream stream1 = IntStream.range(1, 5);
  stream1.forEach(System.out::print);
}

1
2
3
4
private static void streamPractice5() {
  IntStream stream = new Random().ints(4);
  stream.forEach(System.out::println);
}

1
2
3
4
5
6
7
8
9
private static void streamPractice6() {
  Stream<Integer> stream1 = Stream.iterate(2, n -> n+2);
  stream1.limit(5).forEach((i) -> System.out.print(i + " "));

  System.out.println();

  Stream<Integer> stream2 = Stream.generate(() -> 5);
  stream2.limit(5).forEach((i) -> System.out.print(i + " "));
}

1
2
3
4
5
6
7
8
9
private static void streamPractice7() {
  IntStream stream1 = IntStream.of(7, 5, 5, 2, 1, 2, 3, 5, 4, 6);
  IntStream stream2 = IntStream.of(7, 5, 5, 2, 1, 2, 3, 5, 4, 6);

  stream1.distinct().forEach(e -> System.out.print(e + " "));
  System.out.println();

  stream2.filter(n -> n%2 != 0).forEach(e -> System.out.print(e + " "));
}

1
2
3
4
private static void streamPractice8() {
  Stream<String> stream = Stream.of("HTML", "CSS", "JAVA", "JAVASCRIPT");
  stream.map(String::length).forEach(e -> System.out.print(e + " "));
}

1
2
3
4
5
6
private static void streamPractice8() {
  String[] arr = {"Hello", "World", "Happy", "Meet", "Develop"};
  Arrays.stream(arr)
          .flatMap(str -> Stream.of(str.split("")))
          .forEach(c -> System.out.print(c + " "));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
private static void streamPractice10() {
  IntStream stream1 = IntStream.range(0, 10);
  IntStream stream2 = IntStream.range(0, 10);
  IntStream stream3 = IntStream.range(0, 10);

  stream1.skip(4).forEach(n -> System.out.print(n + " "));
  System.out.println();

  stream2.limit(5).forEach(n -> System.out.print(n + " "));
  System.out.println();

  stream3.skip(3).limit(5).forEach(n -> System.out.print(n + " "));
}

1
2
3
4
5
6
7
8
9
private static void streamPractice11() {
  Stream<String> stream1 = Stream.of("Apple", "Zebra", "Banana", "Cup");
  Stream<String> stream2 = Stream.of("Apple", "Zebra", "Banana", "Cup");

  stream1.sorted().forEach(s -> System.out.print(s + " "));
  System.out.println();

  stream2.sorted(Comparator.reverseOrder()).forEach(s -> System.out.print(s + " "));
}

1
2
3
4
5
6
7
8
9
10
11
12
private static void streamPractice12() {
  Stream<String> stream = Stream.of("A", "B", "C", "D", "E", "F", "G");

  stream.peek(s -> System.out.println("원본 : " + s))
          .skip(2)
          .peek(s -> System.out.println("skip(2) 후 : " + s))
          .limit(3)
          .peek(s -> System.out.println("limit(3) 후 : " + s))
          .sorted(Collections.reverseOrder())
          .peek(s -> System.out.println("sorted() 후 : " + s))
          .forEach(System.out::println);
}

1
2
3
4
private static void streamPractice13() {
  Stream<String> stream = Stream.of("알파", "베타", "찰리", "델타", "에코");
  stream.forEach(System.out::println);
}

1
2
3
4
5
6
7
8
9
private static void streamPractice14() {
  Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5);
  Optional<Integer> result1 = stream1.reduce((i, j) -> i + j);
  result1.ifPresent(System.out::println);

  Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5);
  Integer result2 = stream2.reduce(0, (i, j) -> i + j);
  System.out.println(result2);
}

1
2
3
4
5
6
7
8
9
10
private static void streamPractice15() {
  IntStream stream1 = IntStream.of(4, 2, 7, 3, 5, 1, 6);
  IntStream stream2 = IntStream.of(4, 2, 7, 3, 5, 1, 6);

  OptionalInt result1 = stream1.filter((i) -> i % 2 == 1).findFirst();
  System.out.println(result1.getAsInt());

  OptionalInt result2 = stream2.filter((i) -> i % 2 == 1).findAny();
  System.out.println(result2.getAsInt());
}

1
2
3
4
5
6
7
8
9
10
private static void streamPractice15_v2() {
  IntStream stream1 = IntStream.of(4, 2, 7, 3, 5, 1, 6);
  IntStream stream2 = IntStream.of(4, 2, 7, 3, 5, 1, 6);

  OptionalInt result1 = stream1.parallel().filter((i) -> i % 2 == 1).findFirst();
  System.out.println(result1.getAsInt());

  OptionalInt result2 = stream2.parallel().filter((i) -> i % 2 == 1).findAny();
  System.out.println(result2.getAsInt());
}

1
2
3
4
5
6
7
private static void streamPractice16() {
  IntStream stream1 = IntStream.of(30, 90, 70, 10);
  IntStream stream2 = IntStream.of(30, 90, 70, 10);

  System.out.println(stream1.anyMatch(n -> n > 80));
  System.out.println(stream2.allMatch(n -> n > 80));
}

1
2
3
4
5
6
7
8
9
private static void streamPractice17() {
  IntStream stream1 = IntStream.of(30, 90, 70, 10);
  IntStream stream2 = IntStream.of(30, 90, 70, 10);
  Stream<Integer> stream3 = Stream.of(30, 90, 70, 10);

  System.out.println(stream1.count());
  System.out.println(stream2.max().getAsInt());
  System.out.println(stream3.min(Integer::compare).get());
}

1
2
3
4
5
6
7
private static void streamPractice18() {
  IntStream stream1 = IntStream.of(30, 90, 70, 10);
  DoubleStream stream2 = DoubleStream.of(30.3, 90.9, 70.7, 10.1);

  System.out.println(stream1.sum());
  System.out.println(stream2.average().getAsDouble());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
private static void streamPractice19() {
  Stream<String> stream = Stream.of("알파", "베타", "찰리", "델타", "에코", "찰리");
  List<String> list = stream.collect(Collectors.toList());
  for (String s : list) System.out.print(s + " ");
  System.out.println();

  Stream<String> stream2 = Stream.of("알파", "베타", "찰리", "델타", "에코", "찰리");
  Set<String> set = stream2.collect(Collectors.toSet());
  for (String s : set) System.out.print(s + " ");
  System.out.println();

  Stream<Integer> stream3 = Stream.of(2, 4, 6, 8, 10);
  System.out.println(stream3.collect(Collectors.counting()));  // == stream3.count()

  Stream<Integer> stream4 = Stream.of(2, 4, 6, 8, 10);
  System.out.println(stream4.collect(Collectors.maxBy(Integer::compare)).get());  // == stream4.max(Integer::compare).get()

  Stream<String> stream5 = Stream.of("2", "4", "6", "8", "10");
  System.out.println(stream5.collect(Collectors.averagingInt(Integer::parseInt)));

  Stream<String> stream6 = Stream.of("알파", "베타", "찰리", "델타", "에코", "찰리");
  System.out.println(stream6.collect(Collectors.joining("/")));

  Stream<String> stream7 = Stream.of("A0", "B1", "A2", "B0", "A1", "B2");
  Map<Boolean, List<String>> partition = stream7.collect(Collectors.partitioningBy(s -> s.startsWith("A")));
  List<String> trueList = partition.get(true);
  List<String> falseList = partition.get(false);
  System.out.println(trueList + " " + falseList);

  Stream<String> stream8 = Stream.of("A0", "B1", "A2", "B0", "A1", "B2", "C1");
  Map<Character, List<String>> group = stream8.collect(Collectors.groupingBy(s -> s.charAt(0)));
  List<String> aList = group.get('A');
  List<String> bList = group.get('B');
  List<String> cList = group.get('C');
  System.out.println(aList + " " + bList + " " + cList);
}