1.什么是流
- java8提供的对集合数据进行处理的一种方式
- 流中的元素是特定类型的对象,形成一个队列。 Java中的Stream并不会存储元素,而是按需计算。
- 数据源流的来源。 可以是集合,数组,I/O channel, 产生器generator 等。
- 聚合操作 类似SQL语句一样的操作, 比如filter, map, reduce, find, match, sorted等
2. 流的特点
- 一个流只能使用一次
- Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道, 如同流式风格(fluent style)。 这样做可以对操作进行优化, 比如延迟执行(laziness)和短路( short-circuiting)。
- 内部迭代: 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代, 这叫做外部迭代。 Stream提供了内部迭代的方式, 通过访问者模式(Visitor)实现。
3.串行流和并行流
-
创建串行流:stream()
-
创建并行流:parallelStream()
4. 串行流和并行流的性能差异
5.流的常用操作
package cyc.java.stream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Java8StreamAPI
{
public static void main(String[] args)
{
/****************** 获取流 ******************/
// list
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
// 数组
String[] arr = {"a", "b", "c"};
String[] array2 = new String[] {};
String[] array3 = new String[6];
// 使用Arrays静态方法stream转换成流
Arrays.stream(arr);
// 值,直接将值转变成流对象
Stream<String> stream = Stream.of("a", "b", "c");
// Map,获取entrySet调用stream方法
Map<Integer, String> map = new HashMap<>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
map.put(4, "d");
map.entrySet().stream();
// 文件
/*
* try(Stream lines =
* Files.lines(Paths.get(“文件路径名”),Charset.defaultCharset())){
* //可对lines做一些操作 }catch(IOException e){ }
*/
/****************** stream方法 ******************/
/**
* @decription 过滤器filter
* @param 一个返回true或者false的lambda表达式
* @return 筛选出返回结果为true的元素
*/
int cout1 = (int)Arrays.stream(arr).filter(a ->
{
return a.equals("c");
}).count();
/**
* @description 去重
* @return 去除重复的元素后的流
*/
Arrays.stream(arr).distinct();
/**
* @decription 截取前n个元素
* @return 流
*/
Arrays.stream(arr).limit(2);
/**
* @decription 跳过前n个元素
*/
Arrays.stream(arr).skip(1l);
/**
* @decription 映射
*/
int cout2 = (int)Arrays.stream(arr).map(a ->
{
List<String> li = new ArrayList<>();
li.add(a);
return li.toArray();
}).flatMap(Arrays::stream).map(ar ->
{
System.out.println(ar);
return ar;
}).count();
System.out.println(cout2);
/**
* @description 是否匹配任意元素
*/
Arrays.stream(arr).anyMatch(a ->
{
return a.equals("b");
});
/**
* @description 是否匹配所有元素
*/
Arrays.stream(arr).allMatch(a ->
{
return a.equals("b");
});
/**
* @description 是否所有元素都不匹配
*/
Arrays.stream(arr).noneMatch(a ->
{
return a.equals("b");
});
/**
* @description 从流中返回任意元素,返回结果放在Optional对象中(实测怎么感觉就是findFirst())
*/
Optional<String> op1 = Arrays.stream(arr).findAny();
/**
* @description 返回第一个元素,返回结果放在Optional对象中
*/
Optional<String> op2 = Arrays.stream(arr).findFirst();
op2.ifPresent((a) ->
{
System.out.println(a);
});
op2.isPresent();
op2.orElse("dd");
/**
* @description reduce 自定义lambda表达式求和 以
* identity为初始值,对流中的所有元素执行lambda表达式求和
*/
String result = Arrays.stream(arr).reduce("begin:", (a, b) ->
{
return a + b;
});
/****************** stream数值流 ******************/
// 将普通流转换成数值流
Arrays.stream(arr).mapToInt(a ->
{
return Integer.valueOf(a);
});
Arrays.stream(arr).mapToDouble(a ->
{
return Double.valueOf(a);
});
Arrays.stream(arr).mapToLong(a ->
{
return Long.valueOf(a);
});
/**
* @description 数值流计算方法 max min sum
*/
/****************** stream收集器 ******************/
// 规约: 求最值、求和、求平均值
/**
* @description:求数量
*/
long num1 = Arrays.stream(arr).count(); // 使用收集器 long num2 =
stream.collect(Collectors.counting());
/**
* @description:求最值,最大值最小值都类似,比较方法有comparingDouble、comparingInt、comparingLong、甚至自定义
*/
Optional<String> res = Arrays.stream(arr).collect(Collectors.maxBy(Comparator.comparingDouble(a ->
{
String a1 = a;
char[] ch = a1.toCharArray();
return Double.valueOf((int)ch[0]);
})));
System.out.println(res.get());
/**
* @description:求和 方法也很多,类似求最值
*/
int sum = Arrays.stream(arr).collect(Collectors.summingInt(a ->
{
String a1 = a;
char[] ch = a1.toCharArray();
return Integer.valueOf((int)ch[0]);
}));
/**
* @description:求平均值,方法也很多,类似求最值
*/
double avg = Arrays.stream(arr).collect(Collectors.averagingInt(a ->
{
String a1 = a;
char[] ch = a1.toCharArray();
return Integer.valueOf((int)ch[0]);
}));
/**
* Collectors.summarizingInt函数能一次性将最值、均值、总和、元素个数全部计算出来,并存储在对象IntSummaryStatisics中。
* 可以通过该对象的getXXX()函数获取这些值。
*/
/****************** stream连接字符串 ******************/
/**
* @description:连接字符串,默认中间无连接符,可以在joining方法中加入连接符 joining("_")
*/
String str = Arrays.stream(arr).collect(Collectors.joining());
/**
* @description:自定义规约操作
* @param:1.初始值
* @param:2.对流中的数据进行处理
* @param:3.对处理后的元素进行自定义规约操作
*/
Arrays.stream(arr).collect(Collectors.reducing("begin:", a ->
{
return a;
}, (a, b) ->
{
return a + b;
}));
/****************** stream分组 ******************/
/**
* @description:将元素按指定规则分组
*/
Map<String, List<String>> res1 = Arrays.stream(arr).collect(Collectors.groupingBy(a ->
{
if ("a".equals(a))
{
return "isA";
}
else if ("b".equals(a))
{
return "isB";
}
else
{
return "isOthers";
}
}));
// 可以在collect方法中添加参数,如再次分组或者统计每个分组的数量
Map<String, Long> res2 = Arrays.stream(arr).collect(Collectors.groupingBy((a) ->
{
if ("a".equals(a))
{
return "isA";
}
else if ("b".equals(a))
{
return "isB";
}
else
{
return "isOthers";
}
}, Collectors.counting()));
System.out.println("s");
}
}