java

包装类

包装类定义

1. 为什么需要包装类？

• 虽然 Java 是面向对象的编程语言，但它所包含的 8 种基本数据类型却不支持面向对象的编程机制（没有属性和方法）。在 Java 中，很多类的方法都需要接收引用类型的对象，此时就无法将一个基本数据类型的值传入。为了解决这样的问题，JDK 提供了一系列的包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。

注：后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。

2. 包装类的继承关系

3. 包装类的特有功能

• 包装类的变量的默认值可以是 null，容错率更高。
• 可以把基本类型的数据转换成字符串类型(用处不大)
  • 调用 toString()方法得到字符串结果。
  • 调用 Integer.toString(基本类型的数据)。
• 可以把字符串类型的数值转换成真实的数据类型（真的很有用）
  • Integer.parseInt(“字符串类型的整数”)
  • Double.parseDouble(“字符串类型的小数”)。

基本类型包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

常用的操作之一：用于基本数据类型与字符串之间的转换

• 基本类型对应的包装类

Java 为 8 种基本类型提供了对应的引用类型。

Integer类的应用

包装一个对象中的原始类型 int 的值

• Integer 类构造方法

• 示例代码

public class IntegerDemo {
  public static void main(String[] args) {
    //public Integer(int value)：根据 int 值创建 Integer 对象(过时)
    Integer i1 = new Integer(100);
    System.out.println(i1);

    //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
    Integer i2 = new Integer("100");
//    Integer i2 = new Integer("abc"); //NumberFormatException
    System.out.println(i2);
    System.out.println("--------");

    //public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
    Integer i3 = Integer.valueOf(100);
    System.out.println(i3);

    //public static Integer valueOf(String s)：返回一个保存指定值的Integer对象String
    Integer i4 = Integer.valueOf("100");
    System.out.println(i4);
 }
}

基本类型与字符串之间的转换

1. 基本类型转换为 String

• int 转换为 String
  • 转换方式
    • 方式一：直接在数字后加一个空字符串。基本类型直接与""相连接即可； 如：34+""
    • 方式二：通过 String 类静态方法 valueOf()
• 示例代码

public class IntegerDemo {
  public static void main(String[] args) {
    //int --- String
    int number = 100;

    //方式1
    String s1 = number + "";
    System.out.println(s1);

    //方式2
    //public static String valueOf(int i)
    String s2 = String.valueOf(number);

    System.out.println(s2);
    System.out.println("--------");
 }
}

2. String 转换成对应的基本类型

• String 转换为 int
  • 转换方式
    • 方式一：先将字符串数字转成 Integer，再调用 valueOf()方法
    • 方式二：通过 Integer 静态方法 parseInt()进行转换
• 示例代码

public class IntegerDemo {
  public static void main(String[] args) {
    //String --> int
    String s = "100";

    //方式1：String --> Integer --> int
    Integer i = Integer.valueOf(s);
    //public int intValue()
    int x = i.intValue();
    System.out.println(x);

    //方式2
    //public static int parseInt(String s)
    int y = Integer.parseInt(s);
    System.out.println(y);
  }
}


public class Demo18WrapperParse {
  public static void main(String[] args) {
    int num = Integer.parseInt("100");
  }
}

除了 Character 类之外，其他所有包装类都具有 parseXxx 静态方法可以将字符串参数转换为对应的基本

类型：

public static byte parseByte(String s) ：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s) ：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s) ：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s) ：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s) ：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s) ：将字符串参数转换为对应的double基本类
型。
public static boolean parseBoolean(String s) ：将字符串参数转换为对应的boolean基本
类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：
public class Demo18WrapperParse {
  public static void main(String[] args) {
    int num = Integer.parseInt("100");
  }
}

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出 java.lang.NumberFormatException 异常。

应用：字符串数据排序案例

public class IntegerTest {
  public static void main(String[] args) {
    //定义一个字符串
    String s = "91 27 46 38 50";
    //把字符串中的数字数据存储到一个int类型的数组中
    String[] strArray = s.split(" ");
//    for(int i=0; i<strArray.length; i++) {
//      System.out.println(strArray[i]);
//    }
    //定义一个int数组，把 String[] 数组中的每一个元素存储到 int 数组中
    int[] arr = new int[strArray.length];
    for(int i=0; i<arr.length; i++) {
      arr[i] = Integer.parseInt(strArray[i]);
   }
    //对 int 数组进行排序
    Arrays.sort(arr);
    //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
    StringBuilder sb = new StringBuilder();
    for(int i=0; i<arr.length; i++) {
      if(i == arr.length - 1) {
        sb.append(arr[i]);
     } else {
        sb.append(arr[i]).append(" ");
     }
   }
    String result = sb.toString();
    //输出结果
    System.out.println(result);
   }
}

自动装箱和自动拆箱

1. 自动装箱

把基本数据类型转换为对应的包装类对象

2. 自动拆箱

把包装类对象转换为对应的基本数据类型

• 示例代码

基本数值 ----> 包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象 ----> 基本数值
int num = i.intValue();

----------------------------
// 示例1
Integer i = 100;  // 自动装箱
i += 200;    // i = i + 200; i + 200 自动拆箱；i = i + 200; 是自动装箱

// 示例2
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

String类

概述

现此类的实例。

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及

创建具有翻译为大写或小写的所有字符的字符串的副本。

特点

1.字符串不变：字符串的值在创建后不能被更改。

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

2. 因为String对象是不可变的，所以它们可以被共享。

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3.  "abc" 等效于  char[] data={ 'a' , 'b' , 'c' } 。

例如：
String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
// String底层是靠字符数组实现的。

日期时间