如何选择jdk版本，开发ja版本的sdk

对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素,然后打印其中年龄的两个作家的姓名。

对于很多刚接触ja语言的初学者来说，要了解一门语言，的方式就是要能从基础的版本进行了解，升级的过程，以及升级的新特性，这样才能循序渐进的学好一门语言，版本本别为JDK1.5版本到JDK1.7版本。SDK是Software Dlopment Kit的缩写，中文意思是“软件开发工具包”。这是一个覆盖面相当广泛的名词，可以这么说：辅助开发某一类软件的相关文档、范例和工具的都可以叫做“SDK”。SDK是一系列文件的组合，它为软件的开发提供一个平台(它为软件开发使用各种API提供便利)。

自动装箱和自动拆箱 什么叫自动装箱和自动拆箱

1）.自动装箱与拆箱：

自动装箱的过程：每当需要一种类型的对象时，这种基本类型就自动地封装到与它相同类型的包装中。

自动拆箱的过程：每当需要一个值时，被装箱对象中的值就被自动地提取出来，没必要再去调用intValue()和doubleValue()方法。

自动装箱，只需将该值赋给一个类型包装器引用，ja会自动创建一个对象。

自动拆箱，只需将该对象值赋给一个基本类型即可。

ja——类的包装器

类型包装器有：Double,Float,Long,Integer,Short,Character和Boolean

2）.枚举

把里的对象元素一个一个提取出来。枚举类型使代码更具可读性，理解清晰，易于维护。枚举类型是强类型的，从而保证了系统安全性。而以类的静态字段实现的类似替代模型，不具有枚举的简单性和类型安全性。

简单的用法：JaEnum简单的用法一般用于代表一组常用常量，可用来代表一类相同类型的常量值。

复杂用法：Ja为枚举类型提供了一些内置的方法，同事枚举常量还可以有自己的方法。可以很方便的遍历枚举对象。

3）.静态导入

通过使用 import static，就可以不用指定 Constants 类名而直接使用静态成员，包括静态方法。

import xxxx 和 import static xxxx的区别是前者一般导入的是类文件如import ja.util.Scanner;后者一般是导入静态的方法，import static ja.lang.System.out。

4）.可变参数（Varargs）

可变参数的简单语法格式为：

modName([argumentList], dataType...argumentName);

（可以使用Lambda的格式对其进行修改。修改后如下：2）JDK 1.6新特性

1）.Desktop类和SystemTray类

在JDK6中 ,AWT新增加了两个类:Desktop和SystemTray。

前者可以用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档;后者可以用来在系统托盘区创建一个托盘程序.

2）.使用JAXB2来实现对象与XML之间的映射

JAXB是Ja Architecture for XML Binding的缩写，可以将一个Ja对象转变成为XML格式，反之亦然。

我 们把对象与关系数据库之间的映射称为ORM, 其实也可以把对象与XML之间的映射称为OXM(Object XML Mapping). 原来JAXB是Ja EE的一部分，在JDK6中，SUN将其放到了Ja SE中，这也是SUN的一贯做法。JDK6中自带的这个JAXB版本是2.0, 比起1.0(JSR 31)来，JAXB2(JSR 222)用JDK5的新特性Annotation来标识要作绑定的类和属性等，这就极大简化了开发的工作量。 实 际上，在Ja EE 5.0中，EJB和Web Servs也通过Annotation来简化开发工作。另外,JAXB2在底层是用StAX(JSR 173)来处理XML文档。除了JAXB之外，我们还可以通过XMLBeans和Castor等来实现同样的功能。

3）.理解StAX StAX(JSR 173)是JDK6.0中除了DOM和SAX之外的又一种处理XML文档的API。

