Iteger intitjob - 众发娱乐

Iteger intitjob

2019-02-09 10:23:34 | 作者: 碧萱 | 标签: 办法,代码,目标 | 浏览: 283

.Java的Integer与int互转 博客分类: java面试题
JavaCacheJ#JDK .
int转Integer

Java代码 
1.int i = 0; 
2.Integer wrapperi = new Integer(i); 
int i = 0;
Integer wrapperi = new Integer(i);


Integer转int

Java代码 
1.Integer wrapperi = new Integer(0); 
2.int i = wrapperi.intValue(); 
Integer wrapperi = new Integer(0);
int i = wrapperi.intValue();




JDK1.5今后的int转Integer
JDK1.5今后,Java为咱们供给了更为丰厚的转化办法

其间最值得一提的就是主动装包/主动拆包(AutoBoxing/UnBoxing)。
此功用大大丰厚了根本类型(primitive type)数据与它们的包装类(Wrapper Class)
的运用。

因为AutoBoxing的存在,以下代码在JDK1.5的环境下能够编译经过并运转。

Java代码 
1.int i = 0; 
2.Integer wrapperi = i; 
int i = 0;
Integer wrapperi = i;


还有其他办法?
JDK1.5为Integer增加了一个全新的办法:

Java代码 
1.public static Integer valueOf(int i) 
public static Integer valueOf(int i)
以下代码在JDK1.5的环境下能够编译经过并运转。

Java代码 
1.int i = 0; 
2.Integer wrapperi = Integer.valueOf(i); 
int i = 0;
Integer wrapperi = Integer.valueOf(i);


此办法与new Integer(i)的不同处在于:
办法一调用类办法回来一个表明指定的 int 值的 Integer 实例。
办法二发生一个新的Integer目标

JDK API文档中对这个新的valueOf办法有清晰的解说:
假设不需求新的 Integer 实例,则一般应优先运用该办法,而不是结构办法 Integer(int),因为该办法有或许经过缓存常常恳求的值而明显提

高空间和时刻功能。

但这个解说有点不流畅难明。为什么该办法有或许经过缓存常常恳求的值而明显进步功能?

经过反编译东西检查valueOf办法。

Java代码 
1. /* 
2.  * 回来一个表明指定的 int 值的 Integer 实例。假设不需求新的 Integer 实例,则 
3.  * 一般应优先运用该办法,而不是结构办法 Integer(int),因为该办法有或许经过 
4.  * 缓存常常恳求的值而明显进步空间和时刻功能。 
5.  * @param  i an code int /code value. 
6.  * @return a tt Integer /tt instance representing tt i /tt . 
7.  * @since  1.5 
8.  */ 
9.public static Integer valueOf(int i) { 
10.  final int offset = 128; 
11.  if (i = -128 i = 127) { // must cache 
12.  return IntegerCache.cache[i + offset]; 
13.  } 
14.  return new Integer(i); 
15.} 
/* 
  * 回来一个表明指定的 int 值的 Integer 实例。假设不需求新的 Integer 实例,则 
  * 一般应优先运用该办法,而不是结构办法 Integer(int),因为该办法有或许经过 
  * 缓存常常恳求的值而明显进步空间和时刻功能。 
  * @param  i an code int /code value. 
  * @return a tt Integer /tt instance representing tt i /tt . 
  * @since  1.5 
  */ 
