目录
public static Optional of(T value) :
public static Optional ofNullable(T value) :
需要笔记的可以关注私聊,我发给你
Lambda
- Lambda表达式只能针对接口（使用匿名内部类时）
- 接口必须是：函数式接口
1、在一个接口中，只有一个抽象方法需要重写的接口，称为：函数式接口
2、函数式接口中，允许存在：静态方法、私有方法、默认方法
Java语言，为了区分函数式接口和普通接口，在函数式接口中添加一个注解：
@FunctionalInterface
public interface Swimming{
//只有一个抽象方法
public abstract void swim();
}格式
(形参) -> {
//方法体功能.....
}
( ):参数列表
{ }:方法体
->没有特殊含义,仅是连接
当方法体中的代码仅有一行时，可以省略return、大括号、分号
排序
Collections.sort(list,(Integer o1,Integer o2) ->{
return o2-o1;
}) //降序Stream流
获取流:
创建一条流水线,并把数据放到流水线上准备进行操作
.stream( )
单列集合
可以使用Collection接口中的默认方法stream()生成流
default Stream<E> stream()
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "关羽", "张飞", "赵云", "马超", "黄忠");
// forEach( s -> System.out.println(s)) : 遍历stream流中的数据
list.stream().forEach(s -> System.out.println(s));
双列集合
双列集合不能直接获取 , 需要间接的生成流
可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
HashMap<String, String> hs = new HashMap<>();
hs.put("刘备", "尚香");
hs.put("孙策", "大乔");
hs.put("周瑜", "小乔");
// 把双列集合转成单列集合 , 在生成流
Set<String> set1 = hs.keySet();// {刘备 , 孙策 , 周瑜}
set1.stream().forEach(s -> System.out.println(s + "--" + hs.get(s)));
数组
Arrays中的静态方法stream生成流
Integer[] arr = {33, 22, 11, 55, 44};
Arrays.stream(arr).forEach(s -> System.out.println(s));
把同一种数据类型多个数据放到stream
Stream类中的of方法 , 把多个数据放在stream流上
Stream.of(11,22,33,55,44,77,66).forEach(s -> System.out.println(s));操作流(中间方法):
流水线上的操作:一次操作完之后,还可以继续进行其他操作
1 Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值
filter方法会拿到stream流中的每一个元素 , 并把每一个元素传递给lambda表达式的形参s
如果lambda表达式返回true : 表示此元素留下来
如果lambda表达式返回false : 表示此元素过滤掉(从流中去除)
list.stream().filter((String s) -> {
return s.length() == 2;
}).forEach(s -> System.out.println(s));
2 Stream<T> limit(long maxSize)：截取指定参数个数的数据
list.stream().limit(3).forEach(s -> System.out.println(s));
3 Stream<T> skip(long n)：跳过指定参数个数的数据
list.stream().skip(3).forEach(s -> System.out.println(s));
4 static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
Stream<String> stream1 = list.stream();
Stream<String> stream2 = list.stream();
Stream.concat(stream1 , stream2).forEach(s -> System.out.println(s));
5 <R> Stream<R> map(Function<T , R> mapper) : 将流中的元素类型进行转换
泛型T : 表示的流中的元素类型 泛型R : 表示的是把流中的元素转成的目标类型
list.stream().map( (String s) -> { return new Student(s); } ).forEach( (Student s) -> { System.out.println(s);} );
6 Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
list.stream().distinct().forEach(s -> System.out.println(s));
7 Stream<T> sorted () : 将流中元素按照自然排序的规则排序
list2.stream().sorted().forEach(s -> System.out.println(s));
8 Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
list2.stream().sorted( (Integer o1 , Integer o2) -> { return o2 - o1; } ).forEach(s -> System.out.println(s));终结流:
一个Stream流只能有一个终结方法是流水线上的最后一个操作
void forEach(Consumer action)：对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
list.stream().forEach((String s) -> {
System.out.println(s);
});long count()：返回此流中的元素个数
long count = list.stream().count();
System.out.println("count = " + count);收集流的操作
第一部分
需求：过滤元素并遍历集合
定义一个集合，并添加一些整数 1,2,3,4,5,6,7,8,9,10
将集合中的奇数删除，只保留偶数。
遍历集合得到 2，4，6，8，10 结论：在Stream流中无法直接修改集合,数组等数据源中的数据。
public class StreamDemo5 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
// 批量添加数据
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// 将集合中的奇数删除，只保留偶数。
list.stream().filter( (Integer i) -> {return i % 2 == 0;} ).forEach(
s -> System.out.println(s)
);
System.out.println("集合中的元素:" + list);
}
}
第二部分
使用Stream流的方式操作完毕之后，我想把流中的数据起来，该怎么办呢？
Stream流的收集方法
R collect(Collector collector) : 此方法只负责收集流中的数据 , 创建集合添加数据动作需要依赖于参数 工具类Collectors提供了具体的收集方式
public static <T> Collector toList()：把元素收集到List集合中
public static <T> Collector toSet()：把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中
Set
需求 :
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
将集合中的奇数删除，只保留偶数。
遍历集合得到2，4，6，8，10
public class StreamDemo6 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
// 批量添加数据
Collections.addAll(list, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 8, 8, 9, 10);
Set<Integer> set = list.stream().filter((Integer i) -> {
return i % 2 == 0;
}).collect(Collectors.toSet());
System.out.println("set = " + set);
}
List
收集方法叫做collect , 但是此方法只负责收集元素 => 2 4 6 8 10 , 并把添加完元素的List集合返回
Collectors.toList() : 在底层会创建一个新的List集合 , 并把collect方法收集到的元素2 4 6 8 10存储到List集合中
List<Integer> newList = list.stream().filter((Integer i) -> {
return i % 2 == 0;
}).collect(Collectors.toList());
System.out.println("newList = " + newList);
}
第三部分
1 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
"zhangsan,23"
"lisi,24"
"wangwu,25"
2 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
需求1 : 保留年龄大于等于24岁的人
需求2 : 并将结果收集到Map集合中，姓名为键，年龄为值
收集方法 :
public static Collector toMap(Function keyMapper , Function valueMapper)：把元素收集到Map集合中
public static void main(String[] args) {
// 创建一个集合
ArrayList<String> list = new ArrayList<>();// {"zhangsan,23", "lisi,24", "wangwu,25"}
Collections.addAll(list, "zhangsan,23", "lisi,24", "wangwu,25");
Map<String, Integer> map = list.stream().filter((String s) -> {
// 需求1 : 保留年龄大于等于24岁的人
String[] strings = s.split(",");
// 把字符串"23" 转换成 整数 23
int age = Integer.parseInt(strings[1]);
return age >= 24;
}).collect(Collectors.toMap(
/*
流中的数据 : "lisi,24" , "wangwu,25"
lambda中的形参s , 表示的就是流中的每一个数据
举例 : s = "wangwu,25"
*/
(String s) -> {
String[] strings = s.split(",");// {"lisi" , "24"}
return strings[0];
} // 需要设定map集合中的键
,
(String s) -> {
String[] strings = s.split(",");// {"lisi" , "24"}
return Integer.parseInt(strings[1]);
}
));
// 打印map集合
System.out.println(map);
}
}Optional
优势 :
Optional 类的引入很好的解决空指针异常 , 同样Optional类可以对空值判断形成一种规范
boolean present = Optional.ofNullable(stu).isPresent();
if(present){
System.out.println("有效对象");
}
public static <T> Optional<T> of(T value) :
通过非null值构建一个Optional容器,注意value不能不为null否则抛出异常
String s = "abc";
Optional<String> optional = Optional.of(s);
System.out.println(optional);返回结果:Optional[abc]
(null)空的话报错
public static <T> Optional<T> ofNullable(T value) :
通过指定值构建一个Optional容器,如果值为null则返回Optional.empty
String s ="abc";
Optional<String> optional = Optional.ofNullable(s);
System.out.println(optional);
返回结果:Optional[abc]
(null)空的话:Optional.empty
public T orElse(T other) :
返回值如果存在，否则返回 other 。
String s = "abc";
Optional<String> optional = Optional.ofNullable(s);
String result = optional.orElse("qwe");
System.out.println("result = " + result);
返回结果:Optional[abc]
(null)空的话:返回qwe
public boolean isPresent() :
如果对象为null返回的是false , 如果对象不为null返回的是true !!!
boolean result = optional.isPresent();
System.out.println(result);
不为空返回结果true
(null)空的话:返回false
public T get() :
如果 Optional中存在值，则返回值，否则抛出 NoSuchElementException
if (optional.isPresent()) {
String s1 = optional.get();
System.out.println(s1);
}
Optional中存在值，则返回值，否则抛出 NoSuchElementException
775
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
