当前位置:天才代写 > tutorial > JAVA 教程 > 体验J2SE 1.5新特性之装箱和拆箱

体验J2SE 1.5新特性之装箱和拆箱

2017-11-11 08:00 星期六 所属: JAVA 教程 浏览:556

副标题#e#

J2SE 1.5提供了“Autoboxing”和“Auto-Unboxing”的机制,可以让编译器来自动完成在根基范例和它们的包裹工具之间的转化事情,从而可以或许用一种更简朴的方法,来制止同时存在两套范例系统所带来的一些贫苦。本文先容Autoboxing/Auto-Unboxing机制的利用要领、实质、产生机缘、范围、对重载机制的影响以及对机能的故障等问题。

传统上,在Java措施中,可以往一个容器类(无论是Collection照旧Map)里直接放入一个工具;可是假如规划放入的是一个数字、字符或布尔值的话,就要先插手一个“生成包裹它们的工具”的步调。

造成这种现象的原因是,在Java语言傍边一直存在着两套很是差异的范例系统:

一套是所谓的“引用范例”(Reference Types),包罗所有的类和接口。这些范例的数据被看作工具,所以可以用一个Object型的变量来生存。

一套是所谓的“根基范例”(Primitive Types),包罗:byte、short、int、long、float、double、char和boolean。这些范例的数据不是工具,因此也不能用Object型的变量来生存。

同时回收这样两套范例系统,可以获得一些机能方面的长处——因为根基范例的数据不是工具,所以建设得更快、占用的空间更少、收回它们占用的资源也更容易;可是,这样的做法同时也会造成一些编码方面的问题——譬喻,不能界说一个变量(或数组),让它既能生存根基范例的数据,又能生存引用范例的数据(雷同的,也不能界说一个同时能匹配这两种范例的数据的形参,不外这个问题可以借助Java里的重载机制往返避)。

实际上需要界说“不知道用来生存什么范例的数据”的变量(和形参)时,一般对这个问题采纳回避的立场,将它们的范例界说成Object,然后借助可以称为“Boxing”和“Unboxing”的操纵来办理Object不能涵盖根基范例的问题。

1. Boxing和Unboxing操纵

所谓Boxing操纵,是指通过生成一个能包裹根基范例数据的工具,来让根基范例的数据呈此刻只能接管引用范例的处所。

清单1:手工Boxing的典范环境

Collection integers = new ArrayList();
for(int i = 0; i < 10; i++) {
integers.add(new Integer(i));
}

用于生成这些的工具的类,被称作“包裹类”(Wrapper Classes)。Java中的包裹类有Byte 、Short、Integer、Long、Float、Double、Character和Boolean(都在java.lang包里界说)等八种,别离用于包裹byte、short、int、long、float、double、char和boolean范例的数据。

而所谓Unboxing操纵,则是指挪用包裹类工具的相应要领,获得它们所代表的“根基范例的数据”,以便举办进一步的处理。

清单2:手工Unboxing的典范环境

for(Iterator itr = integers.iterator(); itr.hasNext(); ) {
Integer i = (Integer) itr.next();
System.out.println(i.intValue() + 1);
}

而在Java语言的最新版本——J2SE 1.5中,提供了“Autoboxing”和“Auto-Unboxing”的机制,可以让编译器来自动完成这些琐碎的操纵,从而用一种更简朴的方法,来整合两套范例系统。

熟悉的生疏名词

尽量这一对操纵的汗青很悠久,可是把它们称作“Boxing”和“Unboxing”的做法,根基是在呈现“Autoboxing”和“Auto-Unboxing”的观念之后,才获得了遍及的接管。在那之前,它们好像并没有通用的、专门的名字。不外由于当时也很少提及这两个观念,所以这个问题倒也没有造成什么严重的影响。


#p#副标题#e#

2. 利用Autoboxing和Auto-Unboxing

利用Autoboxing和Auto-Unboxing,并不需要什么出格的步调,一切城市在编译器的布置下自动产生。

此刻可以这样来看待一个int型的数据:

清单3:自动完成的Boxing操纵

Collection al = new ArrayList();
al.add(1);

因为编译器会暗暗的把这段代码转换成靠近这个样子:

清单4:作了Autoboxing之后的等价形式

Collection al = new ArrayList();
al.add(Integer.valueOf(1));

