Java-06 枚举、包装类、字符串

枚举

如果一个变量的取值只可能是固定的几个值，可以考虑使用枚举
- 枚举由一组预定义的常量构成

public enum Season {
  SPRING, SUMMER, FALL, WINTER
}

public class Main {
  public static void main(String[] args) {
    Season s = Season.WINTER;
    
    // 打印名称
    System.out.println(s.name());// WINTER
    // 打印下标
    System.out.println(s.ordinal());// 3
  }
}

枚举本质上还是一个类，所有的枚举类型最终都隐式的继承自java.lang.Enum

枚举定义完常量之后可以再定义成员变量，方法等内容(也间接说明了枚举本质上确实是一个类)

public enum Season {
  SPRING, SUMMER, FALL, WINTER;

  int age = 0;
  public void test(){
    System.out.println(age);
  }
}

枚举的构造方法的权限必须是无修饰或者private的。

Java会自动为每一个枚举添加构造函数，外界不能调用，枚举在初始化常量的时候会调用构造方法。也就是枚举的构造方法并不是提供给外部使用的，而是给内部使用的

包装类(Wrapper Class)

在讲述包装类之前，先看看基本类型的缺陷

无法表示不存在的值（null）
不能利用面向对象的方式去操作基本类型（比如直接使用基本类型调用方法）
当方法参数是引用类型时，基本类型无法传递

为了解决这些缺陷，可以将基本类型包装为引用类型

public class IntObject {
  private final int value;
  public  IntObject(int v) {
    this.value = v;
  }

  public int getValue() {
    return this.value;
  }
}

IntObject[] money = {
    new IntObject(10),
    new IntObject(23),
    null,
    new IntObject(-100),
    new IntObject(150),
  };

这样就可以解决上述的缺陷

Java已经内置了基本类型的包装类(都在java.lang包中)，其中，数字类型的基本类型最终都继承自java.lang.Number

基本类型	包装类
byte	Byte
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

Integer[] money2 = {
    new Integer(10),
    new Integer(23),
    null,
    new Integer(-100),
    new Integer(150)
  };

自动装箱、拆箱(Autoboxing and Unboxing)

自动装箱：java编译器会自动调用valueOf方法，将基本类型转换为包装类型

  Integer[] money2 = {
    Integer.valueOf(10),
    Integer.valueOf(100),
    Integer.valueOf(110),
    Integer.valueOf(120),
  };

  // 自动装箱
  // 数组里存储的并不是基本类型 而是Integer
  Integer[] money3 = {
    10, // 等同于 Integer.valueOf(10)
    100,
    110,
    120,
  };

  // 这里也是对的
  // java编译器会自动装箱成Integer类型 
  Object num = 10;

自动拆箱： java编译器会自动调用xxxValue方法，将包装类转为基本类型

  Integer i1 = 10;
  int i2 = i1;
  // 上面等同于下面的代码
  // int i2 = i1.intValue();

包装类的判等

包装类的判等，不要使用==、!=运算符，应该使用equals方法

包装类是一个类，所以在使用==时比较的不是包装的值，而是对象的内存地址。

    Integer i1 = 88; // 等价于 Integer.valueOf(88);
    Integer i2 = 88;
    Integer i3 = 888;
    Integer i4 = 888;
    // 不推荐
    System.out.println(i1 == i2); // true
    System.out.println(i3 == i4); // false 888 超出了缓存范围 所以每次都是新创建的对象

    // 推荐
    System.out.println(i1.equals(i2)); // true
    System.out.println(i3.equals(i4)); // true

在Integer类中有一个IntegerCache嵌套类，会缓存-128到127之间的值，在使用valueOf方法时，会先从该缓存类中检查是否有缓存，有的话直接返回而不是新创建一个Integer对象。所以i1 == i2返回true,而i3 == i4返回false,

    Integer i5 = 88;
    Integer i6 = Integer.valueOf(88);
    Integer i7 = new Integer(88); // 这里是新创建了Integer对象 而没有从缓存取 所以地址不同了

    System.out.println(i5 == i6);// true
    System.out.println(i5 == i7);// false

使用注意

【基本类型数组】与【包装类数组】之间是不能自动装箱、拆箱的。
比如int数组不能直接赋值给Integer数组

字符串

Java中用java.lang.String类代表字符串
低层使用char[]存储字符数据，从java9开始，低层使用byte[]存储字符数据
所有字符串字面亮都是String类的实例
String对象一旦创建完毕，它的字符内容是不可以修改的

字符串常量池(String Constant Pool)

java中有个字符串常量池（String Constant Pool,简称SCP）
从java 7开始属于堆空间的一部分（之前属于方法区）

当遇到字符串字面量时，回去查看SCP，如果SCP中有与字面量内容一样的字符串对象A时，就会返回A，如果没有，就创建一个新的字符串对象，并加入到SCP，然后返回

    String s1 = "lwy"; // 会从scp中查找 没有 然后创建字符串对象返回
    String s2 = "lwy"; // 从scp中查找 找到并返回
    System.out.println(s1 == s2); // true 所以s1与s2是同一个对象

    String s1 = "wy";
    String s2 = new String("wy");// 
    String s3 = new String(s1);
    String s4 = new String(s2);
    char[] cs = {'w','y'};
    String s5 = new String(cs);
    String s6 = new String(s5);

上述字符串的内存分布大致如下

内存分布

前面说过，字符串的底层是通过数组来存放字符的，

    @Stable
    private final byte[] value;

每次调用String的构造方法都会创建一个新的String对象，存放在堆区。

public String(String original) {
        this.value = original.value;
        this.coder = original.coder;
        this.hash = original.hash;
}

但是点开查看String的构造方法查看，当初始化传递一个String对象的时候，会把传递的String的value直接赋值给新对象的value，也就是说s1,s2,s3,s4的value都是同一个。同理，s5，s6也是同一个value

intern的用法

    String s = new String("wy");
    s.intern();

A.intern方法的作用：如果SCP中存在与A内容一样的字符串对象C时，就返回C，如果没有，就将A添加进SCP，并返回A