下载文档原格式
integer类和character类的常用方法Integer类的常用方法1. 创建Integer对象•Integer(int value)：根据指定的int值创建Integer对象。
•Integer(String s)：根据指定的字符串值创建Integer对象。
2. 值转换•int intValue()：将Integer对象转换为int类型的值。
•String toString()：将Integer对象转换为字符串。
3. 比较方法•boolean equals(Object obj)：比较两个Integer 对象是否相等。
•int compareTo(Integer anotherInteger)：将一个Integer对象与另一个Integer对象进行比较。
4. 数学运算•int compareTo(Integer anotherInteger)：将一个Integer对象与另一个Integer对象进行比较。
•static int parseInt(String s)：将字符串转换为int类型。
Character类的常用方法1. 创建Character对象•Character(char value)：根据指定的char值创建Character 对象。
2. 常量方法•static boolean isDigit(char ch)：判断字符是否为数字。
•static boolean isLetter(char ch)：判断字符是否为字母。
•static boolean isUpperCase(char ch)：判断字符是否为大写字母。
•static boolean isLowerCase(char ch)：判断字符是否为小写字母。
3. 字符转换•int charValue()：将Character对象转换为char 类型的值。
•static char toUpperCase(char ch)：将字符转换为大写字母。
java中字符串转int方法Java中字符串转int方法在Java编程中，经常需要将字符串转换为整数类型，这在一些需要处理用户输入的情况下尤为重要。
本文将介绍几种常用的字符串转int的方法，帮助读者在实际开发中灵活运用。
方法一：使用Integer.parseInt()方法Integer.parseInt()方法是Java中最常用的将字符串转换为整数的方法之一。
该方法将字符串作为参数传入，并返回一个对应的整数类型值。
下面是使用该方法的示例代码：```javaString numStr = "123";int num = Integer.parseInt(numStr);System.out.println(num); // 输出 123```需要注意的是，如果字符串无法转换为整数，例如包含了非数字字符，将会抛出NumberFormatException异常。
因此，在使用Integer.parseInt()方法时，需要注意对异常进行处理。
方法二：使用Integer.valueOf()方法Integer.valueOf()方法也可以将字符串转换为整数类型，但与parseInt()方法不同的是，valueOf()方法返回的是一个Integer对象，而不是基本类型int。
需要通过调用Integer对象的intValue()方法获取整数值。
下面是使用valueOf()方法的示例代码：```javaString numStr = "456";Integer numObj = Integer.valueOf(numStr);int num = numObj.intValue();System.out.println(num); // 输出 456```同样地，如果字符串无法转换为整数，将会抛出NumberFormatException异常，需要进行异常处理。
方法三：使用Integer.parseInt()方法的重载形式除了接受一个字符串参数的parseInt()方法，Java还提供了其他重载形式的parseInt()方法，可以接受多个参数。
integer类型的tohexstring方法-回复Integer类是Java编程语言中的一个包装类，用于表示整型数据。
它提供了一系列方法，以处理整数值。
其中，toHexString方法被用于将一个整数转换为它的十六进制字符串表示形式。
本文将深入探讨该方法的使用，并逐步解释其背后的原理和步骤。
首先，我们需要了解十六进制（Hexadecimal）的概念。
十六进制是一种以16为基数的数制系统，它使用0-9的十个数字和A-F的六个字母来表示数值。
在计算机科学中，十六进制常用于表示二进制数，特别是在与计算机内存和寄存器的交互中。
在Java中，toHexString方法是Integer类的一个静态方法，它接收一个整数作为参数，并返回一个十六进制字符串。
方法签名如下：public static String toHexString(int i)接下来，我们将分步解释toHexString方法的执行过程。
首先，方法获取输入整数的二进制补码形式。
二进制补码是用来表示有符号整数的一种方法，它是通过将原始的二进制表示形式取反并加1来获得的。
然后，方法将二进制补码形式转换为十六进制字符串表示形式。
这一步骤的具体实现如下：1. 首先，方法检查输入整数的符号。
如果整数为负数，则在转换为字符串前，将其转换为其对应的正数形式。
2. 接下来，方法执行连续的除法和取余运算，将整数转换为十六进制字符串。
除法运算的除数是16，而取余运算的结果将被用于构建十六进制字符串。
3. 通过除法和取余运算，方法从整数的最低有效位开始，逐步取得十六进制表示中的每个数字。
对于余数为0-9的情况，直接将余数转换为字符并将其添加到结果字符串的开始。
对于余数为10-15的情况，将其转换为字符'A'到'F'（'A'表示10，'B'表示11，等等）。
然后将转换得到的字符添加到结果字符串的开始。
4. 在转换结束后，结果字符串将包含整数的十六进制表示形式。
java string数组转integer数组的方法【最新版4篇】目录（篇1）I.引言A.介绍B.本文目的II.Java字符串数组转整数数组的方法A.使用Arrays类的静态方法B.使用Java自带的字符串处理方法C.使用第三方库方法III.结论A.方法优缺点B.适用场景正文（篇1）I.引言Java是一种流行的编程语言，它在许多领域都有广泛应用。
在Java 中，字符串和整数都是常用的数据类型。
在处理字符串和整数时，常常需要将一个类型转换为另一个类型。
本篇文章将介绍三种将Java字符串数组转换为整数数组的方法。
II.Java字符串数组转整数数组的方法1.使用Arrays类的静态方法：Java提供了Arrays类的静态方法`asList`，它可以将一个字符串数组转换为整数数组。
示例如下：```javaString[] strArray = {"1", "2", "3"};int[] intArray =Arrays.stream(strArray).mapToInt(Integer::parseInt).toArray();```2.使用Java自带的字符串处理方法：Java提供了一些内置的字符串处理方法，如`String`类的`parseInt`方法和`Integer`类的`valueOf`方法。
示例如下：```javaString[] strArray = {"1", "2", "3"};int[] intArray = new int[strArray.length];for (int i = 0; i u003c strArray.length; i++) {intArray[i] = Integer.parseInt(strArray[i]);}```3.使用第三方库方法：Java中有许多第三方库可以用于字符串和整数的转换。
integer.parseint()用法Integer.parseInt()是Java语言中的一个静态方法，它的作用是将字符串参数作为有符号的十进制整数进行解析。
Integer.parseInt()方法在ng包中定义，它使用int和String两个参数，并返回一个int值。
1. Integer.parseInt() 方法的原型： public static int parseInt(String s) throws NumberFormatException2. 参数s：要被解析的字符串3. 返回值：解析后的int值4. 抛出异常：NumberFormatException - 如果字符串不能被解析成一个整数Integer.parseInt()方法使用了多种不同的算法来解析字符串参数，以获得最佳的性能。
它可以处理正负整数，但不能处理小数、大数、科学计数法等格式。
此外，如果字符串参数只包含空格或者其他无效字符，将抛出NumberFormatException异常。
Integer.parseInt()方法可以被用来解析从文件、网络或者命令行传入的字符串格式的数据，解析后的数据可以用在程序里进行各种操作。
例如，通过Integer.parseInt()方法可以解析所传入的字符串参数，然后将其转换成对应的整数值，从而可以用于数据的运算。
Integer.parseInt()方法的一个常见用法是将字符串格式的数字转换成其对应的int值，通过Integer.parseInt()方法可以将字符串格式的数字转换成其对应的int值。
下面是一个简单的示例：// 将字符串“123”转换为int值 int number = Integer.parseInt("123"); // 输出结果为123 System.out.println(number);Integer.parseInt()方法也可以用来解析具有特定进制格式的字符串，这需要使用另外一个重载的方法：public static int parseInt(String s, int radix) throws NumberFormatException该方法接受一个int类型的参数radix，该参数表示要解析的字符串所用的进制，例如：// 将字符串“1010”（2进制）转换为int值 int number = Integer.parseInt("1010", 2); // 输出结果为10 System.out.println(number);当然，Integer.parseInt()方法也可以用来解析其他进制的字符串，如8进制、16进制等。
integer类型的tohexstring方法题目：Integer类型的toHexString方法解析：一窥数据转换的奥秘导言：在计算机科学中，数据转换是一项关键任务。
在编程中，我们常常需要将十进制数字转换为十六进制，或者将十六进制数字转换为十进制。
Java中的Integer类提供了toHexString方法来实现这种转换。
本文将深入探讨该方法的使用原理和应用场景，帮助读者更好地理解数据转换的奥秘。
第一部分：了解toHexString方法的基本概念（200字）Integer类是Java中表示整数的包装类之一。
其中的toHexString方法用于将整数转换为十六进制字符串，并返回结果。
该方法的原型为：public static String toHexString(int i)该方法的输入参数是一个整数，返回值是一个字符串对象。
toHexString方法是一个静态方法，因此可以通过类名直接调用。
第二部分：toHexString方法的使用示例（200字）下面通过几个例子来展示toHexString方法的用法：1. 示例一：将十进制数字转换为十六进制int number = 255;String hexString = Integer.toHexString(number);System.out.println("Number in hexadecimal format: " +hexString);输出结果为：Number in hexadecimal format: ff2. 示例二：将十六进制字符串转换为十进制数字String hexNumber = "1A";int decimalNumber = Integer.parseInt(hexNumber, 16);System.out.println("Number in decimal format: " + decimalNumber);输出结果为：Number in decimal format: 26通过这些示例，我们可以发现toHexString方法在不同的情景下为我们提供了十进制和十六进制之间的转换功能。
integer类型的tohexstring方法-回复Integer是Java中的一个基本数据类型，它用于表示整数。
在Integer类中，有一个toHexString()方法，用于将一个整数转换成十六进制字符串。
本文将一步一步回答有关这个方法的问题，以深入了解这个功能。
首先，我们需要明确toHexString()方法的定义和用法。
Integer类中的toHexString()方法是一个静态方法，它的定义如下：public static String toHexString(int i)该方法接受一个整数作为参数，然后将其转换成一个十六进制字符串表示。
返回的字符串中的字母是小写的，并且没有前缀“0x”。
接下来，我们将详细说明toHexString()方法的工作原理。
首先，该方法将检查传入的参数是否为负数。
如果是负数，则会将其转换为对应的正数，然后执行后面的操作。
然后，toHexString()方法将整数转换为十六进制字符串的步骤如下：1. 将整数转换成二进制字符串。
这可以通过将整数除以16并取其余数的方式，依次将余数拼接起来得到二进制字符串。
2. 将二进制字符串转换成十六进制字符串。
这可以通过将二进制字符串按每四位一组进行分组，然后将每组转换成对应的十六进制数字的方式完成。
3. 将十六进制数字转换成对应的字母（小写）。
这可以通过使用一个映射表，将每个十六进制数字映射成对应的字母。
最后，toHexString()方法将得到的十六进制字符串作为结果返回。
让我们通过一个示例来更好地理解toHexString()方法的工作原理。
假设我们要将整数10转换成十六进制字符串。
首先，我们将10转换成二进制字符串，结果为1010。
然后，将二进制字符串按每四位一组分组，得到10和10，分别对应于十六进制的A和A。
最后，将A和A转换成小写的字母，得到aa。
因此，整数10对应的十六进制字符串为aa。
除了了解toHexString()方法的工作原理之外，我们还需要注意一些使用该方法时需要注意的事项。
integer parseint用法Integer.parseInt()是Java中的一个方法，用于将字符串转换为整数类型的数据。
在Java中，整数类型包括byte、short、int和long。
使用Integer.parseInt()方法可以将字符串转换为int类型的整数。
该方法的语法如下：int num = Integer.parseInt(str);其中，num是一个整数变量，用于存储转换后的整数值；str是一个字符串，表示要转换的数字。
在使用Integer.parseInt()方法时，需要注意以下几点：1. 字符串必须是合法的整数表示，即只包含数字字符和可选的正负号。
否则，会抛出NumberFormatException异常。
2. 如果字符串以0开头，且不是以0x或0X开头表示十六进制数，那么字符串将被解释为八进制数。
例如，字符串"0123"将被解释为十进制数83，因为0123是一个有效的八进制数。
3. 如果字符串表示的整数超出了int类型的取值范围，将会抛出NumberFormatException异常。
需要根据实际情况选择合适的数据类型来存储转换后的整数。
下面是一个使用Integer.parseInt()方法的示例：```javaString str = "12345";int num = Integer.parseInt(str);System.out.println(num); // 输出：12345```在上面的示例中，将字符串"12345"转换为整数类型的数据，并将结果存储在变量num中。
最后，使用System.out.println()方法打印出num的值。
除了将字符串转换为int类型的整数，Integer.parseInt()方法还可以用于将字符串转换为其他整数类型，如byte、short和long。
只需要将转换后的结果赋给相应的变量即可。
Java中string和int的互相转换问题int -> Stringint i=12345;String s="";核⼼：s=i+"";String -> ints="12345";int i;核⼼：i=Integer.parseInt(s);package com.fry.util;public class Transfer {public void stringToInt(){String id="20171091";int n=Integer.parseInt(id);System.out.println(n);}}这个⽅法的测试结果就是20171091。
以下参考：java中string和int互相转化1 如何将字串 String 转换成整数 int?A. 有两个⽅法:1). int i = Integer.parseInt([String]); 或i = Integer.parseInt([String],[int radix]);2). int i = Integer.valueOf(my_str).intValue();注: 字串转成 Double, Float, Long 的⽅法⼤同⼩异.2 如何将整数 int 转换成字串 String ?A. 有叁种⽅法:1.) String s = String.valueOf(i);2.) String s = Integer.toString(i);3.) String s = "" + i;注: Double, Float, Long 转成字串的⽅法⼤同⼩异.int -> Stringint i=12345;String s="";第⼀种⽅法：s=i+"";第⼆种⽅法：s=String.valueOf(i);这两种⽅法有什么区别呢？作⽤是不是⼀样的呢？是不是在任何下都能互换呢？String -> ints="12345";int i;第⼀种⽅法：i=Integer.parseInt(s);第⼆种⽅法：i=Integer.valueOf(s).intValue();这两种⽅法有什么区别呢？作⽤是不是⼀样的呢？是不是在任何下都能互换呢？以下是答案：第⼀种⽅法：s=i+""; //会产⽣两个String对象第⼆种⽅法：s=String.valueOf(i); //直接使⽤String类的静态⽅法，只产⽣⼀个对象第⼀种⽅法：i=Integer.parseInt(s);//直接使⽤静态⽅法，不会产⽣多余的对象，但会抛出异常第⼆种⽅法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产⽣⼀个对象--------------------------------------------------------------------1如何将字串 String 转换成整数 int?A. 有两个⽅法:1). int i = Integer.parseInt([String]); 或i = Integer.parseInt([String],[int radix]);2). int i = Integer.valueOf(my_str).intValue();注: 字串转成 Double, Float, Long 的⽅法⼤同⼩异.2 如何将整数 int 转换成字串 String ?A. 有叁种⽅法:1.) String s = String.valueOf(i);2.) String s = Integer.toString(i);3.) String s = "" + i;注: Double, Float, Long 转成字串的⽅法⼤同⼩异.JAVA数据类型转换关键字类型转换这是⼀个例⼦,说的是JAVA中数据数型的转换.供⼤家学习引package .lwkj.erts.register;import java.sql.Date;public class TypeChange {public TypeChange() {}//change the string type to the int typepublic static int stringToInt(String intstr){Integer integer;integer = Integer.valueOf(intstr);return integer.intValue();}//change int type to the string typepublic static String intToString(int value){Integer integer = new Integer(value);return integer.toString();}//change the string type to the float typepublic static float stringToFloat(String floatstr){Float floatee;floatee = Float.valueOf(floatstr);return floatee.floatValue();}//change the float type to the string typepublic static String floatToString(float value){Float floatee = new Float(value);return floatee.toString();}//change the string type to the sqlDate typepublic static java.sql.Date stringToDate(String dateStr){return java.sql.Date.valueOf(dateStr);}//change the sqlDate type to the string typepublic static String dateToString(java.sql.Date datee){return datee.toString();}public static void main(String[] args){java.sql.Date day ;day = TypeChange.stringToDate("2003-11-3");String strday = TypeChange.dateToString(day);System.out.println(strday);}}JAVA中常⽤数据类型转换函数虽然都能在JAVA API中找到，整理⼀下做个备份。
java中string和int互相转化1 如何将字串 String 转换成整数 int?A. 有两个⽅法:1). int i = Integer.parseInt([String]); 或i = Integer.parseInt([String],[int radix]);2). int i = Integer.valueOf(my_str).intValue();注: 字串转成 Double, Float, Long 的⽅法⼤同⼩异.2 如何将整数 int 转换成字串 String ?A. 有叁种⽅法:1.) String s = String.valueOf(i);2.) String s = Integer.toString(i);3.) String s = "" + i;注: Double, Float, Long 转成字串的⽅法⼤同⼩异.int -> Stringint i=12345;String s="";第⼀种⽅法：s=i+"";第⼆种⽅法：s=String.valueOf(i);这两种⽅法有什么区别呢？作⽤是不是⼀样的呢？是不是在任何下都能互换呢？String -> ints="12345";int i;第⼀种⽅法：i=Integer.parseInt(s);第⼆种⽅法：i=Integer.valueOf(s).intValue();这两种⽅法有什么区别呢？作⽤是不是⼀样的呢？是不是在任何下都能互换呢？以下是答案：第⼀种⽅法：s=i+""; //会产⽣两个String对象第⼆种⽅法：s=String.valueOf(i); //直接使⽤String类的静态⽅法，只产⽣⼀个对象第⼀种⽅法：i=Integer.parseInt(s);//直接使⽤静态⽅法，不会产⽣多余的对象，但会抛出异常第⼆种⽅法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产⽣⼀个对象--------------------------------------------------------------------1如何将字串 String 转换成整数 int?A. 有两个⽅法:1). int i = Integer.parseInt([String]); 或i = Integer.parseInt([String],[int radix]);2). int i = Integer.valueOf(my_str).intValue();注: 字串转成 Double, Float, Long 的⽅法⼤同⼩异.2 如何将整数 int 转换成字串 String ?A. 有叁种⽅法:1.) String s = String.valueOf(i);2.) String s = Integer.toString(i);3.) String s = "" + i;注: Double, Float, Long 转成字串的⽅法⼤同⼩异.数据类型转换关键字类型转换这是⼀个例⼦,说的是JAVA中数据数型的转换.供⼤家学习引package .lwkj.erts.register;import java.sql.Date;public class TypeChange {public TypeChange() {}//change the string type to the int typepublic static int stringToInt(String intstr){Integer integer;integer = Integer.valueOf(intstr);return integer.intValue();}//change int type to the string typepublic static String intToString(int value){Integer integer = new Integer(value);return integer.toString();}//change the string type to the float typepublic static float stringToFloat(String floatstr){Float floatee;floatee = Float.valueOf(floatstr);return floatee.floatValue();}//change the float type to the string typepublic static String floatToString(float value){Float floatee = new Float(value);return floatee.toString();}//change the string type to the sqlDate typepublic static java.sql.Date stringToDate(String dateStr){return java.sql.Date.valueOf(dateStr);}//change the sqlDate type to the string typepublic static String dateToString(java.sql.Date datee){return datee.toString();}public static void main(String[] args){java.sql.Date day ;day = TypeChange.stringToDate("2003-11-3");String strday = TypeChange.dateToString(day);System.out.println(strday);}}JAVA中常⽤数据类型转换函数虽然都能在API中找到，整理⼀下做个备份。
Java是一种面向对象语言，为了能将基本类型视为对象来处理，并能连接相关的方法，Java为每个基本数据类型都提供了包装类，这样便可以把这些基本类型转化为对象来处理。
Java int与integer的区别int与integer的区别从大的方面来说就是基本数据类型与其包装类的区别：int 是基本类型，直接存数值，而integer是对象，用一个引用指向这个对象1.Java 中的数据类型分为基本数据类型和引用数据类型int 是前者而integer 是后者（也就是一个类）；因此在类进行初始化时int类的变量初始为0.而Integer的变量则初始化为null.2.初始化时：int i =1；Integer i= new Integer(1);(要把integer 当做一个类看)；但由于有了自动装箱和拆箱使得对Integer类也可使用：Integer i= 1；注意：Integer i=1编译时被翻译成Integer i=Integer.valueOf(i);int 是基本数据类型（面向过程留下的痕迹，不过是对java的有益补充），Integer 是一个类，是int的扩展，定义了很多的转换方法类似的还有：float Float;double Double等，而且还提供了处理 int 类型时非常有用的其他一些常量和方法举个例子：当需要往ArrayList，HashMap中放东西时，像int，double这种内建类型是放不进去的，因为容器都是装 object的，这是就需要这些基本类型的包装类了。
Java中int和Integer关系是比较微妙的。
关系如下：1.int是基本的数据类型；2.Integer是int的包装类；3.int和Integer都可以表示某一个数值；4.int和Integer不能够互用，因为他们两种不同的数据类型；举例说明ArrayList al=new ArrayList();int n=40;Integer nI=new Integer(n);al.add(n);//不可以al.add(nI);//可以并且泛型定义时也不支持int: 如：List<Integer> list = new ArrayList<Integer>();可以而List<int> list = new ArrayList<int>();则不行Integer与int互转int转Integerint i=0;Integer wrapperi=new Integer(i);Integer转intInteger wrapperi=new Integer(0);int i=wrapperi;JDK1.5以后的int转IntegerJDK1.5以后，Java为我们提供了更为丰富的转换方法。
其中最值得一提的就是自动装包/自动拆包(AutoBoxing/UnBoxing)。
此功能大大丰富了基本类型(primitive type)数据与它们的包装类(Wrapper Class) 的使用。
由于AutoBoxing的存在，以下代码在JDK1.5的环境下可以编译通过并运行。
int i = 0;Integer wrapperi = i;JDK1.5为Integer增加了一个全新的方法：public static Integer valueOf(int i)此方法与new Integer(i)的不同处在于:valueOf（i）方法返回一个表示指定的int值的Integer实例，new Integer（i）产生一个新的Integer对象。
JDK API文档中对这个新的valueOf方法有明确的解释：如果不需要新的 Integer 实例，则通常应优先使用该方法，而不是构造方法Integer(int)，因为该方法有可能通过缓存经常请求的值而显著提高空间和时间性能。
但这个解释有点晦涩难懂。
为什么该方法有可能通过缓存经常请求的值而显著提高性能？通过反编译工具查看valueOf方法。
/** 返回一个表示指定的 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 cachereturn IntegerCache.cache[i + offset];}return new Integer(i);}可以看到对于范围在-128到127的整数，valueOf方法做了特殊处理。
采用IntegerCache.cache[i + offset]这个方法。
从名字，我们可以猜出这是某种缓存机制。
进一步跟踪IntegerCache这个类，此类代码如下/** 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类对象。
再举一个经常被提到的例子Integer i=100;//编译时被翻译成Integer i=Integer.valueOf(100);Integer j=100;//print trueSystem.out.println(i==j);此时的 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数组，只有一个)。
i==j比较的是引用地址，因此返回true。
Integer i=200;Integer j=200;//print falseSystem.out.println(i==j);此时的 i=new Integer(200); 同样j=new Integer(200) 。
两次都在堆中开辟了Integer的对象。
i 和 j 中存储的堆的对象地址是完全不同的。
i==j 自然返回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的环境下可以编译通过并运行。
Integer wrapperi = new Integer(0);int i = wrapperi;附：AutoBoxing与UnBoxing带来的转变在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀。
以下代码在JDK1.5中成为了可能，试想下在JDK1.5之前该如何实现这段代码？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。
此特性同样适用于MapMap map = new HashMap();int x = 1;Integer y = new Integer(2);int z = 3;map.put(x,y + z);//x自动转换成Integer。
y+z自动转换成int。
之后再次转换为Integer。
Integer k=100;Integer k2=100;Integer k3=324;Integer k4=324;Integer s=new Integer(90);Integer s3=new Integer(90);int k5=100;int k6=324;int k7=324;System.out.println("k==k2 "+(k==k2));System.out.println("k3==k4 "+(k3==k4));System.out.println("k==k5 "+(k==k5));System.out.println("k6==k7 "+(k6==k7));System.out.println("s==s3 "+(s==s3));System.out.println("k3==k7 "+(k3==k7));k2=k2.valueOf(100);System.out.println(k2==k);k=k.valueOf(324);System.out.println("k==k3 "+(k==k3));System.out.println("k==k6 "+(k==k6));输出结果：k==k2 truek3==k4 falsek==k5 truek6==k7 trues==s3 falsek==s falsek3==k7 truetruek==k3 falsek==k6 true总而言之：如果我们定义一个int类型的数，只是用来进行一些加减乘除的运算or作为参数进行传递，那么就可以直接声明为int基本数据类型，但如果要像对象一样来进行处理，那么就要用Integer来声明一个对象，因为java是面向对象的语言，因此当声明为对象时能够提供很多对象间转换的方式，与一些常用的方法。
