Java学习笔记-基础核心类

学习目标

1. 了解String类的特殊之处，String是按照引用类型对待。
2. 了解String类的常用方法（截取、格式化、大小写、空值或者空字符串判断、去收尾的空格）
3. 了解StringBuilder类、StringBuilder类
4. 了解StringJoiner类和String.Join的基础用法
5. 了解数据的基本类型、装箱、拆箱、类型转换
6. 了解值类型和引用类型的区别
7. 了解JavaBean（属性）的使用和IDE怎么自动生成
8. 了解BigInteger类
9. 了解BigDecimal类
10. 了解Date类、Catelender类
11. 了解常用工具类Math、Random、SecureRandom

基础知识

String类

1. String是一个引用类型，它本身也是一个class

2. 创建字符串的方法

   String s1 = "Runoob";              // String 直接创建
   String s2 = "Runoob";              // String 直接创建
   String s3 = s1;                    // 相同引用
   String s4 = new String("Runoob");   // String 对象创建
   String s5 = new String("Runoob");   // String 对象创建
   

   String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：
   实际上字符串在String内部是通过一个char[]数组表示的，因此，按下面的写法也是可以的

   String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});
   

3. Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

4. 当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用equals()方法而不能用==。

   public class Main {
       public static void main(String[] args) {
           String s1 = "hello";
           String s2 = "hello";
           System.out.println(s1 == s2);
           System.out.println(s1.equals(s2));
           
           String s3 = "HELLO".toLowerCase();
       	System.out.println(s1 == s3);
       	System.out.println(s1.equals(s3));
       }
   }
   //结果
   true	//Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池，自然s1和s2的引用就是相同的
   true
   false	//toLowerCase会重新创建一个String类对象，用==判断，两个字符串的引用不一致，所最终结果是false
   true
   

   要忽略大小写比较，使用equalsIgnoreCase()方法。

5. 字符串的一些常用方法，注意索引号是从0开始的

   //字符串的length方法可以计算字符串的字符数（也称字符串长度）。
   String site = "www.runoob.com";
   int len = site.length();
   
   // 是否包含子串:
   "Hello".contains("ll"); // true
   //查找第一次匹配到字符时的索引
   "Hello".indexOf("l"); // 2
   //查找最后依次匹配到字符时的索引
   "Hello".lastIndexOf("l"); // 3
   //判断“Hello”是否以字符串“He”开始
   "Hello".startsWith("He"); // true
   //判断“Hello”是否以字符串“lo”结尾
   "Hello".endsWith("lo"); // true
   
   //截取字符串
   "Hello".substring(2); // "llo"，从第2个字符开始截取，包含第2个字符
   "Hello".substring(2, 4); "ll"，从第2个字符开始截取,到第四个字符停止，不包含第四个字符（这块和C#不同，C#后面那个参数是截取多少长度，java这块第二个参数相当于是endIndex）
   
   "  \tHello\r\n ".trim(); // "Hello"，trim()方法可以移除字符串首尾空白字符。空白字符包括空格，\t，\r，\n
   
   //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，因为包含非空白字符
   
   //替换字符串
   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"
   
   //分割字符串，这块传的第一个参数是正则表达式
   String s = "A,B,C,D";
   String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}
   
   //拼接字符串
   String[] arr = {"A", "B", "C"};
   String s = String.join("***", arr); // "A***B***C"
   

6. 格式化字符串
   字符串提供了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文档。

7. 类型转换

   //要把任意基本类型或引用类型转换为字符串，可以使用静态方法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
   
   //String和char[]类型可以互相转换，方法是：
   char[] cs = "Hello".toCharArray(); // String -> char[]
   String s = new String(cs); // char[] -> String
   

