【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)

精选原创

Frank___7 2024-09-07 14:43:00 博主文章分类：JAVA基础学习 ©著作权

文章标签 java 开发语言 System 字符串包装类 文章分类 Html/CSS 前端开发

©著作权归作者所有：来自51CTO博客作者Frank___7的原创作品，请联系作者获取转载授权，否则将追究法律责任

包装类

包装类的分类（针对八种基本数据类型相应的引用类型—包装类）（有了类的特点，就可以调用类中的方法）（实现了接口 Serializable【String 可以串行化:可以在网络传输】）（实现了接口 Comparable [String 对象可以比较大小]）

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_开发语言

包装类和基本数据的转换（jdk5 前的手动装箱和拆箱方式，jdk5 以后(含jdk5)的自动装箱和拆箱方式）

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class Integer01 {
    public static void main(String[] args) {
        //演示 int <--> Integer 的装箱和拆箱
        //jdk5 前是手动装箱和拆箱
        //手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);

        //手动拆箱
        //Integer -> int
        int i = integer.intValue();


        //jdk5 后，就可以自动装箱和自动拆箱
        int n2 = 200;
        //自动装箱 int->Integer
        Integer integer2 = n2; //底层使用的是
        Integer.valueOf(n2);
        //自动拆箱 Integer->int
        int n3 = integer2; //底层仍然使用的是 intValue()方法
    }
}

课堂测试题（Java 会在三元运算符中自动提升返回值的类型）

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_System_02

包装类型和 String 类型的相互转换（String.valueOf(i)，Integer.parseInt(str4)）

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class WrapperVSString {
    public static void main(String[] args) {
        //包装类(Integer)->String
         Integer i = 100;//自动装箱
        //方式 1
        String str1 = i + "";
        //方式 2   必须是包装类才能调用相应的函数
        String str2 = i.toString();
        //方式 3
        String str3 = String.valueOf(i);



        //String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        Integer i3 = new Integer(str4);//构造器

        System.out.println("ok~~");


    }
}

Integer 类和 Character 类的常用方法

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class WrapperMethod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE); //返回最小值
        System.out.println(Integer.MAX_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'));//转成小写

    }
}

Integer 类面试题

new Interger出来的一定不一样

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class WrapperExercise02 {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);    //False
        //所以，这里主要是看范围 -128 ~ 127 就是直接返回
        /*
        老韩解读
        //1. 如果 i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
        //2. 如果不在 -128~127,就直接 new Integer(i)
        public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
        */
        Integer m = 1; //底层 Integer.valueOf(1); -> 阅读源码
        Integer n = 1;//底层 Integer.valueOf(1);
        System.out.println(m == n); //T
        //所以，这里主要是看范围 -128 ~ 127 就是直接返回
        //，否则，就 new Integer(xx);
        Integer x = 128;//底层 Integer.valueOf(1);
        Integer y = 128;//底层 Integer.valueOf(1);
        System.out.println(x == y);//False

    }
}

只要有基本数据类型，判断的是值是否相同

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_java_03

String 类（String 是 final 类，不能被其他的类继承）（String 是不可变对象，即一旦创建，字符串的内容就不能被改变。`当你对字符串进行修改时，实际上是在创建一个新的字符串对象`，而不是修改原来的对象）

String 类的理解和创建对象（String 对象用于保存字符串，也就是一组字符序列）（字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节）

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_04

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_05

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class String01 {
    public static void main(String[] args) {
        //1.String 对象用于保存字符串，也就是一组字符序列
        //2. "jack" 字符串常量, 双引号括起的字符序列
        //3. 字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节
        //4. String 类有很多构造器，构造器的重载
        //	常用的有 String	s1 = new String(); //
        //String	s2 = new String(String original);
        //String	s3 = new String(char[] a);
        //String	s4 =	new String(char[] a,int startIndex,int count)
        //String s5 = new String(byte[] b)

        //5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
        //	接口 Comparable [String 对象可以比较大小]

        //6. String 是 final 类，不能被其他的类继承
        //7. String 有属性 private final char value[]; 用于存放字符串内容
        //8. 一定要注意：value 是一个 final 类型， 不可以修改(需要功力)：即 value 不能指向
        //	新的地址，但是单个字符内容是可以变化


        String name = "jack";
        name = "tom";
        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H';
        //value = v2; 不可以修改 value 地址


    }
}

