java8新特性
待更新
4、Option
常用于解决空指针异常问题
4-1、创建Optional 对象
- Optional.of（）：不允许传入null，否则抛出异常
- Optional.offNullable()：可传入null
// 参数不能是null
Optional<Integer> optional1 = Optional.of(1);
// 参数可以是null
Optional<Integer> optional2 = Optional.ofNullable(null);
// 参数可以是非null
Optional<Integer> optional3 = Optional.ofNullable(2);
4-2、Optional.empty()
包装 NULL 的Option对象
Optional<Integer> optional1 = Optional.ofNullable(null);
Optional<Integer> optional2 = Optional.ofNullable(null);
System.out.println(optional1 == optional2);// true
System.out.println(optional1 == Optional.<Integer>empty());// true
Object o1 = Optional.<Integer>empty();
Object o2 = Optional.<String>empty();
System.out.println(o1 == o2);// true
4-3、isPresent()
判断值是否存在
Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
// isPresent判断值是否存在
System.out.println(optional1.isPresent() == true);
System.out.println(optional2.isPresent() == false);
4-4、ifPresent(Consumer consumer)
- 如果 Optional 实例值存在则调用consumer，否则不调用
Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
// 如果不是null,调用Consumer
optional1.ifPresent(new Consumer<Integer>() {
@Override
public void accept(Integer t) {
System.out.println("value is " + t);
}
});
// null,不调用Consumer
optional2.ifPresent(new Consumer<Integer>() {
@Override
public void accept(Integer t) {
System.out.println("value is " + t);
}
});
4-5、orElse(value)
- 如果Optional 值不是null,返回原来值，否则返回 orElse(value)中的 value 值
Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
// orElse
System.out.println(optional1.orElse(1000) == 1);// true
System.out.println(optional2.orElse(1000) == 1000);// true
4-6、OrElseGet(Supplier supplier)
- Supplier 表示一个“空参函数”
- 如果Optional为null，则执行
Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
// 传递参数是空参的
System.out.println(optional1.orElseGet(() -> {
return 1000;
}) == 1);//true
System.out.println(optional2.orElseGet(() -> {
return 1000;
}) == 1000);//true
4-7、orElseThrow()
值不存在则抛出异常
Optional<Integer> optional1 = Optional.ofNullable(1);
Optional<Integer> optional2 = Optional.ofNullable(null);
optional1.orElseThrow(()->{throw new IllegalStateException();});
try
{
// 抛出异常
optional2.orElseThrow(()->{throw new IllegalStateException();});
}
catch(IllegalStateException e )
{
e.printStackTrace();
}
4-8、Optional操作Map集合
mapOptional.map(tmp -> {})：此时的 tmp 是最外面的 map 集合
Map<String, String> map = new HashMap<>();
map.put("a", "a11");
map.put("b", "b11");
map.put("c", "c11");
map.put("d", "d11");
Optional<Map<String, String>> mapOptional = Optional.ofNullable(map);
String s = mapOptional.map(tmpMap -> {
System.out.println(tmpMap);
return tmpMap.get("af");
}).orElse("none");
System.out.println(s);
5、stream
- desc：应用在一组元素上一次执行的操作序列
- 分为中间操作或者最终操作两种
- 中间操作：返回Stream本身，所以可以将多个中间操作串联起来
- 最终操作：
- 数据源：List或者Set， Map不支持
- Stream的操作可以串行执行或者并行执行。
5-1、Filter
- 用于过滤不满足哦条件的元素
List<String> list = new ArrayList<>();
list.add("ddd2");
list.add("aaa2fda");
list.add("bbb1");
list.add("a1d");
list.add("bbb3");
list.add("ccc");
list.add("bbb2");
list.add("ddd1");
5-2、sort
可以自定义排序规则
list.stream()
.filter(str -> str.startsWith("a"))
.sorted((item1, item2) -> item1.length() - item2.length())
5-3、map 映射
map 操作作用每个list 中的每个元素
list.stream()
.filter(str -> str.startsWith("a"))
.sorted((item1, item2) -> item1.length() - item2.length())
.map(String::toUpperCase) // 将 list 中的元素都String.toUppserCase(item)作用
5-4、Matcher匹配
- 最终操作，最终返回一个布尔值
- 方法：
- anyMatcher( (s) -> s.startsWith(“a”) )：只要集合中一个匹配就返回 true
- allMatcher( (s) -> s.startsWith(‘a’ ) ：集合中全部匹配才返回 true
- noMatcher( (s) -> s.startsWith(‘a’ ) )：集合中全部不匹配才返回 true
boolean flag = list.stream()
.filter(str -> str.startsWith("a"))
.sorted((item1, item2) -> item1.length() - item2.length())
.map(String::toUpperCase)
.anyMatch(str -> str.startsWith("AA"));
5-5、count计数
最终操作，返回在stram 中的个数
list.stream()
.filter(str -> str.startsWith("a"))
.count()
5-6、创建一个列表
// 创建一个字符串列表，每个字符串长度大于2
List<String> filtered = strList.stream()
.filter(x -> x.length()> 2)
.collect(Collectors.toList());
5-6、reduce 规约
- 最终操作，stream中的多个元素规约为一个元素
- 返回Optional
Optional<String> reduce = list.stream().reduce((item1, item2) -> { // item1, item2 分别表示
return item1 + "__" + item2;
});
6、Map新增方法
6-1、遍历
map.forEach((key, val) -> {
System.out.println(key + " -- " + val);
});
6-2、computeIfPresent、computeIfAbsent、compute
computeIfPresent：如果存在则执行自定义方法
computeIfAbsent：如果不存在则执行自定义方法
a、computeIfPresent(key, (key, val) -> {})
传入 key，如果key存在就会执行 {} 方法，否则不会执行
Map<String,String> map = new HashMap<>();
map.put("a", "a1");
map.put("b", "b1");
map.put("c", "c1");
map.forEach((key, val) -> {
System.out.println(key + " " + val);
});
System.out.println("----------");
// 如果"a" 存在就执行
map.computeIfPresent("a", (key, val) -> {
System.out.println(key + " " + val);
return key+"_"+val;
});
System.out.println(map);
/// 传入 lambda 表达式实际上一个方法
BiFunction<String, String, String> biFunc = new BiFunction<String, String, String>(){
@Override
public String apply(String key, String value) {
String result = key;
if (key == null) {
result = u;
}
else {
result += "," + u;
}
return result;
}
};
// 将这个bitFun 方法传入效果和上面一样
myMap.computeIfPresent(key, biFunc);
b、computeIfAbsent(key, (key) -> {} )
- 如果key 不存咋则执行方法，并返回一个存到 "value"里面的值，键即为key
- 可以用于指定默认值
map.computeIfAbsent("key2", (key) -> "dmeo"); // 可以用于指定默认值，如果不存在将 "demo"存到 map 中
System.out.println(map);
map.computeIfAbsent("key2", key -> {
// 能进到这里说明 key2 在 map 中不存在
return "default_val"; // 返回一个存到map中的值
});
c、compute(key, (key, val) -> {} )
不管传入key 是否在map中都会执行方法
Map<String,String> map = new HashMap<>();
map.put("a", "a1");
map.put("b", "b1");
map.put("c", "c1");
map.compute("a", (key, val) -> {
System.out.println(key + "**" + val);
return key+"__"+val;
});
/*输出：
a**a1
{a=a__a1, b=b1, c=c1}
*/
map.compute("d", (key, val) -> {
System.out.println(key + "**" + val);
return key+"__"+val;
});
/*
d**null
{a=a__a1, b=b1, c=c1, d=d__null}
*/
6-3、merge(key, needVal, (keyVal, needVal) -> {} )
- 传入map中的key，和需要比较的 needValue，进行比较（比较规则自定义）
Map<String,String> map = new HashMap<>();
map.put("a", "a1");
map.put("b", "b1");
map.put("c", "c1");
map.merge("a", "jeck123", (val1, val2) -> { // val1是 a在map中对应的值，val2值为"jeck123"
System.out.println(val1 + "__" + val2);
return val1+"__"+val2;
});
结果
a1__jeck123
{a=a1__jeck123, b=b1, c=c1}
6-4、remove(key, value)
- remove(key, val)：key-val 匹配时才删除
- remove(key)：直接删除这个key，和val
6-5、getOrDefault
- 若值不存在，取出自定义默认值
- 不会讲默认值放到map中