第十三章常用类

一、包装类

1. 包装类的分类

（1）针对八种基本数据类型相应的引用类型—包装类

（2）有了类的特点，就可以调用类中的方法。

在这里插入图片描述

2. 包装类和基本数据的转换

jdk5 前的手动装箱和拆箱方式，装箱：基本类型转包装类型，拆箱：包装类型转基本类型
jdk5以后（含idk5）的自动装箱和拆箱方式
自动装箱底层调用的是 valueOf 方法
其它包装类的用法类似，不一一举例

3. 包装类型和 String 类型的相互转换

public class Demo {
    public static void main(String[] args) {

        Integer i = 100;
        String str1 = i +"";
        String str2 = i.toString();
        String str3 = String.valueOf(i);

        Integer i1 = Integer.parseInt(str1);
        Integer i2 = new Integer(str2);
        
    }

}

4. 包装类的常用方法

public class Demo {
    public static void main(String[] args) {

        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        System.out.println(Character.isDigit('a')); // 判断是不是数字
        System.out.println(Character.isLetter('a')); // 判断是不是字母
        System.out.println(Character.isUpperCase('a')); // 判断是不是大写
        System.out.println(Character.isLowerCase('a')); // 判断是不是小写

        System.out.println(Character.isWhitespace('a')); // 判断是不是空格
        System.out.println(Character.toUpperCase('a')); // 转成大写
        System.out.println(Character.toLowerCase('a')); // 转成小写

    }

}

5. Integer 类面试题

public class Demo {
    public static void main(String[] args) {

        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j); // false

        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n); // true

        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y); // false

        /*
            public static Integer valueOf(int i) {
                if (i >= IntegerCache.low && i <= IntegerCache.high)
                    return IntegerCache.cache[i + (-IntegerCache.low)];
                return new Integer(i);
            }
            -128 to 127
        * */
    }

}

二、String 类

1. String 类的理解和创建对象

String 对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如：“你好”、"12.97”、“boy” 等
字符串的字符使用 Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节。

2. 创建 String 对象的两种方式

方式一：直接赋值 String str1 = "hsp";
方式二：调用构造器 String str2 = new String("hsp");

方式一：先从常量池查看是否有 “hsp”数据空间。如果有，直接指向；如果没有则重新创建，然后指向。最终指向的是 常量池 的空间地址。
方式二：先在堆中创建空间，里面维护了value属性，指向常量池的“hsp”空间。如果常量池没有，重新创建，如果有，直接通过value指向。最终指向的是 堆 中的空间地址

public class Demo {
    public static void main(String[] args) {

        String a = "abc";
        String b = "abc";
        System.out.println(a.equals(b)); // true
        System.out.println(a == b); // true

        String c = new String("abc");
        String d = new String("abc");
        System.out.println(c.equals(d)); // true
        System.out.println(c == d); // false

        String e = "hsp";
        String f = new String("hsp");
        System.out.println(e.equals(f)); // true
        System.out.println(e == f); // false
        System.out.println(e == f.intern()); // true
        System.out.println(f == f.intern()); // false
        // intern() 方法最终返回的是常量池的地址（对象）
    }

}

3. String 类的常见方法

String 类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此 Java设计者还提供了 StringBuilder 和 StringBuffer 来增强 String 的功能，并提高效率。

public class Demo {
    public static void main(String[] args) {

        String str1 = "Hello";
        String str2 = "hello";

        // equals：区分大小写，判断内容是否相等
        System.out.println(str1.equals(str2)); // false
        // equalsIgnoreCase：忽略大小写，判断内容是否相等
        System.out.println(str1.equalsIgnoreCase(str2)); //true
        // length：获取字符串的长度
        System.out.println(str1.length()); // 5
        // indexOf：获取字符在字符串中第一次出现的索引
        System.out.println(str1.indexOf('e')); // 1
        System.out.println(str1.indexOf('E')); // -1
        System.out.println(str1.indexOf("ll")); // 2
        //lastIndexOf：取字符在字符串中最后一次出现的索引
        System.out.println(str1.lastIndexOf('e')); // 1
        // substring(a)：从索引a开始截取后面所有的内容
        System.out.println(str1.substring(2)); //llo
        // substring(a,b)：从索引a开始截取，截取到索引b-1位置
        System.out.println(str1.substring(2, 4)); // ll

        //toUpperCase：转大写
        System.out.println(str2.toUpperCase()); //HELLO
        //toLowerCase：转小写
        System.out.println(str2.toLowerCase()); // hello
        //concat：拼接字符串
        System.out.println(str1.concat(str1).concat(str2)); // HelloHellohello

        //replace：替换字符串中的字符
        String str3 = "宝玉，薛宝钗，薛宝钗，薛宝钗";
        System.out.println(str3.replace("薛宝钗", "林黛玉")); // 宝玉，林黛玉，林黛玉，林黛玉

        // split：分割字符串，对于某些分割字符，需要转义
        String[] split1 = str3.split("，");
        System.out.println(Arrays.toString(split1)); // [宝玉, 薛宝钗, 薛宝钗, 薛宝钗]

        String str4 = "E:\\aaa\\bb";
        String[] split2 = str4.split("\\\\");
        System.out.println(Arrays.toString(split2)); // [E:, aaa, bb]

        char[] charArray = str1.toCharArray();
        System.out.println(Arrays.toString(charArray)); // [H, e, l, l, o]        
    }
}