public static Integer valueOf(int i) { 
  final int offset = 128; 
  if (i = -128 i = 127) { // must cache 
  return IntegerCache.cache[i + offset]; 
  } 
  return new Integer(i); 



能够看到关于范围在-128到127的整数,valueOf办法做了特别处理。
选用IntegerCache.cache[i + offset]这个办法。
从姓名,咱们能够猜出这是某种缓存机制。

进一步盯梢IntegerCache这个类,此类代码如下

Java代码 
1./* 
2.  * IntegerCache内部类 
3.  * 其间cache[]数组用于寄存从-128到127总共256个整数 
4.  */ 
5.private static class IntegerCache { 
6.  private IntegerCache(){} 
7. 
8.  static final Integer cache[] = new Integer[-(-128) + 127 + 1]; 
9. 
10.  static { 
11.  for(int i = 0; i cache.length; i++) 
12.  cache[i] = new Integer(i - 128); 
13.  } 
14.} 
/* 
  * IntegerCache内部类 
  * 其间cache[]数组用于寄存从-128到127总共256个整数 
  */ 
private static class IntegerCache { 
  private IntegerCache(){} 
 
  static final Integer cache[] = new Integer[-(-128) + 127 + 1]; 
 
  static { 
  for(int i = 0; i cache.length; i++) 
  cache[i] = new Integer(i - 128); 
  } 



这就是valueOf办法真实的优化办法,当-128= i =127的时分,回来的是IntegerCache中的数组的值;当 i 127 或 i -128 时,回来的是

Integer类目标。

再举一个常常被说到的比如

Java代码 
1.Integer i=100; 
2.Integer j=100; 
3.//print true 
4.System.out.println(ij); 
Integer i=100;
Integer j=100;
//print true
System.out.println(ij);

此刻的 i=IntegerCache.cache[i + 128] = IntegerCache.cache[228],
相同j = IntegerCache.cache[j + 128] = IntgerCache.cache[228]
因而 Integer引证i中存储的是cache数组第228号元素的地址。同理j也是同一个cache数组的第228号元素的地址(因为cache是Integer的static

数组,只要一个)。
ij比较的是引证地址,因而回来true。


Java代码 
1.Integer i=200; 
2.Integer j=200; 
3.//print false 
4.System.out.println(ij); 
Integer i=200;
Integer j=200;
//print false
System.out.println(ij);

此刻的 i=new Integer(200);  相同j=new Integer(200) 。
两次都在堆中拓荒了Integer的目标。
i 和 j 中存储的堆的目标地址是彻底不同的。ij 天然回来false。


引进缓存机制的效果安在?

接着上面的比如,假设咱们在编程时很多需求值为100(100的范围在-128到127之间)的Integer目标。假设只能经过new来创立,需求在堆中开

辟很多值相同的Integer目标。
这是适当不划算的,IntegerCache.cache很好的起到了缓存的效果。
当咱们需求Integer i  = 100的时分,直接从cache中取出第[100+128]号元素的地址赋值给引证i,再次需求Integer j = 100时,仍是直接去这

个地址赋值给j。是不是省去了在堆中不断的创立目标的价值了(空间,时刻上的耗费都很大)。 这就是valueOf办法真实的进步功能之处。
正如JDK API文档对valueOf(int i)办法的描绘,该办法有或许经过缓存常常恳求的值而明显进步空间和时刻功能。

定论

valueOf(int i)的优化只针关于范围在-128到127的整数。




JDK1.5今后的Integer转int
因为UnBoxing的存在,以下代码在JDK1.5的环境下能够编译经过并运转。

Java代码 
1.Integer wrapperi = new Integer(0); 
2.int i = wrapperi; 
Integer wrapperi = new Integer(0);
int i = wrapperi;








附:AutoBoxing与UnBoxing带来的改变
在JDK1.5之前,咱们总是对调集不能寄存根本类型而耿耿于怀。

以下代码在JDK1.5中成为了或许,试想下在JDK1.5之前该怎么完成这段代码?

Java代码 
1.int x = 1; 
2.Collection collection = new ArrayList(); 
3.collection.add(x);//AutoBoxing,主动转化成Integer. 
4.Integer y = new Integer(2); 
5.collection.add(y + 2); //y + 2为UnBoxing,主动转化成int。之后再次转化为Integer。 
int x = 1;
Collection collection = new ArrayList();
collection.add(x);//AutoBoxing,主动转化成Integer.
Integer y = new Integer(2);
collection.add(y + 2); //y + 2为UnBoxing,主动转化成int。之后再次转化为Integer。


此特性相同适用于Map

Java代码 
1.Map map = new HashMap(); 
2.int x = 1; 
3.Integer y = new Integer(2); 
4.int z = 3; 
5.map.put(x,y + z);//x主动转化成Integer。y+z主动转化成int。之后再次转化为Integer。 
版权声明
本文来源于网络,版权归原作者所有,其内容与观点不代表众发娱乐立场。转载文章仅为传播更有价值的信息,如采编人员采编有误或者版权原因,请与我们联系,我们核实后立即修改或删除。

猜您喜欢的文章