包装类

快来打我* 2021-10-30 02:14 422阅读 0赞

为什么需要学习包装类?

*  保证基本数据类型的运算功能以外,还能够有更多属性和方法供开发者调用,更加满足了面向对象思想
 *  八大基本数据类型  
    byte short int long float double boolean char  
    Byte Short integer Long Float Double Boolean Character
 *  构造方法  
    public Integer(int value)  
    public Integer(String s)

public class IntegerDemo01 {
        
    	public static void main(String[] args) {
        
    		System.out.println(Integer.MAX_VALUE); // 2147483647
    		System.out.println(Integer.MIN_VALUE); // -2147483648
    		System.out.println(Integer.SIZE);
    		Class c = Integer.TYPE; //class Integer
    		Class c2 = int.class;
    		System.out.println(c == c2); // true
    		
    		Integer ii = new Integer(100); // 手动装箱: 将基本数据类型 转换成 包装类类型
    		Class c3 = ii.getClass();
    		
    		Integer ii2 = new Integer("100");
    		System.out.println(ii2);
    	}
    }

成员方法  
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类型

public class IntegerDemo02 {
        
    	public static void main(String[] args) {
        
    		Integer ii = new Integer(100);
    		int i = ii.intValue(); // 手动拆箱: 将包装类类型转换成 基本数据类型
    		System.out.println(i);
    		
    		// 任何一个数值类型对应的包装类都可以拆箱成其他任何基本数据类型,只不过可能会出现小问题
    		byte by = ii.byteValue();
    		short s = ii.shortValue();
    		long longValue = ii.longValue();
    		float floatValue = ii.floatValue();
    		double doubleValue = ii.doubleValue();
    		
    		// public static int parseInt(String s)  将字符串转换为int类型
    		int i2 = Integer.parseInt("100");
    		System.out.println(i2);
    		
    		// 将任意数据类型转换成字符串
    		String ss = String.valueOf(100);
    		
    		Integer ii2 = Integer.valueOf(i2); // 这是底层自动装箱的原理
    		System.out.println(ii2);
    		// 为什么有了 new Integer(100), 还需要有个方法 Integer.value()?
    		
    	}
    }

int类型和String类型之间的相互转换  
String s2 = String.valueOf(i); // 推荐使用  
int i2 = Integer.parseInt(ss); // 推荐使用

public class IntegerDemo03 {
        
    	public static void main(String[] args) {
        
    		
    		// int - String
    		// 方式一:
    		int i = 10;
    		String s = i + "";
    		
    		// 方式二:
    		String s2 = String.valueOf(i); // 推荐使用
    		
    		// 方式三: 
    		String s3 = Integer.valueOf(i).toString();
    		
    		// 方式四:
    		String s4 = new Integer(i).toString();
    		
    		// String -> int
    		String ss = "100";
    		// 方式一:
    		int i1 = Integer.valueOf(ss).intValue();
    		
    		// 方式二:
    		int i2 = Integer.parseInt(ss); // 推荐使用
    		
    		// 方式三
    		int i3 = new Integer(ss).intValue();
    		
    	}
    }

自动拆装箱  
手动装箱: Intege.valueOf new Integer  
手动拆箱: intValue

自动装箱: 在编译时期系统会根据实际运算的需求自动帮助我们将基本数据类型转换成包装类类型  
自动拆箱: 在编译时期系统会根据实际运算的需求自动帮助我们将包装类类型转换成基本数据类型

public class IntegerDemo04 {
        
    	public static void main(String[] args) {
        
    		/*Object object = new Object();
    		System.out.println(object + 1);*/
    		
    		Integer ii = new Integer(100);
    		System.out.println(ii + 10);
    		// 本质的结果 System.out.println(ii.intValue + 10);
    		
    		ii += 10; // ii = ii + 10;
    		System.out.println(ii);
    		// 本质的结果ii = Integer.valueOf(ii.intValue + 10);
    		
    		boolean bool = ii > 100;
    		System.out.println(bool);
    		// 本质的结果 boolean bool = ii.intvalue > 100
    		
    		Integer ii2 = null;
    		if (ii2 > 100) {
        
    			System.out.println("hello");
    		} else {
        
    			System.out.println("world");
    		}
    	}
    }

