Java 常用类详解

wrapper 常用方法

• wrapper 到 String：wrapper.toString()
• String 到 wrapper：new Wrapper(String)，利用 wrapper 的重载构造器
• MIN_VALUE : Integer.MIN_VALUE
• MAX_VALUE
• isDigit：Character.isDigit(char)
• isLetter
• isUpperCase
• isLowerCase
• isWhitespace
• toUpperCase
• toLowerCase

public class CommenMethod {
    public static void main(String[] args) {
        // 将 wrapper 转换为 String
        int i = 100;
        // 1.String str = i + "";
        // 2.String str1 = Integer.toString(i);
        // 3.String str2 = String.valueOf(i);
        System.out.println(i);
        System.out.println(str1);
        System.out.println(str2);
        
        // 将 String 转换为 wrapper
        String str3 = "1234";
        int j = Integer.parseInt(str3);
        int m = new Integer(str3); // 利用 Integer 的重载构造器
        
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        
        char c = 'a';
        System.out.println(Character.isDigit(c));
        System.out.println(Character.isLetter(c));
        System.out.println(Character.isUpperCase(c));
        System.out.println(Character.isLowerCase(c));
        System.out.println(Character.toUpperCase(c));
        System.out.println(Character.toLowerCase(c));
        System.out.println(Character.isWhitespace(c));
    }
}

Integer 类面试题

数字常量直接赋值给 Integer 类对象

数字常量直接赋值给 Integer 类对象：主要看范围：-128 到 127 就是直接赋值（基本数据类型）
若不是则 new 创建 Integer 对象（引用数据类型）

基本数据类型和引用数据类型比较

注：只要有基本数据类型，就会判断值是否相等，因为包装类会进行自动拆箱！！！

String 类

String 类继承图

String 对象两种创建方式

两种创建方式

两种方式：
1. 直接赋值：String s = "lcz"
2. 调用构造器：String s1 = new String("lcz")
解读：
1. 先从常量池查看是否有"lcz"数据空间，若有，直接指向；若无则重新创建，然后指向。s 最终指向的是常量池的空间地址
2. 先在堆中创建空间，里面维护了 value 属性，指向常量池的"lcz"空间。若无，则重新创建，若有，则通过 value 指向。s1 最终指向的是堆中的空间地址

两种创建方式的内存布局图

字符串特性

不可变

1）：String 类是一个 final 类，不可继承修改 value 值，所以代表不可变的字符序列
2）：字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的：因为 value 属性是私有的 final 类型

常量池对象无引用指向不创建

String a = "hello" + "abc"; // 优化等价 String a = "helloabc"
分析：编译器底层优化，判断创建的常量池对象，是否有引用指向，无则不创建

常量相加在池中，变量相加在堆中

规则：
String c1 = "ab" + "cd"; // 常量相加，是在池中
String c1 = a + b; // 只要有变量相加，是在堆中
解读：(String c1 = a + b)
1. 先创建一个 StringBuilder sb = new StringBuilder();
2. 执行 sb.append("hello")
3. sb.append("abc")
4. String c = sb.toString()
toString 方法返回的是一个 new 的 value 值是 helloabc 的堆中 String 对象
所以 c 指向 堆中的对象 (String) value[] -> 常量池中 "helloabc"

堆、栈、常量池的理解

考察：
堆中对象、栈的创建、常量池的引用
形参指向的改变对实参的指向无影响，但形参对实参指向的对象进行改变会对实参产生影响

String 类常用方法

• equals
• equalsIgnoreCase
• length
• indexOf
• lastIndexOf
• substring // 截取指定范围内的子串
• trim // 去前后空格
• charAt // 获取某索引处的字符
• toUpperCase
• toLowerCase
• concat // 拼接字符串
• replace
• split // 分割字符串
• compareTo // 字符串的比较，根据 minLength 可比则比，否则 len1-len2
• toCharArray // 转换成字符数组
• format // 格式化字符串：%s、%d、%c、%.2f

public class String01 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = " abc ";
        System.out.println(s1.equals(s2));
        System.out.println(s1.length());
        System.out.println(s1.concat(s2));
        System.out.println(s1.indexOf("e"));
        System.out.println(s1.lastIndexOf("l"));
        System.out.println(s1.substring(1, 3));
        System.out.println(s1.substring(1));
        System.out.println(s2.trim());
        System.out.println(s2.charAt(0));
        System.out.println(s2.toLowerCase());
        System.out.println(s2.toLowerCase());
        System.out.println(s2.charAt(4));
        System.out.println(s1.compareTo(s2));
        System.out.println(s1.toCharArray());
        char[] char1 = s1.toCharArray();
        System.out.println(char1[0]);
    }
}

