jdk1.8新特性

Posted 2020-11-23 perserv

JDK1.8新特性：

hashMap

在jdk1.8中对hashMap等map集合的数据结构优化。hashMap数据结构的优化
原来的hashMap采用的数据结构是哈希表（数组+链表），hashMap默认大小是16，一个0-15索引的数组，如何往里面存储元素，首先调用元素的hashcode
方法，计算出哈希码值，经过哈希算法算成数组的索引值，如果对应的索引处没有元素，直接存放，如果有对象在，那么比较它们的equals方法比较内容
如果内容一样，后一个value会将前一个value的值覆盖，如果不一样，在1.7的时候，后加的放在前面，形成一个链表，形成了碰撞，在某些情况下如果链表
无限下去，那么效率极低，碰撞是避免不了的
加载因子：0.75，数组扩容，达到总容量的75%，就进行扩容，但是无法避免碰撞的情况发生
在1.8之后，在数组+链表+红黑树来实现hashmap，当碰撞的元素个数大于8时 & 总容量大于64，会有红黑树的引入
除了添加之后，效率都比链表高，1.8之后链表新进元素加到末尾
ConcurrentHashMap (锁分段机制)，concurrentLevel,jdk1.8采用CAS算法(无锁算法，不再使用锁分段)，数组+链表中也引入了红黑树的使用

 

Lambda表达式：

　　Lambda表达式的本质是一段匿名内部类。也可以是一段可以传递的代码，

 在商场购物时，需要进行筛选过滤类

public List<Product> filterProductByPredicate(List<Product> list,MyPredicate<Product> mp){
        List<Product> prods = new ArrayList<>();
        for (Product prod : list){
            if (mp.test(prod)){
                prods.add(prod);
            }
        }
        return prods;
    }

//Lambda表达式来代替匿名内部类
@Test
public void test4(){
      List<Product> products = filterProductByPredicate(proList, (p) -> p.getPrice() < 8000);
      for (Product pro : products){
          System.out.println(pro);
      }
  }

 Lmabda表达式的语法总结： () -> ();口诀：左右遇一省括号，左侧推断类型省

前置	语法
无参数无返回值	() -> System.out.println(“Hello WOrld”)
有一个参数无返回值	(x) ->  System.out.println(x)
有且只有一个参数无返回值	x -> System.out.println(x)
有多个参数，有返回值，有多条lambda体语句	(x，y) -> {System.out.println(“xxx”);return xxxx;}；
有多个参数，有返回值，只有一条lambda体语句	(x，y) -> xxxx

 

函数式接口：

　　只定义了一个抽象方法的接口（Object类的public方法除外），就是函数式接口，并且还提供了注解：@FunctionalInterface

常见的四大函数式接口：

• Consume<T>:消费型接口，有参无返回值
• Supplier 《T》：供给型接口，无参有返回值
• Function 《T,R》：:函数式接口，有参有返回值,
• Bifunction<T, U, V> 可以理解为Function的一种扩展, Function接口接收一个参数, 返回一个参数; BiFunction接口接受两个参数, 返回一个参数
• Predicate《T》： 断言型接口，有参有返回值，返回值是boolean类型

　　/**
　　*Consumer<T> 消费型接口
　　*/
    public void accept(String str, Consumer<String> con){
        con.accept(str);
    }

    @Test
    public void testConsumer(){
        accept("hello",str -> System.out.println(str));
}

    /**
     * Supplier<T> 供给型接口
     * @param supplier
     */
    public String getValue(Supplier<String> supplier){
       return supplier.get();
    }

    public void testSupplier(){
       String str= getValue(() ->  "hello");
       System.out.println(str);
    }
}

 /**
     * Function<T,R> 函数式接口
     * @param str
     * @param func
     * @return
     */
    public String strAppend(String str, Function<String,String> func){
        return func.apply(str);
    }

    @Test
    public void testFunction(){
        String str = strAppend("hello",(x) -> x+" function");
    }

 /**
     * Predicate<T> 断言型接口
     * @param str
     * @param pred
     * @return
     */
    public Boolean isOutMax(String str, Predicate<String> pred){
       return  pred.test(str);
    }

    @Test
    public void testPredicate(){
      boolean b =  isOutMax("hello",(x) -> x.length() > 1);
      System.out.println(x);
    }