创建 String 对象的两种方式和其区别（重要）

1)方式一:直接赋值 String s=“hspedu”;（s最终指问的是`常量池的空间地址`）

2)方式二:调用构造器 String s= new String("hspedu”)（s最终指问的是`堆中的空间地址`）（如果常量池没有"hsp”，重新创建，如果有，直接通过value指向）

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_06

测试题

1,2. 两种创建方式地址的区别

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_07

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_字符串_08

3. 对象中属性的字符串指向的是常量池中的空间

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_java_09

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_10

字符串的特性（常量相加，看的是池 VS 变量相加,是在堆中）

1)String是一个final类，代表不可变的字符序列
2)字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的

1.编译器对两个字符串常量相加做了优化

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_System_11

2.常量相加（在池中）和变量相加（在堆中）的区别

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_java_12

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_13

3. 字符串变量（要想修改其值，必须传引用）和final char[]类型的变量

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_14

注：

ex在栈里，str是属性，先会在堆里有个地址（否则str会在栈中）

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_开发语言_15

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_字符串_16

Java—值传递和引用传递（其实只有值传递）

为什么String是不可变的

final修饰的字段意味着引用不可变，这对char[] value数组意味着两个事情：

引用不可变：value这个变量的引用不能指向其他的数组。
内容不可直接修改：尽管final并不阻止我们改变数组元素（如果没有其他机制保护），但String通过设计没有提供任何方法来允许外部代码直接访问和修改这个数组。

String 类的常见方法

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_System_17

1. equals , 区分大小写，判断内容是否相等。 equalslgnoreCase //忽略大小写的判断内容是否相等

String str2 = "Hello";
	System.out.println(str1.equals(str2));//

2. length ,获取字符的个数，字符串的长度

System.out.println("王东梁".length());

3. indexOf ,获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1 `lastlndexOf` //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1

String s1 = "wer@terwe@g";
	int index = s1.indexOf('@');
	System.out.println(index);// 3
	System.out.println("weIndex=" + s1.indexOf("we"));//0
	// lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
	s1 = "wer@terwe@g@";
	index = s1.lastIndexOf('@');
	System.out.println(index);//11
	System.out.println("ter 的位置=" + s1.lastIndexOf("ter"));//4

4. substring ,截取指定范围的子串`[begin,end)`

String name = "hello,张三";
	//下面 name.substring(6) 从索引 6 开始截取后面所有的内容
 	System.out.println(name.substring(6));//截取后面的字符
	//name.substring(0,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
	System.out.println(name.substring(2,5));//llo

5. `trim ,（独有）去前后空格`

6. charAt, 获取某索引处的字符,`注意不能使用Str[index]这种方式,`,此方法也不能改变字符串里面的字符

7. toUpperCase/toLowerCase（独有）

// 1.toUpperCase 转换成大写
        String s = "heLLo";
        System.out.println(s.toUpperCase());//HELLO
        // 2.toLowerCase
        System.out.println(s.toLowerCase());//hello

8. concat,（独有）把两个字符串连接起来

//3.concat拼接字符串
	Strings1="宝玉";
	s1=s1.concat("林黛玉").concat("薛宝钗").concat("together");
	System.out.println(s1);//宝玉林黛玉薛宝钗together

9. replace , 替换字符串中的字符

s1="宝玉 and 林黛玉 林黛玉 林黛玉";
	//在s1中，将所有的林黛玉替换成薛宝钗
	//解读:s1.replace()方法执行后，返回的结果才是替换过的.
	//注意对s1没有任何影响
	Strings11=s1.replace("宝玉","jack");
	System.out.println(s1);//宝玉and林黛玉林黛玉林黛玉
	System.out.println(s11);//jackand林黛玉林黛玉林黛玉

10. split , （独有）分割字符串,`对于某些分割字符，我们需要转义比如|\\等`

String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        //解读：
        // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
        // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
        String[] split = poem.split(",");
        poem = "E:\\aaa\\bbb";
        split = poem.split("\\\\");
        System.out.println("==分割后内容===");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

11. compareTo ,（独有）比较两个字符串的大小（逐个字符比较）（如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0 ）

