Java Code Examples for java.util.stream.Stream#iterate()

/**
 * 创建Stream
 */
@Test
public void test1() {
    // 1.可以通过Collection 系列集合提供的stream()或parallelStream()
    List<String> list = new ArrayList<>();
    Stream<String> stream1 = list.stream();

    // 2.通过 Arrays 中的静态方法stream()获取数组流
    Employee[] emps = new Employee[10];
    Stream<Employee> stream2 = Arrays.stream(emps);

    // 3.通过Stream 类中的静态方法of()
    Stream<String> stream3 = Stream.of("a", "b", "c");

    // 4.创建无限流
    // 迭代
    Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
    stream4.limit(10).forEach(System.out::println);
    // 生成
    Stream.generate(Math::random)
            .limit(5)
            .forEach(System.out::println);
}
 

@Test public void flattenWithInfiniteOuterStream() throws Exception {
  Stream<List<Integer>> infinite = Stream.iterate(
      ImmutableList.of(1), l -> l.stream().map(i -> i + 1).collect(toImmutableList()));
  Stream<Integer> flattened = MoreStreams.flatten(infinite.map(l -> l.stream()));
  assertThat(flattened.limit(5).collect(toList()))
      .containsExactly(1, 2, 3, 4, 5).inOrder();
}
 

/**
 * This test is ignored, because it proves that java 8 collectors
 * materialize whole sets. See the next test.
 */
