常用类 | 格物志

一，Scanner

Scanner 是一个专门用于接收键盘输入的类，它在 java.util 包中

构造函数：
1
new Scanner(System.in)
常用方法：

next()

nextLine()

nextInt()

nextInt(int radix)

例如：nextInt(2)，表示系统将输入的内容视为二进制数，返回一个对应的十进制数

nextDouble()

注：如果输入内容的类型与指定类型不匹配会发生 InputMismatchException

二，Random

Random 是一个专门用于产生随机数的类，它在 java.util 包中

构造函数：
1
new Random()
常用方法：

nextInt()：随机整个 int 范围内的数

nextDouble：随机 [0.0，1.0)

nextInt(int bound)：随机 [0，bound)

例如：随机 [44，55] ，nextInt(55-44+1)+44

三，Math

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

注：

Math 类是最终类，不能被继承

Math 类的构造函数私有化了，其他类无法创建 Math 类的对象

Math 类中成员都是静态的

静态常量：

E：自然对数的底数

PI：圆周率

常用方法：

abs(double d)：求绝对值

ceil(double d)：向上取整

floor(double d)：向下取整

toDegrees(double d)：弧度制转角度制

toRadians(double d)：角度制转弧度制

sin(double d)：求正弦值，参数是弧度制的

acos(double d)：求反余弦值

max(double d，double d)：求较大者

min(double d，double d)：求较小者

pow(double a，double b)：求a的b次方

sqrt(double d)：求平方根

random()：随机 [0.0，1.0)

round(double d)：四舍五入，返回long值

rint(double d)：四舍五入，返回double值

四，Date

类 Date 表示特定的瞬间，精确到毫秒，它在 java.util 包中

Date类的功能：

可以将Date对象转换成时间字段

可以将Date对象进行格式化和解析

构造函数：

new Date()：获取当前时间

new Date(long d)：获取指定时间，从1970 年 1 月 1 日 00:00:00 GMT开始

常用方法：

getTime()：返回1970 年 1 月 1 日 00:00:00 到Date对象的所指定的时间

五，DateFormat

DateFormat是一个抽象类，通常使用它的子类 SimpleDateFormat

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。

它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化

构造函数：

new SimpleDateFormat(String pattern)：根据指定格式模式创建对象

功能：

格式化（Date对象 - > String）
1
2
3
4
5
6
7
8
9
public static void format(){
    // 创建日期对象
    Date d = new Date();
    // 创建日期格式化对象，同时指定格式
    DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
    // 调用format方法对指定的日期对象执行格式化
    String time = df.format(d);
    System.out.println(time);
}
解析（String - > Date对象）
1
2
3
4
5
6
public static void parse() throws Exception{
    DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date d = df.parse("2021-04-06 16:57:04");
    System.out.println(d);
}
// 如果日期字符串与指定格式不匹配，会发生ParseException

六，Calendar

概念：Calendar 类是一个抽象类，它为特定瞬间与日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。瞬间可用毫秒值来表示。它是距格林威治标准时间 1970 年 1 月 1 日的 00:00:00 的偏移量。

Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化

对象获取：
1
Calendar cal = Calendar.getInstance();
常用方法：

get(int field)：返回指定日历字段的值

set(int field，int value)：为指定日历的字段设置值

set(int year，int month，int date，int hourOfDay，int minute，int second)

getTime()：返回 Date 对象

getTimeInMillis()：返回1970 年 1 月 1 日 00:00:00到Calendar对象的所指定的时间

七，Arrays

此类包含用来操作数组的各种方法。

注：

Arrays中的构造函数是私有的，不能创建它的对象

Arrays中的方法都是静态的

常用方法：

toString(Object[] arr)：将数组以字符串的形式返回

binarySearch(Object[] arr，Object key)：使用二分搜索法查找指定元素在数组中的下标

前提：

升序排列

元素唯一

copyOf(Object[] arr，int length)：根据指定的长度创建新数组，将arr数组中的元素拷贝新数组中

copyOfRange(Object[] arr，int from，int to)：根据下标范围拷贝到新创建的数组中

fill(Object[] arr，Object value)：将value值赋值给数组中的每一个元素

sort(Object[] arr)：根据元素的自然顺序对指定对象数组按升序进行排序。

通过sort()方法对对象的属性进行排序：

方式一的步骤：

实现 Comparable 接口

重写 compareTo 方法

在 compareTo 方法中返回要比较的属性的差值，

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

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

方式二：调用sort()方法的重载形式sort(Object[] arr，Comparator c)
调用sort(Object[] arr，Comparator c)，传入要排序的数组和 Comparator 的实现类对象

重写 Comparator 的 compare(T t1，T t2)方法
在compare方法中返回t1和t2的属性差值

