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);
    }