8. 字符编码
   比特（bit）：电脑是以二进制存储以及发送接收数据的。二进制的一位，就叫做 1 bit。也就是说 bit 的含义就是二进制数中的一个数位，即 “0” 或者 “1”。
   字节（byte）：最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），一个字节能表示的最大的整数就是255（二进制11111111=十进制255），如果要表示更大的整数，就必须用更多的字节。

   1Byte=8bit
   1KB=1024B
   1MB=1024KB
   1GB=2014MB
   

   ASCII编码：最早只有127个字符被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码,ASCII编码是1个字节。
   GB2312编码：如果要把汉字也纳入计算机编码，很显然一个字节是不够的。GB2312标准使用两个字节表示一个汉字，其中第一个字节的最高位始终为1，以便和ASCII编码区分开。例如，汉字’中’的GB2312编码是0xd6d0。
   Unicode编码：为了解决每个国家一套编码的问题，Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了，Unicode编码通常是2个字节。
   utf-8编码：Unicode编码的进化版，ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

   你可以猜测，如果把ASCII编码的A用Unicode编码，只需要在前面补0就可以，因此，A的Unicode编码是00000000 01000001。
   新的问题又出现了：如果统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。
   
   所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：
   

   字符	ASCII	Unicode	UTF-8
   01000001	00000000 01000001	01000001
   x	01001110 00101101	11100100 10111000 10101101

   UTF-8编码的另一个好处是容错能力强。如果传输过程中某些字符出错，不会影响后续字符，因为UTF-8编码依靠高字节位来确定一个字符究竟是几个字节，它经常用来作为传输编码。
   

   在Java中，char类型实际上就是两个字节的Unicode编码。

   //String转字节
   byte[] b1 = "Hello".getBytes(); // 按系统默认编码转换，不推荐
   byte[] b2 = "Hello".getBytes("UTF-8"); // 按UTF-8编码转换
   byte[] b2 = "Hello".getBytes("GBK"); // 按GBK编码转换
   byte[] b3 = "Hello".getBytes(StandardCharsets.UTF_8); // 按UTF-8编码转换
   //字节转String
   byte[] b = ...
   String s1 = new String(b, "GBK"); // 按GBK转换
   String s2 = new String(b, StandardCharsets.UTF_8); // 按UTF-8转换
   

StringBuffer、StringBuilder类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

1. StringBuffer类：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
2. StringBuilder类：StringBuilder 类在JDK1.5中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问），由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
3. StringBuilder中新增字符时，不会创建新的临时对象,调用append方法即可，同时支持链式操作。

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

   注意：对于普通的字符串+操作，并不需要我们将其改写为StringBuilder，因为Java编译器在编译时就自动把多个连续的+操作编码为StringConcatFactory的操作。在运行期，StringConcatFactory会自动把字符串连接操作优化为数组复制或者StringBuilder操作。

StringJoiner类

使用StringJoiner类或者String.join方法可以实现字符串数组的连接，StringJoiner类的改造函数，第一个参数是分割字符串，第二个参数是开始插入的字符串，第三个参数是结尾插入的字符串。第二个参数和第三个参数如果忽略掉效果和String.join一致。

//例子1
import java.util.StringJoiner;
public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Grace"};
        StringJoiner sj = new StringJoiner(", ", "Hello ", "!");
        for (String name : names) {
            sj.add(name);
        }
        System.out.println(sj.toString());
    }
}
//例子2
import java.util.StringJoiner;
public class Main {
    public static void main(String[] args) {
        String[] fields = {"name", "position", "salary"};
        String table = "employee";
        String select = buildSelectSql(table, fields);
        System.out.println(select);
        System.out.println("SELECT name, position, salary FROM employee".equalsIgnoreCase(select) ? "测试成功" : "测试失败");
    }

    static String buildSelectSql(String table, String[] fields) {
        // TODO:
        StringJoiner sj = new StringJoiner(", ", "select ", " from ");
        for (String field : fields) {
            sj.add(field);
        }

        return sj.toString()+table;
    }
}

包装类型

我们已经知道，Java的数据类型分两种：

• 基本类型：byte，short，int，long，boolean，float，double，char
• 引用类型：所有class、interface类型（String、数组）

1. 引用类型可以赋值为null，表示空，但基本类型不能赋值为null。

2. 基本类型变成引用类型称为装箱，引用类型变化到基本类型称为拆箱，装箱和拆箱会影响执行效率，且拆箱时可能发生NullPointerException（Null值变基本类型的时候）。

3. 包装类型的比较必须使用equals()。

4. 整数和浮点数的包装类型都继承自Number；

