[学习笔记]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]