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 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 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); // val9concat13、允许多重注解
@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