jdk1.7新特性~

最新推荐文章于 2020-10-02 14:37:07 发布
最新推荐文章于 2020-10-02 14:37:07 发布
阅读量936 收藏
点赞数
分类专栏： java 文章标签： jdk1.7

1.   二进制字面量 

JDK7开始，终于可以用二进制来表示整数(byte,short,int和long)。使用二进制字面量的好处是，可以是代码更容易被理解。语法非常简单，只要在二进制数值前面加 0b或者0B

 


Java代码

byte nByte = (byte)0b0001;        

short nShort = (short)0B0010;        

int nInt = 0b0011;        

long nLong = 0b0100L; 

 

2.   数字字面量允许使用下划线 

byte nByte = (byte)0b0001;    

short nShort = (short)0B0010;    

int nInt = 0b0011;    

long nLong = 0b0100L;  

对于一些比较大的数字，我们定义起来总是不方面，经常缺少或者增加位数。JDK7为我们提供了一种解决方案，下划线可以出现在数字字面量。

Java代码

int a = 10_0000_0000;        

long b = 0xffff_ffff_ffff_ffffl;        

byte c = 0b0001_1000;

byte nByte = (byte)0b0001;    

short nShort = (short)0B0010;    

int nInt = 0b0011;    

long nLong = 0b0100L;  

int a = 10_0000_0000;    

long b = 0xffff_ffff_ffff_ffffl;    

byte c = 0b0001_1000; 


注意：你只能将下划线置于数字之间，以下使用方法是错误的，
1.数字的开头或者结尾
2.小数点的前后
3.‘F’或者‘f’的后缀
4.只能用数字的位置


Java代码

int err1 = _11,err2=11_;    
float err3=3._4,err4=3_.4;   
long err5=0x888_f;

 

3.   switch 语句允许使用字符串

 

这个功能千呼万唤，终于出来了

Java代码

private static void switchString(String str){                

switch(str){                    

case "one":                        

System.err.println("1");                        

break;                   

 case "two":                        

System.out.println("2");                        

break;                    

default :                        

System.out.println("err");                

}        

}

4.   泛型实例的创建可以通过类型推断来简化 


以后你创建一个泛型实例，不需要再详细说明类型，只需用<>,编译器会自动帮你匹配
Java代码

//例如         

Map myMap = new HashMap();       

 //可以简化为        

Map myMap = new HashMap<>();   

//例如     

Map> myMap = new HashMap>();   

 //可以简化为    

Map> myMap = new HashMap<>();



5.   在可变参数方法中传递非具体化参数(Non-Reifiable Formal Parameters),改进编译警告和错误

有些参数类型，例如ArrayList 和 List,是非具体化的(non-reifiable).在编译阶段，编译器会擦除该类型信息。

Heap pollution 指一个变量被指向另外一个不是相同类型的变量。例如

Java代码

List l = new ArrayList();               

List ls = l;       // unchecked warning               

l.add(0, new Integer(42)); // another unchecked warning           

String s = ls.get(0);      // ClassCastException is thrown 

 

List l = new ArrayList();           

List ls = l;       // unchecked warning           

l.add(0, new Integer(42)); // another unchecked warning            String s = ls.get(0);      // ClassCastException is thrown


回到我们的主题，在jdk7中，当你定义下面的函数时

Java代码

public static  void addToList (List listArg, T... elements) {         for (T x : elements) {             

 listArg.add(x);            

 }          

}     

你会得到一个warning   

  

warning: [varargs] Possible heap pollution from parameterized vararg type  

 

 

public static  void addToList (List listArg, T... elements) {         for (T x : elements) {         

 listArg.add(x);        

 }      

} 

你会得到一个warning

 

warning: [varargs] Possible heap pollution from parameterized vararg type



在jdk7之前，当你调用一个含有非具体化参数的可变参数方法，你必须自行保证不会发生“heap pollution”。这有一个问题，如果调用者对方法不熟悉，他根本无法判断。JDK7对此做了改进，在该方法被定义时久发出警告

要消除警告，可以有三种方式

1.加 annotation @SafeVarargs

