java8 stream基本操作集锦
stream java8
//对的
String[] arrl = stack.stream().toArray(String[]::new);
//有问题
arrl = Stream.of(stack).toArray(String[]::new);
String合并、剔除重复、排序
String a = "xyaabbbccccdefww";
String b = "xxxxyyyyabklmopq";
System.out.println(Stream.of(a.concat(b).split(""))
.sorted()
.distinct()
.collect(Collectors.joining())
Stream 装箱流 （Boxed Stream）
将对象流转换为集合：
//It works perfect !!
List
.collect(Collectors.toList());
然而，上述过程对于基本类型流元素却不生效。
//Compilation Error !!
IntStream.of(1,2,3,4,5)
.collect(Collectors.toList());
构建流管道
Collection.stream() 使用一个集合的元素创建一个流。
Stream.of(T...) 使用传递给工厂方法的参数创建一个流。
Stream.of(T[]) 使用一个数组的元素创建一个流。
Stream.empty() 创建一个空流。
Stream.iterate(T first, BinaryOperator
Stream.iterate(T first, Predicate
Stream.generate(Supplier
IntStream.range(lower, upper) 创建一个由下限到上限（不含）之间的元素组成的 IntStream。
IntStream.rangeClosed(lower, upper) 创建一个由下限到上限（含）之间的元素组成的 IntStream。
BufferedReader.lines() 创建一个有来自 BufferedReader 的行组成的流。
BitSet.stream() 创建一个由 BitSet 中的设置位的索引组成的 IntStream。
Stream.chars() 创建一个与 String 中的字符对应的 IntStream。
中间流操作
filter(Predicate
map(Function<T, U>) 将提供的函数应用于流的元素的结果
flatMap(Function<T, Stream> 将提供的流处理函数应用于流元素后获得的流元素
distinct() 已删除了重复的流元素
sorted() 按自然顺序排序的流元素
Sorted(Comparator
limit(long) 截断至所提供长度的流元素
skip(long) 丢弃了前 N 个元素的流元素
takeWhile(Predicate
dropWhile(Predicate
终止流操作
forEach(Consumer
toArray() 使用流的元素创建一个数组。
reduce(...) 将流的元素聚合为一个汇总值。
collect(...) 将流的元素聚合到一个汇总结果容器中。
min(Comparator
max(Comparator
count() 返回流的大小。
{any,all,none}Match(Predicate
findFirst() 返回流的第一个元素（如果有）。
findAny() 返回流的任何元素（如果有）。
stream构造
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
class Rock{
Rock(int i){
System.out.println(i);
}
}
public class HelloDate {
public static void main(String[] args) {
//stream 操作：构建
//1. 单独的值
Stream stream = Stream.of("a","b","c");
//2. 数组
String[] strings = new String[]{"a","b","c"};
stream = Stream.of(strings);
stream = Arrays.stream(strings);
//3. collections
List
stream = list.stream();
}
}
数值流的构造
IntStream.of(new int[]{1,2,3}).forEach(i-> System.out.println(i));
System.out.println(">>next");
IntStream.range(1,3).forEach(i-> System.out.println(i));
System.out.println(">>next");
IntStream.rangeClosed(1,3).forEach(i-> System.out.println(i));
映射
List
List
System.out.println(squareNums);
输出为[1, 4, 9, 16]
map 生成的是个 1:1映射，每个输入元素，都按照规则转换成为另外一个元素。还有一些场景，是一对多映射关系的，这时需要 flatMap。
过滤
Integer[] sixNums = {1,2,3,4,5,6};
Integer[] evens = Stream.of(sixNums).filter(n->n%2==0).toArray(Integer[]::new);
System.out.println(Arrays.asList(evens));
输出为[2,4,6]
例子 打印姓名（forEach 和 pre-java8 的对比）
// Java 8
roster.stream().filter(p -> p.getGender() == Person.Sex.MALE).forEach(p -> System.out.println(p.getName()));
// Pre-Java 8
for (Person p : roster) {
if (p.getGender() == Person.Sex.MALE) {
System.out.println(p.getName());
}
}
peek 例子 对每个元素执行操作并返回一个新的 Stream
System.out.println(Stream.of("one","two","three","four","five")
.filter(p->p.length()>3)
.peek(e-> System.out.println("Filtered value "+e))
.map(String::toUpperCase)
.peek(e-> System.out.println("Mapped value "+e))
.collect(Collectors.toList()));
parallelStream
parallelStream其实就是一个并行执行的流.它通过默认的ForkJoinPool,可能提高你的多线程任务的速度.
Stream具有平行处理能力，处理的过程会分而治之，也就是将一个大任务切分成多个小任务，这表示每个任务都是一个操作，因此像以下的程式片段：
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
numbers.parallelStream()
.forEach(out::println);
你得到的展示顺序不一定会是1、2、3、4、5、6、7、8、9，而可能是任意的顺序，就forEach()这个操作來讲，如果平行处理时，希望最后顺序是按照原来Stream的数据顺序，那可以调用forEachOrdered()。例如：
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
numbers.parallelStream()
.forEachOrdered(out::println);
注意:如果forEachOrdered()中间有其他如filter()的中介操作，会试着平行化处理，然后最终forEachOrdered()会以原数据顺序处理，因此，使用forEachOrdered()这类的有序处理,可能会（或完全失去）失去平行化的一些优势，实际上中介操作亦有可能如此，例如sorted()方法。
reduce
这个方法的主要作用是把 Stream 元素组合起来。 它提供一个 起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。 从这个意义上说，字符串拼接、数值的sum、min、max、average 都是特殊的 reduce。例如 Stream 的 sum 就相当于
Integer sum = integers.reduce(0, (a, b) -> a+b);
或
Integer sum = integers.reduce(0, Integer::sum);
最小值、拼接、求和
Integer sum = Stream.of(sixNums).reduce(0,(a,b)->a+b);
String concat = Stream.of("A","B","c","D").reduce("",String::concat);
double minValue = Stream.of(1.0,2.1,-0.3).reduce(Double.MAX_VALUE,Double::min);
concat = Stream.of("A","B","c","D").filter(x->x.toLowerCase().compareTo("c")>0).reduce("",String::concat);
limit/skip
limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来）。
部分测试代码
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class HelloDate {
public static void main(String[] args) {
//stream 操作：构建
//1. 单独的值
Stream
//转为数组
String[] strArray1 = stream.toArray(String[]::new);
stream = Stream.of("a","b", "c");
List
System.out.println(list1);
List
List
System.out.println(squareNums);
Integer[] sixNums = {1,2,3,4,5,6};
Integer[] evens = Stream.of(sixNums).filter(n->n%2==0).toArray(Integer[]::new);
System.out.println(Arrays.asList(evens));
System.out.println(Stream.of("one","two","three","four","five").filter(p->p.length()>3).peek(
e-> System.out.println("Filtered value "+e)
).map(String::toUpperCase).peek(e-> System.out.println("Mapped value "+e)).collect(Collectors.toList()));
Integer sum = Stream.of(sixNums).reduce(0,(a,b)->a+b);
System.out.println(sum);
String concat = Stream.of("A","B","c","D").reduce("",String::concat);
double minValue = Stream.of(1.0,2.1,-0.3).reduce(Double.MAX_VALUE,Double::min);
concat = Stream.of("A","B","c","D").filter(x->x.toLowerCase().compareTo("c")>0).reduce("",String::concat);
System.out.println(concat);
}
}
如化平方数
import java.util.stream.Collectors;
public class SquareDigit {
public int squareDigits(int n) {
return Integer.parseInt(String.valueOf(n)
.chars()
.map(i -> Integer.parseInt(String.valueOf((char) i)))
.map(i -> i * i)
.mapToObj(String::valueOf)
.collect(Collectors.joining("")));
}
}
部分测试代码
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class HelloDate {
public static int[] HelloDate(int[] arr) {
int[] newArr = IntStream.of(arr).map(x->x*2).toArray();
return newArr;
}
public static void main(String[] args) {
int a = 1246;
String b = "woc";
String c = "123";
System.out.println(String.valueOf(a).chars().map(i->Integer.parseInt(String.valueOf((char)i)))
.map(i->i*i)
.mapToObj(String::valueOf)
.collect(Collectors.joining(""))
);
String d = "1";
System.out.println(Integer.parseInt(String.valueOf(d)));
System.out.println("直接输出char");
String.valueOf(a)
.chars()
.forEach(i-> System.out.println(i));
System.out.println("转化为int之后再输出");
int res = Integer.parseInt(String.valueOf(a)
.chars()
.map(i->Integer.parseInt(String.valueOf((char)i)))
.mapToObj(String::valueOf)
.collect(Collectors.joining(""))
);
char i = '1';
System.out.println(Integer.parseInt(String.valueOf(i)));
System.out.println(res);
int n = 120;
if(n<0) System.out.println("false");
int n_sqrt = (int)Math.round(Math.sqrt(n));
System.out.println(n_sqrt*n_sqrt==n);
String pin = "a123";
String pin2 = "a1 23 dfas";
int[] aaa = new int[]{1,5,2,6,7,3,6};
//Integer[] aaa2 = IntStream.of(aaa).filter(nn->nn%2!=0).toArray();
//System.out.println(list);
System.out.println(IntStream.of(aaa)
.map(li->li*li)
.sum()
);
System.out.println(new StringBuilder(pin).reverse().toString());
String[] l = String.valueOf(pin2).split(" ");
System.out.println();
String afterJoining = Stream.of(l)
.map(i2->new StringBuilder(i2).reverse().toString())
.collect(Collectors.joining(" "))
;
System.out.println(afterJoining);
String[] afterSplit = String.valueOf("123").split(" ");
Stream.of(afterSplit)
.map(iiii->new StringBuilder(iiii).reverse().toString())
.collect(Collectors.joining(" "));
String[] L = new String[]{"ABART 20", "CDXEF 50", "BKWRK 25", "BTSQZ 89", "DRTYM 60"};
String[] M = new String[]{"A", "B", "C", "W"};
int[] mSum = new int[M.length];
for(String ii:L){
StringBuilder stringBuilder = new StringBuilder(ii);
for (int i)
}
}
}
浙公网安备 33010602011771号