4. StringBuffer 类

java.lang.StringBuffer 代表可变的字符序列，可以对字符串内容进行增删。

很多方法与String相同，但StringBuffer是 可变长度 的。

StringBuffer是一个容器。

String VS StringBuffer

String 保存的是字符串 常量，里面的值不能更改，每次 String 类的更新实际上就是更改地址，效率较低
StringBuffer 保存的是字符串 变量，里面的值可以更改，每次 StringBuffer 的更新实际上可以更新内容，不用每次更新地址，效率较高

public class Demo {
    public static void main(String[] args) {
        String str = "hello";
        
        StringBuffer stringBuffer1 = new StringBuffer(str);

        StringBuffer stringBuffer2 = new StringBuffer();
        stringBuffer2.append(str);

        String str1 = stringBuffer1.toString();

        String str2 = new String(stringBuffer1);
    }
}

public class Demo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("hello");

        // 增
        sb.append(',');
        sb.append("张三丰");
        sb.append(',');
        sb.append("赵敏");
        System.out.println(sb); // hello,张三丰,赵敏

        // 删
        // 删除索引 [5,9) 的字符
        sb.delete(5, 9);
        System.out.println(sb); // hello,赵敏

        // 改
        // 替换 [6,8)的字符
        sb.replace(6, 8, "周芷若");
        System.out.println(sb);// hello,赵敏

        // 查
        // 查找指定的子串在字符串第一次出现的索引
        System.out.println(sb.indexOf("张三丰")); // -1
        System.out.println(sb.indexOf("周芷若")); // 6

        // 插
        // 在索引位置插入子串
        sb.insert(6, "赵敏");
        System.out.println(sb); // hello,赵敏周芷若

        // 长度
        System.out.println(sb.length()); // 11
    }
}

5. StringBuilder 类

StringBuilder 是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步（StringBuilder 不是线程安全）。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。

6. String、StringBuffer 和 StringBuilder 的比较

String：不可变字符序列，效率低，但是复用率高
StringBuffer：可变字符序列、效率较高（增删）、线程安全
StringBuilder：可变字符序列、效率最高、线程不安全

7. String、StringBuffer 和 StringBuilder 的选择

如果字符串存在大量的修改操作，并在单线程的情况，使用 StringBuilder
如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等

三、Math 类（P481）

Math 类包含，用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

（1）abs：绝对值
（2）pow：求幂
（3）ceil：向上取整【返回 >= 该参数的最小整数】
（4）floor：向下取整【返回 <= 该参数的最大整数】
（5）round：四舍五入
（6）sqrt：求开方
（7）random：求随机数【返回的是 0 <= x < 1 之间的随机小数】
（8）max：求两个数的最大值
（9）min：求两个数的最小值

public class Demo {

    public static void main(String[] args) {

        // 求幂
        double pow = Math.pow(2, 4); // 2的4次方
        System.out.println(pow); // 16.0

        // ceil 向上取整，返回 >= 该参数的最小整数
        double ceil1 = Math.ceil(-3.2);
        double ceil2 = Math.ceil(3.2);
        System.out.println(ceil1); // -3.0
        System.out.println(ceil2); // 4.0

        // sqrt：求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt); // 3.0

        // random：求随机数【返回的是 0 <= x < 1 之间的随机小数】
        double random1 = Math.random();
        // 请写出获取a-b之间的一个随机整数a，b均为整数？2 <= x <= 7
        double random2 = 2 + Math.random() * 6;
    }
}