// compareTo 比较两个字符串的大小，如果前者大，
        // 则返回正数，后者大，则返回负数，如果相等，返回 0
        // 解读
        // (1) 如果长度相同，并且每个字符也相同，就返回 0
        // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
        //	就返回 if (c1 != c2) {
        //	return c1 - c2;
        //	}
        // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        String a = "jcck";// len = 3
        String b = "jack";// len = 4
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2 的值

12. toCharArray ，（独有）转换成字符数组

s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }

13. format，（独有）格式字符串, %s 字符串 %c 字符 %d 整型 %.2f 浮点型（String.format(formatStr, name, age, score, gender);）

String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';
        //将所有的信息都拼接在一个字符串.
        String info = "我的姓名是" + name +
                "年龄是" + age +
                ",成绩是" + score +
                "性别是" + gender + "。希望大家喜欢我！ ";

        System.out.println(info);


        //老韩解读
        //1. %s , %d , %.2f %c 称为占位符
        //2. 这些占位符由后面变量来替换
        //3. %s 表示后面由 字符串来替换
        //4. %d 是整数来替换
        //5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
        //6. %c 使用 char 类型来替换
        String formatStr = "我的姓名是%s " +
                "年龄是%d，" +
                "成绩是%.2f 性别是%c.希望大家喜欢我！";

        String info2 = String.format(formatStr, name, age, score, gender);

        System.out.println("info2=" + info2);

StringBuffer类（`可变长度的`，因为 StringBuffer 字符内容是存在 char[] value, (增加/删除)不用每次都更换地址(即不是每次创建新对象)，所以效率高于 String）

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删（原因如图）
很多方法与String相同，但StringBuffer是可变长度的。
在父类中 AbstractStringBuilder 有属性 char[] value,不是 final,该 value 数组存放字符串内容，引出存放在堆中的
不用每次都更换地址(即不是每次创建新对象)，所以效率高于 String

String VS StringBuffer

更新的是地址VS更新的是内容

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_java_18

String 和 StringBuffer 相互转换

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class StringAndStringBuffer {
    public static void main(String[] args) {
        // StringBuffer ->String
        StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
        //方式 1 使用 StringBuffer 提供的 toString 方法
        String s = stringBuffer3.toString();
        //方式 2: 使用构造器来搞定
        String s1 = new String(stringBuffer3);

        // String——>StringBuffer
        String str = "hello tom";
        //方式 1 使用构造器
        //注意： 返回的才是 StringBuffer 对象，对 str 本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式 2 使用的是 append 方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);
    }
}

StringBuffer 类常见方法

增，append

s.append(',');// "hello,"
        s.append("张三丰");//"hello,张三丰"
        s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏 100true10.5"
        System.out.println(s);//"hello,张三丰赵敏 100true10.5"

删，delete（begin，end）,[begin,end)

/*
         *删除索引为>=start && <end 处的字符
         *解读: 删除 11~14 的字符 [11, 14)
         */
        s.delete(11, 14);
        System.out.println(s);//"hello,张三丰赵敏 true10.5"

改, replace(int start, int end, String str),[begin,end)

//解读，使用 周芷若 替换 索引 9-11 的字符 [9,11)
        s.replace(9, 11, "周芷若");
        System.out.println(s);//"hello,张三丰周芷若 true10.5"

查, indexOf

//查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
        int indexOf = s.indexOf("张三丰");
        System.out.println(indexOf);//6

插, insert(int offset, String str),`原来索引为offset 的内容自动后移`

//解读，在索引为 9 的位置插入 "赵敏",原来索引为 9 的内容自动后移
        s.insert(9, "赵敏");
        System.out.println(s);//"hello,张三丰赵敏周芷若 true10.5"

转换为字符串

法一：先转换为String

法二：getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)，[begin,end)

StringBuffer stringBuffer = new StringBuffer("stringBuffer");
        char[] bufferCharArray = new char[stringBuffer.length()];
        stringBuffer.getChars(0, stringBuffer.length(), bufferCharArray, 0);

测试题

