Java（十）——面向对象(6)-Java核心类

Java核心类

目录

• 一、String类
  • 1、定义String类型
  • 2、方法介绍
• 二、StringBuilder类
• 三、BigInteger类
• 四、BigDecimal类
• 五、Math类
• 六、Random类
• 七、SecureRandom类

一、String类

1、定义String类型

String s = "aaaa";    //   <====>  String s = new String("aaa");

2、方法介绍

Java 11 API : https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html#

// 1. equals()     两个字符串比较是否相同
s1.equals(s2);

// 2. equalsIgnoreCase()   忽略大小写比较
s1.equalsIgnoreCase(s2);

// 3. contains()   是否包含
str.contains("W");

// 4.indexOf()    返回某个字符在字符串中的索引
str.indexOf("W");

// 5.  length()    返回字符串的长度
str.length();

返回值类型	方法	描述
char	charAt(int index)	返回指定索引位置的字符
boolean	contains(CharSequence s)	是否包含某个字符串
boolea	endsWith(String suffix)	判断是否以指定字符串结尾
boolean	equals(Object anObject)	比较两个字符串是否相等
boolean	matches(String regex)	判断字符串是否和给定的正则匹配
String	replace(char oldChar, char newChar)	用新字符/串 替换旧字符/串
String[]	split(String regex)	对字符串按给定方式切割，返回一个数组
String	trim()	删除字符串的首尾的空白字符串，包括空格、 ， ，
String	toString()	转为字符串
boolean	isEmpty()	判断字符串是否为空
static String	join(CharSequence delimiter, CharSequence... elements)	将可迭代对象中的elements用delimiter拼接成一个字符串，静态方法，由类直接调用

二、StringBuilder类

String对象是不可改变的。每次使用 System.String类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，与创建新的 String对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可以使用System.Text.StringBuilder类。例如，当在一个循环中将许多字符串连接在一起时，使用 StringBuilder类可以提升性能。

Java 11 API : https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/StringBuilder.html

返回值类型	方法	描述
StringBuilder	append(xxx)	将xxx 参数的字符串表示形式追加到序列中
StringBuilder	delete(int start, int end)	删除字符串索引在start与end之间的字符串，含头不含尾
StringBuilder	insert(int offset, xxx)	在offset索引位置插入xxx字符串
StringBuilder	replace(int start, int end, String str)	在索引start到end范围内的字符串用str替换，含头不含尾
StringBuilder	reverse()	反序

三、BigInteger类

来表示任意大小的整数

四、BigDecimal类

可以表示一个任意大小且精度完全准确的浮点数

五、Math类

数学计算

// 求绝对值：
Math.abs(-100); // 100
Math.abs(-7.8); // 7.8

// 取最大或最小值：
Math.max(100, 99); // 100
Math.min(1.2, 2.3); // 1.2

// 计算x的y次方：
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

// Math还提供了几个数学常量：
double pi = Math.PI; // 3.14159...
double e = Math.E; // 2.7182818...
Math.sin(Math.PI / 6); // sin(π/6) = 0.5

// 生成一个随机数x，x的范围是0 <= x < 1：
Math.random(); // 0.53907... 每次都不一样

六、Random类

生成伪随机数，所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的。Random rd = new Random(10);

要生成一个随机数，可以使用nextInt()、nextLong()、nextFloat()、nextDouble()

这是因为我们创建Random实例时，如果不给定种子，就使用系统当前时间戳作为种子，因此每次运行时，种子不同，得到的伪随机数序列就不同。Random rd = new 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

七、SecureRandom类

生成安全的随机数,SecureRandom无法指定种子，它使用RNG（random number generator）算法

SecureRandom sr = new SecureRandom();
System.out.println(sr.nextInt(100));

// 实际使用的时候，可以优先获取高强度的安全随机数生成器，如果没有提供，再使用普通等级的安全随机数生成器
import java.util.Arrays;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;

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));
    }
}