四、Arrays 类（P482）

Arrays 里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）。

（1）tostring：返回数组的字符串形式
（2）sort ：排序（自然排序和定制排序）
（3）binarySearch：通过二分搜索法进行查找，要求必须排好序的数组
（4）copyOf：数组元素的复制
（5）fill：数组元素的填充
（6）equals：比较两个数组元素内容是否完全一致
（7）asList：将一组值，转换成ist

public class Demo {

    public static void main(String[] args) {

        // tostring：返回数组的字符串形式
        Integer[] arr1 = {1, 20, 30};
        System.out.println(Arrays.toString(arr1)); // [1, 20, 30]

        // sort排序：（自然排序和定制排序）
        // 自然排序
        Integer[] arr2 = {1, -1, 7, 50};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2)); // [-1, 1, 7, 50]

        // 定制排序
        Integer[] arr3 = {1, -1, 7, 50};
        // o1 - o2 :升序
        // o2 - o1 :降序
        Arrays.sort(arr3, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(Arrays.toString(arr3)); // [50, 7, 1, -1]

        // binarySearch：通过二分搜索法进行查找，要求必须排好序的数组
        Integer[] arr4 = {-1, 1, 7, 50};
        int index1 = Arrays.binarySearch(arr4, 1);
        System.out.println(index1); // index1 = 1
        // 如果数组中不存在该元素，就返回 -(low +1)
        // low 为，如果存在的索引位置
        int index2 = Arrays.binarySearch(arr4, 5); // low:2
        System.out.println(index2); // index1 = -3

        // copyOf：数组元素的复制4
        Integer[] arr5 = {-1, 1, 7, 50};
        int len1 = arr5.length - 1;
        Integer[] newArr1 = Arrays.copyOf(arr5, len1); // [-1, 1, 7]
        System.out.println(Arrays.toString(newArr1));
        // 如果拷贝长度 > 原数组长度，后面添加 null
        int len2 = arr5.length + 1;
        Integer[] newArr2 = Arrays.copyOf(arr5, len2); // [-1, 1, 7, 50, null]
        System.out.println(Arrays.toString(newArr2));
        // 如果拷贝长度 < 0，抛出异常
        int len3 = -1;
        Integer[] newArr3 = Arrays.copyOf(arr5, len3); 
        System.out.println(Arrays.toString(newArr3));

        // fill：数组元素的填充
        Integer[] arr6 = {-1, 1, 7, 50};
        // 用 99 替换原数组所有元素
        Arrays.fill(arr6,99);
        System.out.println(Arrays.toString(arr6)); // [99, 99, 99, 99]

        // equals：比较两个数组元素内容是否完全一致
        Integer[] arr7 = {-1, 1, 7, 50};
        Integer[] arr8 = {-1, 1, 7, 50};
        System.out.println(Arrays.equals(arr7,arr8)); // true

        // asList：将一组值，转换成ist
        Integer[] arr9 = {-1, 1, 7, 50};
        List<Integer> aslist = Arrays.asList(arr9);
        /*
            aslist 运行类型 class java.util.Arrays$ArrayList
            是 Arrays类的 静态内部类
            private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable
         */
        System.out.println(aslist.getClass());
    }
}

五、System类（P486）

（1）exit：退出当前程序
（2）arraycopy：复制数组元素，比较适合底层调用。一般使用 Arrays.copyOf() 完成复制数组
（3）currentTimeMillens：返回当前时间距离1970-1-1的毫秒数
（4）gc：运行垃圾回收机制 System.gc()；

public class Demo {

    public static void main(String[] args) {
        Integer[] arr = {-1, 1, 7, 50};
        Integer[] destArr = new Integer[4]; // {0,0,0,0};
 
        /*
            五个参数：
            参数一：src【源数组】
            参数二：srcPos【源数组开始拷贝的索引位置】
            参数三：dest【目标数组】
            参数四：destPos【目标数组开始拷贝的索引位置】
            参数五：length【源数组拷贝的数据长度】
         */
        System.arraycopy(arr, 0, destArr, 0, arr.length);
    }
}

六、Biglnteger 和 BigDecimal 类（P487）

（1）Biglnteger 适合保存比较大的整型
（2）BigDecimal 适合保存精度更高的浮点型（小数）

public class Demo {