StringBuffer的append方法比直接用构造器增加更安全

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class StringBufferExercise01 {
    public static void main(String[] args) {
        String str = null;// ok
        StringBuffer sb = new StringBuffer(); //ok
        sb.append(str);//需要看源码 , 底层调用的是 AbstractStringBuilder 的 appendNull
        System.out.println(sb.length());//4

        System.out.println(sb);//null
        //下面的构造器，会抛出 NullpointerException
        StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16),str为null所以会出现空指针异常;
        System.out.println(sb1);

    }
}

stringBuffer的插入操作使用

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class StringBufferExercise02 {
    public static void main(String[] args) {
/*
输入商品名称和商品价格，要求打印效果示例, 使用前面学习的方法完成：
商品名	商品价格
手机	123,564.59	//比如 价格 3,456,789.88
要求：价格的小数点前面每三位用逗号隔开, 在输出。

思路分析
1.定义一个 Scanner 对象，接收用户输入的 价格(String)
2.希望使用到 StringBuffer 的 insert ，需要将 String 转成 StringBuffer
3.然后使用相关方法进行字符串的处理代码实现

*/
        //new Scanner(System.in)
        String price = "8123564.59";
        StringBuffer sb = new StringBuffer(price);
        //先完成一个最简单的实现 123,564.59
        //找到小数点的索引，然后在该位置的前 3 位，插入,即可
        //	int i = sb.lastIndexOf(".");
        //	sb = sb.insert(i - 3, ",");


        //上面的两步需要做一个循环处理,才是正确的
        for (int i = sb.lastIndexOf(".") - 3; i > 0; i -= 3) {
            sb = sb.insert(i, ",");
        }
        System.out.println(sb);//8,123,564.59
    }
}

StringBuilder 类

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_开发语言_19

StringBuilder 常用方法

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_java_20

String、StringBuffer 和 StringBuilder 比较

区别

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样
String:不可变字符序列,效率低,但是复用率高。
StringBuffer:可变字符序列、效率较高(增删)、线程安全,看源码
StringBuilder:可变字符序列、效率最高(增删)、线程不安全
String使用注意说明:
string s=“a”;//创建了一个字符串s+=“b”😕/实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b”(也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能
=>结论:如果我们对String 做大量修改,不要使用String

效率测试

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

        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");


        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//StringBuffer 拼接 20000 次
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer 的执行时间：" + (endTime - startTime));


        StringBuilder builder = new StringBuilder("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//StringBuilder 拼接 20000 次
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder 的执行时间：" + (endTime - startTime));


        String text = "";
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 80000; i++) {//String 拼接 20000
             text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String 的执行时间：" + (endTime - startTime));


    }
}

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_System_21

如何选择

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

StringBuilder 的方法使用和 StringBuffer 一样

Math 类

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

1.abs 绝对值

int abs = Math.abs(-9);
System.out.println(abs);//9

2.pow 求幂，`double` pow(double a, double b)

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

3.ceil 向上取整,返回>=该参数的最小整数(`转成 double`);

double ceil = Math.ceil(3.9);
System.out.println(ceil);//4.0

4.floor 向下取整，返回<=该参数的最大整数(`转成 double`)

double floor = Math.floor(4.001);
System.out.println(floor);//4.0

5.round 四舍五入 Math.floor(该参数+0.5),long round(double a)

long round = Math.round(5.51);
System.out.println(round);//6

6.sqrt 求开方

double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);//3.0

7.random 求随机数 (a + Math.random() * (b-a +1) ）

//	random 返回的是 0 <= x < 1 之间的一个随机小数
    // 思考：请写出获取 a-b 之间的一个随机整数,a,b 均为整数 ，比如 a = 2, b=7
    //	即返回一个数 x	2 <= x <= 7
    // 解读 Math.random() * (b-a) 返回的就是 0	<= 数 <= b-a
    // (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
    // (2) 使用具体的数给小伙伴介绍 a = 2	b = 7
    //	(int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
    //	Math.random()*6 返回的是 0 <= x < 6 小数
    //	2 + Math.random()*6 返回的就是 2<= x < 8 小数
    //	(int)(2 + Math.random()*6) = 2 <= x <= 7
    // (3) 公式就是	(int)(a + Math.random() * (b-a +1) )
    for (int i = 0; i < 100; i++) {
        System.out.println((int) (2 + Math.random() * (7 - 2 + 1)));
    }

8.max , min 返回最大值和最小值

int min = Math.min(1, 9);
    int max = Math.max(45, 90);
    System.out.println("min=" + min);
    System.out.println("max=" + max);

Arrays类

1) tostring 返回数组的字符串形式Arrays.toString(arr)

