Java核心类与常用工具类

最新推荐文章于 2022-05-16 14:33:03 发布

师兄白泽

最新推荐文章于 2022-05-16 14:33:03 发布

阅读量289

点赞数 1

分类专栏： Java 笔记文章标签： java

原文链接：https://www.liaoxuefeng.com/wiki/1252599548343744

版权

笔记同时被 2 个专栏收录

24 篇文章 3 订阅

订阅专栏

Java

22 篇文章 0 订阅

订阅专栏

Java核心类

1.String字符串

1-1.声明：

String name = "name";//直接声明
String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});//使用char声明

注：Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。

1-2.字符串比较：

        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1 == s2);//true
        System.out.println(s1.equals(s2));//true

从表面上看，两个字符串用==和equals()比较都为true，但实际上那只是Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池，自然s1和s2的引用就是相同的。

        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true

结论：两个字符串比较，必须总是使用equals()方法。要忽略大小写比较，使用equalsIgnoreCase()方法。

1-3.搜索子串、提取子串

//搜索字符串
// 是否包含子串:
"Hello".contains("ll"); // true
//注意到contains()方法的参数是CharSequence而不是String，因为CharSequence是String的父类。
"Hello".indexOf("l"); // 2 查找第一个l的索引
"Hello".lastIndexOf("l"); // 3 查找最后一个l的索引
"Hello".startsWith("He"); // true 查找字符串是否以He开头
"Hello".endsWith("lo"); // true 查看字符串是否以lo结尾
//提取字符串
"Hello".substring(2); // "llo"
"Hello".substring(2, 4); // "ll"

1-4.去除收尾空字符

使用trim()方法可以移除字符串首尾空白字符。空白字符包括空格，\t，\r，\n：

"  \tHello\r\n ".trim(); // "Hello"

注意：trim()并没有改变字符串的内容，而是返回了一个新字符串。

另一个strip()方法也可以移除字符串首尾空白字符。它和trim()不同的是，类似中文的空格字符\u3000也会被移除：

"\u3000Hello\u3000".strip(); // "Hello"
" Hello ".stripLeading(); // "Hello "
" Hello ".stripTrailing(); // " Hello"

String还提供了isEmpty()和isBlank()来判断字符串是否为空和空白字符串：

"".isEmpty(); // true，因为字符串长度为0
"  ".isEmpty(); // false，因为字符串长度不为0
"  \n".isBlank(); // true，因为只包含空白字符
" Hello ".isBlank(); // false，因为包含非空白字符

1-5.替换字符串

//正常替换
String s = "hello";
s.replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'
s.replace("ll", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"
//正则替换
String s = "A,,B;C ,D";
s.replaceAll("[\\,\\;\\s]+", ","); // "A,B,C,D"
//上面的代码通过正则表达式，把匹配的子串统一替换为","。关于正则表达式的用法我们会在后面详细讲解。

1-6.分割字符串

要分割字符串，使用split()方法，并且传入的也是正则表达式：

String s = "A,B,C,D";
String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}

1-7.拼接字符串

拼接字符串使用静态方法join()，它用指定的字符串连接字符串数组：

String[] arr = {"A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"

1-8.格式化字符串

字符串提供了formatted()方法和format()静态方法，可以传入其他参数，替换占位符，然后生成新的字符串：

public class Main {
    public static void main(String[] args) {
        String s = "Hi %s, your score is %d!";
        System.out.println(s.formatted("Alice", 80));
        System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5));
    }
}

常用的占位符：
%s：显示字符串；
%d：显示整数；
%x：显示十六进制整数；
%f：显示浮点数。

注：占位符还可以带格式，例如%.2f表示显示两位小数。如果你不确定用啥占位符，那就始终用%s，因为%s可以显示任何数据类型。要查看完整的格式化语法，请参考JDK文档。、

1-9.类型转换

要把任意基本类型或引用类型转换为字符串，可以使用静态方法valueOf()。这是一个重载方法，编译器会根据参数自动选择合适的方法：


String.valueOf(123); // "123"
String.valueOf(45.67); // "45.67"
String.valueOf(true); // "true"
String.valueOf(new Object()); // 类似java.lang.Object@636be97c

要把字符串转换为其他类型，就需要根据情况。例如，把字符串转换为int类型:


int n1 = Integer.parseInt("123"); // 123
int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255

把字符串转换为boolean类型：

boolean b1 = Boolean.parseBoolean("true"); // true
boolean b2 = Boolean.parseBoolean("FALSE"); // false

要特别注意，Integer有个getInteger(String)方法，它不是将字符串转换为int，而是把该字符串对应的系统变量转换为Integer：