@Test(timeout = 500)
@Ignore
public void testGroupByNonStreamyShitty() {
    final Stream<Integer> infiniteStream = Stream.iterate(0, i -> i + 1);
    // This is an infinite stream containing all numbers. We're going to
    // chunk it up into batches of 10, and see if we can get the JVM to
    // explode.
    final Map<Integer, List<Integer>> collect = infiniteStream
            .limit(1000000000)
            .collect(Collectors.groupingBy(i -> i / 10));

    assertEquals(collect.get(0), Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
}
 

/**
 * This test is proves that the streamy way works. Observe how it doesn't
 * time out like the above test does.
 */
@Test(timeout = 500)
public void testGroupByStreamy() {
    final Stream<Integer> infiniteStream = Stream.iterate(0, i -> i + 1);
    // This is an infinite stream containing all numbers. We're going to
    // chunk it up into batches of 10, and see if we can get the JVM to
    // explode.
    final Stream<List<Integer>> groupedStream = OrderedStreamUtils.groupBy(infiniteStream.limit(1000000000), i -> i / 10);

    assertEquals(groupedStream.findFirst().get(), Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
}
 

/**
 * This test validates that we don't get stack overflow exceptions.
 */
@Test
@Ignore
public void testNoStackOverflow() {
    final Stream<Integer> infiniteStream = Stream.iterate(0, i -> i + 1);
    // This is an infinite stream containing all numbers. We're going
    // to group all of them together, and see if the stack explodes.
    final Stream<List<Integer>> groupedStream = OrderedStreamUtils.groupBy(infiniteStream.limit(100000), i -> 1);

    assertEquals(100000, groupedStream.findFirst().get().size());
}
 

@Test
public void whenLimitInfiniteStream_thenGetFiniteElements() {
    Stream<Integer> infiniteStream = Stream.iterate(2, i -> i * 2);

    List<Integer> collect = infiniteStream
      .skip(3)
      .limit(5)
      .collect(Collectors.toList());
  
    assertEquals(collect, Arrays.asList(16, 32, 64, 128, 256));
}
 

@Test
public void should_not_build_a_repeating_stream_on_a_non_sized_stream() {
    // Given
    Stream<String> strings = Stream.iterate("+", s -> s);

    // Then
    assertThatIllegalArgumentException().isThrownBy(() -> StreamsUtils.repeat(strings, 3));
}
 

@Test public void
take_while_takes_items_while_condition_is_met() {
    Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
    Stream<Integer> finiteInts = StreamUtils.takeWhile(infiniteInts, i -> i < 10);

    assertThat(finiteInts.collect(Collectors.toList()), hasSize(10));
}
 

@Test public void
take_while_inclusive_takes_items_while_condition_is_met_but_includes_first_condition_breaker() {
    Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
    Stream<Integer> finiteInts = StreamUtils.takeWhileInclusive(infiniteInts, i -> i < 10);

    assertThat(finiteInts.collect(Collectors.toList()), hasSize(11));
}
 

@Test
public void whenIterateStream_thenGetInfiniteStream() {
    Stream<Integer> evenNumStream = Stream.iterate(2, i -> i * 2);

    List<Integer> collect = evenNumStream
      .limit(5)
      .collect(Collectors.toList());
  
    assertEquals(collect, Arrays.asList(2, 4, 8, 16, 32));
}
 

default <T> void initElements(final T targetPage) {
	final Stream<Class> pageChain = Stream.iterate(targetPage.getClass(), Class::getSuperclass);
	takeWhile(pageChain, pageObject -> !pageObject.equals(Object.class))
			.flatMap(pageObject -> Stream.of(pageObject.getDeclaredFields()))
			.filter(field -> field.isAnnotationPresent(HTML.class))
			.forEach(field -> initElement(targetPage, field, field.getAnnotation(HTML.class)));
}
 

@Test
// givenInfiniteStream_whenTakeWhile10_shouldReturnStreamOfSize10
public void givenInfiniteStream_whenTakeWhile10_shouldReturnStream() {
    Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
    Stream<Integer> finiteInts = StreamUtils.takeWhile(infiniteInts, i -> i < 10);

    assertThat(finiteInts.collect(Collectors.toList()), hasSize(10));
}
 

@Test
public void givenInfiniteStream_whenTakeUntil10_shouldReturnStreamUpto10() {
    Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
    Stream<Integer> finiteInts = StreamUtils.takeUntil(infiniteInts, i -> i > 10);

    assertThat(finiteInts.collect(Collectors.toList()), hasSize(11));
}
 

@Test
public void whenTakeWhile_thenTakenWhile() {
    Stream<Integer> streamOfInt = Stream.iterate(1, i -> i + 1);
    List<Integer> result = StreamUtils.takeWhile(streamOfInt, i -> i < 5).collect(Collectors.toList());
    assertThat(result).contains(1, 2, 3, 4);
}
 

public static Integer getInfiniteStreamLastElementUsingReduce() {
    Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
    return stream.limit(20).reduce((first, second) -> second).orElse(null);
}
 

private static Stream<Optional<PsiElement>> getSiblingsStream(PsiElement element) {
    return Stream.iterate(
            Optional.ofNullable(element),
            prev -> prev.map(e -> Optional.ofNullable(e.getNextSibling())).orElse(Optional.empty())
    );
}
 

@Test
void testPartition() {
    Stream<Integer> stream = Stream.iterate(1, i -> i + 1);
    MoreStreams.partition(stream, 100).limit(10).forEach(System.out::println);
}
 

@Test
public void whenTakeUntil_thenTakenUntil() {
    Stream<Integer> streamOfInt = Stream.iterate(1, i -> i + 1);
    List<Integer> result = StreamUtils.takeUntil(streamOfInt, i -> i > 50).collect(Collectors.toList());
    assertThat(result).contains(10, 20, 30, 40);
}
 

private static void doWhileStreamWay() {
    Stream<Integer> integers = Stream.iterate(0, i -> i + 1);
    integers.limit(10).forEach(System.out::println);
}
 

public void takeWhileAndTakeUntilStream() {
    Stream<Integer> infiniteInts = Stream.iterate(0, i -> i + 1);
    Stream<Integer> finiteIntsWhileLessThan10 = StreamUtils.takeWhile(infiniteInts, i -> i < 10);
    Stream<Integer> finiteIntsUntilGreaterThan10 = StreamUtils.takeUntil(infiniteInts, i -> i > 10);
}