java 定义字符串枚举类型_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