到头来还是逃不开Java - Java13核心类
文章目录
引言#
兜兜转转到了大四,学过了C,C++,C#,Java,Python,学一门丢一门,到了最后还是要把Java捡起来。所以奉劝大家,面向对象还是要掌握一门,虽然Python好写舒服,但是毕竟不能完全面向对象,也没有那么多的应用场景,所以,奉劝看到本文的各位,还是提前学好C#或者Java。
- 在Java中,String是一个引用类型,它本身也是一个class。但是,Java编译器对String有特殊处理,即可以直接用"..."(这里的...是象征字符串的)来表示一个字符串
- Java字符串的一个重要特点就是字符串_不可变_。这种不可变性是通过内部的private final char[]字段,以及没有任何修改char[]的方法实现的。
Copy
publicclass Main { public static void main(String[] args) { String s ="Hello"; System.out.println(s); s = s.toUpperCase(); System.out.println(s); }}字符串比较#
- 当我们想比较两个字符串时,是想比较两个字符串的内容是否相同。这个时候要用equals()而不能用==
Copy
publicclass Main { public static void main(String[] args) { String s1 ="hello"; String s2 ="hello"; System.out.println(s1 == s2); System.out.println(s1.equals(s2)); }}
- 从表面上看,两个字符串用==和equals()比较都为true,但实际上那只是Java编译器在编译期,会自动把所有相同的字符串当作一个对象放入常量池,自然s1和s2的引用就是相同的。
Copy
publicclass Main { public static void main(String[] args) { String s1 ="hello"; String s2 ="HELLO".toLowerCase(); System.out.println(s1 == s2); System.out.println(s1.equals(s2)); }}
- 两个字符串比较,必须总是使用equals()方法。
- 要忽略大小写比较,使用equalsIgnoreCase()方法。
- String类还提供了多种方法来搜索子串、提取子串。常用的方法有:
Copy
// 是否包含子串:"Hello".contains("ll");// true
- 注意到contains()方法的参数是CharSequence而不是String,因为CharSequence是String的父类。
- 搜索子串的更多的例子:
Copy
"Hello".indexOf("l");// 2"Hello".lastIndexOf("l");// 3"Hello".startsWith("He");// true"Hello".endsWith("lo");// true
- 提取子串的例子:
- 注意索引号是从0开始的。
Copy
"Hello".substring(2);// "llo""Hello".substring(2, 4);"ll"去除首尾空白字符#
- 使用trim()方法可以移除字符串首尾空白字符。空白字符包括空格,\t,\r,\n:
Copy
" \tHello\r\n ".trim(); //"Hello"
- 注意:trim()并没有改变字符串的内容,而是返回了一个新字符串。
- 另一个strip()方法也可以移除字符串首尾空白字符。它和trim()不同的是,类似中文的空格字符\u3000也会被移除:
Copy
"\u3000Hello\u3000".strip();// "Hello"" Hello ".stripLeading();// "Hello "" Hello ".stripTrailing();// " Hello"
- String还提供了isEmpty()和isBlank()来判断字符串是否为空和空白字符串:
Copy
"".isEmpty();// true,因为字符串长度为0" ".isEmpty();// false,因为字符串长度不为0" \n".isBlank();// true,因为只包含空白字符" Hello ".isBlank();// false,因为包含非空白字符替换子串#
- 两种方法,一种是根据字符或者字符串替换。
Copy
String s ="hello";s.replace('l','w');// "hewwo",所有字符'l'被替换为'w's.replace("ll","");// "heo",所有子串"ll"被替换为"~~"
- 另一种是通过正则表达式替换:
Copy
String s ="A,,B;C ,D";s.replaceAll("[\\,\\;\\s]+",",");// "A,B,C,D"分割字符串#
- 要分割字符串,使用split()方法,并且传入的也是正则表达式:
Copy
String s ="A,B,C,D";String[] ss = s.split("\\,");// {"A", "B", "C", "D"}拼接字符串#
- 拼接字符串使用静态方法join(),它用指定的字符串连接字符串数组:
Copy
String[] arr = {"A","B","C"};String s = String.join("***", arr);// "A***B***C"类型转换#
- 要把任意基本类型或引用类型转换为字符串,可以使用静态方法valueOf()。这是一个重载方法,编译器会根据参数自动选择合适的方法:
Copy
String.valueOf(123);// "123"String.valueOf(45.67);// "45.67"String.valueOf(true);// "true"String.valueOf(newObject());// 类似java.lang.Object@636be97c
- 要把字符串转换为其他类型,就需要根据情况。例如,把字符串转换为int类型:
Copy
intn1 = Integer.parseInt("123");// 123intn2 = Integer.parseInt("ff", 16);// 按十六进制转换,255
- 把字符串转换为boolean类型:
Copy
booleanb1 = Boolean.parseBoolean("true");// truebooleanb2 = Boolean.parseBoolean("FALSE");// false
- 要特别注意,Integer有个getInteger(String)方法,它不是将字符串转换为int,而是把该字符串对应的系统变量转换为Integer:
Copy
Integer.getInteger("java.version");// 版本号,11转换为char[]#
- String和char[]类型可以互相转换,方法是:
Copy
char[] cs ="Hello".toCharArray();// String -> char[]Strings =newString(cs);// char[] -> String
- 如果修改了char[]数组,String并不会改变:
- 这是因为通过new String(char[])创建新的String实例时,它并不会直接引用传入的char[]数组,而是会复制一份,所以,修改外部的char[]数组不会影响String实例内部的char[]数组,因为这是两个不同的数组。
Copy
publicclass Main { public static void main(String[] args) { char[] cs ="Hello".toCharArray(); String s =newString(cs); System.out.println(s); cs[0] ='X'; System.out.println(s); }}
从String的不变性设计可以看出,如果传入的对象有可能改变,我们需要复制而不是直接引用。
Copy
publicclass Main { public static void main(String[] args) { int[] scores =newint[] { 88, 77, 51, 66 }; Score s =newScore(scores); s.printScores(); scores[2] = 99; s.printScores(); }}class Score { privateint[] scores; public Score(int[] scores) { // 这样传入的就是scores的复制this.scores = Arrays.copyOf(scores, scores.length); // 使用如下方法也可以// this.scores = scores.clone(); } public void printScores() { System.out.println(Arrays.toString(scores)); }}字符编码#
- ASCII编码范围从0到127,每个字符用一个byte表示。
- GB2312使用两个byte表示一个中文字符。
- Unicode是全球统一编码,其中的UTF-8是变长编码,英文字符为1个byte,中文字符为3个byte。
- 在Java中,char类型实际上就是两个字节的Unicode编码。如果我们要手动把字符串转换成其他编码,可以这样做:
Copy
byte[] b1 ="Hello".getBytes();// 按ISO8859-1编码转换,不推荐byte[] b2 ="Hello".getBytes("UTF-8");// 按UTF-8编码转换byte[] b2 ="Hello".getBytes("GBK");// 按GBK编码转换byte[] b3 ="Hello".getBytes(StandardCharsets.UTF_8);// 按UTF-8编码转换
- 如果要把已知编码的byte[]转换为String,可以这样做:
Copy
byte[] b = ...String s1 =newString(b,"GBK");// 按GBK转换String s2 =newString(b, StandardCharsets.UTF_8);// 按UTF-8转换
- 始终牢记:Java的String和char在内存中总是以Unicode编码表示。
StringBuilder#
- Java编译器对String做了特殊处理,使得我们可以直接用+拼接字符串。
Copy
String s ="";for(inti = 0; i < 1000; i++) { s = s +","+ i;}
- 虽然可以直接拼接字符串,但是,在循环中,每次循环都会创建新的字符串对象,然后扔掉旧的字符串。这样,绝大部分字符串都是临时对象,不但浪费内存,还会影响GC效率。
- 为了能高效拼接字符串,Java标准库提供了StringBuilder,它是一个可变对象,可以预分配缓冲区,这样,往StringBuilder中新增字符时,不会创建新的临时对象:
Copy
StringBuilder sb =newStringBuilder(1024);for(inti = 0; i < 1000; i++) { sb.append(','); sb.append(i);}String s = sb.toString();
- StringBuilder还可以进行链式操作:
Copy
publicclass Main { public static void main(String[] args) { var sb =newStringBuilder(1024); sb.append("Mr ") .append("Bob") .append("!") .insert(0,"Hello, "); System.out.println(sb.toString()); }}
- 如果我们查看StringBuilder的源码,可以发现,进行链式操作的关键是,定义的append()方法会返回this,这样,就可以不断调用自身的其他方法。使用链式操作的关键点就在于返回本身。
- 你可能还听说过StringBuffer,这是Java早期的一个StringBuilder的线程安全版本,StringBuilder和StringBuffer接口完全相同,现在完全没有必要使用StringBuffer。
StringJoiner#
- 类似用分隔符拼接数组的需求很常见,所以Java标准库还提供了一个StringJoiner来干这个事:
Copy
publicclass Main { public static void main(String[] args) { String[] names = {"Bob","Alice","Grace"}; var sj =newStringJoiner(", "); for(String name : names) { sj.add(name); } System.out.println(sj.toString()); }}
- 但是这样还不够,还少了开头的hello和结尾的!,于是我们给StringJoiner指定开头和结尾
Copy
publicclass Main { public static void main(String[] args) { String[] names = {"Bob","Alice","Grace"}; // param1 是需要给数组之间插入的字符串 para2和3是指定了StringJoiner的开头和结尾 var sj =newStringJoiner(", ","Hello ","!"); for(String name : names) { sj.add(name); } System.out.println(sj.toString()); }}
- 其实StringJoiner的内部就是用的StringBuilder来拼接字符串的,所以拼接效率几乎和StringBuilder一模一样
String.join()#
String还提供了一个静态方法join(),这个方法在内部使用了StringJoiner来拼接字符串,在不需要指定“开头”和“结尾”的时候,用String.join()更方便:
Copy
String[] names = {"Bob","Alice","Grace"};var s = String.join(", ", names);包装类型#
-
Java的数据类型分两种:
- 基本类型:byte,short,int,long,boolean,float,double,char
- 引用类型:所有class和interface类型
- 引用类型可以赋值为null,表示空,但基本类型不能赋值为null:
Copy
String s =null;intn =null;// compile error!
-
提问:如何把一个基本类型视为对象(引用类型)?
- 想要把int基本类型变成一个引用类型,我们可以定义一个Integer类,它只包含一个实例字段int,这样,Integer类就可以视为int的包装类(Wrapper Class):
Copy
Integer n =null;Integer n2 =newInteger(99);intn3 = n2.intValue();
- 实际上因为包装类型非常有用,所以Java对于每一种基本类型都有他的包装类型。可以直接用,不用自行定义。
基本类型对应的引用类型
booleanjava.lang.Boolean
bytejava.lang.Byte
shortjava.lang.Short
intjava.lang.Integer
longjava.lang.Long
floatjava.lang.Float
doublejava.lang.Double
charjava.lang.CharacterCopy
publicclass Main { public static void main(String[] args) { inti = 100; // 通过new操作符创建Integer实例(不推荐使用,会有编译警告): Integer n1 =newInteger(i); // 通过静态方法valueOf(int)创建Integer实例: Integer n2 = Integer.valueOf(i); // 通过静态方法valueOf(String)创建Integer实例: Integer n3 = Integer.valueOf("100"); // 使用示范 System.out.println(n3.intValue()); }}Auto Boxing#
- 因为int和Integer可以互换,所以Java可以帮助我们在int和Integer之间转型
Copy
Integer n = 100;// 编译器自动使用Integer.valueOf(int)intx = n;// 编译器自动使用Integer.intValue()
- 直接把int变为Integer的赋值写法,称为自动装箱(Auto Boxing),反过来,把Integer变为int的赋值写法,称为自动拆箱(Auto Unboxing)。
自动装箱和自动拆箱只发生在编译阶段,目的是为了少写代码。
- 装箱和拆箱会影响代码的执行效率,因为编译后的class代码是严格区分基本类型和引用类型的。并且,自动拆箱执行时可能会报NullPointerException:
不变类#
- 所有的包装类型都是不变类。我们查看Integer的源码可知,它的核心代码如下:
Copy
publicfinalclass Integer { privatefinalintvalue;}
- 因此,一旦创建了Integer对象,该对象就是不变的。
- 对两个Integer实例进行比较要特别注意:绝对不能用==比较,因为Integer是引用类型,必须使用equals()比较。(引用类型必须用equals()比较)
- 编译器把Integer x = 127;自动变为Integer x = Integer.valueOf(127);,为了节省内存,Integer.valueOf()对于较小的数,始终返回相同的实例,因此,==比较“恰好”为true,但我们_绝不能_因为Java标准库的Integer内部有缓存优化就用==比较,必须用equals()方法比较两个Integer。
按照语义编程,而不是针对特定的底层实现去“优化”。
-
因为Integer.valueOf()可能始终返回同一个Integer实例,因此,在我们自己创建Integer的时候,以下两种方法:
- 方法1:Integer n = new Integer(100);
- 方法2:Integer n = Integer.valueOf(100);
- 方法2更好,因为方法1总是创建新的Integer实例,方法2把内部优化留给Integer的实现者去做,即使在当前版本没有优化,也有可能在下一个版本进行优化。
- 我们把能创建“新”对象的静态方法称为静态工厂方法。Integer.valueOf()就是静态工厂方法,它尽可能地返回缓存的实例以节省内存。
创建新对象时,优先选用静态工厂方法而不是new操作符。
进制转换#
- Integer类本身还提供了大量方法,例如,最常用的静态方法parseInt()可以把字符串解析成一个整数:
Copy
intx1 = Integer.parseInt("100");// 100intx2 = Integer.parseInt("100", 16);// 256,因为按16进制解析
- Integer还可以把整数格式化为指定进制的字符串:
Copy
publicclass 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进制 }}
- 整数和浮点数的包装类型都继承自Number。
JavaBean#
-
在Java中,有很多class的定义都符合这样的规范:
- 若干private实例字段;
通过public方法(getter、setter方法)来读写实例字段。
Copy
publicclass Person { privateString name; privateintage; public String getName() {returnthis.name; } public void setName(String name) {this.name = name; } public int getAge() {returnthis.age; } public void setAge(int age) {this.age = age; }}
- 如果读写方法符合以下这种命名规范,则称为JavaBean
Copy
// 读方法:publicTypegetXyz()// 写方法:publicvoid setXyz(Typevalue)
- boolean字段比较特殊,它的读方法一般命名为isXyz():
Copy
// 读方法:public boolean isChild()// 写方法:public void setChild(boolean value)
-
我们通常把一组对应的读方法(getter)和写方法(setter)称为属性(property)。例如,name属性:
- 对应的读方法是String getName()
- 对应的写方法是setName(String)
-
只有getter的属性称为只读属性(read-only),例如,定义一个age只读属性:
- 对应的读方法是int getAge()
- 无对应的写方法setAge(int)
- 类似的,只有setter的属性称为只写属性(write-only)。
- 很明显,只读属性很常见,只写属性不常见。
JavaBean的作用#
- JavaBean主要用来传递数据。
- JavaBean可以方便地被IDE工具分析,生成读写属性的代码,主要用在图形界面的可视化设计中。
- 通过IDE,可以快速生成getter和setter。例如,在Eclipse中,先输入以下代码,然后,点击右键,在弹出的菜单中选择“Source”,“Generate Getters and Setters”,在弹出的对话框中选中需要生成getter和setter方法的字段,点击确定即可由IDE自动完成所有方法代码。
Copy
publicclass Person { privateString name; privateintage;}枚举JavaBean属性#
- 要枚举一个JavaBean的所有属性,可以直接使用Java核心库提供的Introspector.getBeanInfo(ClassName.class)
枚举类#
- 在Java中,我们可以通过static final来定义常量。例如,我们希望定义周一到周日这7个常量,可以用7个不同的int表示
Copy
publicclass Weekday { publicstaticfinalintSUN = 0; publicstaticfinalintMON = 1; publicstaticfinalintTUE = 2; publicstaticfinalintWED = 3; publicstaticfinalintTHU = 4; publicstaticfinalintFRI = 5; publicstaticfinalintSAT = 6;}
- 无论是int常量还是String常量,使用这些常量来表示一组枚举值的时候,有一个严重的问题就是,编译器无法检查每个值的合理性。例如:
Copy
if(weekday == 6 || weekday == 7) { if(tasks == Weekday.MON) { // TODO: }}
-
上述代码编译和运行均不会报错,但存在两个问题:
- 注意到Weekday定义的常量范围是0~6,并不包含7,编译器无法检查不在枚举中的int值;
定义的常量仍可与其他变量比较,但其用途并非是枚举星期值。
enum#
- 为了让编译器能自动检查某个值在枚举的集合内,并且,不同用途的枚举需要不同的类型来标记,不能混用,我们可以使用enum来定义枚举类。
Copy
publicclass Main { public static void main(String[] args) { Weekday day = Weekday.SUN; if(day == Weekday.SAT || day == Weekday.SUN) { System.out.println("Work at home!"); }else{ System.out.println("Work at office!"); } }}enumWeekday { SUN, MON, TUE, WED, THU, FRI, SAT;}
-
枚举的好处
- 编译器会自动检查出类型错误。
- 不可能引用到非枚举的值,因为无法通过编译。
- 不同类型的枚举不能互相比较或者赋值,因为类型不符。例如,不能给一个Weekday枚举类型的变量赋值为Color枚举类型的值。
Copy
Weekday x = Weekday.SUN;// ok!Weekday y = Color.RED;// Compile error: incompatible typesenum的比较#
前面讲解过引用类型的比较需要使用equals(),虽然enum定义的是一种枚举类型,但是却可以例外用==来比较。这是因为enum类型的每个常量在JVM中只有一个唯一实例,所以可以直接用==比较。
enum类型#
通过enum定义的枚举类,和其他的class有什么区别?
答案是没有任何区别。enum定义的类型就是class,只不过它有以下几个特点:
- 定义的enum类型总是继承自java.lang.Enum,且无法被继承;
- 只能定义出enum的实例,而无法通过new操作符创建enum的实例;
- 定义的每个实例都是引用类型的唯一实例;
- 可以将enum类型用于switch语句。
例如,我们定义的Color枚举类:
Copy
publicenum Color { RED, GREEN, BLUE;}
编译器编译出的class大概就像这样:
Copy
publicfinalclass Color extends Enum {// 继承自Enum,标记为final class// 每个实例均为全局唯一: public staticfinalColorRED=newColor(); public staticfinalColorGREEN=newColor(); public staticfinalColorBLUE=newColor(); // private构造方法,确保外部无法调用new操作符:privateColor() {}}
所以,编译后的enum类和普通class并没有任何区别。但是我们自己无法按定义普通class那样来定义enum,必须使用enum关键字,这是Java语法规定的。
因为enum是一个class,每个枚举的值都是class实例,因此,这些实例有一些方法:
name()#
返回常量名,例如:
Copy
Strings = Weekday.SUN.name();// "SUN"ordinal()#
返回定义的常量的顺序,从0开始计数,例如:
Copy
intn = Weekday.MON.ordinal();// 1
改变枚举常量定义的顺序就会导致ordinal()返回值发生变化。
如果不小心修改了枚举的顺序,编译器是无法检查出这种逻辑错误的。要编写健壮的代码,就不要依靠ordinal()的返回值。因为enum本身是class,所以我们可以定义private的构造方法,并且,给每个枚举常量添加字段:
Copy
publicclass Main { public static void main(String[] args) { Weekday day = Weekday.SUN; if(day.dayValue == 6 || day.dayValue == 0) { System.out.println("Work at home!"); }else{ System.out.println("Work at office!"); } }}enumWeekday { MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6), SUN(0); publicfinalintdayValue; private Weekday(int dayValue) { this.dayValue = dayValue; }}
默认情况下,对枚举常量调用toString()会返回和name()一样的字符串。但是,toString()可以被覆写,而name()则不行。我们可以给Weekday添加toString()方法。
Copy
publicclass 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!"); } }}enumWeekday { MON(1,"星期一"), TUE(2,"星期二"), WED(3,"星期三"), THU(4,"星期四"), FRI(5,"星期五"), SAT(6,"星期六"), SUN(0,"星期日"); publicfinalintdayValue; privatefinalString chinese; private Weekday(int dayValue, String chinese) { this.dayValue = dayValue; this.chinese = chinese; } @Override public String toString() { returnthis.chinese; }}
注意:判断枚举常量的名字,要始终使用name()方法,绝不能调用toString()!
switch#
因为枚举类天生具有类型信息和有限个枚举常量,所以比int、String类型更适合用在switch语句中。
BigInteger#
- Java中提供的整形最大范围是个64位的long,要是超过了这个范围就需要用BigInteger来表示数字。java.math.BigInteger就是用来表示任何数字的。
- BigInteger进行运算的时候只能用实例方法,而且和long整形运算比起来速度较慢。
-
BigInteger和Integer、Long一样,也是不可变类,并且也继承自Number类。因为Number定义了转换为基本类型的几个方法:
- 转换为byte:byteValue()
- 转换为short:shortValue()
- 转换为int:intValue()
- 转换为long:longValue()
- 转换为float:floatValue()
- 转换为double:doubleValue()
- 通过上述方法,可以把BigInteger转换成基本类型。如果BigInteger表示的范围超过了基本类型的范围,转换时将丢失高位信息,即结果不一定是准确的。如果需要准确地转换成基本类型,可以使用intValueExact()、longValueExact()等方法(没有其他的typeValueExact方法),在转换时如果超出范围,将直接抛出ArithmeticException异常。
Copy
BigInteger i1 =newBigInteger("1234567890");BigInteger i2 =newBigInteger("12345678901234567890");BigInteger sum = i1.add(i2);// 12345678902469135780BigInteger mul = i1.multiply(i2);//不知道多大了System.out.println(i.multiply(i).longValueExact());// java.lang.ArithmeticException: BigInteger out of long range// 使用longValueExact()方法时,如果超出了long型的范围,会抛出ArithmeticExceptionBigDecimal#
- 和BigInteger类似,BigDecimal可以表示一个任意大小且精度完全准确的浮点数。
Copy
BigDecimal bd =newBigDecimal("123.4567");System.out.println(bd.multiply(bd));// 15241.55677489
- BigDecimal用scale()表示小数位数,例如:
Copy
BigDecimal d1 =newBigDecimal("123.45");BigDecimal d2 =newBigDecimal("123.4500");BigDecimal d3 =newBigDecimal("1234500");System.out.println(d1.scale());// 2,两位小数System.out.println(d2.scale());// 4System.out.println(d3.scale());// 0
- 通过BigDecimal的stripTrailingZeros()方法,可以将一个BigDecimal格式化为一个相等的,但去掉了末尾0的BigDecimal:
Copy
BigDecimal d1 =newBigDecimal("123.4500");BigDecimal d2 = d1.stripTrailingZeros();System.out.println(d1.scale());// 4System.out.println(d2.scale());// 2,因为去掉了00BigDecimal d3 =newBigDecimal("1234500");BigDecimal d4 = d3.stripTrailingZeros();System.out.println(d3.scale());// 0System.out.println(d4.scale());// -2
- 如果一个BigDecimal的scale()返回负数,例如,-2,表示这个数是个整数,并且末尾有2个0。
- 可以对一个BigDecimal设置它的scale,如果精度比原始值低,那么按照指定的方法进行四舍五入或者直接截断:
Copy
importjava.math.BigDecimal;importjava.math.RoundingMode;publicclass Main { public static void main(String[] args) { BigDecimal d1 =newBigDecimal("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); }}
- 对BigDecimal做加、减、乘时,精度不会丢失,但是做除法时,存在无法除尽的情况,这时,就必须指定精度以及如何进行截断:
Copy
BigDecimal d1 =newBigDecimal("123.456");BigDecimal d2 =newBigDecimal("23.456789");BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP);// 保留10位小数并四舍五入BigDecimal d4 = d1.divide(d2);// 报错:ArithmeticException,因为除不尽
- 还可以对BigDecimal做除法的同时求余数:
Copy
importjava.math.BigDecimal;publicclass Main { public static void main(String[] args) { BigDecimal n =newBigDecimal("12.345"); BigDecimal m =newBigDecimal("0.12"); BigDecimal[] dr = n.divideAndRemainder(m); System.out.println(dr[0]);// 102 System.out.println(dr[1]);// 0.105 }}
- 调用divideAndRemainder()方法时,返回的数组包含两个BigDecimal,分别是商和余数,其中商总是整数,余数不会大于除数。我们可以利用这个方法判断两个BigDecimal是否是整数倍数:
Copy
BigDecimal n =newBigDecimal("12.75");BigDecimal m =newBigDecimal("0.15");BigDecimal[] dr = n.divideAndRemainder(m);if(dr[1].signum() == 0) { // n是m的整数倍}比较BigDecimal#
- 在比较两个BigDecimal的值是否相等时,要特别注意,使用equals()方法不但要求两个BigDecimal的值相等,还要求它们的scale()相等:
Copy
BigDecimal d1 =newBigDecimal("123.456");BigDecimal d2 =newBigDecimal("123.45600");System.out.println(d1.equals(d2));// false,因为scale不同System.out.println(d1.equals(d2.stripTrailingZeros()));// true,因为d2去除尾部0后scale变为2System.out.println(d1.compareTo(d2));// 0
- 必须使用compareTo()方法来比较,它根据两个值的大小分别返回负数、正数和0,分别表示小于、大于和等于。
- 总是使用compareTo()比较两个BigDecimal的值,不要使用equals()!
- 如果查看BigDecimal的源码,可以发现,实际上一个BigDecimal是通过一个BigInteger和一个scale来表示的,即BigInteger表示一个完整的整数,而scale表示小数位数:
Copy
publicclass BigDecimal extends Number implements Comparable<BigDecimal> { privatefinalBigInteger intVal; privatefinalintscale;}
- BigDecimal也是从Number继承的,也是不可变对象。
顾名思义,Math类就是用来进行数学计算的,它提供了大量的静态方法来便于我们实现数学计算:
求绝对值:
Copy
Math.abs(-100);// 100Math.abs(-7.8);// 7.8
取最大或最小值:
Copy
Math.max(100, 99);// 100Math.min(1.2, 2.3);// 1.2
计算xy次方:
Copy
Math.pow(2, 10);// 2的10次方=1024
计算√x:
Copy
Math.sqrt(2);// 1.414...
计算ex次方:
Copy
Math.exp(2);// 7.389...
计算以e为底的对数:
Copy
Math.log(4);// 1.386...
计算以10为底的对数:
Copy
Math.log10(100);// 2
三角函数:
Copy
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还提供了几个数学常量:
Copy
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:
Copy
Math.random();// 0.53907... 每次都不一样
如果我们要生成一个区间在[MIN, MAX)的随机数,可以借助Math.random()实现,计算如下:
Copy
// 区间在[MIN, MAX)的随机数publicclassMain{ public static void main(String[] args) { doublex = Math.random();// x的范围是[0,1)doublemin = 10; doublemax = 50; doubley = x * (max - min) + min;// y的范围是[10,50)longn = (long) y;// n的范围是[10,50)的整数 System.out.println(y); System.out.println(n); }}
有些童鞋可能注意到Java标准库还提供了一个StrictMath,它提供了和Math几乎一模一样的方法。这两个类的区别在于,由于浮点数计算存在误差,不同的平台(例如x86和ARM)计算的结果可能不一致(指误差不同),因此,StrictMath保证所有平台计算结果都是完全相同的,而Math会尽量针对平台优化计算速度,所以,绝大多数情况下,使用Math就足够了。
Random#
Random用来创建伪随机数。所谓伪随机数,是指只要给定一个初始的种子,产生的随机数序列是完全一样的。
要生成一个随机数,可以使用nextInt()、nextLong()、nextFloat()、nextDouble():
Copy
Random r =newRandom();r.nextInt();// 2071575453,每次都不一样r.nextInt(10);// 5,生成一个[0,10)之间的intr.nextLong();// 8811649292570369305,每次都不一样r.nextFloat();// 0.54335...生成一个[0,1)之间的floatr.nextDouble();// 0.3716...生成一个[0,1)之间的double
有童鞋问,每次运行程序,生成的随机数都是不同的,没看出_伪随机数_的特性来。
这是因为我们创建Random实例时,如果不给定种子,就使用系统当前时间戳作为种子,因此每次运行时,种子不同,得到的伪随机数序列就不同。
如果我们在创建Random实例时指定一个种子,就会得到完全确定的随机数序列:
Copy
importjava.util.Random;publicclass Main { public static void main(String[] args) { Random r =newRandom(12345); for(inti = 0; i < 10; i++) { System.out.println(r.nextInt(100)); } // 51, 80, 41, 28, 55... }}
前面我们使用的Math.random()实际上内部调用了Random类,所以它也是伪随机数,只是我们无法指定种子。
SecureRandom#
有伪随机数,就有真随机数。实际上真正的真随机数只能通过量子力学原理来获取,而我们想要的是一个不可预测的安全的随机数,SecureRandom就是用来创建安全的随机数的:
Copy
SecureRandom sr =newSecureRandom();System.out.println(sr.nextInt(100));
SecureRandom无法指定种子,它使用RNG(random number generator)算法。JDK的SecureRandom实际上有多种不同的底层实现,有的使用安全随机种子加上伪随机数算法来产生安全的随机数,有的使用真正的随机数生成器。实际使用的时候,可以优先获取高强度的安全随机数生成器,如果没有提供,再使用普通等级的安全随机数生成器:
Copy
importjava.util.Arrays;importjava.security.SecureRandom;importjava.security.NoSuchAlgorithmException;publicclass Main { public static void main(String[] args) { SecureRandom sr =null; try{ sr = SecureRandom.getInstanceStrong();// 获取高强度安全随机数生成器 }catch(NoSuchAlgorithmException e) { sr =newSecureRandom();// 获取普通的安全随机数生成器 } byte[] buffer =newbyte[16]; sr.nextBytes(buffer);// 用安全随机数填充buffer System.out.println(Arrays.toString(buffer)); }}
SecureRandom的安全性是通过操作系统提供的安全的随机种子来生成随机数。这个种子是通过CPU的热噪声、读写磁盘的字节、网络流量等各种随机事件产生的“熵”。
在密码学中,安全的随机数非常重要。如果使用不安全的伪随机数,所有加密体系都将被攻破。因此,时刻牢记必须使用SecureRandom来产生安全的随机数。
作者: DawsonLee

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论