2.加 annotation @SuppressWarnings({"unchecked", "varargs"})

3.使用编译器参数 –Xlint:varargs;

6.   try-with-resources 语句

 

jdk7提供了try-with-resources,可以自动关闭相关的资源(只要该资源实现了AutoCloseable接口，jdk7为绝大部分资源对象都实现了这个接口)
Java代码

static String readFirstLineFromFile(String path) throws IOException {          

try (   

     BufferedReader br = new BufferedReader(new FileReader(path))){            

     return br.readLine();          

  }        

}   

 

 

static String readFirstLineFromFile(String path) throws IOException {      

try (

     BufferedReader br = new BufferedReader(new FileReader(path))){        

     return br.readLine();      

  }    

} 


try 语句块中还可以同时处理多个资源,可以跟普通的try语句一样catch异常，有finally语句块

Java代码

try (              

java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);              

java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(outputFilePath, charset)           

 ) {     }   

catch(…){     }   

finally{     }  

 

 

7.   Catch多个Exception，throw exception 改进了类型检测

 

try (          

java.util.zip.ZipFile zf = new java.util.zip.ZipFile(zipFileName);          

java.io.BufferedWriter writer = java.nio.file.Files.newBufferedWriter(outputFilePath, charset)       

 ) {     }

catch(…){     }

finally{     } 

很多时候，我们捕获了多个异常，却做了相同的事情，比如记日志，包装成新的异常，然后rethrow。这时，代码就不那么优雅了，例如

Java代码