StringBuffer 类

介绍

StringBuffer 代表可变的字符序列
因为 StringBuffer 字符内容 是存在 char[] value，所以在变化 (增加/删除) 时，不用每次都创建新对象，所以效率高于 String
只有数组空间已满，扩容时需创建新对象，更换地址

String vs StringBuffer

1. String 保存的是 字符串常量，里面的值不能更改，每次 String 类的更新实际上就是更改地址，效率较低
   // private final char value[] 存放在常量池
2. StringBuffer 保存的是 字符串变量，里面的值可以更改，每次 StringBuffer 的更新实际上可以更新内容，不用每次都更新地址，效率较高
   // char[] value 存放在堆

StringBuffer 的构造器

1. StringBuffer(): 初始容量为 16 个字符
2. StringBuffer(int capacity): //capacity[容量] 具有指定初始容量
3. StringBuffer(String str): str.length()+16

String 和 StringBuffer 相互转换

1. String——>StringBuffer:
   String s = "hello";
   (1): StringBuffer b1 = new StringBuffer(s);
   (2): StringBuffer b2 = new StringBuffer(); b2.append(s);
2. StringBuffer——>String:
   (1): String s1 = b1.toString();
   (2): String s2 = new String(b1);

StringBuffer 常见方法

增 append(str) 删 delete(start,end) 改 replace(start,end,str) 查 indexOf(str) 插 insert(index,str) 获取长度 length

public class StringBuffer01 {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("hello");
        // 增
        s.append(',');
        s.append("张三丰").append(100).append(true);
        System.out.println(s);
        // 删
        s.delete(3, 5);
        System.out.println(s);
        // 改
        s.replace(3, 5, "lcz");
        System.out.println(s);
        // 查
        int indexOf = s.indexOf("lcz");
        System.out.println(indexOf);
        // 插
        s.insert(3, "lhc");
        System.out.println(s);
        // 长度
        System.out.println(s.length());
    }
}

StringBuilder 类

和 StringBuffer 的区别：StringBuilder 存在线程安全问题
因为没有做互斥处理，没有用 Synchronized 关键字
所以单线程场景用 StringBuilder，多线程场景用 StringBuffer

三个字符串类优缺点及选择

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

结论：

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

三个字符串类效率测试

public class Test {
    public static void main(String[] args) {
        String text = "";
        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        
        // StringBuffer
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer 的执行时间为：" + (endTime - startTime));
        
        // StringBuilder
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder 的执行时间为：" + (endTime - startTime));
        
        // String
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text += i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String 的执行时间为：" + (endTime - startTime));
    }
}

Math 类常用方法

• abs
• pow：返回 double
• ceil：返回 double
• floor：返回 double
• round:四舍五入，返回 long
• sqrt：返回 double
• random：返回 double
• max
• min
• 获取一个 a - b 之间的一个随机整数：(int)(a + Math.random()*(b-a+1))

public class Math01 {
    public static void main(String[] args) {
        // 1. abs
        System.out.println(Math.abs(-9));
        // 2. pow, 返回 double
        System.out.println(Math.pow(2, 3));
        // 3. ceil, 返回 double
        System.out.println(Math.ceil(3.5));
        // 4. floor, 返回 double
        System.out.println(Math.floor(-4.3));
        // 5. round, 返回 long
        long round = Math.round(4.0001);
        System.out.println(round);
        // 6. sqrt, 返回 double
        double res = Math.sqrt(16);
        System.out.println(res);
        // 7. random, 返回 [0,1) 之间的小数，返回 double
        int a = 2, b = 7;
        int num = (int)(a + Math.random()*(b-a+1));
        System.out.println(num);
    }
}

Arrays 类常用方法

