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