/** * Accumulates the elements of stream into a new Set. * @param stream the {@code java.util.stream.BaseStream} * @param <T> the type of element * @return a new {@code java.util.Set} instance */ public static <T> Set<T> toSet(BaseStream<T, ? extends BaseStream> stream) { return StreamSupport.stream( Spliterators.spliteratorUnknownSize(stream.iterator(), Spliterator.ORDERED), false).collect(Collectors.<T>toSet()); }
@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 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]; }
public static void main(String[] args) { Set<Integer> l = new TreeSet<>(); l.add(1); l.add(10); l.add(3); l.add(-3); l.add(-4); System.out.println("Serial Stream"); l.stream().map(s->s+" ").forEach(System.out::print); System.out.println(); l.stream().unordered().map(s->s+" ").forEach(System.out::print); System.out.println("\n"); System.out.println("Unordered Operations on a Parallel Stream"); l.stream().parallel().map(s->s+" ").forEach(System.out::print); System.out.println(); l.stream().unordered().map(s->s+" ").parallel().forEach(System.out::print); System.out.println("\n"); System.out.println("Ordered Operations on a Parallel Stream"); l.stream().parallel().skip(2).limit(2).findFirst().ifPresent(System.out::print); System.out.println(); l.stream().unordered().parallel().skip(2).limit(2).findFirst().ifPresent(System.out::print); System.out.println("\n"); }
List<String> f = asList("Banana", "Apple", "Grape"); AtomicInteger number = new AtomicInteger(0); String result = f.stream() .sorted() .sequential() .map(i -> String.format("%d. %s", number.incrementAndGet(), i)) .collect(Collectors.joining("\n"));
int[] numbers = {25, 20, 50}; String[] cities = {"New York", "New Jersey", "Detroit", "Atlanta", "Chicago", "Los Angeles"}; Map<Object, Object> map = new TreeMap<>(Comparator.comparing(Integer.class::cast, Integer::compare).reversed()); for (Iterator<?> n = Arrays.stream(numbers).iterator(), s = Arrays.stream(String.join(",", cities).split(",(?=(([^,]*,){2})*[^,]*,[^,]*$)")).iterator(); n.hasNext() && s.hasNext(); ) map.put(n.next(), s.next()); numbers = map.keySet().stream().map(String::valueOf).mapToInt(Integer::parseInt).toArray(); cities = map.values().stream().map(String::valueOf).map(s -> s.split(",")).flatMap(Arrays::stream).toArray(String[]::new);
package testing; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; import java.util.stream.Stream; public class StreamTest { /** * @param args the command line arguments * @throws java.io.IOException */ public static void main(String[] args) throws IOException { URL url = new URL("http://www.google.com"); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setUseCaches(false); if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) { BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream())); Stream<String> s = br.lines(); s.parallel().forEach(System.out::println); } } }
stream.parallel().forEach(new Consumer<Integer>() { stream.parallel().forEachOrdered(new Consumer<Integer>() {
/** * <pre> * {@code * assertThat(Streams.flatMapStream(Stream.of(1,2,3), * i->Stream.of(i)).collect(CyclopsCollectors.toList()), * equalTo(Arrays.asList(1,2,3))); * * } * </pre> * */ public final static <T, R> Stream<R> flatMapStream(final Stream<T> stream, final Function<? super T, ? extends BaseStream<? extends R, ?>> fn) { return stream.flatMap(fn.andThen(bs -> { if (bs instanceof Stream) return (Stream<R>) bs; else return Streams.stream(bs.iterator()); })); }
int equal = 0; for(int i=0; i<100; i++) { // create test input map like {0 -> 0, 1 -> 1, 2 -> 2, ...} Map<Integer, Integer> input = IntStream.range(0, 200).boxed() .collect(Collectors.toMap(x -> x, x -> x)); Map<Integer, Integer> result = new HashMap<>(); // write it into another HashMap in parallel way without key collisions input.entrySet().parallelStream().unordered() .forEach(entry -> result.put(entry.getKey(), entry.getValue())); if(result.equals(input)) equal++; } System.out.println(equal);