枚举
- 如果一个变量的取值只可能是固定的几个值，可以考虑使用枚举
- 枚举由一组预定义的常量构成
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
网友评论