StAX是The Streaming API for XML的缩写，一种利用拉模式解析(pull-parsing)XML文档的API.StAX通过提供一种基于迭代器(Iterator)的API让 程序员去控制xml文档解析过程,程序遍历这个迭代器去处理每一个解析，解析可以看做是程序拉出来的，也就是程序促使解析器产生一个解析 然后处理该，之后又促使解析器产生下一个解析，如此循环直到碰到文档结束符； SAX也是基于处理xml文档，但却 是用推模式解析，解析器解析完整个xml文档后，才产生解析，然后推给程序去处理这些；DOM 采用的方式是将整个xml文档映射到一颗内存树，这样就可以很容易地得到父节点和子结点以及兄弟节点的数据，但如果文档很大，将会影响性能。

3. 自定义自动关闭类以下是jdk7 api中的接口，（不过注释太长，删掉了close()方法的一部分注释）

“Ja is still not dead—and people are starting to figure that out.”

本教程将用带注释的简单代码来描述新特性，你将看不到大片吓人的文字。

一、接口的默认方法

代码如下:

intece Formula {

default double sqrt(int a) {

Formula接口在拥有calculate方法之外同时还定义如果我们想获取值自己进行处理可以使用get方法获取，但是不。因为当Optional内部的数据为空的时候会出现异常。了sqrt方法，实现了Formula接口的子类只需要实现一个calculate方法，默认方法sqrt将在子类上可以直接使用。

代码如下:

Formula formula = new Formula() {

formula.calculate(100); // 100.0

文中的formula被实现为一个匿名类的实例，该代码非常容易理解，6行代码实现了计算 sqrt(a 100)。在下一节中，我们将会看到实现单方法接口的更简单的做法。

译者注： 在Ja中只有单继承，如果要让一个类赋予新的特性，通常是使用接口来实现，在C++中支持多继承，允许一个子类同时具有多个父类的接口与功能，在其他 语言中，让一个类同时具有其他的可复用代码的方法叫做mixin。新的Ja 8 的这个特新在编译器实现的角度上来说更加接近Scala的trait。 在C#中也有名为扩展方法的概念，允许给已存在的类型扩展方法，和Ja 8的这个在语义上有别。

代码 代码如下:

Collections.sort(names, new Comparator() {

只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。

在Ja 8 中你就没必要使用这种传统的匿名对象的方式了，Ja 8提供了更简洁的语法，lambda表达式：

代码 代码如下:

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

看到了吧，代码变得更段且更具有可读性，但是实际上还可以写得更短：

代码 代码如下:

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

对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：

代码 代码如下:

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

总结：试着看哪个版本更顺手，用的效率，。JDK 1.7 。

请问ja中，Double类型和double有什么不同？能否转换？

当我们声明一个Integer c = 100;的时候。此时会进行自动装箱作，简单点说，也就是把基本数据类型转换成Integer对象，而转换成Integer对象正是调用的valueOf方法，可以看到，Integer中把-128-127 缓存了下来。解释是小的数字使用的频率比较高，所以为了优化性能，把这之间的数缓存了下来。这就是为什么这道题的回事false和ture了。当声明的Integer对象的值在-128-127之间的时候，引用的是同一个对象，所以结果是true。

Double 是类 double是基础数据类型。Double类型是double的包装类，在JDK1.5以后，二者可以直接相互赋值，称为自动拆箱和自动装箱。如果是这样，可以用Double中的方法，将包装类转为基本数据类型。

2.由static修饰的方法称为静态方法/类方法

可以转换的。

double 和 float 的区别是double精度高，有效数字16位，float精度7位。但double消耗内存是float的两倍，double的运算速度比float慢得多，C语言中数学函数名称double 和 float不同，不要写错，能用单精度时不要用双精度（以省内存，加快运算速度）。

类型 重载就是同名不同参，同一行为接收不同的参数，重写是子类对超类的复写，达到多态比特数 有效数字 数值范围

float 32 6-7 -3.410(-38)～3.410(38)

double 64 15-16 -1.710(-308)～1.710(308)

long double 128 18-19 -1.210(-4932)～1.210(4932)

简单来说，Float为单精度，内存中占4个字节，有效数位是7位（因为有正

负，所以不是8位），在我的电脑且VC++6.0平台中默认显示是6位有效数字；double为双精度，占8个字节，有效数位是16位，但在我的电脑且VC++6.0平台中默认显示同样是6位有效数字。

double类型的包装类是Double；

备注：double是基本数据类型，Double是对象。但是现在的jdk1.5以上版本都是可以直接进行转换的，ja会自动进行封装，所有使用上的区别不是很大的。

函数式编程-Lambda与Stream

12

我们在创建线程并启动时可以使用匿名内部类的写法：

Lambda写法：

现有方法定义如下，其中IntPredicate是一个接口。先使用匿名内部类的写法调用该方法。

Lambda写法：

现有方法定义如下，其中Function是一个接口。先使用匿名内部类的写法调用该方法。

Lambda写法：

现有方法定义如下，其中IntConsumer是一个接口。先使用匿名内部类的写法调用该方法。

Lambda写法：

Ja8的Stream使用的是函数式编程模式，如同它的名字一样，它可以被用来对或数组进行链状流式的作。可以更方便的让我们对或数组作。

我们可以调用getAuthors方法获取到作家的。现在需要打印所有年龄小于18的作家的名字，并且要注意去重。

单列： 对象.stream()

数组：Arrays.stream(数组)或者使用Stream.of来创建

双列：转换成单列后再创建

可以对流中的元素进行条件过滤，符合过滤条件的才能继续留在流中。

例如：Integer i_a = new Integer(a); //将int型a装箱

打印所有姓名长度大于1的作家的姓名

可以把对流中的元素进行计算或转换。

例如：

打印所有作家的姓名

可以去除流中的重复元素。

例如：

打印所有作家的姓名，并且要求其中不能有重复元素。

注意：distinct方法是依赖Object的equals方法来判断是否是相同对象的。所以需要注意重写equals方法。

例如：

对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素。

注意：如果调用空参的sorted()方法，需要流中的元素是实现了Comparable。

可以设置流的长度，超出的部分将被抛弃。

例如：

跳过流中的前n个元素，返回剩下的元素

例如：

打印除了年龄的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。

map只能把一个对象转换成另一个对象来作为流中的元素。而flatMap可以把一个对象转换成多个对象作为流中的元素。

例一：

打印所有书籍的名字。要求对重复的元素进行去重。

例二：

对流中的元素进行遍历作，我们通过传入的参数去指定对遍历到的元素进行什么具体作。

例子：

输出所有作家的名字

可以用来获取当前流中元素的个数。

例子：

打印这些作家的所出书籍的数目，注意删除重复元素。

可以用来或者流中的最值。

例子：

分别获取这些作家的所出书籍的分和分并打印。

把当前流转换成一个。

例子：

获取一个存放所有作者名字的List。

获取一个所有书名的Set。

获取一个Map，map的key为作者名，value为List

可以用来判断是否有任意符合匹配条件的元素，结果为boolean类型。

例子：

判断是否有年龄在29以上的作家

可以用来判断是否都符合匹配条件，结果为boolean类型。如果都符合结果为true，否则结果为false。

例子：

判断是否所有的作家都是成年人

可以判断流中的元素是否都不符合匹配条件。如果都不符合结果为true，否则结果为false

例子：

判断作家是否都没有超过100岁的。

获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的个元素。

例子：

获取任意一个年龄大于18的作家，如果存在就输出他的名字

获取流中的个元素。

例子：

获取一个年龄最小的作家，并输出他的姓名。

对流中的数据按照你指定的计算方式计算出一个结果。（缩减作）

reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和初始化值进行计算，计算结果再和后面的元素计算。

reduce两个参数的重载形式内部的计算方式如下：

其中identity就是我们可以通过方法参数传入的初始值，accumulator的apply具体进行什么计算也是我们通过方法参数来确定的。

例子：

使用reduce求所有作者年龄的和

使用reduce求所有作者中年龄的值

使用reduce求所有作者中年龄的最小值

reduce一个参数的重载形式内部的计算

如果用一个参数的重载方法去求最小值代码如下：

我们在编写代码的时候出现最多的就是空指针异常。所以在很多情况下我们需要做各种非空的判断。

例如：

尤其是对象中的属性还是一个对象的情况下。这种判断会更多。

而过多的判断语句会让我们的代码显得臃肿不堪。

所以在JDK8中引入了Optional,养成使用Optional的习惯后你可以写出更优雅的代码来避免空指针异常。

并且在很多函数式编程相关的API中也都用到了Optional，如果不会使用Optional也会对函数式编程的学习造成影响。

我们一般使用 Optional 的 静态方法ofNullable 来把数据封装成一[ja] view plaincopy个Optional对象。无论传入的参数是否为null都不会出现问题。

你可能会觉得还要加一行代码来封装数据比较麻烦。但是如果改造下getAuthor方法，让其的返回值就是封装好的Optional的话，我们在使用时就会方便很多。

而且在实际开发中我们的数据很多是从数据库获取的。Mybatis从3.5版本可以也已经支持Optional了。我们可以直接把dao方法的返回值类型定义成Optional类型，MyBastis会自己把数据封装成Optional对象返回。封装的过程也不需要我们自己作。

如果你 确定一个对象不是空 的则可以使用 Optional 的 静态方法of 来把数据封装成Optional对象。

但是一定要注意，如果使用of的时候传入的参数必须不为null。（尝试下传入null会出现什么结果）

如果一个方法的返回值类型是Optional类型。而如果我们经判断发现某次计算得到的返回值为null，这个时候就需要把null封装成Optional对象返回。这时则可以使用 Optional 的 静态方法empty 来进行封装。

所以你觉得哪种方式会更方便呢？ ofNullable

我们获取到一个Optional对象后肯定需要对其中的数据进行使用。这时候我们可以使用其 ifPresent 方法对来消费其中的值。

这个方判断其内封装的数据是否为空，不为空时才会执行具体的消费代码。这样使用起来就更加安全了。

例如,以下写法就优雅的避免了空指针异常。

如果我们期望安全的获取值。我们不使用get方法，而是使用Optional提供的以下方法。

我们可以使用filter方法对数据进行过滤。如果原本是有数据的，但是不符合判断，也会变成一个无数据的Optional对象。

我们可以使用isPresent方法进行是否存在数据的判断。如果为空返回值为false,如果不为空，返回值为true。但是这种方式并不能体现Optional的好处， 更使用ifPresent方法 。

Optional还提供了map可以让我们的对数据进行转换，并且转换得到的数据也还是被Optional包装好的，保证了我们的使用安全。

例如我们想获取作家的书籍。

只有一个抽象方法 的接口我们称之为函数接口。

JDK的函数式接口都加上了 @FunctionalIntece 注解进行标识。但是无论是否加上该注解只要接口中只有一个抽象方法，都是函数式接口。

我们在使用lambda时，如果方法体中只有一个方法的调用的话（包括构造方法）,我们可以用方法引用进一步简化代码。

我们在使用lambda时不需要考虑什么时候用方法引用，用哪种方法引用，方法引用的格式是什么。我们只需要在写完lambda方法发现方法体只有一行代码，并且是方法的调用时使用快捷键尝试是否能够转换成方法引用即可。

当我们方法引用使用的多了慢慢的也可以直接写出方法引用。

类名或者对象名::方法名

其实就是引用类的静态方法

如果我们在重写方法的时候，方法体中 只有一行代码 ，并且这行代码是 调用了某个类的静态方法 ，并且我们把要重写的 抽象方法中所有的参数都按照顺序传入了这个静态方法中 ，这个时候我们就可以引用类的静态方法。

例如：

如下代码就可以用方法引用进行简化

注意，如果我们所重写的方法是没有参数的，调用的方法也是没有参数的也相当于符合以上规则。

优化后如下：

如果我们在重写方法的时候，方法体中 只有一行代码 ，并且这行代码是 调用了某个对象的成员方法 ，并且我们把要重写的 抽象方法中所有的参数都按照顺序传入了这个成员方法中 ，这个时候我们就可以引用对象的实例方法

例如：

优化后：

如果我们在重写方法的时候，方法体中 只有一行代码 ，并且这行代码是 调用了个参数的成员方法 ，并且我们把要 重写的抽象方法中剩余的所有的参数都按照顺序传入了这个成员方法中 ，这个时候我们就可以引用类的实例方法。

例如：

优化后如下：

如果方法体中的一行代码是构造器的话就可以使用构造器引用。

如果我们在重写方法的时候，方法体中 只有一行代码 ，并且这行代码是 调用了某个类的构造方法 ，并且我们把 要重写的抽象方法中的所有的参数都按照顺序传入了这个构造方法中 ，这个时候我们就可以引用构造器。

例如：

优化后：

我们之前用到的很多Stream的方法由于都使用了泛型。所以涉及到的参数和返回值都是引用数据类型。

即使我们作的是整数小数，但是实际用的都是他们的包装类。JDK5中引入的自动装箱和自动拆箱让我们在使用对应的包装类时就好像使用基本数据类型一样方便。但是你一定要知道装箱和拆箱肯定是要消耗时间的。虽然这个时间消耗很下。但是在大量的数据不断的重复装箱拆箱的时候，你就不能无视这个时间损耗了。

所以为了让我们能够对这部分的时间消耗进行优化。Stream还提供了很多专门针对基本数据类型的方法。

例如：mapToInt,mapToLong,mapToDouble,flatMapToInt,flatMapToDouble等。

当流中有大量元素时，我们可以使用并行流去提高作的效率。其实并行流就是把任务分配给多个线程去完全。如果我们自己去用代码实现的话其实会非常的复杂，并且要求你对并发编程有足够的理解和认识。而如果我们使用Stream的话，我们只需要修改一个方法的调用就可以使用并行流来帮我们实现，从而提高效率。

parallel方法可以把串行流转换成并行流。

谁能告诉我，用Integer in=new Integer(10),将int包装成integer

StAX 的来历 ：在JAXP1.3(JSR 206)有两种处理XML文档的方法:DOM(Document Object Model)和SAX(Simple API for XML).

List list = new ArrayList<>(); //这样的语句是通不过编译的，因为泛型的本质是类型擦除，最终都会擦除为Object类型

List list = new ArrayList<>(); //必须使用包装器类I2、重载、重写、重定义的异同点？nteger来存储整型数

int a = 105、接口可以多继承，意义不同，接口是面向契约。有，一般为了抽象时用;

list.add(i_a); //添加到ArrayList中

int a = i_get.intValue(); //将包装器对象i_get拆箱得到整数的值并赋给int型变量a你可以看到上面这一系列装箱和拆箱的代码有多么繁琐，所以从jdk1.5开始引入了自动装箱/自动拆箱的语法糖，上面的代码可以简化为：

List list = new ArrayList<>(); //必须使用包装器类Integer来存储整型数

int a = 10;

list.add(a); //将a自动装箱为Integer类对象并添加到ArrayList中

int a = list.get(a); //从ArrayList中取出第0个元素并自动拆箱得到int型赋给变量a此外，这些包装器类还提供一些工具类的功能，比如将一个数字字符串转化成它对应的整型数字：

int a = Integer.valueOf("123"); //a=123

Integer a = 1 Integer b = 1 a==b -> true Integer a = 1111 Integer b = 1111 a==b -> false 求解释啊。

现有方法定义如下，其中IntBinaryOperator是一个接口。先使用匿名内部类的写法调用该方法。

Integer是类，a和b就不是基本类型有些方法，特别是泛型方法，需要传递对象作为参数，而int、boolean等基本数据类型的变量不是对象，所以不能使用这些方法。为了能让这些变量也能使用这些方法，就需要将它们装箱为类类型如Integer和Boolean类的对象，然后传递到方法中。例如，使用ArrayList保存一串整型数据：了，而是一个对象，对象用“==”做比较时是比较的内存地址而不是值。为1的时候相等的原因应该是楼上那位的解释吧。

Integer i_get = list.get(0); //从ArrayList中取出第0个元素并赋值给包装器对象i_get

你都已经用了Integer了 为啥不用.equals()方法判等于呢

==判定的是内存地址 目前可以知道的是当 a b 定义的值小于128的时候其内存地址指向一个数据 而超过此值则为两个地址

ja开发的缺点有哪些？

可以对流中的元素进行排序。

我认为Ja语言的10大问题是：

1、缺少闭包（closure）：我想这个不需要解释了。函数式编程已经存在几十年了，但最近几年，它们获得了越来越多的关注，最主要的原因，是它可以自然地编写并行程序。我部分的同意Joshua Bloch强调在Ja中引入闭包的问题需要再想一想（BGGA提议的方式真的很糟），至少闭包的缺失，使得在Ja中做任何真正的函数式编程都是不可能的。

2、缺少一等函数：这个问题与前一个有些关联，但我认为它更糟糕。在Ja里，要达到类似效果的方式，是使用的、丑陋悲惨的单方法匿名内部类，但这看上去的确是一个拙劣的方法。甚至在C#中，也通过机制，提供了一个更好的实现。

3、原生类型（Primitive types）：如果在Ja中一切皆对象，那是多么完美啊，但他们偏偏不这样设计。因而，这一点导致了一些问题，比如，不能把一个int放到（Collection）里，这个在Ja5中通过自动装箱特性得到了解决（下面会提到）。它也造成了传值与传引用上的困扰，原生类型数据是通过值传给方法的（一份拷贝，然后传给函数），而真正的对象是通过传递（译注：其实是对象地址再传递，因此应该也是传值方式，只是由于函数内部可通过这个对象地址访问对象，因此效果上类似传引用）。

4、自动装箱（Autoboxing）和自动拆箱（autounboxing）：这个特性是为了解决因原生类型的存在所导致的问题，在Ja5引入的。它允许静默地转换原生类型到相应的对象，但这常常导致其它的问题。比如Integer可以为null，但int不能，因此这时JVM只能抛出一个难以调试的空指针异常（NullSystem.out.println(a == b);PointerException）。此外，它还可能导致其它奇怪的行为，就像下面的例子，我们就很难理解，变量test为什么是false：

Intger a = new Integer(1024);

Intger b = new Integer(1024);

boolean test = a < b || a == b || a > b;

5、缺少范型具类化：范型是Ja5引入的一个很酷的特征，但是为了保持与旧版本Ja的兼容性，导致缺失某些重要的特性，尤其是不能在运行时反省范型的类型。例如，你有一个方法，接受List参数，如果传进来一个List，你却不能知道运行里该范型的确切类型。同理，你也不能创建范型数组。这意味着，尽管下面的代码看起来很自然，但却不编译不了：

List[] listsOfStrings = new List[3];

6、不可避免的范型：你有发现过自己陷入不可能去掉的关于范型的么？如果你像我一样大量使用范型，我打你碰到过。事实上，是这个问题的规模化症状，让他们认为需要引入一个特定的注解(@SuppressWarnings("unchecked"))来处理这种情况，我觉得，范型应该可能被设计的更好。

7、不能传void给方法调用：我得承认，这种给方法传递void的需求，乍一看有些怪异。我喜欢DSL，当我实现自己的DSL库（lambdaj）的一个特定特性时，我不得不需要一个方法声明成这样的签名：void doSoming(Object parameter)，这里为这个方法传进来的参数parameter，是另一个方法调用的结果，它的目的，是注册调用（的对象）自身，以可以在以后执行它。让我吃惊的是，即使println方法返回void，看上去也并没有一个好理由，不允许我把代码写成这样，：

doSoming(System.out.println("test"));

8、没有原生的机制：是一种非常有效和应用广泛的模式，但Ja提供的机制，只针对接口，而不是具体类。这是为什么象cblib这样提供这种机制的库，被如此多的主流框架，如Spring和Hibernate，采用的原因。此外，由于cglib通过运行时创建被类的子类来实现的，因此这些种方式有一个众所周知的限制——不能final类，比如String。

9、劲的Switch...case语句：Ja规定，switch...case只能选择int和enum（J由 于JDK6.0中的JAXB2(JSR 222)和JAX-WS 2.0(JSR 224)都会用到StAX所以Sun决定把StAX加入到JAXP家族当中来，并将JAXP的版本升级到1.4(JAXP1.4是JAXP1.3的维护版 本). JDK6里面JAXP的版本就是1.4. 。a5开始）。这一点如果跟更现代的语言如Scala相比，看起来简直太弱了。

10、受检查异常（Checked exception）：类似原生类型，受检查异常也已经成为Ja的一个罪孽之源。它迫使程序员必须做下面两件极其糟糕讨厌的事情中的一个：让你的代码里充斥大量的、糟糕难读的、容易出错的try...catch语句，而这样做的意义，只是将捕获的异常，包装成运行时异常，然后再重新抛出；或者是让大量的抛出声明子句污染你的API，让接口缺少灵活性和可扩展性。

真正的问题是，这里我提到的这几大主要问题，的解决办法，是要做一个痛苦的决择，定义一套新的语言规范，放下当前版本的向后兼容性。我猜他们永远也不会这么做，虽然我相信，如果编写一个能够自动转换旧Ja源码的程序，让它们与假设的新版本兼容，并不是很困难。，这就是我决定开始寻找一个更好的JVM兼容语言的原因。

包装有哪些分类

}}

Ja 的每个基本类型都对应了一个包装类型，比如说 int 的包装类型为 Integer，double 的包装类型为 Double。基本类型和包装类型的区别主要有以下 4 点

Optional就好像是包装类，可以把我们的具体数据封装Optional对象内部。然后我们去使用Optional中封装好的方法作封装进去的数据就可以非常优雅的避免空指针异常。

1.包装类型可以为 null，而基本类型不可以

它使得包装类型可以应用于 POJO 中，而基本类型则不行

POJO：简单无规则的 Ja 对象，只有属性字段以及 setter 和 getter 方法，示例如下。

class Writer {

private Integer age;

private String name;

public Integer getAge() {

return age;

}public void setAge(Integer age) {

this.age = age;

}public 8、给网络传输提供一个标准，rmi，ejb里都用String getName() {

return name;

}public void setName(String name) {

this.name = name;

为什么 POJO 的属性必须要用包装类型?

《阿里巴巴 Ja 开发手册》上有详细的说明

数据库的查询结果可能是 null，如果使用基本类型的话，因为要自动拆箱（将包装类型转为基本类型，比如说把 Integer 对象转换成 int 值），就会抛出 NullPointerException 的异常。

2.包装类型可用于泛型，而基本类型不可以

List list = new ArrayList>();

// 提示 Syntax error, insert "Dimensions" to complete ReferenceType

List list = new ArrayList>();

3.基本类型比包装类型更高效

基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用

相比较于基本类型而言，包装类型需要占用更多的内存空间。假如没有基本类型的话，对于数值这类经常使用到的数据来说，每次都要通过 new 一个包装类型就显得非常笨重。

两个包装类型的值可以相同，但却不相等

Integer chenmo = new Integer(10);

Integer wanger = new Integer(10);

System.out.println(chenmo == wanger); // false

System.out.println(chenmo.equals(wanger )); // true

两个包装类型在使用“==”进行判断的时候，判断的是其指向的地址是否相等。将“==”作符应用于包装类型比较的时候，其结果很可能会和预期的不符。

4.自动装箱和自动拆箱

有了基本类型和包装类型，肯定有些时候要在它们之间进行转换。

把基本类型转换成包装类型的过程叫做装箱。

反之，把包装类型转换成基本类型的过程叫做拆箱

在 Ja SE5 之前，开发人员要手动进行装拆箱

Integer chenmo = new Integer(10); // 手动装箱

int wanger = chenmo.intValue(); // 手动拆箱

Integer chenmo = 10; // 自动装箱

int wanger = chenmo; // 自动拆箱

等价于

=>

Integer chenmo = Integer.valueOf(10);

int wanger = chenmo.intValue();

也就是说，自动装箱是通过Integer.valueOf()完成的；自动拆箱是通过 Integer.intValue() 完成的

特别注意：

当需要进行自动装箱时，如果数字在 -128 至 127 之间时，会直接使用缓存中的对象，而不是重新创建一个对象

在ja中，Double类型和double有什么不同？能否相互转换？

new Runnable() {

Double类型是double的包装类，在JDK1.5以后，二者可以直接相互赋值，称为自动拆箱和自动装箱。 double是基本类型数据，Double是基本类型double的包装类，是一个对象。所以两个不能直接相加。需要用amount.doubleValue()返回的值就变成了基本类型的double，就可以相加了。

3,

你用的是JDK1.5以下的版本。不支持自动装箱拆箱

Ja SE5 为了减少开发人员的工作，提供了自动装箱与自动拆箱的功能

Double 是double的包装类。 也就是对象化了。

在1.4中可以这样使用

Double d =new Double(dou)可将double基本数据类型装箱为Double包装类

double dou =d.doubleValue()可将Double的包装类拆箱为基本数据类型

ja中double类型如果小数点后为零显示整数否则保留

第三阶段——Ja框架

Double是对象，double是基本类型。

（3）JDK 1.List names = Arrays.asList("peter", "anna", "mike", "xenia");7 新特性

你好Double类型是double的包装类，在JDK1.5以后，二者可以直接相互赋值，称为自动拆箱和自动装箱。看你的提示，我推测你的jdk版本在1.5以前。 如果是这样，可以用Double中的方法，将包装类转为基本数据类型，如：

double amount = rec.getAmount().doubleValue() 。

Ja基本类型：

Ja基本类型共有八种，基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。

数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者作系统的改变而改变。

实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类ja.lang.Void，不过我们无法直接对它们进行作。

ja问题

打印现有数据的所有分类。要求对分类进行去重。不能出现这种格式：哲学,爱情

首先，

Integer[] a

这是个Integer类型的数组，是一个对象，那么你要放入的肯定是Integer这种类型的对象，

但是数字3，并不是Integer，他是ja的简单类型，那么在jaEE5以后，ja有了这种自动封装的能力，可以把简单类型封装为相应的对象。

因此，3//autoBoxing是为了让你明白，即便是你不new Integer(3)，ja也可以自动的给你封装，但是要注意的是，这种能力有jdk版本限制

Autoboxing是自动装箱的意思

自动拆箱指的是由封装类型自动转化为简单类型

当前定义的数组为Integer类型,而其中的数据3默认情况为int类型,在这里无需转换类型,程序自动进行转化,这个过程称为装箱

在jdk5.0之前,像这样的声明是编译通不过的,如:

而5.0之后的版本均提供了自动装箱的功能,这也是JAVA性能改进的一个方面

3, // Autobo}System.out.println(name);xing

3是代表值 也就是说向数组中插的值有1，2，3

//Autoboxing 代表的是注释

补充 Integer[] a = {

new Integer(1),

new Inte（4）投稿：junjie 字体：[增加 减小] 类型：转载本教程将Ja8的新特新逐一列出，并将使用简单的代码示例来指导你如何使用默认接口方法，lambda表达式，方法引用以及多重Annotation，之后你将会学到的API上的改进，比如流，函数式接口，Map以及全新的日期APIger(2),

}; 这句话的意思 就是向这个int类型的数组a 中加入3个值

值 为(1,2,3) 。

JAVA 中的 box 可以理解为一个盒子对象。它在JDK1.5版本提出的，它源于JDK之前的版本在把一个基本数据类型从包装类中提出是需要显性调用包装方法，在JDK1.5后可以自动自动装包/拆包(Autoboxing/unboxing)

自动装包/拆包大大方便了基本类型数据和它们包装类地使用。

自动装包：基本类型自动转为包装类.(int >> Integer)

自动拆包：包装类自动转为基本类型.(Integer >> int)

生成了俩对象！

---

免责声明： 本文由用户上传，如有侵权请联系删除！

---

标签：