这里所用的能接管int范例的值为参数,生成Integer实例的valueOf要领,是J2SE 1.5中新插手的内容。其它包裹类也都有可以接管对应的根基范例的值为参数,生成对应的包裹类实例的valueOf要领插手。

而这样看待一个Integer型的工具也是可以的:

清单5:自动完成的Unboxing操纵

Integer one = new Integer(1);
int two = one + 1;

因为编译器会暗暗的把这段代码转换成雷同这个形状:

清单6:作了Auto-Unboxing之后的等价形式

Integer one = new Integer(1);
int two = one.intValue() + 1;

#p#分页标题#e#

概略上,只要把一个功效范例是根基范例的表达式,放到需要让它们的包裹类呈现的位置上,就会诱发Autoboxing;雷同的,只要把一个功效范例是包裹类的表达式,放到只答允相应的根基范例呈现的位置上,就会诱发Auto-Unboxing。

“Autoboxing/Auto-Unboxing”特性的来历

J2SE 1.5中增加的很多语言特性都可以在C#里找到对应的对象。不外按照Bruce Eckel对Joshua Bloch的采访,尽量Java的研发小组确实很存眷C#(Joshua Bloch本人的案头就放着一本关于C#的书),可是只有“Autoboxing/Auto-Unboxing”和“Metadata”确实是从C#中直接警惕来的特性。

#p#副标题#e#

3. 产生Autoboxing的详细机缘

产生Autoboxing的详细机缘,主要有这么三种:

把根基范例的数据赋给引用范例的变量时。譬喻把一个int型的数据赋给一个Integer型变量。

清单7:赋给引用范例的变量根基范例的数据

Integer i = 31415;

把根基范例的数据传给引用范例的参数时。譬喻给一个界说成Object的参数通报一个boolean型的数据。

清单8:传给引用范例的参数根基范例的数据

HashMap map = new HashMap();
map.put(true, null);

把根基范例的数据往引用范例上强制转化时。譬喻在一个long型的数据前面加上(Long)。

清单9:从根基范例的数据到引用范例上强制转化

System.out.println((Long) 27828L);

4. Autoboxing的范围

Autoboxing的机制有一个范围——只能把根基范例的数据往它们本身的包裹类(以及包裹类的上级类)上转化。

雷同这样的代码是不能事情的,尽量int型的数据完全可以用一个Long工具来暗示:

清单10:不能同时举办自动向上转型和Autoboxing

int i = 27828;
System.out.println((Long) i);/* 编译时堕落 */

这是因为这段代码实际上相当于:

清单11:Autoboxing操纵会在自动向上转型之前产生

int i = 27828;
System.out.println((Long) Integer.valueOf(i));/* 编译时堕落 */

而Integer并不是Long的子类,所以这个转化无法举办。假如必然要举办这种操纵,需要手工追加一次转型:

清单12:需要先强制向上转型,再作Boxing

int i = 27828;
System.out.println((Long)(long) i);

#p#副标题#e#

5. 产生Auto-Unboxing的详细机缘

产生Auto-Unboxing的详细机缘,则主要有这么七种:

把包裹类工具赋给根基范例的变量时。譬喻把一个Integer型的数据赋给一个int型变量。

清单13:赋给根基范例的变量包裹类工具

int i = new Integer(32);

把包裹类工具传给根基范例的参数时。—www.bianceng.cn。譬喻给一个界说成boolean的参数通报一个Boolean型的数据。

清单14:传给根基范例的参数包裹类工具

JFrame frame = new JFrame("^_^");
frame.setSize(320, 200);
frame.setVisible(new Boolean(true));

把包裹类工具往根基范例上强制转化时。譬喻在一个Long型的数据前面加上(long)。

清单15:从包裹类工具到根基范例的强制转化

Long l = new Long(31415L);
System.out.println((long) l);

把包裹类工具看成运算符的操纵数时。譬喻在两个Byte型的数据之间放上“+”号。

清单16:把包裹类工具看成运算符的操纵数

Byte a = new Byte((byte) 1);
Byte b = new Byte((byte) -1);
System.out.println(((a++) << 2) + (~b));/* 输出“4” */
System.out.println(a);/* 输出“2” */

用包裹类工具来指定命组的巨细时。虽然,从语义上说,这个工具的范例必需是Byte、Short、Integer或Character。

清单17:用包裹类工具来指定命组的巨细

Character size = new Character('★');/* Unicode: 9733 */
int[] integers = new int[size];/* 生成一个可放9733个int元素的数组 */

