Java Stream.iterate方法代码示例

import java.util.stream.Stream; //导入方法依赖的package包/类
static Stream<int[]> combinations(Case c) {
    int[] sizes = c.replacementKeys().stream()
                   .mapToInt(key -> c.replacements().get(key).size())
                   .toArray();

    return Stream.iterate(
        new int[sizes.length],
        state -> state != null,
        state -> {
            int[] newState = state.clone();
            for (int i = 0; i < state.length; i++) {
                if (++newState[i] < sizes[i]) {
                    return newState;
                }
                newState[i] = 0;
            }
            // wrapped-around
            return null;
        }
    );
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
@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();
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public static Stream<String> infinite(String line, long pauseMillis) {
    return Stream.iterate(line, (s) -> {
        try {
            Thread.sleep(pauseMillis);
        } catch (Exception e) {
        }
        return s;
    });
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException {
	
	//Creating Streams using user/programmatically specified elements  
	 Stream<String> Userstream = Stream.of("Creating","Streams","from","Specific","elements");
	 Userstream.forEach(p -> System.out.println(p));
     
	 
	 //Creating Streams using array of objects
        Stream<String> ArrayStream = Stream.of( new String[]{"Stream","from","an","array","of","objects"} );
        ArrayStream.forEach(p -> System.out.println(p)); 
    
       
        //Creating Streams from an array
        String[] StringArray=new String[]{"We","can","convert","an","array","to","a","Stream","using","Arrays","as","well"};
        Stream<String> StringStream=Arrays.stream(StringArray);
        StringStream.forEach(p -> System.out.println(p));
        
        //Creating Streams from Collection
        List<Double> myCollection = new ArrayList<>();
        for(int i=0; i<10; i++){
       	 myCollection.add(Math.random());
        }
               //sequential stream
        Stream<Double> sequentialStream = myCollection.stream();
        sequentialStream.forEach(p -> System.out.println(p));
        		
                //parallel stream
        Stream<Double> parallelStream = myCollection.parallelStream();
        parallelStream.forEach(p -> System.out.println(p));
        
        
        //Stream from Hashmap
        Map<String, Integer> mapData = new HashMap<>();
        mapData.put("This", 1900);
        mapData.put("is", 2000);
        mapData.put("HashMap", 2100);
        
        mapData.entrySet()
       		.stream()
       		.forEach(p -> System.out.println(p));
        
        mapData.keySet()
               .stream()
               .forEach(p-> System.out.println(p));
        
        //primitive streams 
        IntStream.range(1, 4)
        .forEach(p -> System.out.println(p));
        
        LongStream.rangeClosed(1, 4)
        .forEach(p -> System.out.println(p));
        
        DoubleStream.of(1.0,2.0,3.0,4.0)
        .forEach(p -> System.out.println(p));
        
        //Infinite Streams using generate()
        Stream <Double> sequentialDoubleStream = Stream.generate(Math :: random); 

        Stream<Integer> sequentialIntegerStream = Stream.generate(new AtomicInteger () :: getAndIncrement); 

        //Infinite Streams using iterate()
        Stream <Integer> sequentialIntegerStream1 = Stream.iterate (Integer.MIN_VALUE, i -> i++); 

        Stream <BigInteger> sequentialBigIntegerStream = Stream.iterate(BigInteger.ZERO, i -> i.add (BigInteger.TEN)); 
        
        //Streams from File
        Stream<String> streamOfStrings = Files.lines(Paths.get("Apology_by_Plato.txt"));
        Stream<String> streamWithCharset = Files.lines(Paths.get("Apology_by_Plato.txt"), Charset.forName("UTF-8"));

      
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
private Stream<ImmutableBoard> historyStream() {
  return Stream.iterate(this, Objects::nonNull, ImmutableBoard::parentBoard);
}
 

import java.util.stream.Stream; //导入方法依赖的package包/类
/**
 * Indexes the elements of the given finite list, starting from {@code 0}.
 * For example (pseudo code): {@code zipIndex([a,b,c]) = [(a, 0), (b, 1),
 * (c, 2)]}.
 * This is a terminal operation on the input streams.
 * @param <X> any type.
 * @param xs the list to index.
 * @return the indexed list.
 * @throws NullPointerException if any argument is {@code null}.
 */
public static <X> Stream<Pair<Integer, X>> zipIndex(Stream<X> xs) {
    Stream<Integer> ks = Stream.iterate(0, x -> x + 1);
    return zip(ks, xs);
}