这些Java常用类，你必须要学会，还不快快收藏？（近两万字详细介绍）

Posted 2022-02-10 Faith_xzc

零基础学习之Java常用类

• • 概述
  • 包装类
  • 和数学相关的类
  • String类
  • • 创建字符串对象
    • • 使用构造方法
      • 使用静态方法
      • 使用" " + 拼接
    • 字符串对象的比较
    • 字符串的常用方法
  • 可变字符序列
  • 时间日期
  • • JDK1.8之前
    • • java.util.Date
      • java.util.Calendar
    • JDK1.8之后
    • • LocalDate、LocalTime、LocalDateTime
      • DateTimeFormatter

概述

在Java中，类是一个非常重要的东西，想要学好Java（做到简历上的精通Java😄😄😄），我们不仅要自己能够根据业务需求创建合适的类，进行相关的开发，还要必须要学会使用Java常用类，这样才能获得更高的效率。在Java中常用类主要包括：

• 包装类
• 和数学相关的类（Math）
• String类（字符串）
• 可变字符序列（StringBuilder和StringBuffer）
• 时间日期（Date）

下面呢，就介绍下Java常用类，帮助各位更进一步。（内容比较多，水平有限，感谢指正！）

包装类

前面有文章说过这个内容，可以看下：近7000字长文详细讲解Java包装类，面试稳了

和数学相关的类

在计算机中进行数学计算是及其重要的一项工作，因此非常用必要提前设计一个类，来满足基本数学函数所需要的属性和方法。在Java中，这个类就是和数学相关的一个常用类，即Math类。其类在源码中的定义如下：

public final class Math 

    private Math() 
    
    public static final double PI = 3.14159265358979323846; //属性举例
    
	public static double sin(double a)  //方法举例
        return StrictMath.sin(a);
        
   	 ...//省略了的方法和属性
    

Math 被定义成了final类，所以是不能被继承的；另外Math的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

Math类中常用的属性和方法列举如下：

Math.E   		//欧拉常数，也是自然对数的底数，约等于 2.718
Math.PI 		//圆周率，一个圆的周长和直径之比，约等于 3.14159。
Math.abs(x) 	//返回一个数的绝对值。
Math.cbrt(x)	//返回一个数的立方根。
Math.ceil(x)	//返回大于一个数的最小整数，即一个数向上取整后的值。
Math.exp(x)		//返回欧拉常数的参数次方，Ex，其中 x 为参数，E 是欧拉常数（2.718...，自然对数的底数）。
Math.floor(x)	//返回小于一个数的最大整数，即一个数向下取整后的值。
Math.fround(x)	//返回最接近一个数的单精度浮点型表示。
Math.hypot([x[, y[, …]]])//返回其所有参数平方和的平方根。
Math.max([x[, y[, …]]])//返回零到多个数值中最大值。
Math.min([x[, y[, …]]])//返回零到多个数值中最小值。
Math.pow(x, y)	//返回一个数的 y 次幂。
Math.random()	//返回一个 0 到 1 之间的伪随机数。
Math.round(x)	//返回四舍五入后的整数。
Math.sign(x)	//返回一个数的符号，得知一个数是正数、负数还是 0。
Math.sqrt(x)	//返回一个数的平方根。
Math.toSource()//返回字符串 "Math"。
Math.trunc(x)	//返回一个数的整数部分，直接去除其小数点及之后的部分。
Math.imul(x, y)	//返回 32 位整数乘法的结果。
Math.log(x)		//返回一个数的自然对数（㏒e，即 ㏑）。
Math.log10(x)	//返回一个数以 10 为底数的对数。
Math.log2(x)	//回一个数以 2 为底数的对数。

String类

String类代表字符串，在Java中字符串属于对象，Java 提供了 String 类创建和操作字符串。其类在源码中的定义如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence 

		public String() 
        this.value = "".value; //构造方法举例1；String有很多的构造方法
  	  
  	    public String(char value[]) 
        this.value = Arrays.copyOf(value, value.length);//构造方法举例2；String有很多的构造方法
	    

		 private static void checkBounds(byte[] bytes, int offset, int length)
		... //静态构造方法举例；类名直接调用
		
    	 public String replace(char oldChar, char newChar)
		... //非静态方法举例；对象名调用
		
	... //其他内容省略
    

从源码中我们可以看出：

• 字符串是常量；它们的值在创建之后不能更改；其构造方法有多种；

• 其方法有静态和非静态的，即有的需要通过类名调用，有的需要通过对象名调用。

• 字符串的对象是不可变对象，意味着一旦进行修改，就会产生新对象，因此其不适合大量修改字符串的场景使用。字符串对象设计为不可变,那么所以字符串有常量池来保存很多常量对象。

