JDK1.8的新特性

JDK1.8的十大新特性

本文主要介绍JDK1.8版本的一些新特性，乃作者笔记，仅供参考

jdk1.8新特性知识点：

1. 接口的默认方法
2. Lambda表达式
3. 函数式接口
4. 方法与构造函数引用
5. Lambda作用域
6. 局部访问变量
7. 访问对象字段与静态变量
8. 访问接口的默认方法
9. Date API
10. Annotation注解

1.接口的默认方法

jdk1.8之前接口中只能有抽象方法

Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法

public interface happy{

	double happiness(int a);

	default double wish(int b){
		return Math.wish(b);
}

2.Lambda表达式

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

在这里插入图片描述

或者可以写的更简单

    Collections.sort(names, (String a, String b) -> b.compareTo(a));

    Collections.sort(names, (a, b) -> b.compareTo(a));

3. 函数式接口

Lambda表达式是如何在java的类型系统中表示的呢??每一个lambda表达式都对应一个类型，通常是接口类型。
而"函数式接口"是指只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个这个抽象方法。因为默认方法（扩展方法） 不算是抽象方法，所以可以在函数式接口添加默认方法

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

注意的是：@FunctionalInterface如果没有指定，上面的代码也是可以的

4.方法与构造函数引用

上边的代码还可以通过静态方法引用来表示:

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123


converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    //J


class Person {
    String firstName;
    String lastName;
    Person() {}
    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

接下来我们指定一个用来创建Person对象的对象工厂接口：

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

这里我们使用构造函数引用来将他们关联起来，而不是实现一个完整的工厂：

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

5.Lambda作用域

在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。

6.访问局部变量

lambda表达式访问外层的局部变量：

final int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
stringConverter.convert(2);     // 3

和匿名对象不同的是，这里的变量num可以不用声明为final,该代码同样正确:

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
stringConverter.convert(2);     // 3

试图修改num值是不能通过编译的：

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
         num = 3;
         代码编译不通过

7.访问对象字段与静态变量

class Lambda4 {
    static int outerStaticNum;
    int outerNum;
    void testScopes() {
        Converter<Integer, String> stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };
        Converter<Integer, String> stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }

}

8.访问接口的默认方法

还记得第一节中的happy例子么，接口happy定义了一个默认方法wish可以直接被happy的实例包括匿名对象访问到，但是在lambda表达式中这个是不行的。
Lambda表达式中是无法访问到默认方法的，以下代码将无法编译：

Happy happy = (a) -> wish( a * 100);

9.Date API

10.Annotation注解

在Java 8中支持多重注解了，先看个例子来理解一下是什么意思。
首先定义一个包装类Hints注解用来放置一组具体的Hint注解：

@interface Hints {
    Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
    String value();
}

Java 8允许我们把同一个类型的注解使用多次，只需要给该注解标注一下@Repeatable即可。

例 1: 使用包装类当容器来存多个注解（老方法）

@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}

例 2：使用多重注解（新方法）

@Hint("hint1")
@Hint("hint2")
class Person {}

第二个例子里java编译器会隐性的帮你定义好@Hints注解，了解这一点有助于你用反射来获取这些信息：

Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint);                   // null
Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length);  // 2
Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length);          // 2

即便我们没有在Person类上定义@Hints注解，我们还是可以通过 getAnnotation(Hints.class) 来获取 @Hints注解，更加方便的方法是使用 getAnnotationsByType 可以直接获取到所有的@Hint注解。
另外Java 8的注解还增加到两种新的target上了：

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}

在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算法(无锁算法，不再使用锁分段)，数组+链表中也引入了红黑树的使用