把包裹类工具在switch语句里利用时。虽然,从语义上说,这个工具的范例必需是Byte、Short、Integer或Character。

清单18:在switch语句里利用包裹类工具

Character c = new Character('a');
switch (c) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("A Vowel in English");
break;
default:
System.out.println("Not A Vowel in English");
break;
}

把Boolean工具在if/for/while/do-while语句中作为条件表达式利用时。

清单19:把Boolean工具作为条件表达式

#p#分页标题#e#

Boolean bool = new Boolean(Math.random() > 0.5);
if (bool) {
System.out.println("Aye!");
} else {
System.out.println("Nay!");
}

#p#副标题#e#

6. Auto-Unboxing的范围

Auto-Unboxing的机制则有这样一个范围——只能把包裹类工具往它们对应的根基范例(以及容纳范畴更广的范例)上转化。

雷同这样的代码是不能事情的,尽量32并未超出byte所能暗示的范畴:

清单20:不能同时举办Auto-Unboxing和强制向下转型

Integer i = new Integer(32);
System.out.println((byte) i);/* 编译时堕落 */

这是因为编译器并不承认同时举办Auto-Unboxing和强制向下转型的操纵,所以这个转化无法举办。假如必然要举办这种操纵,需要手工增补一次转型:

清单21:需要先作Unboxing,再强制向下转型

Integer i = new Integer(32);
System.out.println((byte)(int) i);

不外同时举办Auto-Unboxing和强制向上转型的操纵是没有问题的,所以下面的代码事情得很正常:

清单22:可以同时举办Auto-Unboxing和强制向上转型

Integer i = new Integer(32);
System.out.println((double) i);

7. 其它不能自动转化的环境

撤除强制范例转化时的限制之外,尚有这样一些环境下不会产生Autoboxing/Auto-Unboxing:

1. 根基范例的数组和包裹类数组之间不会自动转化。这样的代码完全不被编译器接管:

清单23:元素可以,容器不可

int[] ints = {1, 2, 3};
Integer[] integers = ints;/* 编译时堕落 */

2. 不能对着根基范例的表达式来挪用包裹类里的要领。这样的申请会被编译器彻底拒绝:

清单24:没有要领,就是没有要领

int i = 1;
byte b = i.byteValue();/* 编译时堕落 */

8. null的转化问题

Java里的引用范例可以有一个出格的取值——“null”。试图对null举办Auto-Unboxing操纵会导致一个“NullPointerException”。

譬喻这段代码就会在运行时抛出异常,尽量在编译期间会表示得很是正常:

清单25:外貌上,只是普通的赋值

Integer i = null;
int j = i;/* 运行时错误 */

这是因为这段代码实际上相当于:

清单26:实际上,是在试图挪用null的要领

Integer i = null;
int j = i.intValue();/* 运行时错误 */

而试图挪用null的要领是一种不被虚拟机承认的行为。

假如没记着有关的法则

大部门违反了利用“Autoboxing/Auto-Unboxing”机制时,需要遵守的约束的代码,城市造成编译错误。因此,纵然并未精确的记着有关的法则,也不难实时发明、纠正。只有违背了“不能对null举办Auto-Unboxing操纵”的限制时,激发的是运行时异常,需要出格小心。

#p#副标题#e#

9. 对重载的影响

Java支持“重载”的机制,答允在同一个类拥有很多名称沟通而形参列表差异的要领。然后,由编译器按照挪用时的实参来选择到底要执行哪一个。

Autoboxing/Auto-Unboxing机制的引入,稍微增加了一些作这种选择时要思量的因素——因为大概会有一个要领,既有一个能接管一个Integer型参数的版本,又有一个能接管一个int型参数的版本,而Autoboxing/Auto-Unboxing机制能自动的把实参在这两种范例之间转化,光凭原有的判定法则,二者是难以取舍的。可是,因为同时有这两个版本的做法完全合情公道,又不能在这里给出一个“reference to 被挪用的要领名 is ambiguous”的编译错误来推卸责任。这就需要增加一条新的判定法则。

这条新增的法则是,不消举办Autoboxing/Auto-Unboxing的版本,优先于需要举办Autoboxing/Auto-Unboxing的版本。

因此,在这种环境下详细选择哪一个,要看通报的实参最初是什么范例。

清单27:不消举办Autoboxing/Auto-Unboxing的版本优先

