创建 Stream方式二：通过数组Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
public default Stream
stream() : 返回一个顺序流 public default Stream
parallelStream() : 返回一个并行流
Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
public static
Stream stream(T[] array): 返回一个流
创建 Stream方式三：通过Stream的of()重载形式，能够处理对应基本类型的数组：
public static IntStream stream(int[] array)：返回一个整型数据流
public static LongStream stream(long[] array)：返回一个长整型数据流
public static DoubleStream stream(double[] array)：返回一个浮点型数据流
创建 Stream方式四：创建无限流可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。
public static
Stream of(T... values) : 返回一个顺序流
流的中间操作
public static
Stream iterate(final T seed, final UnaryOperator f):返回一个无限流 public static
Stream generate(Supplier s) ：返回一个无限流
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
public class MiddleTest {
@Test
public void test05(){
String [] strArr = {"hello","hello","kitty","Bob"};
Arrays.stream(strArr)
.flatMap(new Function>() {
@Override
public Stream apply(String s) {
System.out.print(s + " ");
System.out.println("---------------");
return Stream.of(s.split("")).distinct();
}
}).forEach(System.out::println);
}
@Test
public void test04(){
Stream.of("hello","world")
.map(String::toUpperCase)
.forEach(System.out::println);
}
@Test
public void test03(){
Stream.of(7,6,1,2,3,4,5,1,2,3,7,8,9)
.distinct()//去重
.sorted() //默认从小到大排序
// .sorted((Integer::compare)
.sorted(Comparator.reverseOrder())//倒叙
.limit(3)//限制长度
.skip(2)//跳过指定数量
.forEach(System.out::println);
}
@Test
public void test02(){
ArrayList list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Stream integerStream = list.stream().filter((e) -> e % 2 == 0);
System.out.println("list = " + list);
}
@Test
public void test01(){
//1:创建流
Stream stream = Stream.of(1,2,3,4,5,6,7);
//2:中间操作
Stream stream1 = stream.filter(integer -> true);
//3:终止操作
stream1.forEach(System.out::println);
}
流的终结操作
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void。流进行了终止操作后，不能再次使用。
public class EndTest {
@Test
public void test04() {
List list = Stream.of(1, 3, 5, 7, 9, 2, 4)
.filter(k -> k % 2 != 0)
.collect(Collectors.toList());//将奇数保存到数组中
System.out.println("list = " + list);
}
@Test
public void test03() {
Stream.of(1, 3, 5, 6, 9, 2, 4)
.filter(k -> k % 2 == 0)
.forEach(System.out::println);
Optional max = Stream.of(1, 3, 5, 6, 9, 2, 4)
.filter(k -> k % 2 == 0)
.max(new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
// .max(Integer::compareTo);
System.out.println("max = " + max);
}
@Test
public void test02(){
Optional first = Stream.of(1, 3, 7, 9, 2, 4)
.sorted()
.peek(System.out::println)
.findFirst();
System.out.println("first = " + first);
// peek.forEach(System.out::println);
}
@Test
public void test01(){
// System.out.println("b = " + b);
Stream.of(1,3,5,7,9,2,4)
.filter(k -> k % 2 == 0)
.forEach(System.out::println);
}
}
练习
现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以 下若干操作步骤：
第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
第一个队伍筛选之后只要前3个人；存储到一个新集合中。
第二个队伍只要姓张的成员姓名；存储到一个新集合中。
第二个队伍筛选之后不要前2个人；存储到一个新集合中。
将两个队伍合并为一个队伍；存储到一个新集合中。
根据姓名创建 Person 对象；存储到一个新集合中。
打印整个队伍的Person对象信息。
public class Person {
private String name;
public Person(){}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
'}';
}
}
public class PersonTest {
public static void main(String[] args) {
//第一支队伍
ArrayList one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
//第二支队伍
ArrayList two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("赵丽颖");
two.add("张三丰");
two.add("尼古拉斯赵四");
two.add("张天爱");
two.add("张二狗");
//第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
List list1 = one.stream()
.filter(name -> name.length() == 3)
.collect(Collectors.toList());
System.out.println("list1 = " + list1);
//第一个队伍筛选之后只要前3个人；存储到一个新集合中。
List list2 = one.stream()
.limit(3)
.collect(Collectors.toList());
System.out.println("list2 = " + list2);
//第二个队伍只要姓张的成员姓名；存储到一个新集合中。
List list3 = two.stream()
.filter(str -> str.charAt(0) == '张')
.collect(Collectors.toList());
System.out.println("list3 = " + list3);
//第二个队伍筛选之后不要前2个人；存储到一个新集合中。
List list4 = two.stream()
.skip(2)
.collect(Collectors.toList());
System.out.println("list4 = " + list4);
//将两个队伍合并为一个队伍；存储到一个新集合中。
Stream stream1 = one.stream();
Stream stream2 = two.stream();
//Stream concatStream = Stream.concat(stream1, stream2);
//根据姓名创建 Person 对象；存储到一个新集合中。
//终止的流将不能进行二次操作
Stream.concat(stream1, stream2).map(Person::new).forEach(System.out::println);
}
}
