Java8 新特性之Stream----java.util.stream

int sum = widgets.stream()
.filter(b -> b.getColor() == RED)
.mapToInt(b -> b.getWeight())
.sum();

Stream.of(Object[]),IntStream.range(int, int) or Stream.iterate(Object, UnaryOperator);

static Stream<Path>     list(Path dir)
static Stream<Path>     walk(Path start, FileVisitOption... options)

java.util.stream包中的接口和类

BaseStream<T,S extends BaseStream<T,S>>

Collector<T,A,R>

Stream<T> -

Stream.Builder<T>

int sumOfWeights = widgets.parallelStream()
.filter(b -> b.getColor() == RED)
.mapToInt(b -> b.getWeight())
.sum();

int[] wordLength = new int[12];

Stream.of("It", "is", "your", "responsibility").parallel().forEach(s -> {
if (s.length() < 12) wordLength[s.length()]++;
});

List<String> l = new ArrayList(Arrays.asList("one", "two"));
Stream<String> sl = l.stream();
l.add("three");
String s = sl.collect(joining(" "));

List<Integer> datalist=new ArrayList<>(1000);
List<Integer> datalist_collect=new ArrayList<>();
//无状态的并行操作，即元素的操作和其他元素状态无关，线程安全
long sum = IntStream.range(0,1000).parallel().filter(s->s%2==0).count();
System.out.println("并行:"+sum);
//datalist为非线程安全的，因此属于有状态并行操作，非线程安全     IntStream.range(0,1000).parallel().forEach(data->datalist.add(data));
System.out.println("并行foreach:"+datalist.size());

//collect操作线程安全
datalist_collect=IntStream.range(0,1000).parallel().collect(ArrayList::new, (c,e)->c.add(e), (c1,c2)->c1.addAll(c2));
System.out.println("并行collect:"+datalist_collect.size());

long sum2 = IntStream.range(0,1000).filter(s->s%2==0).count();
System.out.println("串行:"+sum2);

List<Integer> intlist=IntStream.range(0,10).collect(ArrayList::new, (c,e)->c.add(e), (c1,c2)->c1.addAll(c2));
System.out.println("并行数据开始：");
//并行操作时无顺序    intlist.parallelStream().map(e->e+1).forEach(System.out::println);

System.out.println("串行数据开始：");
//串行操作保证顺序
intlist.stream().forEach(System.out::println);
System.out.println("串行数据结束：");

运行结果如下-----：

并行:500
并行foreach:980
并行collect:1000
串行:500
并行数据开始：
7
8
10
6
5
4
1
9
3
2
串行数据开始：
0
1
2
3
4
5
6
7
8
9
串行数据结束

int sum = 0;
for (int x : numbers) {
sum += x;
}

int sum = numbers.parallelStream().reduce(0, Integer::sum);

T reduce(T identity,
BinaryOperator<T> accumulator)

T result = identity;
for (T element : this stream)
result = accumulator.apply(result, element)
return result;

Optional<T> reduce(BinaryOperator<T> accumulator)

boolean foundAny = false;
T result = null;
for (T element : this stream) {
if (!foundAny) {
foundAny = true;
result = element;
}
else
result = accumulator.apply(result, element);
}
return foundAny ? Optional.of(result) : Optional.empty();

<U> U reduce(U identity,
BiFunction<U,? super T,U> accumulator,
BinaryOperator<U> combiner)

U result = identity;
for (T element : this stream)
result = accumulator.apply(result, element)
return result;

<R> R collect(Supplier<R> supplier,
BiConsumer<R,? super T> accumulator,
BiConsumer<R,R> combiner)

R result = supplier.get();
for (T element : this stream)
accumulator.accept(result, element);
return result;

T reduce(T identity,
BinaryOperator<T> accumulator)

<R,A> R collect(Collector<? super T,A,R> collector)

Collector<? super T,A,R> collector

String concatenated = strings.reduce("", String::concat)

String[] testStrings={"a","b","c","d","e"};
String testStringBuilder=Stream.of(testStrings).parallel().collect(StringBuilder::new, StringBuilder::append,StringBuilder::append).toString();

String[] testStrings={"a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e","a","b","c","d","e"};

StringBuilder sumbuilder=new StringBuilder();
for(int i=0;i<testStrings.length;i++)
sumbuilder.append(testStrings[i]);

String  sumString="";
for(int i=0;i<testStrings.length;i++)
sumString+=testStrings[i];

String testStringBuilder=Stream.of(testStrings).collect(StringBuilder::new, StringBuilder::append,StringBuilder::append).toString();

String concatenated = Stream.of(testStrings).reduce("", String::concat);

ArrayList<String> strings = stream.collect(() -> new ArrayList<>(),(c, e) -> c.add(e.toString()), (c1, c2) -> c1.addAll(c2));

ist<String> strings = stream.map(Object::toString)
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

List<String> strings = stream.map(Object::toString)
.collect(Collectors.toList());

Collector<Employee, ?, Integer> summingSalaries
= Collectors.summingInt(Employee::getSalary);
Map<Department, Integer> salariesByDept
= employees.stream().collect(Collectors.groupingBy(Employee::getDepartment,
summingSalaries));

A a1 = supplier.get();
accumulator.accept(a1, t1);
accumulator.accept(a1, t2);
R r1 = finisher.apply(a1);  // result without splitting

A a2 = supplier.get();
accumulator.accept(a2, t1);
A a3 = supplier.get();
accumulator.accept(a3, t2);
R r2 = finisher.apply(combiner.apply(a2, a3));  // result with splitting

Function<T,R>