(java)包装类型+整型常量池(Integer中使用)

java中八种基本数据类型对应的包装类型

基本数据类型		包装类型
byte			java.lang.Byte
short			java.lang.Short
int				java.lang.Integer
long			java.lang.Long
	
float			java.lang.Float
double			java.lang.Double

boolean			java.lang.Boolean

char			java.lang.Character

思考：java中提供的八种基本数据类型不够用吗?为什么java中还要提供对应的包装类呢？

应用场景如下：规定一个方法的入口参数可以是java中任何一种数据类型
public class Test{
	public static void m1(Object o1){
		//如果没有数据类型对应的包装类型，放的入口参数只能传单一的数据类型
		//相当于是基本数据有个附带的引用类型，Object是任何类型的父类，即可以传递任何一种数据类型的包装类
		System.out.println(o1);
	}
	public static void main(String[] args){
		//基本数据类型
		byte b = 5;
		//引用类型(包装类)
		Byte b1  = new Byte(b);
		
		m1(b);
	}
}

包装类型之间的继承结构关系

这里以Integer为例，讲解包装类中常用的方法

1.Integer类中的常量，最大最小值

	System.out.println("int max"+Integer.MAX_VALUE);

2.Integer的两个构造法方法
Integer​(int value)
Integer​(String s)

Integer i1 = new Integer(10); //int---->Integer
Integer i2 = new Integer("123");//String -->Interger
Integer i3 = new Integer("abc");	
			
System.out.println(i1);//输出10
System.out.println(i2);//输出123
System.out.println(i3);//在这里输出的编译的时候不会报，运行的时候会报出异常，因为String转化为Integer时，字符串里必须要是数字
//如果字符串里不是数字的话，将报出的异常为数字格式异常

3.Integer中的一些常用方法

1.//将Integer转换为int
Integer i1 = new Integer(10);
int t1 = i1.intValue();
System.out.println(t1);

2.//将String转换为int    static int parsenInt(String s);
//使用方法
int price = parsenInt("123");
//以下会报数组格式异常
int ds = Integer.parseInt("dsds");

//如果想把字符串里的带小数点的类型,即double类型转换，则需要使用Double类型里面的方法   static parseDouble("3.14");
double t2  = Double.parseDouble("3.14");
System.out.println(t2);


3.将int转为2,16,8进制数   static String toBinaryString(int i)
static String toHexString(int i)
static String toOctalString(int i)

例:		System.out.println(Integer.toBinaryString(25));//11001

4.将int -->Integer
Integer.valuseOf(10);

5.String--->Integer
Integer i3 = Integer.valuseOf("10");

	

总结转换关系

	//int-->Integer
			Integer.valueOf(10);
			//Integer--->int
			Integer t3 = new Integer(10);
			int s5 = t3.intValue();
			
			//String--->Integer
			Integer i3 = Integer.valueOf("1");
			
			//Integer--->String;
			String s6 = i3.toString();
			
			//String --->int
			int i4 = Integer.parseInt("123");
			
			
			//int-->String
			String s2 = 10 + "";

自动装箱与拆箱
自动装箱和自动拆箱是程序编译阶段的一个概念，和程序运行无关

public class Test{
	public static void main(String[] args){
		//JDK5.0之前
		//int---Integer  （装箱）
		Integer n1 = new Integer(10);

		//Integer--->int (拆箱)
		int n2 = n1.intValue();
		
		//自动装箱
		Integer n3 = 10;
		//自动拆箱
		int n4 = n3;

		//下面也是自动装箱的用法之一：
		m1(10);

		m2(10,5);
		
	}
	public static void m1(Object o){
		System.out.println(o);
	}

	public static int m2(Integer o1,Integer o2){
		return o1-o2;  //自动拆箱
	}


	重点:如果数据是在(-128~127之间)，java中引入了一个“整型常量池”
	Integer i5 = 127;
	Integer i6 = 127;	
	
	System.out.println(i5==i6);//true，当加入了整型常量池之后，提升了效率
	
	Integer i7 = 129;
	Integer i8 = 1279;	
	
	System.out.println(i7==i8);//false，当加入了整型常量池之后，提升了效率
	
	
}