5. Java核心库为每种基本类型都提供了对应的包装类型(帮助我们将基本类型转换为引用类型）

6. 包装类型默认值为null
   
   
   创建包装类型对象：

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

   因为Integer.valueOf()可能始终返回同一个Integer实例，因此，在我们自己创建Integer的时候，以下两种方法：

   ①方法1：Integer n = new Integer(100);
   ②方法2：Integer n = Integer.valueOf(100);
   

   方法2更好，因为方法1总是创建新的Integer实例，方法2把内部优化留给Integer的实现者去做，即使在当前版本没有优化，也有可能在下一个版本进行优化。

7. Java提供进制转换。

   //最常用的静态方法parseInt()可以把字符串解析成一个整数
   int x1 = Integer.parseInt("100"); // 100
   int x2 = Integer.parseInt("100", 16); // 256,因为按16进制解析
   
   //Integer还可以把整数格式化为指定进制的字符串：
   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进制
   

8. 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)
   

JavaBean

1. JavaBean是一种符合命名规范的class，它通过getter和setter来定义属性；
   如果读写方法符合以下这种命名规范,那么这种class被称为JavaBean。（类似C#的属性，但是没有C#的好用）

   private Type xyz;
   // 读方法:
   public Type getXyz()
   // 写方法:
   public void setXyz(Type value)
   

   上面的字段是xyz，那么读写方法名分别以get和set开头，并且后接大写字母开头的字段名Xyz，因此两个读写方法名分别是getXyz()和setXyz()。
   boolean字段比较特殊，它的读方法一般命名为isXyz()：

   // 读方法:
   public boolean isChild()
   // 写方法:
   public void setChild(boolean value)
   

   我们通常把一组对应的读方法（getter）和写方法（setter）称为属性（property）

2. 要枚举一个JavaBean的所有属性，可以直接使用Java核心库提供的Introspector

   import java.beans.*;
   	
   public class Main {
       public static void main(String[] args) throws Exception {
           BeanInfo info = Introspector.getBeanInfo(Person.class);
           for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
               System.out.println(pd.getName());
               System.out.println("  " + pd.getReadMethod());
               System.out.println("  " + pd.getWriteMethod());
           }
       }
   }
   
   class Person {
       private String name;
       private int age;
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   }
   

3. 利用IDE工具自动生成属性。
   Eclipse：
   ①输入代码

   public class Person {
       private String name;
       private int age;
   }
   

   ②选中代码，点击右键
   ③在弹出的菜单中选择“Source”，“Generate Getters and Setters”，在弹出的对话框中选中需要生成getter和setter方法的字段，点击确定即可由IDE自动完成所有方法代码

   Idea：参考资料 传送门
   ①选中代码右键，选择Geberate
   
   ②选择对应的Getter and Setter
   

快捷键为：alt+insert

BigInteger类

1. BigInteger用于表示任意大小的整数；

   BigInteger bi = new BigInteger("1234567890");
   //对BigInteger做运算的时候，只能使用实例方法
   BigInteger i1 = new BigInteger("1234567890");
   BigInteger i2 = new BigInteger("12345678901234567890");
   BigInteger sum = i1.add(i2); // 12345678902469135780
   

2. BigInteger是不变类，并且继承自Number；

3. 将BigInteger转换成基本类型时可使用longValueExact()等方法保证结果准确,如果超出了long型的范围，会抛出ArithmeticException。

4. BigInteger和Integer、Long一样，也是不可变类，并且也继承自Number类。因为Number定义了转换为基本类型的几个方法：

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

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

BigDecimal类

1. 和BigInteger类似，BigDecimal可以表示一个任意大小且精度完全准确的浮点数。

   BigDecimal bd = new BigDecimal("123.4567");
   System.out.println(bd.multiply(bd)); // 15241.55677489
   

2. BigDecimal用scale()表示小数位数。

   BigDecimal d1 = new BigDecimal("123.45");
   BigDecimal d2 = new BigDecimal("123.4500");
   BigDecimal d3 = new BigDecimal("1234500");
   System.out.println(d1.scale()); // 2,两位小数
   System.out.println(d2.scale()); // 4
   System.out.println(d3.scale()); // 0
   