• toString(arr)：返回数组的字符串形式
• sort(arr)、sort(arr,new Comparator{})：无返回值
• 自然排序和基于二叉树排序的定制排序
• 基于冒泡的定制排序
• binarySearch(arr,element)：通过折半查找法进行查找，要求为有序数组，时间复杂度：O(log n)
• copyOf(arr,len)：数组元素的复制
• fill(arr,fillElem)：填充数组元素
• equals(arr1,arr2)：比较两个数组元素内容是否完全一致
• asList：将一组值，转换成 List(集合)

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Arrays01 {
    public static void main(String[] args) {
        // 1. toString(arr)
        System.out.println("=== 定制排序前 ===");
        Integer[] n1 = {1, 2, 3, 8, 4, 9, 5};
        System.out.println(Arrays.toString(n1));
        
        // 2. sort(arr)、sort(arr,new Comparator{})
        // Arrays.sort(n1);
        // System.out.println("=== 自然排序后 ===");
        // System.out.println(Arrays.toString(n1));
        System.out.println("=== n1 定制排序后 ===");
        Arrays.sort(n1, new Comparator<Integer>() {
            // n1 需要为对象数组，不能是基本类型数组
            @Override
            public int compare(Object o1, Object o2) {
                int n1 = (Integer) o1;
                int n2 = (Integer) o2;
                return n2 - n1;
            }
        });
        System.out.println(Arrays.toString(n1));
        
        // 3. 基于冒泡的定制排序
        int[] n2 = {2, 5, 3, 6, 4, 7, 2};
        System.out.println("=== n2 定制排序前 ===");
        System.out.println(Arrays.toString(n2));
        bubbleSort(n2, new Comparator<Integer>() {
            @Override
            public int compare(Object o1, Object o2) {
                int n1 = (Integer) o1;
                int n2 = (Integer) o2;
                return n2 - n1;
            }
        });
        System.out.println("=== n2 定制排序后");
        System.out.println(Arrays.toString(n2));
        
        // 4. binarySearch
        // 要求为有序数组，无序数组排为有序也不行，若找不到，返回-(low+1),low 为若存在的索引值
        int[] n3 = {1, 2, 3, 4};
        System.out.println(Arrays.binarySearch(n3, 2));
        
        // 5. copyOf(arr,len)
        // (1):len > arr.length:补 0
        // (2):len < 0 抛出异常 NegativeArraySizeException
        // (3):底层调用的是 System.arraycopy()
        int[] arr2 = Arrays.copyOf(n3, 3);
        System.out.println(Arrays.toString(arr2));
        
        // 6. fill(arr,fillElem)
        Arrays.fill(n3, 1);
        System.out.println(Arrays.toString(n3));
        
        // 7. equals(arr1,arr2)
        System.out.println(Arrays.equals(n2, n3));
        
        // 8. asList
        // (1):asList 方法，将 (2,3,45,5) 转成一个集合
        // (2):编译类型：List(接口)
        // (3):运行类型：java.util.Arrays$ArrayList：是 Arrays 的静态内部类 ArrayList
        List asList = Arrays.asList(2, 3, 45, 5);
        System.out.println("asList:" + asList);
        System.out.println("asList 运行类型：" + asList.getClass());
    }
    
    public static void bubbleSort(int[] arr1, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1.length - i - 1; j++) {
                if (c.compare(arr1[j], arr1[j + 1]) > 0) {
                    temp = arr1[j];
                    arr1[j] = arr1[j + 1];
                    arr1[j + 1] = temp;
                }
            }
        }
    }
}

System 类常用方法

• exit：退出当前程序
• arraycopy：复制数组元素，用于底层调用（Arrays.copyOf）
• currentTimeMillis：返回当前时间距离 1970-1-1 0:0:0 的毫秒数
• gc：运行垃圾回收机制 System.gc();

public class SystemDemo {
    public static void main(String[] args) {
        // 1. exit
        // 0:表示程序退出的状态：正常退出
        // System.exit(0);
        
        // 2. arraycopy
        // 参数：
        // src:原数组
        // srcPos：原数组复制起始位置
        // dest：目标数组
        // destPos：目标数组复制起始位置
        // length：复制的元素长度
        int[] n1 = {1, 2, 3};
        int[] n2 = new int[3];
        System.arraycopy(n1, 0, n2, 0, 1);
        for (int i = 0; i < n2.length; i++) {
            System.out.println(n2[i]);
        }
        
        // 3. currentTimeMillis:格林尼治时间
        System.out.println(System.currentTimeMillis());
        
        // 4. gc
        System.gc();
    }
}

BigInteger 和 BigDecimal

应用场景：

1):BigInteger 适合保存比较大的整型

2):BigDecimal 适合保存精度更高的浮点型（小数）

