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中