Java学习笔记十三

今日整理记录内容：
1、JDK1.7新特性
2、JDK1.8新特性

一、jDK1.7新特性

1.二进制字面量
可以用二进制的方式表示整数（byte、short、int、long）

例 byte b = 0B0001; // 等于 1
   int i = 0b11;   //等于 3
   short s = 0b1001; //等于 9
   long l = 0b000101 // 等于 5

用法就是 在二进制前加上 0b或0B,如果是负数就在0b前加上 - ，这里要注意的是这种表示方式会存在自检数字1所在位，也就是说数字1所在位数要小于等于类型实际位数-1。比如 byte数据类型占1个字节共八位，那么数字 1 所以的位是低7位。因为基本数据类型的最后一位是控制正负数的。

byte b = 0b10000001;  //这里编辑器会报错，数字1超过数据类型的实际位数位数

2.数字字面量可以出现下划线
可以用下划线将数字隔开，便于查看。

例：
int x = 1111_1111;//正确，数字与数字之间只有一个下划线
long y = 100__100L;//正确，数字与狮子之间有多个下划线
short a = 100_100_;//错误，将下划线放在了最后
int b = _100_100;//错误，将下划线放在了前面

3.switch 语句可以用字符串了
switch语句中可以用的数据类型：int、byte、short、char、character、Byte、Short、Integer、String、枚举类型。

switch("abc"){
case "a":
break;
case "b"
break;
case "c"
break;
case "ab"
break;
case "abc"
break;
}

4.泛型实例的创建可以通过类型推断来简化
以后你创建一个泛型实例，不需要再详细说明类型，只需用<>,编译器会自动帮你匹配
Java代码

//例如   
Map<String, List<String>> myMap = new HashMap<String, List<String>>();  
//可以简化为  
Map<String, List<String>> myMap = new HashMap<>();  

5.多个catch块合并成一个

try {
FileInputStream fis = new FileInputStream("123.txt");
Thread.sleep(1);
} 
catch (InterruptedException | FileNotFoundException  e) {//在这里将多个catch块合并成一个。
   e = new InterruptedException();//编辑器报错，因为这里的e是final修饰的，所以不能再指向其他地址。
   e.printStackTrace(); 
}

6.新增AutoCloseable接口 和 try-with-resource
只有实现AutoCloseable接口的类，才能在try-with-resource使用
例：

class AutoClose implements AutoCloseable{
        public AutoClose(){}
        @Override
        public void close() throws Exception {
            // TODO Auto-generated method stub
            System.out.println("当执行完try块代码时自动调用close方法");
        }

    }

    try(AutoClose ac = jdk7.new AutoClose()){
    //执行一些操作
    } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
输出结果：
当执行完try块代码时自动调用close方法

这里要注意的是：
1、当执行完try块中的代码时，系统自动调用close（）方法。
2、在try()中定义的变量是 final的。
3、当try{}块中和close（）方法中同时抛出异常，try{}块中异常会覆盖close（)方法中异常。

二、JDK1.8新特性
1、接口中允许我们使用 default标记的默认方法，当实现接口时不用再必须实现 用 default标记的方法，可以直接使用。

public interface JDK8 {
    default String backStr(){
        return "我是JDK8接口中default修饰的方法";
    }
    int backInt();
}

public class JDK8Test implements JDK8{
 public static void main(String[] args){
        JDK8Test test1 = new JDK8Test();
        System.out.println(test1.backStr());//没有覆盖backStr方法，直接调用
    }

/*覆盖没有用default修饰的方法*/
    @Override
    public int backInt() {
        return 0;
    }
}

2、Lambda表达式可以替换匿名内部类；（注意匿名内部类中只有一个抽象方法）；
3、只有一个抽象方法的接口叫做函数式接口；（函数式接口中可以额外定义多个抽象方法，但这些抽象方法签名必须和Object的public方法一样）
4、创建一个只有一个抽象方法的接口的实例现在有两种方式
（1、lambda表达式：2、匿名内部类。）

/*只有一个抽象方法的接口*/
public interface LambdaInterface {
    int add(int x, int y);
}

public class JDK8Test{
    public static void main(String[] args){
        /*通过匿名内部类创建接口对象*/
        sum(new LambdaInterface() {
            @Override
            public int add(int x, int y) {
                return x+y;
            }
        });
        /*通过lambda表达式创建接口对象*/
        sum((x, y)-> {
            return x+y;
        });
    }

    public static void sum(LambdaInterface lambdaInterface){
       int xAddY = lambdaInterface.add(5, 6);
       System.out.println(xAddY);
    }
}

5、通过lambda方法创建函数式接口的实力对象