常用方法：

• add
• subtract
• multiply
• divide

import java.math.BigDecimal;

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal bigDecimal1 = new BigDecimal("161618.12222222222222222222");
        BigDecimal bigDecimal2 = new BigDecimal("161618.122222222222222");
        System.out.println(bigDecimal2.add(bigDecimal1));
        System.out.println(bigDecimal2.subtract(bigDecimal1));
        System.out.println(bigDecimal2.multiply(bigDecimal1));
        System.out.println(bigDecimal2.divide(bigDecimal1)); // 可能会报异常 Non-terminating decimal expansion
        // 因为碰到除不尽，无限循环，精度又很大，就异常：不可终止的小数扩展
    }
}

import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger bigInteger1 = new BigInteger("155646846846846");
        BigInteger bigInteger2 = new BigInteger("155646846846846");
        System.out.println(bigInteger2.add(bigInteger1));
        System.out.println(bigInteger2.subtract(bigInteger1));
        System.out.println(bigInteger2.multiply(bigInteger1));
        System.out.println(bigInteger2.divide(bigInteger1));
    }
}

日期类

LocalTime、LocalDate、LocalDateTime

常见方法：

1.now：静态方法，类调用，获取日期或时间或日期加时间字段
2.getYear()
3.getMonth():返回月份英文
4.getMonthValue()：返回月份数字
5.getDayOfMonth():返回天
6.getHour()
7.getMinute()
8.getSecond()

DateTimeFormatter 格式日期类

类似于 SimpleDateFormat

y 年 M 月 d 日 h 时 (12) H 时 (24) m 分 s 秒 E 星期几

测试

import java.sql.Time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.chrono.ChronoLocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        // 第一代：Date
        // 1.创建 Date 对象
        // 无参创建
        System.out.println("=====第一代日期类 Date=====");
        Date d1 = new Date();
        System.out.println("d1 = " + d1);
        
        // 以毫秒数创建 Date
        Date d2 = new Date(1135153135);
        System.out.println("d2 = " + d2);
        
        // SimpleDateFormat 格式化日期类
        //(1):将 Date 对象格式化为字符串
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(d1);
        System.out.println("Date 对象格式化为字符串： " + format);
        
        //(2):将字符串转化为对象
        String s = "1986-01-01 17:56:47";
        Date parse = sdf.parse(s); // sdf 的格式化规则和字符串 s 不匹配，会报转化异常
        System.out.println("字符串转化为 Date 对象： " + parse);
        
        // 第二代日期类：Calendar
        System.out.println("=====第二代日期类 Calendar=====");
        Calendar c = Calendar.getInstance();
        System.out.println("c = " + c);
        System.out.println(Calendar.YEAR);
        System.out.println(Calendar.MONTH);
        System.out.println(Calendar.DAY_OF_MONTH);
        System.out.println(Calendar.HOUR);
        System.out.println(Calendar.HOUR_OF_DAY);
        System.out.println(Calendar.MINUTE);
        System.out.println(Calendar.SECOND);
        
        // 第三代日期类：LocalDateTime LocalDate LocalTime
        LocalDateTime ldt = LocalDateTime.now();
        LocalDate ld = LocalDate.now();
        LocalTime lt = LocalTime.now();
        System.out.println(ldt.getYear());
        System.out.println(ldt.getMonth());
        System.out.println(ldt.getMonthValue());
        System.out.println(ldt.getDayOfMonth());
        System.out.println(ldt.getHour());
        System.out.println(ldt.getYear());
        System.out.println(ldt.getMinute());
        System.out.println(ldt.getSecond());
        
        // 格式化日期类:DateTimeFormatter
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format1 = dtf.format(ldt);
        System.out.println("格式化后的字符串： " + format1);
        
        // 时间戳：Instant
        //(1):Date 转化为 Instant
        Date d3 = new Date();
        Instant instant = d3.toInstant();
        System.out.println("Date 转化为时间戳： " + instant);
        
        //(2):Instant 转化为 Date
        Date d4 = Date.from(instant);
        System.out.println("时间戳转化为 Date 对象： " + d4);
        
        // 提供 plus 和 minus 对当前时间进行加或减
        // 应用：如查看历史订单
        LocalDateTime ldt1 = LocalDateTime.now();
        LocalDateTime newldt = ldt1.plusDays(586);
        System.out.println(newldt);
    }
}