JavaSE|基本类型包装类

àì夳堔傛蜴生んèń 2022-05-10 16:16 309阅读 0赞

### JavaSE|基本类型包装类 ###

*  Integer
 *   *  构造方法
     *  int 类型和 String 类型的相互转换
     *  进制转换
     *  JDK5以后新特性:自动装拆箱
     *  Integer 面试题
 *  Character
 *   *  构造方法
     *  成员方法

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。  
byte–Byte  
short–Short  
int-- Integer  
long–Long  
float–Float  
double–Double  
char–Character  
boolean-- Boolean

# Integer #

## 构造方法 ##

**1. public Integer(int value)**  
**2. public Integer(String s)**  
这里的String必须**包含数字**才可以，否则会报错NumberFormatException。

String s = "100";
    		// NumberFormatException
    		// String s = "abc"; 
    		Integer iii = new Integer(s);

**public static Integer valueOf(int i)**  
**public static Integer valueOf(String s)**

上面两个不是构造方法，是静态的成员方法，但也可以把int、String转换为Interger类型。

## int 类型和 String 类型的相互转换 ##

**\[int – String\]**  
4种方法，推荐 **String.valueOf(int number)**  
String.valueOf() 系列方法可以把大部分类型转换为 String。

// int -- String
    		int number = 100;
    		// 方式1
    		String s1 = "" + number;
    		System.out.println("s1:" + s1);
    		// 方式2
    		String s2 = String.valueOf(number);
    		System.out.println("s2:" + s2);
    		// 方式3
    		// int -- Integer -- String
    		Integer i = new Integer(number);
    		String s3 = i.toString();
    		System.out.println("s3:" + s3);
    		// 方式4
    		// public static String toString(int i)
    		String s4 = Integer.toString(number);
    		System.out.println("s4:" + s4);

**\[String – int\]**  
两种方法，推荐使用 **Integer.parseInt(String s)**  
类似的有 Float.parseFloat(String s)

// String -- int
    		String s = "100";
    		// 方式1
    		// String -- Integer -- int
    		Integer ii = new Integer(s);
    		// public int intValue()
    		int x = ii.intValue();
    		System.out.println("x:" + x);
    		//方式2
    		//public static int parseInt(String s)
    		int y = Integer.parseInt(s);
    		System.out.println("y:"+y);

## 进制转换 ##

*  常用的基本进制转换：  
    **1. public static String toBinaryString(int i)**  
    **2. public static String toOctalString(int i)**  
    **3. public static String toHexString(int i)**
 *  十进制到其他进制：  
    **1. public static String toString(int i,int radix)**

System.out.println(Integer.toString(100, 10));//100
    		System.out.println(Integer.toString(100, 2));//1100100
    		System.out.println(Integer.toString(100, 8));//144
    		System.out.println(Integer.toString(100, 16));//64
    		System.out.println(Integer.toString(100, 5));//400
    		System.out.println(Integer.toString(100, 7));//202
    		System.out.println(Integer.toString(100, 17));//5f
    		System.out.println(Integer.toString(100, 32));//34
    		System.out.println(Integer.toString(100, 36));//2s

**进制的范围是2-36（因为0-9，a-z加起来共有36个）**  
对于不在进制范围的数值， public static String toString(int i,int radix) 会返回原来的数字。

System.out.println(Integer.toString(100, -7));//100
    		System.out.println(Integer.toString(100, 70));//100
    		System.out.println(Integer.toString(100, 1));//100
    		System.out.println(Integer.toString(100, 37));//100

*  其他进制到十进制：  
    **1. public static int parseInt(String s,int radix)**  
    其中 s 必须是 radix能够表示出来的。  
    eg. 2 进制不可能表示出 123

//其他进制到十进制
    		System.out.println(Integer.parseInt("100", 10));//100
    		System.out.println(Integer.parseInt("100", 2));//4
    		System.out.println(Integer.parseInt("100", 8));//64
    		System.out.println(Integer.parseInt("100", 16));//256
    		System.out.println(Integer.parseInt("100", 23));//529
    		//NumberFormatException
    		//System.out.println(Integer.parseInt("123", 2));
    		//2进制的表示不可能是123，2进制中只能出现0和1

## JDK5以后新特性:自动装拆箱 ##