int[] intArr = {1, 20, 90};
        //遍历数组
        //	for(int i = 0; i < integers.length; i++) {
        //	System.out.println(integers[i]);
        //	}
        //直接使用 Arrays.toString 方法，显示数组
        System.out.println(Arrays.toString(intArr ));//[1, 20, 90]

2) sort 排序(自然排序和定制排序)

Java—自定义排序的多种写法和其适用场景

3) binarySearch 通过二分搜索法进行查找,`要求必须排好序`,`返回的是下标`

int index = Arrays.binarySearch(arr, 3);

4) copyOf 数组元素的复制

// 解读
        //1. 从 arr 数组中，拷贝 arr.length 个元素到 newArr 数组中
        //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        //3. 如果拷贝长度 < 0 就抛出异常 NegativeArraySizeException
        //4. 该方法的底层使用的是 System.arraycopy()
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));

5) fill 数组元素的填充

int[] num = new int[]{9,3,2};
	Arrays.fill(num, 99);

6) equals 比较两个数组元素内容是否完全一致

boolean equals = Arrays.equals(arr, arr2);

7) asList 将一组值，转换成list，`类型变为了包装类类型`（这个方法返回的是一个`固定大小的 List,可以修改里面的值，但是不能修改其大小`，并且并不是 java.util.ArrayList 类型，而是 Arrays 类的一个内部静态类java.util.Arrays.ArrayList ）

//asList 将一组值，转换成 list
        //解读
        //1. asList 方法，会将 (2,3,4,5,6,1)数据转成一个 List 集合
        //2. 返回的 asList 编译类型 List(接口)
        //3. asList 运行类型 java.util.Arrays#ArrayList, 是 Arrays 类的
        //	静态内部类 private static class ArrayList<E> extends AbstractList<E>
        //	implements RandomAccess, java.io.Serializable
        List<Integer> asList = Arrays.asList(2, 3, 4, 5, 6, 1);
        System.out.println("asList=" + asList);
        System.out.println("asList 的运行类型" + asList.getClass());

System 类

1) exit 退出当前程序,0 表示一个状态 , 正常的状态

//	//1. exit(0) 表示程序退出
        //	//2. 0 表示一个状态 , 正常的状态
        System.exit(0);

2) arraycopy:复制数组元素，`比较适合底层调用`，一般使用Arrays.copyOf完成复制数组

int[] src={1,2,3};int[] dest = new int[3];
System.arraycopy(src, 0, dest, 0, 3);

3) currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数

4) gc:运行垃圾回收机制 System.gc();

BigInteger 和 BigDecimal 类

BigInteger适合保存比较大的整型
BigDecimal适合保存精度更高的浮点型(小数)

BigInteger 常见方法

add 加
subtract减
multiply乘
divide除

import java.math.BigInteger;

/**
 * @创建人 wdl
 * @创建时间 2024/9/4
 * @描述
 */
public class BigInteger_ {
    public static void main(String[] args) {
        //当我们编程中，需要处理很大的整数，long 不够用
        //可以使用 BigInteger 的类来搞定
        //	long l = 23788888899999999999999999999l;
        //	System.out.println("l=" + l);


        BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
        BigInteger bigInteger2 = new BigInteger("10099999999999999999999999999999999999999999999999999999999999999999999999999999999");
        System.out.println(bigInteger);

        //解读
        //1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
        //2. 可以创建一个 要操作的 BigInteger 然后进行相应操作
        BigInteger add = bigInteger.add(bigInteger2);
        System.out.println(add);//
        BigInteger subtract = bigInteger.subtract(bigInteger2);
        System.out.println(subtract);//减
        BigInteger multiply = bigInteger.multiply(bigInteger2);
        System.out.println(multiply);//乘
        BigInteger divide = bigInteger.divide(bigInteger2);
        System.out.println(divide);//除
    }
}

BigDecimal 常见方法

import java.math.BigDecimal;

/**
 * @创建人 wdl
 * @创建时间 2024/9/4
 * @描述
 */
