基本类型的包装类

为什么需要学习包装类?

保证基本数据类型的运算功能以外,还能够有更多属性和方法供开发者调用,更加满足了面向对象思想

八大基本数据类型

byte short int long float double boolean char
对应的包装类
Byte Short integer Long Float Double Boolean Character

基本数据类型的装拆箱

Integer：

装箱：Integer.valueof(String s) 、new Integer(String s)
$实现方法：核心是返回Integer型$
拆箱：intValue() 、 integer.parseInt()
$实现方法：核心是返回int型$

 拆箱1： Integer i1=new Integer(100);
 	int i=i1.intValue();
 	
 拆箱2： int i2=Integer.parseInt("123");

自动装拆箱和格式化与解析

自动装拆箱

格式化与解析

格式化：对象现有的输出方式不满足用户需求，需要重新定义输出格式
解析：将文本文件加载到类中，生成对象
摘抄于String方法篇

	static String format(Locale l, String format, Object... args) 
	使用指定的区域设置，格式字符串和参数返回格式化的字符串。  
	static String format(String format, Object... args) 
	使用指定的格式字符串和参数返回格式化的字符串。  

​	System.out.format("大家好我叫做%s,我今年%d,我的性别是%c,我的爱好是%s", "张三", 18, '男', "打羽毛球");