*  自动装箱：把基本类型转换为包装类类型
 *  自动拆箱：把包装类类型转换为基本类型

在使用时，Integer x = null;代码就会出现NullPointerException。  
建议先判断是否为null，然后再使用。

// 定义了一个int类型的包装类类型变量i
    		// Integer i = new Integer(100);
    		Integer ii = 100;
    		ii += 200;
    		System.out.println("ii:" + ii);
    
    		// 通过反编译后的代码
    		// Integer ii = Integer.valueOf(100); //自动装箱
    		// ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱，再自动装箱
    		// System.out.println((new StringBuilder("ii:")).append(ii).toString());
    
    		Integer iii = null;
    		iii += 1000;  // NullPointerException

## Integer 面试题 ##

Integer i1 = new Integer(127);
    		Integer i2 = new Integer(127);
    		System.out.println(i1 == i2);  //false
    		System.out.println(i1.equals(i2));  //true
    
    		Integer i3 = new Integer(128);
    		Integer i4 = new Integer(128);
    		System.out.println(i3 == i4);  // false
    		System.out.println(i3.equals(i4));  //true
    
    		Integer i5 = 128;
    		Integer i6 = 128;
    		System.out.println(i5 == i6);  //false
    		System.out.println(i5.equals(i6));  //true
    
    		Integer i7 = 127;
    		Integer i8 = 127;
    		System.out.println(i7 == i8); //true
    		System.out.println(i7.equals(i8)); //true
    
    		// 通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间
    		// Integer ii = Integer.valueOf(127);

自动装箱操作：Integer i7 = 127 -> Integer i7 = Integer.valueOf(127)

通过查看Integer.valueOf()方法源码，发现，对于IntegerCache.low 和IntegerCache.high之间的int是直接从IntegerCache.cache\[\]数组中拿的。

其中IntegerCache.low = -128， IntegerCache.high = 127。  
所以上面代码的i7和i8是取的IntegerCache.cache\[\]中同一位置元素，故地址值相同。

public static Integer valueOf(int i) {
        
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    
    	 private static class IntegerCache {
        
            static final int low = -128;
            static final int high;
            static final Integer cache[];
    
            static {
        
                // high value may be configured by property
                int h = 127;
                String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                if (integerCacheHighPropValue != null) {
        
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                }
                high = h;
    
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
            }
    
            private IntegerCache() {
        }
        }

# Character #

Character 类在对象中包装一个基本类型 char 的值。  
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。

## 构造方法 ##

**1. public Character(char value)**

## 成员方法 ##

**1. public static boolean isUpperCase(char ch)**  
**2. public static boolean isLowerCase(char ch)**  
**3. public static boolean isDigit(char ch)**  
**4. public static char toUpperCase(char ch)**  
**5. public static char toLowerCase(char ch)**

// public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
    		System.out.println("isUpperCase:" + Character.isUpperCase('A'));
    		System.out.println("isUpperCase:" + Character.isUpperCase('a'));
    		System.out.println("isUpperCase:" + Character.isUpperCase('0'));
    		System.out.println("-----------------------------------------");
    		// public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
    		System.out.println("isLowerCase:" + Character.isLowerCase('A'));
    		System.out.println("isLowerCase:" + Character.isLowerCase('a'));
    		System.out.println("isLowerCase:" + Character.isLowerCase('0'));
    		System.out.println("-----------------------------------------");
    		// public static boolean isDigit(char ch):判断给定的字符是否是数字字符
    		System.out.println("isDigit:" + Character.isDigit('A'));
    		System.out.println("isDigit:" + Character.isDigit('a'));
    		System.out.println("isDigit:" + Character.isDigit('0'));
    		System.out.println("-----------------------------------------");
    		// public static char toUpperCase(char ch):把给定的字符转换为大写字符
    		System.out.println("toUpperCase:" + Character.toUpperCase('A'));
    		System.out.println("toUpperCase:" + Character.toUpperCase('a'));
    		System.out.println("-----------------------------------------");
    		// public static char toLowerCase(char ch):把给定的字符转换为小写字符
    		System.out.println("toLowerCase:" + Character.toLowerCase('A'));
    		System.out.println("toLowerCase:" + Character.toLowerCase('a'));