2、如何计算65的二进制，八进制，十六进制呢？ 如果可以的话能不能计算 3进制 9进制 17进制 45进制?

进制转换

*  十进制到其他进制  
    public static String toBinaryString(int i)  
    public static String toOctalString(int i)  
    public static String toHexString(int i)  
    public static String toString(int i,int radix)
 *  其他进制到十进制  
    public static int parseInt(String s,int radix)
 *  任意进制的转换: 先将其它进制转换成十进制,再将十进制转换成其他机制
    
    使用代码进行进制转换如果超过了进制的范围,会返回原值  
    计算机只能够使用 0-9 a-z来表示进制位,最多能够表示到36进制
    
    编写一个方法实现任意进制的转换

public class IntegerDemo05 {
        
    	public static void main(String[] args) {
        
    		// Integer ii = 100; // Integer.valueOf(ii); ? 为什么不用 new的形式装箱
    		System.out.println(Integer.toString(100)); 
    		System.out.println(Integer.toBinaryString(100));
    		System.out.println(Integer.toOctalString(100));
    		System.out.println(Integer.toHexString(100));
    		
    		System.out.println(Integer.toString(100, 2));
    		System.out.println(Integer.toString(100, 8));
    		System.out.println(Integer.toString(100, 3));
    		System.out.println(Integer.toString(100, 17));
    		System.out.println(Integer.toString(100, 36));
    		System.out.println(Integer.toString(100, 37));
    		
    		// public static int parseInt(String s,int radix)	
    		System.out.println(Integer.parseInt("ffff", 16));
    		System.out.println(Integer.parseInt("1001", 2));
    		
    		
    		System.out.println(radixConvert("9zzz", 36, 10));
    	}
    	
    	/*
    	 * 编写一个方法实现任意进制的转换
    	 * 返回值类型: int num
    	 * 参数列表: String num, int xRadix, int yRadix
    	 * 方法名: radixConvert
    	 */
    	public static String radixConvert(String num, int xRadix, int yRadix) {
        
    		// 先将X进制的num转换成十进制
    		int i = Integer.parseInt(num, xRadix);
    		// 再将十进制转换成对应的Y进制
    		String s = Integer.toString(i, yRadix);
    		return s;
    	}
    }

/\*  
关于Intger的面试题

观察Ineger.valueOf的源码:  
public static Integer valueOf(int i) \{  
if (i >= IntegerCache.low && i <= IntegerCache.high)  
return IntegerCache.cache\[i + (-IntegerCache.low)\];  
return new Integer(i);  
\}  
\*/

public class IntegerDemo06 {
        
    	public static void main(String[] args) {
        
    		Integer i01 = 128; // Integer.valueOf(59);
    		int i02 = 128;
    		Integer i03 = Integer.valueOf(128);
    		Integer i04 = new Integer(128);
    		
    		System.out.println("i01 == i02:" + (i01 == i02)); // true i01.intValue = i02
    	    System.out.println("i01 == i03:" + (i01 == i03)); // true  ? false
    	    System.out.println("i03 == i04:" + (i03 == i04)); // false 
    	    System.out.println("i02 == i04:" + (i02 == i04)); // true 
    	}  
    }

其他包装类  
Byte Short Long Float Double 都是和 Integer类似  
Boolean 不能够参与运算

*  Character  
    1.任意的包装类类型都能够满足自动拆装箱  
    2.使用包装类型参与运算以及类型转换和基本数据类型完全一样  
    3.包装类类型有更多的成员方法供我们使用,更加满足了面向对象的思想