catch (IOException ex) {             

logger.log(ex);            

 throw ex;       

catch (SQLException ex) {             

logger.log(ex);             

throw ex;        

}  

catch (IOException ex) {         

logger.log(ex);        

 throw ex;   

catch (SQLException ex) {         

logger.log(ex);         

throw ex;    

} 



Jdk7允许捕获多个异常

Java代码

catch (IOException|SQLException ex) {            

logger.log(ex);            

throw ex;        

} 

   

catch (IOException|SQLException ex) {        

logger.log(ex);        

throw ex;    

} 


注意，catch后面的异常参数是final的，不能重新再复制

Rethrow Exception更具包容性的类型检测

当你重新抛出多个异常时，不再需要详细定义异常类型了，编译器已经知道你具体抛出的是哪个异常了。你只需在方法定义的时候声明需要抛出的异常即可

Java代码

public void call() throws ReflectiveOperationException, IOException {            

try {              

callWithReflection(arg);            

}    

catch (final Exception e) {              

logger.trace("Exception in reflection", e);              

throw e;            

}        

} 

   


8.   菱形语法

 

菱形语法（泛型实例化类型自动推断）

 

Java代码

List<String> list = new ArrayList<>(); // <>这个真的很像菱形

   

9.   不可具体化的泛型（任意类型）可变参数

 

List<String> list = new ArrayList<>(); // <>这个真的很像菱形

在目前版本中，不可具体化的泛型（任意类型）可变参数，在编译时，会在调用处产生警告，JDK7里将这个警告挪到了方法定义处。
变化前：

static <T> List<T> asList(T... elements) { ... }  

static List<Callable<String>> stringFactories() {  

     Callable<String> a, b, c;  

     ...  

     // 警告处  

     return asList(a, b, c);  

   } 

 

static <T> List<T> asList(T... elements) { ... }

static List<Callable<String>> stringFactories() {

     Callable<String> a, b, c;

     ...

     // 警告处

     return asList(a, b, c);

   } 

   变化后：

   // 警告处  

static <T> List<T> asList(T... elements) { ... }  

static List<Callable<String>> stringFactories() {  

     Callable<String> a, b, c;  

     ...  

     return asList(a, b, c);  

   } 

 

// 警告处

static <T> List<T> asList(T... elements) { ... }

static List<Callable<String>> stringFactories() {

     Callable<String> a, b, c;

     ...

     return asList(a, b, c);

   } 

 

   3，switch现在可以支持字符串了

   String s = ...  

switch(s) {  

   case "quux":  

     processQuux(s); //没有break,继续往下  

 

   case "foo":  

   case "bar":  

     processFooOrBar(s);  

     break;  

   case "baz":  

     processBaz(s); //没有break,继续往下  

 

   default:  

     processDefault(s);  

     break;  

} 

 

String s = ...

switch(s) {

   case "quux":

     processQuux(s); //没有break,继续往下

 

   case "foo":

   case "bar":

     processFooOrBar(s);

     break;

   case "baz":

     processBaz(s); //没有break,继续往下

 

   default:

     processDefault(s);

     break;

}


Java代码

static <T> List<T> asList(T... elements) { ... }      

static List<Callable<String>> stringFactories() {      

     Callable<String> a, b, c;      

     ...      

     // 警告处      

     return asList(a, b, c);      

   }     

  

static <T> List<T> asList(T... elements) { ... }   

static List<Callable<String>> stringFactories() {   

     Callable<String> a, b, c;   

     ...   

     // 警告处   

     return asList(a, b, c);   

   }     

   变化后：   

   // 警告处      

static <T> List<T> asList(T... elements) { ... }      

static List<Callable<String>> stringFactories() {      

     Callable<String> a, b, c;      

     ...      

     return asList(a, b, c);      

   }     

  

// 警告处   

static <T> List<T> asList(T... elements) { ... }   

static List<Callable<String>> stringFactories() {   

     Callable<String> a, b, c;   

     ...   

     return asList(a, b, c);   

   }     

  

   3，switch现在可以支持字符串了   

   String s = ...      

switch(s) {      

   case "quux":      

     processQuux(s); //没有break,继续往下      

     

   case "foo":      

   case "bar":      

     processFooOrBar(s);      

     break;      

   case "baz":      

     processBaz(s); //没有break,继续往下      

     

   default:      

     processDefault(s);      

     break;      

}     

  

String s = ...   

switch(s) {   

   case "quux":   

     processQuux(s); //没有break,继续往下   

  

   case "foo":   

   case "bar":   

     processFooOrBar(s);   

     break;   

   case "baz":   

     processBaz(s); //没有break,继续往下   

  

   default:   

     processDefault(s);   

     break;   

}  

 

 

10.      支持二进制语法和单位级别的数字表示方式

 

Java代码

// 8位byte      

byte aByte = (byte)0b00100001;      

// 16位short      

short aShort = (short)0b1010000101000101;      

// 32位int      

int anInt1 = 0b10100001010001011010000101000101;     

  

// 8位byte   

byte aByte = (byte)0b00100001;   

// 16位short   

short aShort = (short)0b1010000101000101;   

// 32位int   

int anInt1 = 0b10100001010001011010000101000101;     

支持单位级别的数字，提高可读性   

long underScores = 9_223_372_036_854_775_807L; // 每三位加一下划线，等同于 9,223,372,036,854,775,807     

  

long underScores = 9_223_372_036_854_775_807L; // 每三位加一下划线，等同于 9,223,372,036,854,775,807

   

11.      从语法层面上支持集合，不再是数组的专利

 

Java代码

final List<Integer> piDigits = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9];      

final Set<Integer> primes = { 2, 7, 31, 127, 8191, 131071, 524287 };      

final Map<Integer, String> platonicSolids = { 4 : "tetrahedron",      

6 : "cube", 8 : "octahedron", 12 : "dodecahedron", 20 : "icosahedron"     

};     

  

final List<Integer> piDigits = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9];   

final Set<Integer> primes = { 2, 7, 31, 127, 8191, 131071, 524287 };   

final Map<Integer, String> platonicSolids = { 4 : "tetrahedron",   

6 : "cube", 8 : "octahedron", 12 : "dodecahedron", 20 : "icosahedron"  

};  

12.      JSR 292 动态类型语言支持

 

Java代码

Dynamic x = (动态语言脚本);      

Object   y = x.foo("ABC").bar(42).baz();     

  

Dynamic x = (动态语言脚本);   

Object   y = x.foo("ABC").bar(42).baz();  

13.      动态资源管理

 

Dynamic x = (动态语言脚本);  

Object   y = x.foo("ABC").bar(42).baz(); 

 