如果程序中涉及到大量的字符串的修改操作，那么此时的时空消耗比较高。可能需要考虑使用StringBuilder或StringBuffer的可变字符序列(这两个后面会介绍)

• String对象内部是用字符数组进行保存的；例如：“abc” 等效于 char[] data= ‘a’ , ‘b’ , ‘c’ `。

JDK1.9之前有一个char[] value数组，JDK1.9之后byte[]数组
常量池在不同时期位置不同，具体如下：
①JDK1.6及其之前：方法区
②JDK1.7：堆
③JDK1.8：元空间

下面进一步说明String类及其常用的方法。

创建字符串对象

使用构造方法

使用构造方法创建字符串有三种形式：

• 直接赋值，类似于基本数据类型就可以（创建一个，在常量池中）
• 通过对象赋值，参数是字符串（创建两个对象，首先指向堆中的一个字符串对象，然后堆中字符串的value数组指向常量池中常量对象的value数组）
• 也是使用通过对象赋值，只不过参数是数组，数组里面是char类型的数据（创建两个对象，同上）

  @Test
    public void test1()
        //创建String对象的三种方法
        String str1 = "method1";
        String str2 = new String("method2");
        char[] chars = 'm','e','t','h','o','d','3';
        String str3 = new String(chars);

        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
    

使用静态方法

这是String类自定义的静态方法；介绍如下：

• copyValueOf(char data[]) 返回指定数组中表示该字符序列的 String
• copyValueOf(char data[], int offset, int count)返回指定数组中表示该字符序列的 String
• valueOf(char c)返回指定数组中表示该字符序列的 String
• valueOf(char data[], int offset, int count)返回指定数组中表示该字符序列的 String
• valueOf(int i) 支持各种数据类型(int改为其他的也行)，返回各种数据类型的value参数的字符串表示形式。

其源代码如下：

// 返回指定数组中表示该字符序列的 String
 public static String copyValueOf(char data[]) 
        return new String(data);
    
//返回指定数组中表示该字符序列的 String
 public static String copyValueOf(char data[], int offset, int count) 
        return new String(data, offset, count);
    

//返回指定数组中表示该字符序列的 String
    public static String valueOf(char c) 
        char data[] = c;
        return new String(data, true);
    
//返回指定数组中表示该字符序列的 String
public static String valueOf(char data[], int offset, int count) 
        return new String(data, offset, count);
    
//支持各种数据类型(int改为其他的也行)，返回各种数据类型的value参数的字符串表示形式。
 public static String valueOf(int i) 
        return Integer.toString(i);
    

使用" " + 拼接

Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持（toString()方法）。在String类型中，任意数据类型与" "进行拼接，结果都是字符串。

代码示例如下：

public class Demo 
    public static void main(String[] args) 
        int num = 123456;
        String s = "" +num;
        System.out.println(s);

        Student stu = new Student();
        String s2 = stu + "";//自动调用对象的toString()，然后与""进行拼接
        System.out.println(s2);
    


class Student 
    int id;
    String name;

    @Override
    public String toString() 
        return "Student" +
                "id=" + id +
                ", name='" + name + '\\'' +
                '';
    

这里既然说到了拼接，就不得不说字符串其拼接的特殊性问题，即不同形式创建的字符串所存储的位置是不同的，这也就使得即使字符串内容相同，但进行 == 比较时候，结果不同。其具体分类如下：

• 常量和常量：结果是常量池
• 常量与变量 或 变量与变量：结果是堆
• 任何形式拼接后调用intern方法：结果在常量池
• 使用contcat()方法拼接：结果在堆

代码示例：

 @Test
    public void test06()

        String s1 = "hello"; //变量
        String s2 = "world";
        String s3 = "helloworld";

        String s4 = (s1 + "world").intern();//把拼接的结果放到常量池中
        String s5 = (s1 + s2).intern();

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//true
    

    @Test
    public void test05()
        final String s1 = "hello"; //final变成常量了
        final String s2 = "world";
        String s3 = "helloworld"; //变量

        String s4 = s1 + "world";//s4字符串内容是helloworld，s1是常量，"world"常量，常量 + 常量 结果在常量池中
        String s5 = s1 + s2;//s5字符串内容是helloworld，s1和s2都是常量，常量 + 常量 结果在常量池中
        String s6 = "hello" + "world";//常量 + 常量 结果在常量池中，因为编译期间就可以确定结果

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//true
        System.out.println(s3 == s6);//true
    

    @Test
    public void test04()
        String s1 = "hello"; //变量
        String s2 = "world";
        String s3 = "helloworld";

        String s4 = s1 + "world"; //s4字符串内容是helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中
        String s5 = s1 + s2;//s5字符串内容是helloworld，s1和s2都是变量，变量 + 变量的结果在堆中
        String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果

        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//true
    


 @Test
    public void test03()
        String str = "hello";
        String str2 = "world";
        String str3 ="helloworld";

        String str4 = "hello".concat("world"); //concat方法拼接，哪怕是两个常量对象拼接，结果也是在堆。
        String str5 = "hello"+"world";

        System.out.println(str3 == str4);//false
        System.out.println(str3 == str5);//true
    

字符串对象的比较

字符串的比较有很多种方式，不同方式比较的东西和形式不一样。其比较方式如下：

• ==：比较是对象的地址
• equals：String类型重写equals方法，比较是对象的内容（区分大小写）
• equalsIgnoreCase：比较的是对象的内容（不区分大小写）
• compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的（区分大小写）
• compareToIgnoreCase：按照字符的Unicode编码值进行比较大小（不区分大小写）

代码示例

import org.junit.Test;
public class Demo7 

    // ==：比较的是地址

    @Test
    public void test1()
        String str1 = "hello";
        String str2 = "hello";
        System.out.println(str1 == str2);//true

        String str3 = new String("hello");
        String str4 = new String("hello");
        System.out.println(str1 == str4); //false
        System.out.println(str3 == str4); //false
    

    //     equals：比较是对象的内容，因为String类型重写equals，区分大小写
    @Test
    public void test2()
        String str1 = "hello";
        String str2 = "hello";
        String str5 = "Hello";
        System.out.println(str1.equals(str2));//true

        String str3 = new String("hello");
        String str4 = new String("hello");
        System.out.println(str1.equals(str3));//true
        System.out.println(str3.equals(str4));//true
        System.out.println(str1.equals(str5));//false
    

    //     equalsIgnoreCase：比较的是对象的内容，不区分大小写
    @Test
    public void test3()
        String str1 = new String("hello");
        String str2 = new String("HELLO");
        System.out.println(str1.equalsIgnoreCase(str2)); //true
    

    //compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的，严格区分大小写
    @Test
    public void test4()
        String str1 = "hello";
        String str2 = "world";
        int i = str1.compareTo(str2);
        System.out.println(i);//小于0的值

    

    //compareToIgnoreCase：不区分大小写，其他按照字符的Unicode编码值进行比较大小
    @Test
    public void test5()
        String str1 = "hello";
        String str2 = "HELLO";
        int i = str1.compareToIgnoreCase(str2);
        System.out.println(i);//0
    

字符串的常用方法

String类是非常常用的类，其方法也有很多，但并不是所有的方法都使用的那么频繁，所以在这里介绍了字符串的常用方法是有必要滴。常用方法介绍如下：

查找相关

• boolean contains(xx)：是否包含xx
• int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
• int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1
• String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

代码示例

@Test
	public void test01()
		String str = "这是一个有关查找的测试方法，这个方法很棒";
		System.out.println("是否包含“这个”：" + str.contains("这个"));
		System.out.println("“这”出现的第一次下标：" + str.indexOf("这"));
		System.out.println("“这”出现的最后一次下标：" + str.lastIndexOf("这"));
	

字符串相关

• String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
• char charAt(index)：返回[index]位置的字符
• char[] toCharArray()： 将此字符串转换为一个新的字符数组返回
• String(char[] value)：返回指定数组中表示该字符序列的 String。
• String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。
• static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
• static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
• static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
• static String valueOf(char[] data) ：返回指定数组中表示该字符序列的 String

@Test
	public void test01()
		String str = "helloworldjava";
		String sub1 = str.substring(5); //截取5到最后
		String sub2 = str.substring(5,10);//截取5到10
		System.out.println(sub1);
		System.out.println(sub2);
	

	@Test
	public void test02()
		String fileName = "快速学习Java的秘诀.dat";
		//截取文件名
		System.out.println("文件名：" + fileName.substring(0,fileName.lastIndexOf(".")));
		//截取后缀名
		System.out奉劝那些刚参加工作的学弟学妹们：要想进大厂，这些基础能力是你必须要掌握的！！（建议收藏）

 奉劝那些刚参加工作的学弟学妹们：要想进大厂，这些基础能力是你必须要掌握的！！（建议收藏）
 奉劝那些刚参加工作的学弟学妹们：要想学好并发编程，这些并发容器的坑是你必须要注意的！！（建议收藏）
 奉劝那些刚参加工作的学弟学妹们：要想学好并发编程，这些并发容器的坑是你必须要注意的！！（建议收藏）
 奉劝那些刚参加工作的学弟学妹们：要想进大厂，这些并发编程知识是你必须要掌握的！完整学习路线！！（建议收藏）
 奉劝那些刚参加工作的学弟学妹们：要想进大厂，这些并发编程知识是你必须要掌握的！完整学习路线！！（建议收藏）