    public static void main(String[] args) {
        BigInteger bigInteger = new BigInteger("10000");
        BigDecimal bigDecimal = new BigDecimal("20.88");
    }
}

（1）add加
（2）subtract减
（3）multiply乘
（4）divide除【divide 可以指定精度：BigDecimal.ROUND_CEILING等等】

七、日期类（P488）

1. 第一代日期类 Date

（1）Date：精确到毫秒，代表特定的瞬间
（2）SimpleDateFormat：格式和解析日期的类
在这里插入图片描述

public class Demo {

    public static void main(String[] args) throws ParseException {
        Date date = new Date(); // 获取当前系统时间
        System.out.println(date); // Mon Jul 25 20:42:17 CST 2022

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String format = sdf.format(date);
        System.out.println(format); // 2022年07月25日 08:42:17 星期一

        Date parse = sdf.parse(format);
        System.out.println(parse); // Mon Jul 25 08:42:17 CST 2022
    }
}

2. 第二代日期类 Calendar （日历）

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar> {

（1）Calendar类 是一个抽象类，并且构造器是 protected。只能通过 getInstance() 来获取实例

（2）它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法

public class Demo {

    public static void main(String[] args) throws ParseException {
        Calendar instance = Calendar.getInstance();
        // 获取日历对象的某个日历字段
        System.out.println("年："+instance.get(Calendar.YEAR));
        System.out.println("月："+(instance.get(Calendar.MONTH)+1));
        System.out.println("日："+instance.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时(12)："+instance.get(Calendar.HOUR));
        System.out.println("小时(24)："+instance.get(Calendar.HOUR_OF_DAY));
        System.out.println("分钟："+instance.get(Calendar.MINUTE));
        System.out.println("秒："+instance.get(Calendar.SECOND));
    }
}

3. 第三代日期类

3.1 前面两代日期类的不足分析

JDK1.0中包含了一个 java.util.Date 类，但是它的大多数方法已经在 JDK1.1 引入 Calendar 类之后被弃用了。

而 Calendar 也存在问题是：
（1）可变性：像日期和时间这样的类应该是不可变的
（2）偏移性：Date中的年份是从1900开始的，而月份都从0开始
（3）格式化：格式化只对Date有用，Calendar则不行
（4）此外，它们也不是线程安全的；不能处理闰秒等（每隔2天，多出1s）。

3.2 第三代日期类常见方法

LocalDate（日期/年月日）、LocalTime（时间/时分秒）、LocalDateTime（日期时间/年月日时分秒）JDK8加入

LocalDate只包含日期，可以获取日期字段
LocalTime只包含时间，可以获取时间字段
LocalDateTime包含日期+时间，可以获取日期和时间字段

public class Demo {
    public static void main(String[] args) throws ParseException {
        LocalDateTime now = LocalDateTime.now();
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        
        System.out.println(now); // 2022-07-26T00:04:00.395

        System.out.println(now.getYear()); // 2022
        System.out.println(now.getMonth()); // JULY
        System.out.println(now.getMonthValue()); // 7
        System.out.println(now.getDayOfMonth()); // 26
        System.out.println(now.getHour()); // 0
        System.out.println(now.getMinute()); // 4
        System.out.println(now.getSecond()); // 0
    }
}

3.3 DateTimeFormatter格式日期类

类似于 SimpleDateFormat

public class Demo {

    public static void main(String[] args) throws ParseException {
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now); // 2022-07-26T00:38:30.801

        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dtf.format(now);
        System.out.println(format); // 2022-07-26 00:38:30
    }
}

3.4 Instant 时间戳

类似于 Date

public class Demo {

    public static void main(String[] args) throws ParseException {
        Instant now = Instant.now();
        System.out.println(now); // 2022-07-25T16:43:09.732Z

        Date date = Date.from(now);
        Instant instant = date.toInstant();
    }
}

3.5 第三代日期类更多方法

提供 plus 和 minus 方法可以对当前时间进行加或者减

public class Demo {

    public static void main(String[] args) throws ParseException {
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now); // 2022-07-26T00:50:49.265

        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println(dtf.format(now)); // 2022-07-26 00:50:49

        // 890 天后
        LocalDateTime ldt1 = now.plusDays(890);
        System.out.println(dtf.format(ldt1)); // 2025-01-01 00:50:49

        // 180 分钟前
        LocalDateTime ldt2 = now.minusMinutes(180);
        System.out.println(dtf.format(ldt2)); // 2022-07-25 21:50:49
    }
}