摘抄与于日期类实际应用（重要）篇
Date格式化为字符串，字符串解析为Date

			//将date转化为字符串，并输出
			DateFormat df=new SimpleDateFormat("YYYY/MM/dd");
			Date d5=new Date();
			String da=df.format(d5);
			System.out.println(da);
			
			//将字符串转化为date
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			   try {
				Date bir= sdf.parse(s);//抛出解析异常（最好抛出throw）****************
				System.out.println(bir);
			} catch (ParseException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

其他包装类：

• Byte Short Long Float Double 都是和 Integer类似
• Boolean 不能够参与运算
• Character
• 1.任意的包装类类型都能够满足自动拆装箱
• 2.使用包装类型参与运算以及类型转换和基本数据类型完全一样
• 3.包装类类型有更多的成员方法供我们使用,更加满足了面向对象的思想
• 4.拆箱时，几个基本类型可以相互转换，因为都继承Number类（下面第六行代码）
• 5.拆箱函数会有基本数据类型在里（doubleValue、doubleValue）
• 6装箱一般就（valueof/new）

		Double d1=new Double("2.23");//装箱1
		Double d2=Double.valueOf(2.5);//装箱2，参数为double
		Double s=2.6;//自动装箱
		
		double d3=d1.doubleValue();//拆箱1
		double d4=d1.parseDouble("2.27");//拆箱2
		byte b=d1.byteValue();//拆箱
	
		Character ch=new Character('c');//装箱1
		Character ch2=Character.valueOf('k');//装箱2
		char ch3=ch.charValue();//拆箱

Character的其他方法

		System.out.println(Character.isJavaIdentifierPart('s'));//T
		//判断是否是char类型
		System.out.println(Character.isJavaIdentifierPart(1643424231));//F
		System.out.println(Character.isUpperCase('A'));//T，判断是否为大写
		System.out.println(Character.isLowerCase('a'));//T，判断是否为小写
		System.out.println(Character.isDigit('5'));//T，判断是否为数字

包装类对象的加减方法

		//ch+=3;//报错，Character对象不能加    因为ch=ch+3 ch（Character）对象不能和int运算  但是char可以
		ch3+=3;//正确，基本数据类型char可以与int运算
		ch=ch3;//如果要对对象进行操作可以先对char操作
		//将基本数据类型自动装箱，再赋值给ch对象
		Integer ii=new Integer(1);
		ii+=1;//正确，ii比较特殊，因为Integer与int一起时会自动变成int

构造方法//相当于装箱

• public Integer(int value)
• public Integer(String s)

包装类的成员方法

public int intValue() 拆箱，将Integer转化为整型
public static int parseInt(String s) 拆箱，将字符串转换为int类型
public static String toString(int i) 将整型转换为字符串
public static Integer valueOf(int i) 装箱，将整型装换为Integer类型
public static Integer valueOf(String s) 装箱，将字符串转换为Integer类型

		Integer i1=new Integer(100);//装箱，构造
		byte b=i1.byteValue();//拆箱		
		Integer a=Integer.valueOf("123");//装箱
		int q=Integer.parseInt("14");//拆箱

int和string的相互转换

int->String

		String a=String.valueOf(10);//***************用我******************
		String a1=Integer.valueOf(10).toString();//装箱变Integer，再转String（Integer复写过tostring）
		String a2="";
		String a3=new Integer(10).toString();
		

//String->int

		int i=Integer.valueOf(a).intValue();//先转为Integer,再拆箱为int型
		int i2=Integer.valueOf(a2);//自动转换，Integer自动转换成int型
		int i3=Integer.parseInt(a2);//********************用我****************
		//“拆箱进阶版”直接由string-》int
		int i4=new Integer(a2).intValue();//不推荐用

int的自动转拆箱

     Integer i1=new Integer(10);
	System.out.println(i1+10);
	// 本质的结果 System.out.println(ii.intValue + 10);--》20

	System.out.println(i1-20);
	Boolean b1=(i1\==10);//实质：i1.intValue==10
	System.out.println(b1);//返回true
	Boolean b2=i1>2;
	System.out.println(b2);//返回true

--------------------------------------------------------------------------------------------------
$很重要！！！！$
当Integer和int做±*/<>或==时,integer会自动拆箱，得到int结果

进制转换

普通进制转换方法

public class Integer_02 {
	public static void tenTOtwo(int num){
		int i=0;
		int two[]=new int[50];
		while(num>0)
		{
		two[i]=num%2;//先求余数，再除2，得到的数组的倒数是二进制
		num/=2;
		i++;	
		}
		for(i--;i>=0;i--)
		{
			System.out.print(two[i]);
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		tenTOtwo(30);
	}
}

Integer的转进制方法：

十进制到其他进制（注意最多9（0-9）+26（a-z）进制）

public static String toBinaryString(int i)//十进制转二进制

String a=Integer.toBinaryString(num);//将num转换成二进制

public static String toHexString(int i)//十进制转16进制

String a2=Integer.toHexString(65);//将num转换成16进制

$publicstaticStringtoString(inti,intradix)$ //十进制转任意进制

		String a1=Integer.toString(65,16);//将65转换成16进制-------41
		String a4=Integer.toString(49,7);//将49转化为7进制--------100（7进制  首位0-6  十位7*1-7*6   百位7*7-7*7*6）
		

任意进制转十进制

public static int parseInt(String s,int radix)

	int nums=Integer.parseInt("fff",16);//4095
	System.out.println(nums);

任意进制转任意进制

//16转2 先由16进制变成十进制，再由十进制变成2进制

	int nums=Integer.parseInt("fff",16);//4095  （16变十进制）
	String nums2=Integer.toString(nums,2);//（10变2进制）
	//十六变2   ：一位变四位 f一位变成1111   共3个f变成12个1
	System.out.println(nums2);//111111111111

关于Intger的面试题

基础版本：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Integer i01 = 127; // Integer.valueOf(59);自动装箱
		int i02 = 127;
		Integer i03 = Integer.valueOf(127);
		Integer i04 = new Integer(127);
		
		System.out.println("i01 == i02:" + (i01 == i02)); // true 之前讲过当Integer对象和int在一起时+-/*=><都会自动转型为int
	    System.out.println("i01 == i03:" + (i01 == i03)); // true i01和i03是对象与对象比较，看地址
	    //因为Integer.valueOf（）里面有个Cache数组范围[-128,127],Static修饰（产生于类加载），i01和103所指向的都是这个静态方法中的数组    
	    System.out.println("i03 == i04:" + (i03 == i04)); // false 对象与对象的比较，指向不同地址
	    System.out.println("i02 == i04:" + (i02 == i04)); // true   对象与int比较，自动转换成int
	
	}

进阶版本：

Integer i01 = 128;
Integer i03 = Integer.valueOf(128);
 System.out.println("i01 == i03:" + (i01 == i03));//false  cache[]中没有128，所以要自己创.
 //因为i01是在类加载时，生成的静态常量 。但i03是对象创建时，生成的新地址，在堆区。