jdk1.8新特性

2019/11/13 11:39
阅读数 20


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

 

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部