stream判断数组长度⼤于0_Stream流处理介绍以及Stream的
基本操作
Stream介绍
Stream（流）是⼀个来⾃数据源的元素队列，元素是特定类型的对象，形成⼀个队列。 Java中的Stream并不会存储元素，⽽是按需计Stream（流）
算。数据源：流的来源，可以是集合，数组 等。
和以前的Collection操作不同， Stream操作还有两个基础的特征：
Pipelining: 中间操作都会返回流对象本⾝。 这样多个操作可以串联成⼀个管道， 如同流式风格（fluentstyle）。 这样做可以对操作进⾏Pipelining
优化， ⽐如延迟执⾏(laziness)和短路( short-circuiting)。
内部迭代： 以前对集合遍历都是通过Iterator或者增强for的⽅式, 显式的在集合外部进⾏迭代， 这叫做外部迭代。 Stream提供了内部迭内部迭代
代的⽅式，流可以直接调⽤遍历⽅法。
这张图中展⽰了过滤、映射、跳过、计数等多步操作，这是⼀种集合元素的处理⽅案，⽽⽅案就是⼀种“函数模型”。图中的每⼀个⽅框都是⼀个“流”，调⽤指定的⽅法，可以从⼀个流模型转换为另⼀个流模型。⽽最右侧的数字3是最终结果。这⾥的 filter 、 map 、 skip 都是在对函数模型进⾏操作，集合元素并没有真正被处理。只有当终结⽅法 count执⾏的时候，整个模型才会按照指定策略执⾏操作。⽽这得益于Lambda的延迟执⾏特性。
备注
备注：“Stream流”其实是⼀个集合元素的函数模型，它并不是集合，也不是数据结构，其本⾝并不存储任何元素（或其地址值）。
当使⽤⼀个流的时候，通常包括三个基本步骤：
获取⼀个数据源（source）→ 数据转换→执⾏操作获取想要的结果，每次转换原有 Stream 对象不改变，返回⼀个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条⼀样排列，变成⼀个管道。
Stream操作filter过滤对象数组
1、获取流：
java.util.stream.Stream<T> 是Java 8新加⼊的最常⽤的流接⼝。（这并不是⼀个函数式接⼝。）获取⼀个流⾮常简单，有以下⼏种常⽤的⽅式：所有的 Collection 集合都可以通过 stream 默认⽅法获取流；Stream 接⼝的静态⽅法 of 可以获取数组对应的流。
1.1、根据Collection获取流
java.util.Collection 接⼝中加⼊了default⽅法 stream ⽤来获取流，所以其所有实现类均可获取流。java.util.Collection 接⼝中加⼊了default⽅法 stream ⽤来获取流，所以其所有实现类均可获取流。
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
1.2、根据Map获取流
java.util.Map 接⼝不是 Collection 的⼦接⼝，且其K-V数据结构不符合流元素的单⼀特征，所以获取对应的流需要分key、value或entry 等情况：
Stream<String> keyStream = map.keySet().stream();
Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String, String>> entryStream = Set().stream();
1.3、据数组获取流
如果使⽤的不是集合或映射⽽是数组，由于数组对象不可能添加默认⽅法，所以 Stream 接⼝中提供了静态⽅法of 。
String[] array = { "张⽆忌", "张翠⼭", "张三丰", "张⼀元" };
Stream<String> stream = Stream.of(array);
2、Stream中的常⽤⽅法
2.1、forEach：逐⼀处理
void forEach(Consumer<? super T> action);
该⽅法接收⼀个 Consumer 接⼝函数，会将每⼀个流元素交给该函数进⾏处理。
private static void forEachDemo(){
String[] array = { "张⽆忌", "张翠⼭", "张三丰", "张⼀元" };
Stream<String> stream = Stream.of(array);
stream.forEach(s -> System.out.println(s));
}
输出：
forEach ==================
张⽆忌
张翠⼭
张三丰
张⼀元
2.2、filter：过滤
Stream<T> filter(Predicate<? super T> predicate);
该接⼝接收⼀个 Predicate 函数式接⼝参数（可以是⼀个Lambda或⽅法引⽤）作为筛选条件。
private static void filterDemo(){
String[] array = { "张⽆忌", "张三丰", "周芷若" };
Stream<String> stream = Stream.of(array);
Stream<String> result = stream.filter(s -> s.startsWith("张"));
result.forEach(s -> System.out.println(s));
}
输出：
filter ==================
张⽆忌
张三丰
2.3、map： 映射
如果需要将流中的元素映射到另⼀个流中，可以使⽤ map ⽅法。
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
该接⼝需要⼀个 Function 函数式接⼝参数，可以将当前流中的T类型数据转换为另⼀种R类型的流。
private static void mapDemo(){
String[] array = {"10", "12", "18"};
Stream<String> stringStream = Stream.of(array);
Stream<Integer> integerStream = stringStream.map(s -> Integer.parseInt(s));
integerStream.forEach(integer -> System.out.println(integer));
}
输出：
map ==================
10
12
18
2.4、count：统计流中的元素个数
正如旧集合 Collection 当中的 size ⽅法⼀样，流提供 count ⽅法来数⼀数其中的元素个数：
long count();
该⽅法返回⼀个long值代表元素个数（不再像旧集合那样是int值）。
private static void countDemo(){
String[] array = { "张⽆忌", "张翠⼭", "张三丰", "张⼀元" };
Stream<String> stream = Stream.of(array);
long num = unt();
System.out.println(num);
}
输出：
count ==================
4
2.5、limit：取⽤前⼏个
limit ⽅法可以对流进⾏截取，只取⽤前n个。
Stream<T> limit(long maxSize);
参数是⼀个long型，如果集合当前长度⼤于参数则进⾏截取；否则不进⾏操作。
private static void limitDemo(){
String[] array = { "张⽆忌", "张翠⼭", "张三丰", "张⼀元" };
Stream<String> stream = Stream.of(array);
Stream<String> newStream = stream.limit(3);
newStream.forEach(s -> System.out.println(s));
}
输出：
limit ==================
张⽆忌
张翠⼭
张三丰
2.6、skip：跳过前⼏个
如果希望跳过前⼏个元素，可以使⽤ skip ⽅法获取⼀个截取之后的新流：
Stream<T> skip(long n);
如果流的当前长度⼤于n，则跳过前n个；否则将会得到⼀个长度为0的空流。
n必须⼤于等于0，如果⼤于当前流中的元素个数，则产⽣⼀个空流。
private static void skipDemo(){
String[] array = { "张⽆忌", "张翠⼭", "张三丰", "张⼀元" };
Stream<String> stream = Stream.of(array);
Stream<String> newStream = stream.skip(2);
newStream.forEach(s -> System.out.println(s));
}
输出：
skip ==================
张三丰
张⼀元
2.7、concat：组合
如果有两个流，希望合并成为⼀个流，那么可以使⽤ Stream 接⼝的静态⽅法 concat ：static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
例⼦：
private static void concatDemo(){
Stream<String> stream1 = Stream.of("张三");
Stream<String> stream2 = Stream.of("李四");
Stream<String> stream = at(stream1,stream2); stream.forEach(s -> System.out.println(s));
}
输出：
concat ==================
张三
李四
2.8、sorted：排序
Stream<T> sorted()
sorted ⽅法⽤于对流进⾏排序。
private static void sortedDemo(){
String[] array = { "张⽆忌", "张翠⼭", "张三丰", "张⼀元" };
Stream<String> stream = Stream.of(array);
stream.limit(3).sorted().forEach(System.out::println);
}
输出：
sorted ==================
张三丰
张⽆忌
张翠⼭
2.9、元素收集
1）收集到List集合：
流对象.collect( List() )
获得List集合。
2）收集到Set集合：
流对象.collect( Set() )
获得Set集合。
3）收集到数组：
流对象. toArray()
由于泛型擦除的原因，返回值类型是Object[]
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论