Java Integer类的使用

integer

整数 / 整型数

是编程语言的基本数据类型之一，用以指示变量的数据类型，也用于常量（变量、表达式）的强制数据类型转换(也是我们主要学的)。整型数据的长度及其取值范围并不固定，受编译环境影响。

(1）Integer有一个实例域value，它保存了这个Integer所代表的int型的值，且它是final的，也就是说这个Integer对象一经构造完成，它所代表的值就不能再被改变。

(2）Integer重写了equals()方法，它通过比较两个Integer对象的value，来判断是否相等。

(3）重点是静态内部类IntegerCache，通过类名就可以发现：它是用来缓存数据的。它有一个数组，里面保存的是连续的Integer对象。
(a) low：代表缓存数据中最小的值，固定是-128。
(b) high：代表缓存数据中最大的值，它可以被该改变，默认是127。

( 4）调用valueOf(int i)方法时，首先判断i是否在[low,high]之间，如果是，则复用Integer.cache[i-low]。比如，如果Integer.valueOf(3)，直接返回Integer.cache[131]；如果i不在这个范围，则调用构造方法，构造出一个新的Integer对象。

( 5）调用intValue()，直接返回value的值。
通过3）和4）可以发现，默认情况下，在使用自动装箱时，VM会复用[-128,127]之间的Integer对象。

常用的integer方法：
1.toString()方法

//返回值类型：String,返回一个表示该 Integer 值的 String 对象

代码如下：

public class test{
	public static void main(String args[]){
		Integer x=5;//封箱手法，后面有详细
		System.out.println(x.toString());  
		//输出结果为5，接下来验证它为String类型
		
		String a=Integer.toString(12);
		System.out.println(a);
		//输出结果为12，a为String类型的，证明int类型已转换为String类型的
		}
	}	

由以上代码可知toString可以把int类型已转换为String类型的，接下来我们看一下toString的实例用法

public class CSDN {
	public static void main(String[] args) {
		a a=new a();
		System.out.println(a.toString());
	}
}
class a{
	private String s;
	void b(){
		System.out.println("b");
		s="我在A类"+66;
	}
	public String toString() {
		b();
		return s;
	}
}

//输出结果为：我在A类66
----------------------------------------------
//如果不用toString方法呢？public class CSDN {
	public static void main(String[] args) {
		a a=new a();
		System.out.println(a.toString());
	}
}
class a{
	private String s;
	void b(){
		s="我在A类"+66;
		System.out.println(s);
	}
	public void c() {
		b();	
	}
}
//输出结果为储存地址（四月二十六.a@6d06d69c）

Arrays.toString(}方法

 public static void main(String[] args){
    	int[] array = {3,8,5,65,34,27};
    	System.out.println(array.toString());
    	System.out.println(Arrays.toString(array));
    	bubbleSort(array);
    	System.out.println(Arrays.toString(array));
    	
    }

	private static void bubbleSort(int[] array) {
		// TODO Auto-generated method stub
		
	}

integer的构造方法

public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);

		Integer Int1=new Integer(100);
		System.out.println(Int1);//100

		Integer Int2=new Integer("100");
		System.out.println(Int2);//100

		Integer Int3=new Integer("abc");//错误，打印不出结果，因为abc不是数字字符串，所以转换回报错
		}
	}

Java的封箱与拆箱机制

Java有8种基本类型，每种基本类型又有对应的包装类型。在Java中，一切都以对象作为基础，但是基本类型并不是对象，如果想以对象的方式使用这8中基本类型，可以将它们转换为对应的包装类型。基本类型和包装类型的对应：

数据类型	包装类型
int（4字节）	Integer
byte（1字节）	Byte
short（2字节）	Short
long（8字节）	Long
float（4字节）	Float
double（8字节）	Double
char（2字节）	Character
boolean（未定）	Boolean

封箱的概念：基本数据类型转换为包装类的过程称为装箱

拆箱的概念：包装类变为基本数据类型的过程称为拆箱

包装类也重写了equals方法，只要两个包装类对象所包装的基本类型数据是相等的，那么，则认为两个包装类对象是相等的；

封箱的代码

jdk5之前

Integer vaule=new Integer(10);

5及5以后

public class CSDN{
	public static void main(String[] args) {
		Integer s1 = 100;
		Integer s2 = 100;
		Integer s3 = 200;
		Integer s4 =Integer.VauleOf(200);//手动封箱	
		System.out.println(s1 == s2);
		System.out.println(s1.equals(s2));
		System.out.println(s3 == s4);
		System.out.println(s3.equals(s4));
	}
}
---------------------拆箱--------------------
		Integer  a1 = 1;
    	Integer  a2 = 1;
    	Integer  a3 = new Integer(1);
    	int b1=a1;
    	int b2=a2;
    	
    	 int b3 = a3.intValue();//手动拆箱
    	System.out.println(a1 == a2);
    	System.out.println(a1 == a3);
    	System.out.println(b1==b3);

结果为

true 
true 
false
true 
---------------
true
false
true

进一步展示

public static void main(String[] args) {
		
	Integer a = 1;
	Integer b = 2;
	Integer c = 3;
	Integer d = 3;
	Integer e = 321;
	Integer f = 321;
	Long g = 3l;
	Long h = 2l;

	System.out.println(c == d);
	System.out.println(e == f);
	System.out.println(c == (a+b));
	System.out.println(c.equals(a+b));
	System.out.println(g == (a+b));
	System.out.println(g.equals(a+b));
	System.out.println(g.equals(a+h));

	}

true
false
true
true
true，因为Java中小类型会自动转化为大类型

false，因为类型上根本就不匹配，Long和Integer
public static void main(String[] args){
double a=1;
Long b=2l;
Long c=3l;
System.out.println(c.equals(a+b));
}
}
true，小类型与大类型运算时发生了自动转换。
public static void main(String[] args){
double a=1;
Long b=2l;
Long c=3l;
System.out.println(c.equals(a+b));
}

包装类做运算时会拆箱将其转变为基本类型去运算，然后在比较的时候再进行一次自动的装箱比较引用。而实际上最后比较的就是3和3的引用，3在Integer类的缓冲区中故为true。