@Override public TS build(boolean parallel) { return parallel ? wrapped.parallel() : wrapped; } }
String result = new BufferedReader(new InputStreamReader(inputStream)).lines() .parallel().collect(Collectors.joining("\n"));
BufferedReader fooBarReader = new BufferedReader(new StringReader("Foo\nBar")); fooBarReader.lines() .skip(1L) .parallel() .forEach(System.out::println);
public static String streamToString(final InputStream inputStream) throws Exception { // buffering optional try ( final BufferedReader br = new BufferedReader(new InputStreamReader(inputStream)) ) { // parallel optional return br.lines().parallel().collect(Collectors.joining("\n")); } catch (final IOException e) { throw new RuntimeException(e); // whatever. } }
List<String> list = Arrays.asList("Anne", "Bill", "Chris", "Dean", "Eve", "Fred", "George"); list.stream().parallel().collect(EveryNth.collector(3)).forEach(System.out::println);
return Arrays.stream(state.array) .parallel() .map(x -> x.toLowerCase()) .collect(Collectors.toList());
@SuppressWarnings("varargs") @SafeVarargs // Creating a Stream of an array is safe. private static <T extends BaseStream<?, ?>> T configureAutoCloseStream(T concatStream, T... streams) { @SuppressWarnings("rawtypes") final boolean parallel = Stream.of(streams).anyMatch(BaseStream::isParallel); // T:::isParallel gives IDE warning if (parallel) { concatStream.parallel(); } concatStream.onClose(() -> composedClose(streams)); return concatStream; }
private BaseStream<E, ?> getStream() { BaseStream<?, ?> result = getInitialSupplier().get(); for (Action<?, ?> action : this) { result = cast(result, action); } // Convey pipeline parallelism and ordering // setting to the destination stream. if (parallel) { result.parallel(); } else { result.sequential(); } if (!ordered) { result.unordered(); } @SuppressWarnings("unchecked") final BaseStream<E, ?> castedResult = (BaseStream<E, ?>) result; return castedResult; }
public static Stream<Object> flatten(Object[][][] arr){ return Arrays.stream(arr).parallel() .flatMap(Arrays::stream) .flatMap(Arrays::stream); }
List<int[]> searchForArrays(int[][] data, int[] value) { return Arrays.stream(data).parallel() .filter(line -> { for (int i = 0; i < value.length; i++) if (i >= line.length || value[i] != line[i]) return false; return true; }); .collect(Collectors.toList()); }
public static boolean containsAny(final String searchString, final Collection<String> searchCollection) { return searchCollection.stream().parallel() .anyMatch(x -> searchString.indexOf(x) > -1); }
String[] largeArray = null; Set<String> distinctStrings = Arrays.stream(largeArray).parallel() .collect(Collectors.toConcurrentMap((s) -> s, (s) -> s)).keySet();
String data = IntStream.range(0, 10000).mapToObj(String::valueOf) .collect(Collectors.joining("\n")); List<String> list = new BufferedReader(new StringReader(data)).lines().parallel() .collect(oddLines()); list.stream().mapToInt(Integer::parseInt).filter(x -> x%2 != 0) .forEach(System.out::println);
public static boolean withinAndInOrder(String[] a, String[] b) { return Arrays.equals(a, Arrays.stream(b) .parallel() .filter(element -> Arrays.binarySearch(a, element) >= 0) .toArray()); }
List<String> output= new ArrayList<>(); List<String> input= new ArrayList<>(); input.add("A"); input.add("B"); input.add("C"); input.add("D"); input.stream().parallel().map((item) -> item.toLowerCase()) .collect(Collectors.toCollection(() -> output));
public String[] generateFirstRow(int startingRow) { final String[] row1 = rowList.get(startingRow); final String[] row2 = rowList.get(startingRow + 1); final List<String> list1 = Arrays.stream(row1).collect(toList()); final List<String> toAdd = Arrays.stream(row2).parallel().sorted().filter(s -> !list1.contains(s)).collect(Collectors.toList()); if (list1.get(list1.size() - 1) == "") { list1.set(list1.size() - 1, toAdd.get(0)); return list1.toArray(new String[0]); } return new String[0]; }
new Random().ints(100).boxed() .parallel() .map(this::slowOperation) .collect(Collectors.toList()) // Start new stream here .stream() .map(Function.identity())//some fast operation, but must be in single thread .collect(Collectors.toSet());
public static <T> Stream<T> recreate(Stream<T> stream) { return StreamSupport.stream(stream.spliterator(), stream.isParallel()) .onClose(stream::close); } public static void main(String[] args) { recreate(new BufferedReader(new StringReader("JUNK\n1\n2\n3\n4\n5")).lines() .skip(1).parallel()).forEach(System.out::println); }
int[][] values = fillMatrix(new int[1000][1000]); OptionalInt max = Arrays.stream(values) .parallel() .flatMapToInt(Arrays::stream) .parallel() .max();
@SuppressWarnings("varargs") @SafeVarargs // Creating a Stream of an array is safe. private static <T extends BaseStream<?, ?>> T configureAutoCloseStream(T concatStream, T... streams) { @SuppressWarnings("rawtypes") final boolean parallel = Stream.of(streams).anyMatch(BaseStream::isParallel); // T:::isParallel gives IDE warning if (parallel) { concatStream.parallel(); } concatStream.onClose(() -> composedClose(streams)); return concatStream; }