Java常用类（详解）

柒分、

已于 2022-11-16 09:34:16 修改

阅读量127

点赞数

文章标签： java

于 2022-11-16 09:15:14 首次发布

本文链接：https://blog.csdn.net/Qifen123321/article/details/127877938

版权

一、Math

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

Math类的特点：

1.Math类是final

2.Math类的构造函数是private

3.Math类的成员都是静态的

静态常量：

1.E：自然对数的底数

2.PI：圆周率

Math类中的常用方法：
	1.Math.sqrt()：//求平方根

	2.Math.abs()：//求绝对值

	3.Math.sin(角度)：//求正弦值  Math.PI / (int)a = 度数

	4.Math.toDegrees(角度)： //弧度转角度

	5.Math.toRadians(默认是弧度制)：//角度转弧度

	6.Math.ceil():  //向上取整(比这个参数大的距离这个参数最近的整数)

	7.Math.floor()：//向下取整（比这个参数小的距离这个参数最近的整数）

	8.Math.round(): //四舍五入

	9.Math.random():  //随机数（0-1中的小数）

	10.Math.min(a,b):  //求a,b两个中的较小的

	11.Math.max(a,b):  //求a,b两个中的较大的

	12.Math.pow(a,b): //求a的b次方

二、Random

此类的实例用于生产伪随机数流。

创建对象：

Random 对象名 = new Randon();

常用方法：

1.对象名.nextInt();
2.对象名.nextInt(n);
	//注：如果参数是负数或者是0，会发生IllegalArgumentException,非法参数异常
3.对象名.nextDouble();

三、Sacnner

一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器

创建对象：
Scanner 对象名 = new Scanner(System.in);
常用方法：
1.对象名.nextInt();
2.对象名.nextDouble();
3.对象名.next();
4.对象名.nextLine();
	//注：next()不能接收空白内容，nextLine()可以接收空白内容
5.对象名.nextInt(n); 
	//n表示指定的进制，它表示将输入的内容视为指定的进制值返回对应的十进制数
注：如果输入值的类型与方法接收值的类型不一致会发生InputMismatchException，输入不匹配异常

四、Date

类Date表示特定的瞬间，精确到毫秒

作用：

1.将日期对象转换成年月日时分秒的值（被Calendar取代）

2.将日期对象格式化成日期字符串、解析日期字符串变为一个日期对象（被DateFormat取代）

创建对象：
1. Date d = new Date();
2. Date d = new Date(long t);
常用方法：
1. d.getTime();//获取当前时间秒数

五、DateFormat

DateFormat是日期/时间格式化子类的抽象类

我们要使用它的子类SimpleDateFormat，它允许进行格式化（日期->文本）、解析（文本->日期）和规范化

功能：

1.格式化：将日期对象转换为指定的字符串

2.解析：将指定的字符串转换为日期对象

创建对象：

SimplDateFormat sdf = new SimplDateFormat("模式");

格式化：

sdf.format(Date d);

解析：

sdf.parse(String t);

注：如果日期字符串的格式与指定格式不匹配会发生ParseException解析异常

六、Calendar

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR,MONTH,DAY_OF_MONTH,HOUR等日历字段之间的转换提供了一些方法

Calendar提供了一个类方法getInstance，以获得此类的一个通用对象。Calendar的getInstance方法返回一个Calendar对象，其日历字段已由日期和时间初始化

对象的获取：
Calendar c = Calendar.getInstance();
常用方法：
1. c.get(n)
2. c.set(int filed,int value)
3. c.set(int year,int month,int day,int minute,int second)
4. c.getTime() //获取当前时间
5. c.getTimeInMillis() //获取毫秒数

七、String

String 类代表字符串。Java程序中的所有字符串字面值（如"abc"）都作为此类的实现类。

字符串是常量，它们的值在创建之后不能更改。因为String对象是不可变的，所有可以共享

构造函数：