Integer.getInteger("java.version"); // 版本号，11

转换为char[],String和char[]类型可以互相转换

char[] cs = "Hello".toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String

注：如果修改了char[]数组，String并不会改变：

这是因为通过new String(char[])创建新的String实例时，它并不会直接引用传入的char[]数组，而是会复制一份，所以，修改外部的char[]数组不会影响String实例内部的char[]数组，因为这是两个不同的数组。

从String的不变性设计可以看出，如果传入的对象有可能改变，我们需要复制而不是直接引用。

1-10.字符编码

在早期的计算机系统中，为了给字符编码，美国国家标准学会（American National Standard Institute：ANSI）制定了一套英文字母、数字和常用符号的编码，它占用一个字节，编码范围从0到127，最高位始终为0，称为ASCII编码。例如，字符’A’的编码是0x41，字符’1’的编码是0x31。
如果要把汉字也纳入计算机编码，很显然一个字节是不够的。GB2312标准使用两个字节表示一个汉字，其中第一个字节的最高位始终为1，以便和ASCII编码区分开。例如，汉字’中’的GB2312编码是0xd6d0。
类似的，日文有Shift_JIS编码，韩文有EUC-KR编码，这些编码因为标准不统一，同时使用，就会产生冲突。
为了统一全球所有语言的编码，全球统一码联盟发布了Unicode编码，它把世界上主要语言都纳入同一个编码，这样，中文、日文、韩文和其他语言就不会冲突。
Unicode编码需要两个或者更多字节表示，我们可以比较中英文字符在ASCII、GB2312和Unicode的编码：

2.StringBuilder

Java编译器对String做了特殊处理，使得我们可以直接用+拼接字符串。

虽然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。为了能高效拼接字符串，Java标准库提供了StringBuilder，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象：

StringBuilder sb = new StringBuilder(1024);
for (int i = 0; i < 1000; i++) {
    sb.append(',');
    sb.append(i);
}
String s = sb.toString();

StringBuilder还可以进行链式操作：

public class Main {
    public static void main(String[] args) {
        var sb = new StringBuilder(1024);
        sb.append("Mr ")
          .append("Bob")
          .append("!")
          .insert(0, "Hello, ");
        System.out.println(sb.toString());
    }
}

你可能还听说过StringBuffer，这是Java早期的一个StringBuilder的线程安全版本，它通过同步来保证多个线程操作StringBuffer也是安全的，但是同步会带来执行速度的下降。StringBuilder和StringBuffer接口完全相同，现在完全没有必要使用StringBuffer。

3.StringJoiner

3-1.StingJoiner

要高效拼接字符串，应该使用StringBuilder。
用分隔符拼接数组的需求很常见，所以Java标准库还提供了一个StringJoiner来干这个事：(StringJoiner常用于拼接有分隔符的拼接)

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}

同时StringJoiner还提供了指定开头和结尾的参数传递

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        var sj = new StringJoiner(", ", "Hello ", "!");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}

3-2.String.join()

String还提供了一个静态方法join()，这个方法在内部使用了StringJoiner来拼接字符串，在不需要指定“开头”和“结尾”的时候，用String.join()更方便：

String[] names = {"Bob", "Alice", "Grace"};
var s = String.join(", ", names);

4.装箱和拆箱

基本类型：byte，short，int，long，boolean，float，double，char引用
类型：所有class和interface类型
引用类型可以赋值为null，表示空，但基本类型不能赋值为null。那么如何将基本类型转换为引用类型(对象)，我们可以定义一个Integer类，它只包含一个字段int，这样Integer类就可以视为int的包装类（Wrapper Clsaa）:

//注：包装类在jdk中已经封装好了,我们可以直接使用
public class Integer {
    private int value;

    public Integer(int value) {
        this.value = value;
    }

    public int intValue() {
        return this.value;
    }
}

定义好了Integer类，我们就可以把int和Integer互相转换：
实际上，因为包装类型非常有用，Java核心库为每种基本类型都提供了对应的包装类型：

基本类型	对应的引用类型
boolean	java.lang.Boolean
byte	java.lang.Byte
short	java.lang.Short
int	java.lang.Integer
long	java.lang.Long
float	java.lang.Float
double	java.lang.Double
char	Charset

public class Main {
    public static void main(String[] args) {
        int i = 100;
        // 通过new操作符创建Integer实例(不推荐使用,会有编译警告):
        Integer n1 = new Integer(i);
        // 通过静态方法valueOf(int)创建Integer实例:
        Integer n2 = Integer.valueOf(i);
        // 通过静态方法valueOf(String)创建Integer实例:
        Integer n3 = Integer.valueOf("100");
        System.out.println(n3.intValue());
    }
}

