【Java】面向对象——核心类

Java面向对象——核心类

String

1. 字符串比较

要用equals()，不能用==。因为equals()比较的是内容值，而==比较的是地址。

• 忽略大小写比较

"Hello".equalsIgnoreCase("HELLO") //true

• 是否包含字串

"Hello".contains("lo") //true

• 搜索字串（索引从0开始）

"Hello".indexOf("l"); // 2
"Hello".lastIndexOf("l"); // 3
"Hello".startsWith("He"); // true
"Hello".endsWith("lo"); // true

• 提取字串

"Hello".substring(2); // 从第三个单词开始提取："llo"
"Hello".substring(2, 4); //提取第3~5个单词："ll"

2. 去除首尾空白字符

trim()可以移除字符串首尾空白字符。空白字符包括：空格、\t、\r、\n。

strip()也可以移除字符串首尾空白字符。它不同于trim()，它还可以移除类似中文的空格字符\u3000。不过要 JDK11 及以上才能支持。

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

3. 替换字串

• 根据字符/字符串替换

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"

4. 分割字符串

使用split()方法，并且传入的也是正则表达式：

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

5. 拼接字符串

使用String.join()方法，第一个参数是分隔符，第二个是待拼接的字符串数组

String[] arr = {"Hello","World","!!!"};
String arrs = String.join("#",arr); //Hello#World#!!!

6. 类型转换

• 基本类型==>字符串

String.valueOf(123); // "123"

• 字符串==>int

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

• 字符串==>boolean

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

• 字符串<==>char[]

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

---

StringBuilder

问题：使用+拼接字符串会一直创建新的对象，很浪费内存，还会影响GC效率。

String s = "";
for (int i = 0; i < 1000; i++) {
 s = s + "," + i;
}

StringBuilder是一个可变对象，可以预分配缓冲区。这样新增字符时，不会创建新的临时对象了。

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

---

enum枚举类

enumeration相比与普通常量的好处：

• 不会引用到非枚举的值。因为无法通过编译
• 不同类型的枚举不能进行比较或赋值。因为类型都不符

注意：enum是一个class，每个枚举的值都是class实例！

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() { //重写toString()是为了输出是更具可读性
        return this.chinese;
    }
}

Today is 星期日. Work at home!

enum更适合用在switch语句中：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        switch(day) {
        case MON:
        case TUE:
        case WED:
        case THU:
        case FRI:
            System.out.println("Today is " + day + ". Work at office!");
            break;
        case SAT:
        case SUN:
            System.out.println("Today is " + day + ". Work at home!");
            break;
        default:
            throw new RuntimeException("cannot process " + day);
        }
    }
}

enum Weekday {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}

---

BigInteger

表示任意大小的整数，(-∞,+∞)。

可以把BigInteger转换为基本类型的数，如long型：

BigInteger i = new BigInteger("123456789000");
System.out.println(i.longValue()); // 123456789000

如果BigInteger表示的范围超过了基本类型的范围，转换时将丢失高位信息，即结果不一定是准确的。如果需要准确地转换成基本类型，可以使用intValueExact()、longValueExact()等方法，在转换时如果超出范围，将直接抛出ArithmeticException异常：

System.out.println(i.multiply(i).longValueExact()); // java.lang.ArithmeticException: BigInteger out of long range

• 转换为byte：byteValue()
• 转换为short：shortValue()
• 转换为int：intValue()
• 转换为long：longValue()
• 转换为float：floatValue()
• 转换为double：doubleValue()

---

BigDecimal

表示一个任意大小且精度完全准确的浮点数。常用于财务计算

• scale()表示小数位数

• stripTrailingZeros()去掉小数点末尾多余的零

BigDecimal num1 = new BigDecimal("123.4500");
BigDecimal num2 = num1.stripTrailingZeros();
System.out.println(num1.scale()); // 4
System.out.println(num2.scale()); // 2,因为去掉了00==>123.45

• setScale()指定小数点后的精度
• divide()做除法时除不尽就要指定精度

BigDecimal d1 = new BigDecimal("123.456789");
BigDecimal d2 = d1.setScale(4, RoundingMode.HALF_UP); // 四舍五入，123.4568
BigDecimal d3 = d1.setScale(4, RoundingMode.DOWN); // 直接截断，123.4567
BigDecimal d4 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小数并四舍五入

注意：总是使用**compareTo()**比较两个BigDecimal的值，不要使用~~equals()~~！

• equals()方法不但要求两个BigDecimal的值相等，还要求它们的scale()相等
• compareTo()方法根据两个值的大小分别返回负数（小于）、正数（大于）和0（等于）

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("123.45600");
System.out.println(d1.equals(d2)); // false,因为scale不同
System.out.println(d1.equals(d2.stripTrailingZeros())); // true,因为d2去除尾部0后scale变为2
System.out.println(d1.compareTo(d2)); // 0

---

常用工具类

1. Math

• abs/min/max
• pow/sqrt/exp/log/log10

Math.pow(2,10); // 2的10次方==>1024
Math.exp(2); // e的2次方==>7.389...
Math.log(4); // 以e为底的对数==>1.386...
Math.log10(100); // 2

• sin/cos/tan/asin/acos
• 常量
  • Math.PI = 3.1415926…
  • Math.E = 2.71828…

2. Random 伪随机数

Random用来创建伪随机数。

所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的，一次产生就不会变了。

• 创建Random实例时，如果不给定种子，每次产生的随机数序列都会不同；
• 如果指定了种子，就会得到不会变的随机数。

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

（1）不给定种子

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

（2）给定种子

Random r = new Random(123456);
r.nextInt(); // 2071575453,每次都一样！

3. SecureRandom 安全随机数

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