// 1.
String s1 = new String();
// 2.
String s2 = new String("abcde");
// 3.
char[] cha = {'a','b','+','9'}
String s3 = new String(cha); //将数组元素拼起来形成字符串
// 4.
char[] cha = {'a','b','+','9'}
String s4 = new String(cha,a,b); (从下标a开始拼b个元素)//重要
// 5.
int[] arr = {97,98,99}
String s5 = new String(arr,a,b); (从下标a开始拿b个元素)转成字符再拼接
// 6.
byte[] byt = {90,91,92}
String s6 = new String(byt,"utf-8");//需要抛出异常（throws UnsupportedEncodingException）
// 7.
byte[] byt = {97,98,99,100}  
String s7 = new String(byt);//转换成字符拼接输出
// 8.
byte[] byt = {97,98,99,100} 
String s8 = new String(byt,1,3);//从下标1开始拿三个转成字符拼接输出//重要

常用方法：

字符串和数组一样
// 1.
变量名.length();//求字符串长度
// 2.
变量名.charAt(int a);//求下标为a的字符（StringIndexOutOfBoundsException字符串下标越界异常）
// 3.
变量名.indexOf("内容");//根据内容起始位置返回内容所在的下标（找不到返回-1）
// 4.
变量名.lastIndexOf("内容");//根据内容起始位置找最后的起始位置的下标（找不到返回-1）
// 5.
变量名.equalsIgnoreCase(String s);//忽略大小写的字符串比较
// 6.
byte[] bs = 变量名.getBytes();//转换成字节数组（字符对应的十进制数）
// 7.
char[] ch = 变量名.toCharArray();//转换成字符数组
// 8.
变量名.toUpperCase();//小写变大写
变量名.toLowerCase();//大写变小写
// 9.
变量名.substring(5);//从5开始截取到最后
变量名.substring(2,5);//从下标2开始截取到第5个（含头不含尾）
// 10.
变量名.startWith();//判断是不是以xxx开头
变量名.endsWith();//判断是不是以xxx开结尾
// 11.
变量名.replace(char olderChar , new Char);//替换内容
变量名.replace("abcd","P");// P 替换 abcd
// 12.
变量名.trim();//去除两端的空格/Tab键（空白）

八、String Builder 、String Buffer（安全同步）

String Builder 、String Buffer都是可变的字符序列，他们有兼容的API。

区别是：

String Buffer：线程安全，保证线程同步，效率（性能）较低

String Builder：不保证线程安全，不保证保证线程同步，效率（性能）更高

创建对象：

//StringBuilder
// 1.
StringBuilder sb1 = new StringBuilder();
// 2.
StringBuilder sb3 = new StringBuilder(int capacity);//容量
// 3.
StringBuilder sb4 = new StringBuilder(String s);
// 4.
StringBuilder sb4 = new StringBuilder(CharSequence);//可以放String，StringBuffer，StringBuilder

//StringBuffer
// 1.
StringBuffer sb1 = new StringBuffer();
// 2.
StringBuffer sb3 = new StringBuffer(int capacity);
// 3.
StringBuffer sb4 = new StringBuffer(String s);
// 4.
StringBuffer sb4 = new StringBuffer(CharSequence);//可以放String，StringBuffer，StringBuilder

常用方法：

StringBuilder sb = new StringBuilder();
// 1.拼接
sb.append(Object o);
// 2.删除
sb.delete(int start , int end);//从下标start开始，删到下标为end（含头不含尾）
// 3.替换
sb.replace(int start , int end , String s);
// 4.反转（倒过来）
sb.reverse();
// 5.插入
sb.insert(insert , Object o);//下标
// 6.删除字符下标
sb.deleteCharAt(index);

String Builder 、String Buffer 与 String的转换：

1.String Builder 、String Buffer => String

// 1.调用String Builder 、String Buffer的toString()方法
StringBuilder sb1 = new StringBuilder("abc");
String s1 = sb1.toString();
// 2.使用String的构造函数
StringBuffer sb2 = new StringBuffer("123");
String s2 = new String(sb2);