3. 通过BigDecimal的stripTrailingZeros()方法，可以将一个BigDecimal格式化为一个相等的，但去掉了末尾0的BigDecimal

   BigDecimal d1 = new BigDecimal("123.4500");
   BigDecimal d2 = d1.stripTrailingZeros();
   System.out.println(d1.scale()); // 4
   System.out.println(d2.scale()); // 2,因为去掉了00
   
   BigDecimal d3 = new BigDecimal("1234500");
   BigDecimal d4 = d3.stripTrailingZeros();
   System.out.println(d3.scale()); // 0
   System.out.println(d4.scale()); // -2，如果一个BigDecimal的scale()返回负数，例如，-2，表示这个数是个整数，并且末尾有2个0。
   

4. 可以对一个BigDecimal设置它的scale，如果精度比原始值低，那么按照指定的方法进行四舍五入或者直接截断

   	import java.math.BigDecimal;
   	import java.math.RoundingMode;
   	
   	public class Main {
   	    public static void main(String[] args) {
   	        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
   	        System.out.println(d2);
   	        System.out.println(d3);
   	    }
   	}
   

5. 对BigDecimal做加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断

   BigDecimal d1 = new BigDecimal("123.456");
   BigDecimal d2 = new BigDecimal("23.456789");
   BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小数并四舍五入
   BigDecimal d4 = d1.divide(d2); // 报错：ArithmeticException，因为除不尽
   

6. 对BigDecimal做除法的同时求余数

   public class Main {
       public static void main(String[] args) {
           BigDecimal n = new BigDecimal("12.345");
           BigDecimal m = new BigDecimal("0.12");
           BigDecimal[] dr = n.divideAndRemainder(m);
           System.out.println(dr[0]); // 102
           System.out.println(dr[1]); // 0.105
       }
   }
   
   //调用divideAndRemainder()方法时，返回的数组包含两个BigDecimal，分别是商和余数，
   //其中商总是整数，余数不会大于除数。我们可以利用这个方法判断两个BigDecimal是否是整数倍数
   BigDecimal n = new BigDecimal("12.75");
   BigDecimal m = new BigDecimal("0.15");
   BigDecimal[] dr = n.divideAndRemainder(m);
   if (dr[1].signum() == 0) {
       // n是m的整数倍
   }	
   

7. 在比较两个BigDecimal的值是否相等时，要特别注意，使用equals()方法不但要求两个BigDecimal的值相等，还要求它们的scale()相等

   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
   

   必须使用compareTo()方法来比较，它根据两个值的大小分别返回负数、正数和0，分别表示小于、大于和等于。

枚举类

1. 使用enum关键字定义枚举类

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

2. 枚举类的方法

   //name()返回常量名
   String s = Weekday.SUN.name(); // "SUN"
   //ordinal()返回定义的常量的顺序
   int n = Weekday.MON.ordinal(); // 1
   //valueOf()方法返回指定字符串值的枚举常量。
   System.out.println(Weekday.valueOf("SUN"));
   

3. enum类对象可以使用==比较是否相等

4. 可以为enum编写构造方法、字段和方法。
   enum的构造方法要声明为private，字段强烈建议声明为final；
   enum适合用在switch语句中。

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

Date类

待补充

Calender类

待补充

常用工具类

Math类

数学运算相关的类。

//求绝对值：
Math.abs(-100); // 100
Math.abs(-7.8); // 7.8
//取最大或最小值：
Math.max(100, 99); // 100
Math.min(1.2, 2.3); // 1.2
//计算xy次方：
Math.pow(2, 10); // 2的10次方=1024
//计算√x：
Math.sqrt(2); // 1.414...
//计算ex次方：
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用来创建伪随机数。所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的。
要生成一个随机数，可以使用nextInt()、nextLong()、nextFloat()、nextDouble()：

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类

生成安全的随机数

import java.util.Arrays;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;

public class AAA {
    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));
    }
}

思考题(持续补充中）

括号选中状态下查看答案

1. 以下关于Integer与int的区别错误的是(D)
   A.int是java提供的8种原始数据类型之一
   B.Integer是java为int提供的封装类
   C.int的默认值为0
   D.Integer的默认值为1