/*创建一个函数式接口，方法为将N类型转换为T类型*/
public interface Convert<T, N> {
    T convert(N n);
}

 ..........
        //完整写法
        Convert<Integer, String> convert1 = (str)-> {
           return Integer.valueOf(str);
        };
        //简写
        Convert<Integer, String> convert2 = str-> Integer.valueOf(str);

       //通过类引用静态方法的方式创建函数式接口对象
       Convert<Integer, String> convert3 = Integer::valueOf;
       //通过对象引用方法的方式构建函数式接口对象
        String str4 = "创建一个字符串对象";
       Convert<Integer, String> convert4 =str4::indexOf;
       System.out.println(convert4.convert("一")); //输出 2

 ..........

6、通过函数式接口的方法指定用类的哪个方法构建类对象

    /*创建函数式接口，成员是带两个参数的方法*/
    interface PersonFactory<T extends Person>{
        T create(int sex, int age);
    }
    /*创建一个Person类，定义两个构造方法*/
    class Person{
        public int sex;
        public int age;
        public Person(){ }

        public Person(int sex, int age){
            this.sex = sex;
            this.age = age;
        }
         @Override
        public String toString() {
            return "性别："+sex+"  年龄："+age;
        }
    }
......
 PersonFactory<Person> pf1 = Person::new;
 Person p1 = pf1.create();
 System.out.println(p1.toString());
 输出结果：
 性别：0  年龄：22
......

6、访问局部变量可以加final也可以不加final,不加的话就会隐式加上
7、lambda表达式中不允许调用函数式接口的 默认（default）方法。
8、Optional 接口：Optional 被定义为一个简单的容器，在Java 8之前一般某个函数应该返回非空对象但是偶尔却可能返回了null，而在Java 8中，不推荐你返回null而是返回Optional。
这里介绍几个基本方法：
empty()：返回默认实例对象 EMPTY;这里的value 是 null;
of(T value)：创建实例对象并初始化this.value = value; 这里要求value参数不能为空；
ofNullable(T value)：同of()方法，只不过这里的value参数可以为空
get()：获得value值，如果value值为空则抛出异常
isPresent()：判断value值是否为空

9、常用函数式接口：Comparator 接口、Consumer 接口、Supplier 接口、Function 接口、Predicate接口

10、Stream 接口：java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作和最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。**Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， **Map不支持。Stream的操作可以串行执行或者并行执行。常用方法(Filter 过滤、Sort 排序、Map 映射、Match 匹配、Count 计数、Reduce 规约)
串行Streams和并行Streams
前面提到过Stream有串行和并行两种，串行Stream上的操作是在一个线程中依次完成，而并行Stream则是在多个线程上同时执行。
下面的例子展示了是如何通过并行Stream来提升性能：
首先我们创建一个没有重复元素的大表：
复制代码代码如下:

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

然后我们计算一下排序这个Stream要耗时多久，
串行排序：
复制代码代码如下:

long t0 = System.nanoTime();
long count = values.stream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));
// 串行耗时: 899 ms

并行排序：
复制代码代码如下:

long t0 = System.nanoTime();
long count = values.parallelStream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));
// 并行排序耗时: 472 ms

上面两个代码几乎是一样的，但是并行版的快了50%之多，唯一需要做的改动就是将stream()改为parallelStream()。

11、输出map中的键值

Map<String ,Integer> map = new HashMap<>();
        map.putIfAbsent("1", 1);//如果存在键 1  就不存放。
        map.putIfAbsent("2", 2);
        /*方式一：输出Map中的键值*/
        Set<Entry<String, Integer>> entries = map.entrySet();
        for (Entry<String, Integer> entry : entries) {
            System.out.println("key:"+entry.getKey()+"--value:"+entry.getValue());
        }
        /*方式二：输出Map中的键值*/
        map.forEach((id, val) -> System.out.println(id+" "+val));

12、Map中常用的好方法

map.computeIfPresent(3, (key, val) -> val + num);
map.get(3);             // val33
map.computeIfPresent(9, (key, val) -> null);
map.containsKey(9);     // false
map.computeIfAbsent(23, key -> "val" + num);
map.containsKey(23);    // true
map.computeIfAbsent(3, key -> "bam");
map.get(3);             // val33
map.remove(3, "val3");//移除map中键等于3，值等于val3的数据。
map.get(3);             // val33
map.remove(3, "val33");
map.get(3);             // null
map.getOrDefault(42, "not found");  // not found
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));//对map中指定键的值做合并。
map.get(9);             // val9concat

13、允许多重注解

@Repeatable(Hints.class)//当使用多重注解@Hint时，默认创建@Hints({@Hint1, @Hint2,......})
public @interface Hint {
    String value();
}
public @interface Hints {
    Hint[] value();
}
@Hint("2")
@Hint("1")   //在JDK1.8之前 使用@Hints({@Hint("2"),@Hint("1")})
public class Person {}
采用@Hint("2") @Hint("1") 这种多重注解的，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