升序：t1.属性 - t2.属性

降序：t2.属性 - t1.属性
1
2
3
4
5
6
Arrays.sort(emps,new Comparator<Emp>(){
    @Override
    public int compare(Emp o1, Emp o2) {
        return o2.salary - o1.salary;
    }
});

八，Object

概念：类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

常用方法：
toString()

打印对象时，会默认调用toString()方法，如果没有重写Object中的toString()，会执行Object中的toString()，输出地址：
1
2
3
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
我们可以对Object中的toString()进行重写，来更方便直观的查看对象的属性。
1
2
3
4
5
6
7
@Override
public String toString() {
    return "Teacher{" +
        "name='" + name + '\'' +
        ", age=" + age +
        '}';
}

equals

用于比较两个对象的地址值是否相同

1
2
3

public boolean equals(Object obj) {
    return (this == obj);
}

我们可以通过重写equals()方法来比较两个对象的属性是否完全相同

public boolean equals(Object obj) {
    if(this == obj) return true;
    if(obj != null && obj instanceof Emp){
        Emp e = (Emp)obj;
        if(this.name != null){
            return this.name.equals(e.name) && this.age == e.age;
        }else{
            if(e.name == null){
                return this.age == e.age;
            }
        }
    }
    return false;
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || this.getClass() != o.getClass()) return false;
    Stu stu = (Stu) o;
    return age == stu.age &&
        Objects.equals(name, stu.name);
}

补充：

Objects 的 equals() 方法
1
2
3
public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}
作用：比较两个对象是否相同，避免了空指针异常

九，String

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

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

注：

所有字符串字面值都是String类的对象

字符串都是常量

字符串存储在字符串常量池中，是共享的

== 在比较基本数据类型时，比较的是数据值；== 在比较引用数据类型时，比较的是对象的地址值；比较字符串中的内容是否相同应该是使用 equals()

构造函数：

new String()：创建一个空的字符串

new String(byte[] bytes)：将字节数组中的元素根据ASCII码表转换成字符后生成字符串

new String(char[] chars)：将字符数组中的元素拼接成一个字符串

new String(String s)

new String(byte[] bytes, String charset)：可以根据指定的字符集编码生成字节数组所对应的字符串

new String(byte[] bytes , int offset , int length)：从字节数组的指定位置开始获取指定数量的元素拼接成字符串

new String(char[] chars , int offset , int count)：从字符数组的指定位置开始获取指定数量的元素拼接成字符串

常用方法：

charAt(int index)：根据下标返回字符

indexOf(String str)：根据字符串内容返回所在下标

indexOf(String str，int index)：从指定位置开始查找指定字符串所在的下标

lastIndexOf(String str)：返回最后一个字符串内容所在的下标

lastIndexOf(String str, int index)：从指定位置开始，从后往前查找最后一个字符串所在的下标

compareTo(String str)：根据字典顺序比较字符的大小，返回差值

compareToIgnoreCase(String str)：忽略大小写比较

equals(String str)：比较字符串的内容，返回布尔值

equalsIgnoreCase(String str)：忽略大小写比较字符串内容

contains(String str)：判断字符串是否包含子串

codePointAt(int index)：通过下标返回字符的十进制数

concat(String str)：拼接字符串

endsWith(String str)：判断是否以指定字符串结尾

startsWith(String str)：判断是否以指定字符串开头

getBytes()：获取字符串的字节数组

toCharArray()：获取字符串的字符数组

isEmpty()：判断字符串的内容是否为空

length()：返回字符串的长度

replace(String oldStr, String newStr)：将新字符串替换原始字符串

substring(int index)：从指定位置截取到字符串末尾

subString(int beginIndex, int endIndex)：从begin下标截取到end下标，不包含end

toLowerCase()：将大写字母转换成小写字母

toUpperCase()：将小写字母转换成大写字母

trim()：去除字符串两端的空格

正则表达式

概念：又称规则表达式，（英语：Regular Expression，在代码中常简写为regex、regexp或RE），它用来对字符串进行匹配、替换、切割、查找。

特点：

灵活、逻辑性强
可以迅速地用非常简单的方式来对字符串进行复杂控制
对刚学的人来说，可读性差

功能：

匹配：

public static void f1(String email){
    String regex = "\\w{6,16}@[0-9a-zA-Z]{2,8}[.]com";
    System.out.println(email.matches(regex));
}

切割

public static void f2(){
    String ip = "192-+-+-+-+-168++++1+++1";
    String[] strs = ip.split("[+-]+");
    System.out.println(Arrays.toString(strs));
}

替换

public static void f3(){
    String str = "你骑过马马马马吗？我骑过马马马马马呀！";
    String regex = "马+";
    str = str.replaceAll(regex,"*");
    System.out.println(str);
}