2.String => String Builder 、String Buffer

// 1.使用String Builder 、String Buffer的构造函数
String s = "Love";
StringBuilder sb3 = new StringBuilder(s);
StringBuffer sb4 = new StringBuffer(s);

九、Arrays

此类包含用来操作数组（比如排序和搜索）的各种方法。

特点：

1.Arrays的构造函数是私有的

2.Arrays中的方法都是静态方法

常见方法：

// 1.遍历数组
Arrays.toString(Object[] o);
// 2.返回一个新数组
Arrays.copyOf(Object[] o ,newLength);
// 3.将传入的指定的若干个值，构造出一个集合
Arrays.asList();
// 4.二分搜索法
Arrays.binarySearch(Object[] os,Object o);//类型一致；使用二分搜索法返回值在指定数组中的下标
注：数组必须要满足一下两个条件
    1.数组中的元素必须是升序排列的
    2.数组中的元素必须唯一
// 5.返回一个对应的数组（含头不含尾）
Arrays.copyOfRange(Object[] os,from int a ,to int a);   
// 6.填充（将内容填充）
Arrays.fill(Object[] os ,Object o);
// 7.比较两个数组的内容是否一致
Arrays.equals(Object[] os1 , Object[] os2);
// 8.排序（升序）
Arrays.sort();

排序方法：

方法一：sort(数组)

然后对对象的属性进行排序

步骤：

1.使指定类实现Comparable接口，在接口的泛型中写该实现类

2.重写compareTo方法，在方法中返回要进行排序的属性之差

升序：this.属性 - 参数.属性

降序：参数.属性 - this.属性

方法二：sort(数组,Comparator)
Arrays.sort(emps ,new Comparator<Emp>{
   @Override
    public int compare(Emp e1 , Emp e2){
        return e1.age - e2.age;//升序 反之降序
    }
});
列子：（多态）

十、Object

类Object是类层次结构的跟类。每个类都使用Object作为超类

常用方法：
1.toString();
输出对象时打印的是对象的地址值，因为输出对象时，默认调用toString()方法，在本类中没有对toString()方法的重写所以调用的Object类中的toString()，Object类中的toString()输出的是当前对象的地址

可以对Object类中的toString()进行重写，在输入对象时直接输出对象的属性
public String toString(){
return this.name + "----"+ this.age;
}
// 2.返回对象真实类型
getClass();
// 3.
equals();
Object类中的equals()方法用于比较两个地址是否相同，如果我们需要比较两个对象的属性是否完全相同，可重写Object类中的equals()方法
@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return getId() == student.getId() && 								getName().equals(student.getName());
    }

十一、包装类

任何类型的对象都可以进行属性和方法的调用但是基本类型不能调用属性和方法；为了能让基本类型也可以调用属性和方法；在Java中对这8个基本类型进行封装，封装成了对应的8个引用数据类型，这八个引用数据类型就成为包装类。

基本类型引用类型（包装类）
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

基本类型	引用类型（包装类）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

包装类对象的创建:

Integer i = new Integer(int n);
Integer j = new Integer(String s);
// 注：这个参数类型是String的构造函数的参数，只能是整数形式的字符串，否则会发生NumberFormatException，数字格式异常

常用的静态方法：

1.toString();
2.toString(int n , int r);// r表示进制，功能是将n转换r进制的字符串值
3.compare(int n , int m)
4.max(int n , int m);
5.min(int n , int m);
6.parseInt(String s);
7.parseInt(String s , r); // r表示进制，功能是将指定的r进制的s转换成十进制数
8.valueOf(int i);
9.valueOf(String s);
10.valueOf(String s,int r);//r表示进制，功能是将指定的r进制的s转换成十进制数
11.toBinaryString();//转成二进制
12.toOctalString();//转成八进制
13.toHexString(); // 转成16进制

注：参数是String用于将String转换成整数的方法，参数只能是整数形式的字符串，否则会发生NumberFormatException，数字格式异常

常用的成员方法：