Dynamic x = (动态语言脚本);

Object   y = x.foo("ABC").bar(42).baz();

\
在目前版本的java中，当你操作流时，一定会加try..finally以保证出现异常时，流能被正确关闭。

 

Java代码

BufferedReader br = new BufferedReader(new FileReader(path));      

try {      

     return br.readLine();      

} finally {      

     br.close();      

}     

  

BufferedReader br = new BufferedReader(new FileReader(path));   

try {   

     return br.readLine();   

} finally {   

     br.close();   

}  

   

BufferedReader br = new BufferedReader(new FileReader(path));  

try {  

     return br.readLine();  

} finally {  

     br.close();  

} 

 

BufferedReader br = new BufferedReader(new FileReader(path));

try {

     return br.readLine();

} finally {

     br.close();

}


在JDK7里，你只需要将资源定义在try()里，Java7就会在readLine抛异常时，自动关闭资源。另外，资源类必须实现 Disposable<?> 接口。支持管理多个资源

Java代码

try (BufferedReader br = new BufferedReader(new FileReader(path)) {      

     return br.readLine();      

} 

   

try (BufferedReader br = new BufferedReader(new FileReader(path)) {  

     return br.readLine();  

}

 

tchqiq
关注
专栏目录
jdk1.7_新特性
03-18
jdk1.7_新特性1、对集合的支持 1、创建List / Set / Map 时写法更简单了 2、对资源的自动回收管理 3、泛型实例创建过程中类型引用的简化
jdk1.7新特性详解
weixin_JimZemlin的博客
02-09 511
开发期间略知jdk1.7的一些特性，没有真正的一个一个得展开研究，而是需要说明再去查，导致最整个新特性不是特别的清楚，这种情况以后得需要改变了，否则就会变成代码的奴隶。现在正好有时间可以细细的研究研究了。文章主要参照。
JDK7新特性
huyuchaoheaven的专栏
04-05 753
jdk7新特性
集合类中泛型Integer与int的联系
qq_44375810的博客
10-02 1187
先说结论：在集合类中，内置方法进行比较运算（如contains()、get()）的时候，Integer等同于int。 集合类的泛型不允许使用基本数据类型，因此当我们需要使用int类型时往往会用Integer的泛型代替。这样，我们即可以向集合中添加Integer类型又可以添加int类型。我们知道，new不同Integer对象，以及-128~127范围外的Integer.valueOf()创建的对象都是不相等的，但在集合类中他们却相等。显然我们有必要通过源码了解一下集合类中对于这两种类型的处理。 事实上，集合类
新特性总结-JDK1.7
无为而治
08-16 411
JDK1.7新增和修改特性
jdk1.7安装包下载
03-28
JDK1.7，也被称为Java SE 7（Java Standard Edition 7），是Oracle公司在2011年发布的一个重要版本，引入了许多新特性和改进。在此，我们将深入探讨JDK1.7的一些关键知识点。 1. **动态类型**：JDK1.7引入了` ...
java jdk 1.7官网免安装版本
10-25
这个版本的JDK在2012年发布，引入了许多新特性，提升了性能，并优化了开发者的工作流程。 1. **Java SE 7新特性** - **多线程处理增强**：Java 7增加了Fork/Join框架，用于高效处理大规模并行计算任务。 - **动态...
jdk1.7版本免安装
07-26
JDK 1.7，也被称为Java SE 7（Java Standard Edition 7），是Oracle公司发布的一个重要版本，包含了对语言特性和API的诸多改进和增强。这个"免安装"版本意味着它不需要传统的安装过程，用户可以直接解压并配置环境...
jdk1.7正式版64位下载
最新发布
08-08
标题"jdk1.7正式版64位下载"指的是这个资源是针对64位操作系统的JDK 1.7的官方稳定版本。64位操作系统能够处理更大的内存地址空间，因此对于需要处理大量数据或者运行大型应用的开发者来说，64位JDK是一个必要的选择...
linux jdk1.7
08-06
在本案例中，标题提到的是"linux jdk1.7"，这指的是Oracle JDK的1.7版本，也被称为Java SE 7。由于Oracle已经停止了对JDK 1.7的公开更新和下载，所以这个压缩包可能是为了便于那些仍需使用旧版本Java环境的用户保存...
第32项：谨慎地结合泛型和可变参数（Combine generics and varargs judiciously）
Coloured_Glaze的博客
07-08 2771
  可变参数方法（第53项）和泛型都在Java 5时添加到了平台中，所以你可能会期望它们会优雅地相互作用；可悲的是，它们不能相互作用。可变的目的是允许客户端将数量可变的参数传递给方法，但它是一个漏洞抽象（ leaky abstraction）：当你调用可变参数方法时，会创建一个数组来保存可变参数；该数组应该是一个实现细节，是可见的。因此，当可变参数具有泛型或者参数化类型时，会出现令人困惑的编译器警...
堆污染
掌心童林
07-11 4201
堆污染 大部分参数化类型，例如ArrayList 和 List，都属于非具体化类型(non-reifiable types)。非具体化类型是指在运行时(runtime)并不完整的类型。在编译时，非具体化类型经过了一个名为“类型擦除”的过程，编译器删除了与类型参数相关的信息。这将保证Java运行库与那些诞生在Java泛型之前的应用程序之间的二进制兼容性。由于在编译时，类型擦除操作删除了来自
Java线程(六)：Callable和Future
web开发
04-11 1197
上一篇：Java线程(五) 接着上一篇继续并发包的学习，本篇说明的是Callable和Future，它俩很有意思的，一个产生结果，一个拿到结果。 Callable接口类似于Runnable，从名字就可以看出来了，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是...
JDK7新特性<二> 语法
huali_cc的专栏
12-14 368
JDK7对Java语法有少量更新，重点是在易用性和便捷性的改进。   1.二进制字面量   JDK7开始，终于可以用二进制来表示整数（byte,short,int和long）。使用二进制字面量的好处是，可以是代码更容易被理解。语法非常简单，只要在二进制数值前面加 0b或者0B   Java代码   byte nByte = (byte)0b0001;  short n
The Java™ Tutorials — Generics ：Non-Reifiable Types 不可具体化类型
FIRE_TRAY的Android之路
02-06 2028
The Java™ Tutorials — Generics ：Non-Reifiable Types 不可具体化类型 原文地址：https://docs.oracle.com/javase/tutorial/java/generics/nonReifiableVarargsType.html 关键点 可具体化类型和不可具体化类型的定义：  可具体化类型：就是一个可
java7新特性 当使用可变并且非具体类型形式化参数的方法时候，改进警告与报错的提示
sixianfeng的专栏
10-01 1万+
原文 本页涵盖以下主题： Heap Pollution带可变参数方法与非具体化参数安全漏洞可变的非具体化参数的方法对可变的非具体化参数消除提示警告 Heap Pollution 像ArrayList,ArrayList被参数化类型是非具体化类型。一个非具体化类型在运行
一场由Java堆污染(Heap Pollution)引发的思考
zxm317122667的专栏
11-02 8627
1 Kotlin的数组比Java的更加安全，可以避免Heap Pollution 2 Kotlin代码比Java更加简洁 3 结论：赶紧Kotlin搞起
Python 位运算及二进制基础知识
热门推荐
bestallen的博客
06-26 2万+
来补点基础知识，这篇讲的是位运算 二进制实际上就是用10进制的数的每一位数字的2的幂数 来看例子： 然后再python的操作中，只要在数字前面加上0b的字符，就可以用二进制来表示十进制数了。
Java千百问_06数据结构（024）_用二进制如何表示整型数值
幽灵雾的专栏
07-03 3827
点击进入_更多_Java千百问1、用二进制如何表示整型数值我们都知道，计算机只认识0、1二进制，我们一般操作的寄存器和存储单元也都只认识二进制，我们称一个二进制为一个bit（位），一般32位计算机的寄存器允许操作32bit的数据，即32个0或1，由于书写过长，我们一般使用十六进制表示（每两个十六进制成为一个byte字节，即8bit=1byte）。例如：1111 1111 1111 1111 1111
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值