public class BigDecimal_ {
    public static void main(String[] args) {
        //当我们需要保存一个精度很高的数时，double 不够用
        //可以是 BigDecimal
        //	double d = 1999.11111111111999999999999977788d;
        //	System.out.println(d);
        BigDecimal bigDecimal = new BigDecimal("1999.11");
        BigDecimal bigDecimal2 = new BigDecimal("3");
        System.out.println(bigDecimal);

        //解读
        //1. 如果对 BigDecimal 进行运算，比如加减乘除，需要使用对应的方法
        //2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可 S
        // ystem.out.println(bigDecimal.add(bigDecimal2));
        // System.out.println(bigDecimal.subtract(bigDecimal2));
        // System.out.println(bigDecimal.multiply(bigDecimal2));
        //System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常 ArithmeticException

        //在调用 divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
        //如果有无限循环小数，就会保留 分子 的精度
//        System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
        System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_DOWN));
    }
}

日期类

第一代日期类（Date类:精确到毫秒，代表特定的瞬间）（SimpleDateFormat:格式和解析日期的类，它允许进行格式化(日期->文本) 解析(文本 ->日期)和规范化）

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_System_22

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @创建人 wdl
 * @创建时间 2024/9/5
 * @描述
 */
public class Date01 {
    public static void main(String[] args) throws ParseException {
        //解读
        //1. 获取当前系统时间
        //2. 这里的 Date 类是在 java.util 包
        //3. 默认输出的日期格式是国外的方式, 因此通常需要对格式进行转换
        Date d1 = new Date(); //获取当前系统时间 System.out.println("当前日期=" + d1);
        Date d2 = new Date(9234567); //通过指定毫秒数得到时间 System.out.println("d2=" + d2); //获取某个时间对应的毫秒数
//


        //解读
        //1. 创建 SimpleDateFormat 对象，可以指定相应的格式
        //2. 这里的格式使用的字母是规定好，不能乱写
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E");
        String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
        System.out.println("当前日期=" + format);

        //解读
        //1. 可以把一个格式化的 String 转成对应的 Date
        //2. 得到 Date 仍然在输出时，还是按照国外的形式，如果希望指定格式输出，需要转换
        //3. 在把 String -> Date ， 使用的 sdf 格式需要和你给的 String 的格式一样，否则会抛出转换异常
        String s = "1996 年 01 月 01 日 10:20:30 星期一";
        Date parse = sdf.parse(s);
        System.out.println("parse=" + sdf.format(parse));
    }
}

第二代日期类（Calendar类(日历)，是一个抽象类）

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

当我们说 Calendar c = Calendar.getInstance(); 时，实际上是在使用多态性。
多态性指的是父类（抽象类）的引用可以指向子类（实现类）的对象。在这个例子中，Calendar 的引用 c 指向了 GregorianCalendar 对象。

import java.util.Calendar;

/**
 * @创建人 wdl
 * @创建时间 2024/9/5
 * @描述
 */
public class Calendar_ {
    public static void main(String[] args) {
        //解读
        //1. Calendar 是一个抽象类， 并且构造器是 private
        //2. 可以通过 getInstance() 来获取实例
        //3. 提供大量的方法和字段提供给程序员
        //4. Calendar 没有提供对应的格式化的类，因此需要程序员自己组合来输出(灵活)
        //5. 如果我们需要按照 24 小时进制来获取时间， Calendar.HOUR ==改成=> Calendar.HOUR_OF_DAY
        Calendar c = Calendar.getInstance(); //创建日历类对象//比较简单，自由
        System.out.println("c=" + c);
        
        //2.获取日历对象的某个日历字段 System.out.println("年：" + c.get(Calendar.YEAR));
        // 这里为什么要 + 1, 因为 Calendar 返回月时候，是按照 0 开始编号 System.out.println("月：" + (c.get(Calendar.MONTH) + 1)); System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH)); System.out.println("小时：" + c.get(Calendar.HOUR)); System.out.println("分钟：" + c.get(Calendar.MINUTE)); System.out.println("秒：" + c.get(Calendar.SECOND));
        //Calender 没有专门的格式化方法，所以需要程序员自己来组合显示
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DAY_OF_MONTH) +
                " " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND));


    }
}

第三代日期类（LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日时分秒)`JDK8加入`）

