一、字符串相关类
1.String类
作用：表示字符串，所有字符串文字（例如“abc”）都为String的实例
使用：
- 字符串常量池中是否存在“abc”，如果存在“abc”就不创建直接使用
- new String(“abc”);在堆中创建对象
特点：被final修饰，不可变字符串，一旦改变则为新建对象。
public class TestString1 {
public static void main(String[] args) {
String s1 = new String("abcdef");
String s2 = s1.substring(2, 4);// 打印：ab199863
System.out.println(Integer.toHexString(s1.hashCode())); // 打印：c61, 显然 s1 和 s2 不是同一个对象
System.out.println(Integer.toHexString(s2.hashCode()));
}
}
2. StringBuilder 类
可变长度字符序列，线程不安全，效率高
常用方法列表：
- 重载的 public StringBuilder append(…)
方法可以为该 StringBuilder 对象添加字符序列，仍然返回自身对象。 - 方法 public StringBuilder delete(int start,int end)
可以删除从 start 开始到 end-1 为止的一段字符序列，仍然返回自身对象。 - 方法 public StringBuilder deleteCharAt(int index)
移除此序列指定位置上的 char，仍然返回自身对象。 - 重载的 public StringBuilder insert(…)方法
可以为该 StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。 - 方法 public StringBuilder reverse()
用于将字符序列逆序，仍然返回自身对象。 - 方法 public String toString()
返回此序列中数据的字符串表示形式。
3. StringBuffer 类
可变长字符序列，线程安全，效率低
常用方法列表：
- 重载的 public StringBuffer append(…)
方法可以为该 StringBuffer 对象添加字符序列，仍然返回自身对象。 - 方法 public StringBuffer delete(int start,int end)
可以删除从 start 开始到 end-1 为止的一段字符序列，仍然返回自身对象。 - 方法 public StringBuffer deleteCharAt(int index)
移除此序列指定位置上的 char，仍然返回自身对象。 - 重载的 public StringBuffer insert(…)方法
可以为该 StringBuffer 对象在指定位置插入字符序列，仍然返回自身对象。 - 方法 public StringBuffer reverse()
用于将字符序列逆序，仍然返回自身对象。 - 方法 public String toString()
返回此序列中数据的字符串表示形式。
4.StringBuffer和StringBuilder的使用
public class TestStringBufferAndBuilder {
public static void main(String[] args) { /**StringBuilder*/StringBuilder sb = new StringBuilder();
for (int i = 0; i < 7; i++) {
sb.append((char) ('a' + i));//追加单个字符
}
System.out.println(sb.toString());//转换成 String 输出
sb.append(", I can sing my abc!");//追加字符串
System.out.println(sb.toString());
/**
* StringBuffer，下面的方法同样适用 StringBuilder
*/
StringBuffer sb2 = new StringBuffer("北京尚学堂");
sb2.insert(0, "爱").insert(0, "我");//插入字符串
System.out.println(sb2);
sb2.delete(0, 2);//删除子字符串
System.out.println(sb2);
sb2.deleteCharAt(0).deleteCharAt(0);//删除某个字符
System.out.println(sb2.charAt(0));//获取某个字符
System.out.println(sb2.reverse());//字符串逆序
}
}
执行效率：StringBuilder > StringBuffer > String
二、包装类
1. 基本数据类型 --> 包装类
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| int | Integer |
| long | Long |
| short | Short |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
在这八个类名中，除了 Integer 和 Character 类以外，其它六个类的类名和基本数据 类型一致，只是类名的第一个字母大写而已。 在这八个类中，除了 Character 和 Boolean 以外，其他的都是“数字型”，“数字 型”都是 java.lang.Number 的子类。
作用：
- 作为和基本数据类型对应的类型存在，方便涉及到对象的操作，如 Object[ ]、集合等 的操作。
- 包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法（这些操 作方法的作用是在基本数据类型、包装类对象、字符串之间提供相互之间的转化！）。
2. 自动拆装箱
自动装箱：
int i= 1；
Integer in = i；
自动拆箱：
int i2 = in；
自动拆箱为包装类和基本数据类型的比较（int和Integer）数值相等时:
- 两个基本数据类型相比，肯定相等
- 两个通过new构建的Integer对象不相等，地址不同
- 当基本数据类型int与对应的包装类型Integer比较都相等，包装类会自动拆箱再比较
- 如果两个Integer比较（Integer.valueOf()），内部会新建比较是否再缓存区中，如故宫不在会新建对象，如果过在则直接使用
三、时间相关类
在计算机世界，我们把 1970 年 1 月 1 日 00:00:00 定为基准时间，每个度量单 位是毫秒(1 秒的千分之一)
我们用 long 类型的变量来表示时间，从基准时间往前几亿年，往后几亿年都能表示。 如果想获得现在时刻的“时刻数值”，可以使用：long now = System.currentTimeMillis();
1. Date 时间类(java.util.Date)
在标准 Java 类库中包含一个 Date 类。它的对象表示一个特定的瞬间，精确到毫秒。
Date类的常用方法：
- Date() 分配一个 Date 对象，并初始化此对象为系统当前的日期和时间，可以精 确到毫秒）。
- Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称 为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
- boolean after(Date when) 测试此日期是否在指定日期之后。
- booleanbefore(Date when) 测试此日期是否在指定日期之前。
- boolean equals(Object obj) 比较两个日期的相等性。
- long getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对 象表示的毫秒数。
- String toString() 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中：dow 是一周中的某一天 (Sun、Mon、 Tue、 Wed、 Thu、 Fri、 Sat)。
Date d = new Date(); //当前时刻的对象
System.out.println(d.getTime()); //返回时间对应的毫秒数
Date d2 = new Date(1000L * 3600 * 24 * 365 * 150); //距离 1970 年 150 年
2. DateFormat 类和 SimpleDateFormat 类
DateFormat 的作用：
把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。 DateFormat 是一个抽象类，一般使用它的的子类 SimpleDateFormat 类来实现。
SimpleDateFormat sdm = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
System.out.println(sdm.format(new Date()));
例：
public class TestDateFormat2 {
public static void main(String[ ] args) {
SimpleDateFormat s1 = new SimpleDateFormat("D");
String daytime = s1.format(new Date()); System.out.println(daytime);
}
}
四、数学运算类
1. Math类
java.lang.Math 提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一 般为 double 型。如果需要更加强大的数学运算能力，计算高等数学中的相关内容，可以使用 apache commons 下面的 Math 类库。
常用方法：
abs 绝对值
acos,asin,atan,cos,sin,tan 三角函数
sqrt 平方根
pow(double a, double b) a 的 b 次幂
max(double a, double b) 取大值
min(double a, double b) 取小值
ceil(double a) 大于 a 的最小整数
floor(double a) 小于 a 的最大整数
random() 返回 0.0 到 1.0 的随机数
1. [max,min) = (int)(Math.random()*(max-min)+min);
2. [max,min] = (int)(Math.random()*(max-min+1)+min);
long round(double a) double 型的数据 a 转换为 long 型（四舍五入）
toDegrees(double angrad) 弧度->角度
toRadians(double angdeg) 角度->弧度
2. Random 类
Math 类中虽然为我们提供了产生随机数的方法 Math.random()，但是通常我们需要的随机数范围并不是[0, 1)之间的 double 类型的数据，这就需要对其进行一些复杂的运算。 如果使用 Math.random()计算过于复杂的话，我们可以使用例外一种方式得到随机数，即 Random 类，这个类是专门用来生成随机数的，并且 Math.random()底层调用的就是 Random 的 nextDouble()方法。
public class TestRandom {
public static void main(String[] args) {
Random rand = new Random();
//随机生成[0,1)之间的 double 类型的数据
System.out.println(rand.nextDouble());
//随机生成 int 类型允许范围之内的整型数据
System.out.println(rand.nextInt());
//随机生成[0,1)之间的 float 类型的数据
System.out.println(rand.nextFloat());
//随机生成 false 或者 true
System.out.println(rand.nextBoolean());
//随机生成[0,10)之间的 int 类型的数据
System.out.print(rand.nextInt(10));
//随机生成[20,30)之间的 int 类型的数据
System.out.print(20 + rand.nextInt(10));
//随机生成[20,30)之间的 int 类型的数据（此种方法计算较为复杂）
System.out.print(20 + (int) (rand.nextDouble() * 10));
}
}
五、File 类
java.io.File 类：代表文件和目录。 在开发中，读取文件、生成文件、删除文件、修改文件的属性时经常会用到本类。
1. 使用File类创建文件
public class TestFile1 {
public static void main(String[] args) throws Exception {
System.out.println(System.getProperty("user.dir"));
File f = new File("a.txt"); //相对路径：默认放到 user.dir 目录下面
f.createNewFile();
//创建文件
File f2 = new File("d:/b.txt");
//绝对路径
f2.createNewFile();
}
}
2. 使用File类访问文件或目录的属性
public class TestFile2 {
public static void main(String[] args) throws Exception {
File f = new File("d:/b.txt");
System.out.println("File 是否存在：" + f.exists());
System.out.println("File 是否是目录：" + f.isDirectory());
System.out.println("File 是否是文件：" + f.isFile());
System.out.println("File 最后修改时间：" + new Date(f.lastModified()));
System.out.println("File 的大小：" + f.length());
System.out.println("File 的文件名：" + f.getName());
System.out.println("File 的目录路径：" + f.getPath());
}
}
3. 创建文件夹
mkdir：创建单个文件夹，如果创建路径中，目录结构中有一个不存在，则不会创建整个目录树
mkdirs：创建多级目录，目录结构中有一个不存在也没关系；创建整个目录。
4. 递归遍历和树状展示目录树
class TestFile6 {
public static void main(String[] args) {
File f = new File("d:/DDU");
printFile(f, 0);
}
/**
* 打印文件信息
* @param file 文件名称
* @param level 层次数(实际就是：第几次递归调用)
*/
static void printFile(File file, int level) {
//输出层次数
for (int i = 0; i < level; i++) {
System.out.print("-");
}
// 输出文件名
System.out.println(file.getName());
//如果 file 是目录，则获取子文件列表，并对每个子文件进行相同的操作
if (file.isDirectory()) {
File[] files = file.listFiles();
for (File temp : files) { //递归调用该方法：注意等+1
printFile(temp, level + 1);
}
}
}
}
六、枚举
枚举类，也是一种类，是表示一种事物的所有情况，这个类型的实例有枚举类自己控制和提供。
enum 枚举名 {
枚举体（常量列表）
}
1. 创建枚举类
enum Season {
SPRING, SUMMER, AUTUMN, WINDER
}
所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类！而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是 public static final 修饰的。可以直接通 过枚举类型名使用它们。
2. 枚举类的使用
public class TestEnum {
public static void main(String[] args) { // 枚举遍历
for (Week k : Week.values()) {
System.out.println(k);
}
// switch 语句中使用枚举
int a = new Random().nextInt(4); // 生成 0，1，2，3 的随机数
switch (Season.values()[a]) {
case SPRING:
System.out.println("春天");
break;
case SUMMER:
System.out.println("夏天");
break;
case AUTUMN:
System.out.println("秋天");
break;
case WINDTER:
System.out.println("冬天");
break;
}
}
}
/**
* 季节
*/
enum Season {SPRING, SUMMER, AUTUMN, WINDTER}
/**
* 星期
*/
enum Week {星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日}