public class OverloadingTest
{
private static void testOverloading(int i){
System.out.println("int");
}
private static void testOverloading(Integer i){
System.out.println("Integer");
}
public static void main(String[] args)
{
int i = 1;
Integer j = new Integer(1);
testOverloading(i);/* 输出“int” */
testOverloading(j);/* 输出“Integer” */
}
}

10. 值相等和引用相等

在Java语言中有两个差异的“相等”观念——值相等和引用相等。这样就有一个“两个值相等的根基范例数据,颠末Autoboxing之后,获得的工具的引用是否相等”的问题。

在《JSR 201: Extending the Java Programming Language with Enumerations, Autoboxing, Enhanced for loops and Static Import》中,对这个问题,是作了这样的划定:

#p#分页标题#e#

If the value p being boxed is true, false, a byte, an ASCII character, or an integer or short number between -127 and 128, then let r1 and r2 be the results of any two boxing conversions of p. It is always the case that r1 == r2.

这意味着这个谜底大概是“是”也大概是“否”,由被Autoboxing的数据的范例和取值来抉择。因此在检测两个工具是否代表沟通的值的时候,照旧有须要挪用equals()要领来举办。

不外在J2SDK 1.5 Beta 1和Beta 2里的实际环境,和这稍微有些进出,“Autoboxing之后获得沟通的工具引用”的范畴被缩小了:

清单28:本来的值相等,颠末Autoboxing之后的引用大概相等,也大概不相等

boolean b = true;
Boolean b1 = b;
Boolean b2 = b;
System.out.println(b1 == b2);/* 输出“true” */
char c = '1';
Character c1 = c;
Character c2 = c;
System.out.println(c1 == c2);/* 输出“false” */

#p#副标题#e#

11. 对机能的故障

由于Autoboxing机制的实质是“自动建设能代表根基范例数据的工具”,所以,不行制止的会对机能造成一些故障。

假如只是操作Autoboxing/Auto-Unboxing机制来生存根基范例的数据(譬喻把根基范例的数据放到Collection内里之类),这种影响倒还可以忽略,因为这只是把本来需要手工举办的事情自动化了;可是,假如要频繁的借助Autoboxing来给一个包裹类变量赋值,这开销很容易上升到需要加以留意的水平。

留意对包裹类的变量利用“++”和“–”运算符的时候,也会建设新的工具,而不是在修改本来工具的状态。

清单29:是替换不是修改

Integer i = new Integer(1);
Integer j = i;/* 让j、i指向同一工具 */
System.out.println(j == i);/* 今朝j、i是同一工具,因此输出“true” */
i++;
System.out.println(j == i);/* 此刻j、i是差异工具,因此输出“false” */
System.out.println(i);/* 此刻i的值是“2” */
System.out.println(j);/* 而j的值仍是“1” */

这个现象是由于Java里的包裹类是“不行变的(immutable)”——即没有提供一种能让本身所代表的值产生变革的途径——而造成的。

在需要大量赋值操纵的时候,可以通过适当利用一些根基范例的局部变量来减轻对机能方面的影响。不外,假如机能的瓶颈在于要往一个容器里频繁放入根基范例的数据的话,恐怕就得靠改用一些专门为容纳根基范例的数据而设计的容器类来办理了(譬喻Jarkata Commons Primitives组件里提供的那些)。

清单30:一段需要往一个容器里频繁放入根基范例的数据的措施

import java.util.*;
public class WordCounter {
public static void main(String[] args) {
HashMap counts = new HashMap();
for (int i = 0; i < args.length; i++) {
String current = args[i];
if (counts.containsKey(current)) {
counts.put(current, ((Integer) counts.get(current)) + 1);
} else {
counts.put(current, 1);
}
}
for (Iterator itr = counts.keySet().iterator(); itr.hasNext();) {
String key = (String) itr.next();
System.out.println(key + ":" + counts.get(key));
}
}
}

12. 归纳总结

借助J2SE 1.5里提供的Autoboxing/Auto-Unboxing机制,可以用一种更简朴的方法,来办理同时存在两套范例系统而造成的一些不利便。不外,这种机制并没有办理所有的相关问题,有些事情照旧需要靠手工操纵来举办。别的,由于不得当的利用这一机制会造成一些机能方面的负面影响,所以在利用的时候还要留意一些问题才行。

 

    关键字:

[contact-form-7 id="17097" title="form2"]天才代写-代写联系方式