4-1.自动装箱

Auto Boxing
因为int和Integer可以互相转换，所以，Java编译器可以帮助我们自动在int和Integer之间转型：

Integer n = 100; // 编译器自动使用Integer.valueOf(int)
int x = n; // 编译器自动使用Integer.intValue()

这种直接把int变为Integer的赋值写法，称为自动装箱（Auto Boxing），反过来，把Integer变为int的赋值写法，称为自动拆箱（Auto Unboxing）。

注意：自动装箱和自动拆箱只发生在编译阶段，目的是为了少写代码。装箱和拆箱会影响代码的执行效率，因为编译后的class代码是严格区分基本类型和引用类型的。并且，自动拆箱执行时可能会报NullPointerException：

所有的包装类型都是不变类(原码中有final)

4-2.比较

对两个Integer实例进行比较要特别注意：绝对不能用==比较，因为Integer是引用类型，必须使用equals()比较：

public class Main {
    public static void main(String[] args) {
        Integer x = 127;
        Integer y = 127;
        Integer m = 99999;
        Integer n = 99999;
        System.out.println("x == y: " + (x==y)); // true
        System.out.println("m == n: " + (m==n)); // false
        System.out.println("x.equals(y): " + x.equals(y)); // true
        System.out.println("m.equals(n): " + m.equals(n)); // true
    }
}

4-3.进制转换


int x1 = Integer.parseInt("100"); // 100
int x2 = Integer.parseInt("100", 16); // 256,因为按16进制解析

//Integer还可以把整数格式化为指定进制的字符串：
public class Main {
    public static void main(String[] args) {
        System.out.println(Integer.toString(100)); // "100",表示为10进制
        System.out.println(Integer.toString(100, 36)); // "2s",表示为36进制
        System.out.println(Integer.toHexString(100)); // "64",表示为16进制
        System.out.println(Integer.toOctalString(100)); // "144",表示为8进制
        System.out.println(Integer.toBinaryString(100)); // "1100100",表示为2进制
    }
}

4-4.其他

Java的包装类型还定义了一些有用的静态变量:

// boolean只有两个值true/false，其包装类型只需要引用Boolean提供的静态字段:
Boolean t = Boolean.TRUE;
Boolean f = Boolean.FALSE;
// int可表示的最大/最小值:
int max = Integer.MAX_VALUE; // 2147483647
int min = Integer.MIN_VALUE; // -2147483648
// long类型占用的bit和byte数量:
int sizeOfLong = Long.SIZE; // 64 (bits)
int bytesOfLong = Long.BYTES; // 8 (bytes)

最后，所有的整数和浮点数的包装类型都继承自Number，因此，可以非常方便地直接通过包装类型获取各种基本类型：

// 向上转型为Number:
Number num = new Integer(999);
// 获取byte, int, long, float, double:byte b = num.byteValue();
int n = num.intValue();
long ln = num.longValue();
float f = num.floatValue();
double d = num.doubleValue();

小结：

Java核心库提供的包装类型可以把基本类型包装为class；
自动装箱和自动拆箱都是在编译期完成的（JDK>=1.5）；
装箱和拆箱会影响执行效率，且拆箱时可能发生NullPointerException；
包装类型的比较必须使用equals()；
整数和浮点数的包装类型都继承自Number；
包装类型提供了大量实用方法。

5.枚举

5-1.枚举的作用：

枚举是为了更简便的定义常量的一种方法，并且可以让编译器实时检查每个值的合理性。
使用enum定义的枚举类是一种引用类型。前面我们讲到，引用类型比较，要使用equals()方法，如果使用==比较，它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用equals()方法，但enum类型可以例外。

5-2.枚举的语法：

public enum Color {
    RED, GREEN, BLUE;
}
//引用方法：
class demo{
    System.out.println(Color.RED);
}

5-3.枚举的方法：

因为enum是一个class，每个枚举的值都是class实例，因此，这些实例有一些方法：

name() 返回常量名

String s = Weekday.SUN.name(); // "SUN"

2.ordinal() 返回定义的常量的顺序，从0开始计数。

int n = Weekday.MON.ordinal(); // 1

在枚举中，也可以指定常量的顺序

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Today is " + day + ". Work at home!");
        } else {
            System.out.println("Today is " + day + ". Work at office!");
        }
    }
}
enum Weekday {
    MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");
    public final int dayValue;
    private final String chinese;