1.toString();
2.equals();
3.compareTo();
4.byteValue();
5.intValue();
6.shortValue();
7.longValue();
8.doubleValue();
9.floatValue();

静态常量

1.MAX_VALUE
2.MIN_VALUE

装箱和拆箱

1.装箱：将基本类型转换成对应的包装类
 //装箱
int i = 3;
Integer j = new Integer(i);
2.拆箱：将包装类转换成对应的基本类型
//拆箱
Integer a = new Integer(3);
int b = a.intValue();
从JDK1.5开始，自动装拆箱，包装类和它对应的基本类型可以直接赋值；

从JDK1.9开始，包装类的构造函数变成了过期函数

包装类、基本类型和字符串的转换

包装类、基本类型 => 字符串
// 1.拼接字符串
int i = 1;
String s = i + "";
// 2.包装类的成员方法
Integer j = 4;
String s2 = j.toString();
// 3.包装类的静态方法
String s3 = Integer.toString(5);
// 4.String类中的静态方法
String s4 = String.valueOf(i);


字符串 => 包装类、基本类型
String s4 = "3";
//1.包装类的构造函数
Integer n = new Integer(s4);
// 2.包装类的静态方法valueOf
Integer m = Integer.valueOf("6");
// 3.包装类的静态方法
int p = Integer.parseInt("7");

十二、System

特点：

1.System类是final的

2.它不能被实例化

3.System中的成员都是静态的

常用方法：
1.System.arrayCopy(a,b,c,d,e);
2.System.currentTimeMillis();
3.System.exit(int n); //结束JVM
		// 注意：参数0表示正常终止，非0表示异常终止
4.System.gc(); //告知垃圾回收站收垃圾

十三、正则表达式

概念：通过指定的模式对其它字符串进行匹配、替换、切割、查找的字符串叫正则表达式，也叫规则表达式

匹配：字符串.matches（正则）

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

       System.out.println("请输入要检测的QQ邮箱：");
        String qq = new Scanner(System.in).next();
        boolean b = qq.matches("[A-Za-z]{2,5}[0-9]{6,10}@[0-9a-zA-Z_]{2,6}\\.com");
        if (b==true){
            System.out.println("是标准邮箱");
        }else {
            System.out.println("不是标准邮箱");
        }
    }
}

切割的用法：字符串.split(正则),字符串会以正则表达式切割成若干字符串组成的数组

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

        /*
        	String ip = "192.168.1.100";
        	String[] arr = ip.split("[.]");
        	System.out.println(Arrays.toString(arr));
        */
      
       	String ip = "192.......168.......1......100";
        String[] arr = ip.split("[.]+");
        System.out.println(Arrays.toString(arr));
    }
}

替换的用法：字符串.replaceAll(正则,新值)，将字符串中符合正则表达式的部分用新值替换

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

      /*
        String s = "你真是个小**，你天天吃*，所以长成这*样";
        String s1 = s.replaceAll("\\*","?");
        System.out.println(s1);
       */

        String s = "你真是个小**，你天天吃*，所以长成这*样";
        String s1 = s.replaceAll("\\*+","?");
        System.out.println(s1);

    }
}

public class Reg4 {
    public static void main(String[] args) {
        
        String s = "我我我我我爱爱爱中中中中中中中中国国国";//=>我爱中国
        System.out.println(s.replaceAll("(.)\\1+", "$1"));
    }
}

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

  /*
    String s = "你真是个小**，你天天吃*，所以长成这*样";
    String s1 = s.replaceAll("\\*","?");
    System.out.println(s1);
   */

    String s = "你真是个小**，你天天吃*，所以长成这*样";
    String s1 = s.replaceAll("\\*+","?");
    System.out.println(s1);

}

}


```java
public class Reg4 {
    public static void main(String[] args) {
        
        String s = "我我我我我爱爱爱中中中中中中中中国国国";//=>我爱中国
        System.out.println(s.replaceAll("(.)\\1+", "$1"));
    }
}