[学习笔记]Java基本数据类型包装类

概述

根据Java万物皆对象的思想，将基本数据类型封装成对象的好处，在于可以在对象中定义更多的功能方法操作该数据。基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。

对应关系

数据类型  包装类

byte     Byte

short    Short

int      Integer

long     Long

boolean  Boolean

float    Float

double   Double

char     Character

字符串与数值类型的转换（以int为例）

1. 字符串 -> 数值（只有Character没有解析方法）

static int  parseInt(String s)

static int  parseInt(String s, int radix)

2. 数值 -> 字符串

static String  String.valueOf(int i)

static String  toString(int i)

static String  toString(int i, int radix)

static String  toBinaryString(int i)

static String  toHexString(int i)

static String  toOctalString(int i)

3. 数值/字符串 -> 包装类对象

构造器：Integer(int/String)

static Integer  valueOf(int i)

static Integer  valueOf(String s)

static Integer  valueOf(String s, int radix)

4. 包装类对象 -> 数值/字符串

int  intValue();

String  toString();

示例

  
  

   
   

    
    // 1. 字符串 -> 数值
   
   
   
   

    
    int num1 = Integer.parseInt("100"); // 100
   
   
   
   

    
    int num2 = Integer.parseInt("100", 16); // 256
   
   
   
   

    
    // 可以使用该方法转换其他进制到十进制
   
   
   
   

    
    // 解析异常：NumberFormatException
   
   
   
   

    
     
   
   
   
   

    
    // 2. 数值 -> 字符串
   
   
   
   

    
    String str1 = Integer.toString(100); // "100"
   
   
   
   

    
    String str2 = Integer.toString(100, 4); // "1210"
   
   
   
   

    
    String str3 = Integer.toBinaryString(100); // "1100100"
   
   
   
   

    
    String str4 = Integer.toOctalString(100); // "144"
   
   
   
   

    
    String str5 = Integer.toHexString(100); // "64"
   
   
   
   

    
    // 可以转换十进制到其他进制
   
   
   
   

    
    String str6 = String.valueOf(100); // "100"
   
   
   
   

    
     
   
   
   
   

    
    // 3. 数值/字符串 -> 包装类对象
   
   
   
   

    
    Integer inte1 = new Integer(100); // 100
   
   
   
   

    
    Integer inte2 = Integer.valueOf(100); // 100
   
   
   
   

    
    Integer inte3 = new Integer( "100" ); // 100
   
   
   
   

    
    Integer inte4 = Integer.valueOf("100"); // 100
   
   
   
   

    
    Integer inte5 = Integer.valueOf("100", 4); // 16
   
   
   
   

    
     
   
   
   
   

    
    // 4. 包装类对象 -> 数值/字符串
   
   
   
   

    
    int no = inte1.intValue(); // 100
   
   
   
   

    
    String str = inte1.toString(); // "100"
   
   
  
  

自动装箱拆箱（Java 5支持）

Integer i = 10; // 自动装箱，相当于：Integer i = Integer.valueOf(10);

i = i + 1; // 自动拆箱，相当于：i = Integer.valueOf(i.intValue() + 1);

内存驻留机制（享元模式）

在自动装箱时，如果数值范围在byte范围内，则共享内存空间，类似于String常量。

Integer a1 = 127;

Integer a2 = 127;

System.out.println( a1 == a2); // true

Integer b1 = 128;

Integer b2 = 128;

System.out.println( b1 == b2); // false

案例

  
  

   
   

    
    package wrapper;
   
   
   
   

    
     
   
   
   
   

    
    import java.util.Arrays;
   
   
   
   

    
     
   
   
   
   

    
    public class WrapperTest {
   
   
   
   

    
     
   
   
   
   

    
      private static final String SPACE = " ";
   
   
   
   

    
     
   
   
   
   

    
      public static void main(String[] args) {
   
   
   
   

    
        /*
   
   
   
   

    
         * 对一字符串中数据进行排序
   
   
   
   

    
         * 思路：
   
   
   
   

    
         * 1. 将字符串转换为数组。
   
   
   
   

    
         * 2. 对数组进行排序。
   
   
   
   

    
         * 3. 将有序数组转换为字符串输出。
   
   
   
   

    
         */
   
   
   
   

    
        String numberString = "85 64 74 11 9 52 93" ;
   
   
   
   

    
        System.out.println( numberString);
   
   
   
   

    
        numberString = sortNumberString(numberString );
   
   
   
   

    
        System.out.println( numberString);
   
   
   
   

    
      }
   
   
   
   

    
     
   
   
   
   

    
      public static String sortNumberString(String numberString ) {
   
   
   
   

    
        // 1. 使用split方法对字符串进行分离
   
   
   
   

    
        String[] strs = numberString.split( SPACE );
   
   
   
   

    
        // 2. 将字符串数组转换为整型数组
   
   
   
   

    
        int[] ints = toIntArray(strs );
   
   
   
   

    
        // 3. 对整型数组排序
   
   
   
   

    
        Arrays.sort(ints );
   
   
   
   

    
        // 4. 将数组转换为字符串
   
   
   
   

    
        String str = arrayToString(ints );
   
   
   
   

    
        return str;
   
   
   
   

    
      }
   
   
   
   

    
     
   
   
   
   

    
      public static String arrayToString(int[] ints) {
   
   
   
   

    
        StringBuilder builder = new StringBuilder( "[" );
   
   
   
   

    
        for (int i = 0; i < ints.length; i++) {
   
   
   
   

    
          if (i != ints.length - 1) {
   
   
   
   

    
            builder.append( ints[ i] + " " );
   
   
   
   

    
          } else {
   
   
   
   

    
            builder.append( ints[ i] + "]" );
   
   
   
   

    
          }
   
   
   
   

    
        }
   
   
   
   

    
        return builder.toString();
   
   
   
   

    
      }
   
   
   
   

    
     
   
   
   
   

    
      public static int [] toIntArray(String[] strs) {
   
   
   
   

    
        int[] ints = new int[strs.length];
   
   
   
   

    
        for (int i = 0; i < ints.length; i++) {
   
   
   
   

    
          ints[i] = Integer.parseInt(strs [i ]);
   
   
   
   

    
        }
   
   
   
   

    
        return ints;
   
   
   
   

    
      }
   
   
   
   

    
    }
   
   
  
  

运行结果

85 64 74 11 9 52 93

[9 11 52 64 74 85 93]