    private Weekday(int dayValue, String chinese) {
        this.dayValue = dayValue;
        this.chinese = chinese;
    }
    @Override
    public String toString() { 
        return this.chinese;
    }
}

小结：
Java使用enum定义枚举类型，它被编译器编译为final class Xxx extends Enum { … }；
通过name()获取常量定义的字符串，注意不要使用toString()；
通过ordinal()返回常量定义的顺序（无实质意义）；
可以为enum编写构造方法、字段和方法enum的构造方法要声明为private，字段强烈建议声明为final；
enum适合用在switch语句中。

6.常见工具类

6-1.Math

求绝对值 Math.abs();
两数间取最大/最小值 Math.max(); Math.min();
计算y^x次方 Math.pow(2, 10); // 2的10次方=1024
计算根号x Math.sqrt(2); // 1.414…
计算e^x次方 Math.exp(2); // 7.389…
计算以e为底的对数 Math.log(4); // 1.386…
计算以10为底的对数 Math.log10(100); // 2
三角函数
Math.sin(3.14); // 0.00159…
Math.cos(3.14); // -0.9999…
Math.tan(3.14); // -0.0015…
Math.asin(1.0); // 1.57079…
Math.acos(1.0); // 0.0
部分数学常量:
double pi = Math.PI; // 3.14159…
double e = Math.E; // 2.7182818…
Math.sin(Math.PI / 6); //sin(π/6) = 0.5
随机数范围是0 <= x < 1
Math.random(); // 0.53907… 每次都不一样
如果我们要生成一个区间在[MIN, MAX)的随机数，可以借助Math.random()实现，计算如下：

// 区间在[MIN, MAX)的随机数
public class Main {
    public static void main(String[] args) {
        double x = Math.random(); // x的范围是[0,1)
        double min = 10;
        double max = 50;
        double y = x * (max - min) + min; // y的范围是[10,50)
        long n = (long) y; // n的范围是[10,50)的整数
        System.out.println(y);
        System.out.println(n);
    }
}

6-2.随机数

6-2-1.伪随机数Random

Random r = new Random();
r.nextInt(); // 2071575453,每次都不一样
r.nextInt(10); // 5,生成一个[0,10)之间的int
r.nextLong(); // 8811649292570369305,每次都不一样
r.nextFloat(); // 0.54335...生成一个[0,1)之间的float
r.nextDouble(); // 0.3716...生成一个[0,1)之间的double

我们创建Random实例时，如果不给定种子，就使用系统当前时间戳作为种子，因此每次运行时，种子不同，得到的伪随机数序列就不同。如果我们在创建Random实例时指定一个种子，就会得到完全确定的随机数序列：
// 51 80 41 28 55 84 75 2 1 89

Random r = new Random(12345);for (int i = 0; i < 10; i++) {    System.out.println(r.nextInt(100));}

6-2-2.真随机数SecureRandom

SecureRandom无法指定种子，它使用RNG（random number generator）算法。JDK的SecureRandom实际上有多种不同的底层实现，有的使用安全随机种子加上伪随机数算法来产生安全的随机数，有的使用真正的随机数生成器。实际使用的时候，可以优先获取高强度的安全随机数生成器，如果没有提供，再使用普通等级的安全随机数生成器：

public class Main {
    public static void main(String[] args) {
        SecureRandom sr = null;
        try {
            sr = SecureRandom.getInstanceStrong(); // 获取高强度安全随机数生成器
        } catch (NoSuchAlgorithmException e) {
            sr = new SecureRandom(); // 获取普通的安全随机数生成器
        }
        byte[] buffer = new byte[16];
        sr.nextBytes(buffer); // 用安全随机数填充buffer
        System.out.println(Arrays.toString(buffer));
    }
}

注：需要使用安全随机数的时候，必须使用SecureRandom，绝不能使用Random！

注：文章来源——廖雪峰的官方网站（侵删）

师兄白泽

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java核心类与常用工具类

文章目录Java核心类1.String字符串1-1.声明：1-2.字符串比较：1-3.搜索子串、提取子串1-4.去除收尾空字符1-5.替换字符串1-6.分割字符串1-7.拼接字符串1-8.格式化字符串1-9.类型转换1-10.字符编码2.StringBuilder3.StringJoiner3-1.StingJoiner3-2.String.join()4.装箱和拆箱4-1.自动装箱4-2.比较4-3.进制转换4-4.其他5.枚举5-1.枚举的作用：5-2.枚举的语法：5-3.枚举的方法：6.常见工具类6-
复制链接

扫一扫