// 叠词替换
public static void f4(){
    String str = "我我我我我我爱爱爱爱爱爱学习习习习习习习习习习习习";   // 我爱学习
    String regex = "(.)\\1+";
    str = str.replaceAll(regex,"$1");
    System.out.println(str);
}

查找

public static void f(){
    String msg = "today is a funny day,let us go out and play";
    Pattern p = Pattern.compile("\\b[a-z]{5}\\b");
    Matcher m = p.matcher(msg);
    while(m.find()){
        System.out.println(m.group());
    }
}

十，StringBuilder 和 StringBuffer

10.1 StringBuilder 概述

一个可变的字符序列。

StringBuilder 与 StringBuffer 有兼容的 API，

StringBuilder 不保证同步，StringBuffer 保证同步。

建议优先采用 StringBuilder ，因为它比 StringBuffer 要快。

10.2 StringBuffer 概述

线程安全的可变字符序列。

通过某些方法调用可以改变该序列的长度和内容。

10.3 构造函数

构造函数：

StringBuilder()

StringBuilder(int capacity)

StringBuilder(String str)

10.4 常用方法

常用方法：

append(Object obj)

delete(int start, int end)

deleteCharAt(int index)

insert(int index, Object obj)

reverse()

setCharAt(int index, Char c)

10.5 StringBuilder 和 StringBuffer 的区别

StringBuffer 保证线程安全的（同步的）

StringBuilder 速度快，不保证同步

10.6 StringBuilder、StringBuffer 与 String 的转换

StringBuilder、StringBuffer -> String

// 使用toString()
StringBuilder sb1 = new StringBuilder("abc");
String s1 = sb1.toString();
// 使用String的构造函数
StringBuffer sb2 = new StringBuffer("abc");
String s2 = new String(sb2);

String -> StringBuilder、StringBuffer

// 使用StringBuilder、StringBuffer的构造函数
String s3 = "abc";
StringBuilder sb3 = new StringBuilder(s3);
StringBuffer sb4 = new StringBuffer(s3);

十一，包装类

11.1 概念

概念：java 中的数据类型分为基本数据类型和引用数据类型，但是基本数据类型没有对象的概念，不能调用属性和方法，如果我们想要使用基本数据类型的属性和方法，就需要使用基本数据类型所对应的引用数据类型，就是包装类。
1
2
3
4
5
6
7
8
9
基本类型                      包装类
byte                        Byte
short                       Short
int                         Integer
long                        Long
float                       Float
double                      Double
char                        Character
boolean                     Boolean
补：建议将对象属性的类型写成包装类，不要使用基本类型

11.2 包装类对象的创建

格式：
1
2
Integer i = new Integer(3);
Integer j = new Integer("666");
注：

如果参数不是整数或者不是整数形式的字符串会发生 NumberFormatException

Boolean d = new Boolean(“110+1”); 参数是字符串时，只要参数不是”true”，结果都是 false

11.3 成员方法

toString()：转换成字符串

doubleValue()：转换成Double类型

equals()：判断两个值是否相同，前提是数据类型必须是相同的

compareTo()：比较调用者和参数的大小，返回 1 表示调用者大，-1 表示调用者小，0 表示两者相同

11.4 静态方法和静态变量

MAX_VALUE

MIN_VALUE

max(int x，int y)

min(int x，int y)

compare(int x，int y)

sum(int x，int y)

toBinaryString(int n)

toOctalString(int n)

toHexString(int n)

11.5 装箱和拆箱

概念：基本类型与对应包装类之间的转换就是装箱和拆箱

装箱：将基本类型转换成对应的包装类（基本 -> 包装）
1
2
3
4
5
int i = 1;
Integer j = new Integer(i);// 构造函数

int m = 2;
Integer n = Integer.valueOf(m);// 静态方法
拆箱：将包装类转换成对应的基本类型（包装 -> 基本）
1
2
Integer a = new Integer("4");
int b = a.intValue();
从 java5 开始提供了自动装拆箱（直接赋值）
1
2
3
4
5
6
7
// 自动装箱
int a = 3;
Integer i = a;


// 自动拆箱
int b = i;
注：从 Java9 开始包装类中的构造函数变成了过期函数，建议使用自动装箱来完成创建动作

11.6 基本类型/包装类与字符串的转换

基本类型/包装类 - > 字符串

拼接空字符串

使用包装类的静态方法 toString(int n)

补充：toString(int n，int radix)

例如：toString(4，2) 表示返回十进制数的二进制数

使用包装类的成员方法 toString()

使用 String 类中的静态方法 valueOf(int n)

字符串 -> 基本类型/包装类

使用包装类的构造函数

使用包装类的静态方法 parseInt(String s)

使用包装类的静态方法 valueOf(String s)