前面两代日期类的不足分析
JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar也存在问题是:

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

基本用法

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

/**
 * @创建人 wdl
 * @创建时间 2024/9/5
 * @描述
 */


public class LocalDate_ {
    public static void main(String[] args) {
        //第三代日期
        //解读
        //1. 使用 now() 返回表示当前日期时间的 对象
        LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now()
         System.out.println(ldt);

        //2. 使用 DateTimeFormatter 对象来进行格式化
        // 创建 DateTimeFormatter 对象
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = dateTimeFormatter.format(ldt);
        System.out.println("格式化的日期=" + format);


        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.getMinute());
        System.out.println("秒=" + ldt.getSecond());

        LocalDate now = LocalDate.now(); //可以获取年月日
        LocalTime now2 = LocalTime.now();//获取到时分秒


        //提供 plus 和 minus 方法可以对当前时间进行加或者减
        //看看 890 天后，是什么时候 把 年月日-时分秒
        LocalDateTime localDateTime = ldt.plusDays(890);
        System.out.println("890 天后=" + dateTimeFormatter.format(localDateTime));


        //看看在 3456 分钟前是什么时候，把 年月日-时分秒输出
        LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
        System.out.println("3456 分钟前 日期=" + dateTimeFormatter.format(localDateTime2));


    }
}

DateTimeFormatter 格式日期类

DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);
	String str = dtf.format(日期对象);

Instant类时间戳（绝对时间，无时区依赖）（ `高精度，支持纳秒级别的时间表示`）（`线程安全`）

表示绝对时间，无时区依赖。
高精度，支持纳秒级别的时间表示。
跨系统、跨时区标准化，避免时区带来的复杂性。
便于时间戳计算，适合时间差异的测量和时间比较。
兼容旧 API，容易与 Date 进行转换。
线程安全，适合多线程环境。

Instant与Date 互相转换

/**
 * @创建人 wdl
 * @创建时间 2024/9/5
 * @描述
 */
package com.hspedu.date_;


import java.time.Instant;
import java.util.Date;

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

        //1.通过 静态方法 now() 获取表示当前时间戳的对象
        Instant now = Instant.now();
        System.out.println(now);

        //2. 通过 from 可以把 Instant 转成 Date
        Date date = Date.from(now);

        //3. 通过 date 的 toInstant() 可以把 date 转成 Instant 对象
        Instant instant = date.toInstant();

    }
}

Instant与LocalDateTime互相转换

从 Instant 转换到 LocalDateTime

使用 ZoneId和 ZoneOffset：
你需要提供一个时区，以将 Instant 转换为 LocalDateTime。通常，可以使用系统默认时区或指定时区。

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

public class InstantToLocalDateTime {
    public static void main(String[] args) {
        Instant instant = Instant.now();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        System.out.println("Instant: " + instant);
        System.out.println("LocalDateTime: " + localDateTime);
    }
}

如果使用其他时区**：

ZoneId zoneId = ZoneId.of("America/New_York");
LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zoneId);

从 LocalDateTime转换到 Instant

提供时区信息：
将 LocalDateTime转换为 Instant 也需要一个 ZoneId，以确定 LocalDateTime 所表示的时刻在 UTC 中的表示。

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

public class LocalDateTimeToInstant {
    public static void main(String[] args) {
        LocalDateTime localDateTime = LocalDateTime.now();
        Instant instant = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
        System.out.println("LocalDateTime: " + localDateTime);
        System.out.println("Instant: " + instant);
    }
}

如果使用其他时区：

ZoneId zoneId = ZoneId.of("America/New_York");
		 Instant instant = localDateTime.atZone(zoneId).toInstant();

本章练习

1. String中的部分字符进行翻转（String与char[]之间的转换）（在Java中，`所有的传递都是值传递`。对于基本类型传递的是`值本身`，而对于对象类型，传递的是`对象引用的副本`）

2. 字符串的两种创建方式的不同

方式一：

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_包装类_23

方式二：

【零基础快速学Java】韩顺平零基础30天学会Java--- 常用类(2024JavaReview)_字符串_24

上一篇：【零基础快速学Java】韩顺平零基础30天学会Java---JAVA概述、变量、运算符(2024JavaReview)

下一篇：Java---自定义排序的多种写法和其适用场景

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