Java JDK常用的类

电玩女神 2023-02-10 07:54 116阅读 0赞

### 目录 ###

*   *   *  根类 Object
         *  数学操作 Math
         *  数字格式化 NumberFormat、DecimalFormat
         *  大数 BigInteger、BigDecimal
         *  随机数 Random、ThreadLocalRandom
         *  字符串 String、StringBuilder、StringBuffer
         *   *  比较|区别
             *  源码分析
             *  字符串修改的性能问题
             *  字符串、数组的相互转换

### 根类 Object ###

Object是所有类的根类，提供了对象的基本方法

*  getClass()：获取所属类的Class对象
 *  hashCode()：获取对象的hashCode，提供对hash表的支持
 *  equals()：判断对象是否相等
 *  clone()：克隆当前对象，得到一个对象副本
 *  toString()
 *  wait()：
 *  notify()：
 *  notifyAll()：
 *  finalize()：

### 数学操作 Math ###

Math.round(x)  //四舍五入
    Math.floor()  //向下取整
    Math.ceil()  //向上取整
    
    Math.min(x,y)  //返回2个数中小的一个
    Math.max(x,y)  //返回大的一个
    
    Math.random()  //返回一个[0，1)之间的伪随机数

/是整除，如果2个操作数都是整数，则结果默认舍弃小数部分、只取整；只要有1个操作数是浮点数，结果就是浮点数。

### 数字格式化 NumberFormat、DecimalFormat ###

这2个类都可以格式化数字，只不过目标格式不同

**NumberFormat**

NumberFormat nf1 = NumberFormat.getCurrencyInstance(Locale.CHINA);  //获取指定国家的货币格式，比如中国是¥，美国是$，参数为Locale类的常量
    NumberFormat nf2 = NumberFormat.getIntegerInstance();  //整型数字格式，如果含有小数，先四舍五入转换为整数
    NumberFormat nf3 = NumberFormat.getNumberInstance();  //通用数字格式，可以格式化所有类型的数字，保留原值、不四舍五入
    
    
    // 格式化数字，返回字符串。从末尾起，每3位加一个逗号
    String str1 = nf1.format(12345);  //"¥12,345"
    String str2 = nf2.format(12345);   //"12,345"
    String str3 = nf3.format(12345.678);  //"12，345.678"
    
    
    // 将格式字符串转换为数值，返回Number类型
    try { 
        Number n1 = nf1.parse(str1);  //12345
        Number n2 = nf2.parse(str2);  //12345
        Number n3 = nf3.parse(str3);  //12345.678
    } catch (ParseException e) { 
        e.printStackTrace();
    }

**DecimalFormat**

//舍弃小数部分，只保留整数部分（不是四舍五入）
    DecimalFormat df1 = new DecimalFormat("#");
    
    //保留2位小数
    DecimalFormat df2 = new DecimalFormat("#.##");
    
    //转换为百分数形式，%前面部分保留2位小数
    DecimalFormat df3 = new DecimalFormat("#.##%");
    
    
    //参数是数值型，返回的是String
    String format = df1.format(60.5);

占位符可以使用\#或者0，区别位数不足时，\#不会自动填充，0会自动填充0。

eg. 60.5 保留2位小数  
\#.\#\# => 60.5 不会自动填充0  
0.00 => 60.50 位数不够会自动填充0

### 大数 BigInteger、BigDecimal ###

int | Integer只能表示正负21亿+范围内的整数，对于大整数，需要使用BigInteger表示。

//为保持精度，参数使用字符串
    BigInteger a = new BigInteger("1111111111");
    BigInteger b = new BigInteger("2222222222");
    BigInteger sum = a.add(b);

计算机表示浮点数有误差，不管是单精度、双精度，是浮点型的基本类型、还是包装类型，都存在这个问题。

Bigdecimal以字符串形式存储数值，可以精确表示浮点数，并进行精确的四则运算。

// 以下2种方式创建方式才可以精确表示浮点数，其余创建BigDecimal的方式都不推荐，因为会损失精度
    
    //方式一 传入String类型的数值 （推荐）
    BigDecimal db1=new BigDecimal("1.23");  
    
    //方式二 传入数值。实质是先调用Double的toString()方法将数值转换为字符串，再调用方式一，性能比方式一低
    BigDecimal db2=BigDecimal.valueOf(1.23)
    
    
    // BigDecimal类提供了加减乘除的方法，可以进行精确的四则运算
    // add 加，subtract 减，multiply 乘，divide 除
    BigDecimal db3=db1.add(db2);
    
    
    // 转换为数值型，xxxValue()
    double d=db3.doubleValue();

BigDecimal是借助BigInteger实现的, 所不同的是 BigDecimal 加入了小数位的概念

BigInteger、BigDecimal是对象，不能像基本类型一样直接使用+、-、\*、/等运算符进行数学运算，需要使用BigInteger、BigDecimal自带的方法进行运算。

### 随机数 Random、ThreadLocalRandom ###

*  Random、ThreadLocalRandom生成的都是伪随机数，生成的随机数是预测的，种子相同时生成的随机数相同
 *  并发场景下多线程使用同一个Random对象时，多线程使用的是同一个种子，Random使用原子类+CAS算法保证线程安全，但多线程竞争种子的使用权严重拉低生成随机数的效率。
 *  ThreadLocalRandom是Random的子类，内部用ThreadLocal存储线程各自的种子，多线程下线程安全，且避免了多线程竞争种子，生成随机数的效率比Random高得多，推荐并发场景下使用ThreadLocalRandom。
 *  Math.random()是对Random的简易封装，实际使用的还是Random。
 *  严格意义上来说，计算机自身不能生成真随机数，生成真随机数往往需要借助外部硬件设备，代价高昂。java.security.SecureRandom借助真实世界中的鼠标点击、按键点击等事件，模拟随机事件生成随机数，虽然生成的也是伪随机数，但比Random、ThreadLocalRandom要随机得多，更趋近于真随机。

Random random1 = new Random();  //默认以当前时间戳作为种子
    Random random2 = new Random(1212121122323232L);  //设置种子
    
    int next = random1.nextInt(10);  //返回[0,10)内的一个随机整数
    int i = random1.nextInt();  //返回int范围内的一个随机整数
    boolean b = random1.nextBoolean();  //随机生成布尔值
    
    
    // ThreadLocalRandom是Random的加强版，在并发环境下资源占用更少，并且可以设置范围的下限
    ThreadLocalRandom random = ThreadLocalRandom.current();

### 字符串 String、StringBuilder、StringBuffer ###

#### 比较|区别 ####

1、整体结构

*  都实现了Serializable、CharSequence接口
 *  String还实现了Comparable<String>接口，可用于比较、排序
 *  StringBuilder、StringBuffer还继承了抽象类AbstractStringBuilder

2、可变性

*  String不可变，修改字符串是在副本上操作，以新串形式返回，原串不变。
 *  StringBuffer、StringBuilder都是可变的，修改字符串是在原串上操作，原串改变。

可变、不可变指的是对象本身，变量本身持有的引用都是可变的。

3、线程安全

*  String、StringBuilder没有使用任何保证线程安全的机制，线程不安全
 *  StringBuffer：操作字符串的方法都使用synchronized修饰，线程安全，但为保证线程安全，有额外的开销，性能比如String、StringBuilder

使用建议

*  需要考虑线程安全的用StringBuffer
 *  不需要考虑线程安全、需要频繁修改字符串的用StringBuilder
 *  不需要考虑线程安全、也不需要频繁修改字符串的用String

#### 源码分析 ####

String部分源码

public final class String implements java.io.Serializable, Comparable<String>, CharSequence { 
    
    	//存储字符串
        private final char value[];
    
        /** Cache the hash code for the string */
        private int hash;
        
        public String concat(String str) { 
            int otherLen = str.length();
            if (otherLen == 0) { 
                return this;
            }
            int len = value.length;
            char buf[] = Arrays.copyOf(value, len + otherLen);
            str.getChars(buf, len);
            //并不是修改内置的char[]，而是直接返回一个新的String对象，使用新的char[]
            return new String(buf, true);
        }
    
    }

AbstractStringBuilder封装了修改字符串的常用操作，部分源码如下

abstract class AbstractStringBuilder implements Appendable, CharSequence { 
    
        //存储字符串
        char[] value;
    
        //char[]中存储的字符数量
        int count;
        
        public AbstractStringBuilder append(String str) { 
            if (str == null)
                return appendNull();
            int len = str.length();
            //先确保数组容量足够。扩容时会复制到新的char[]中，会改变value的指向
            ensureCapacityInternal(count + len);
            //再在内置的char[]上修改内容。容量保证够的，直接在char[]上进行修改，不改变value指向
            str.getChars(0, len, value, count);
            count += len;
            return this;
        }
    
        public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
        { 
            if (srcBegin < 0)
                throw new StringIndexOutOfBoundsException(srcBegin);
            if ((srcEnd < 0) || (srcEnd > count))
                throw new StringIndexOutOfBoundsException(srcEnd);
            if (srcBegin > srcEnd)
                throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
            //源数组、目标数组都是value，value的内存地址不变，只是修改其上存储的内容
            System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
        }
        
        private void ensureCapacityInternal(int minimumCapacity) { 
            //容量不足则自动扩容
            if (minimumCapacity - value.length > 0) { 
            	//value指向新的char[]数组
                value = Arrays.copyOf(value,
                        newCapacity(minimumCapacity));
            }
        }
    
        private int newCapacity(int minCapacity) { 
            //新容量 = 原容量*2 + 2
            int newCapacity = (value.length << 1) + 2;
            //之所以有这个判断，是因为可能存在这种情况：目前容量较小，将要存储的字符串很多，超过了 原容量*2 + 2，则取实际要存储的字符个数
            if (newCapacity - minCapacity < 0) { 
                newCapacity = minCapacity;
            }
            return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
                ? hugeCapacity(minCapacity)
                : newCapacity;
        }
        
        private int hugeCapacity(int minCapacity) { 
            if (Integer.MAX_VALUE - minCapacity < 0) {  // overflow
                throw new OutOfMemoryError();
            }
            return (minCapacity > MAX_ARRAY_SIZE)
                ? minCapacity : MAX_ARRAY_SIZE;
        }
    
    }

//StringBuffer、StringBuilder未设置char[]的初始容量时，默认取16
    public StringBuffer() { 
        super(16);
    }
    
    public StringBuilder() { 
        super(16);
    }

都是使用char\[ \]存储字符串

*  但String不可变，字符串长度就是char\[ \]的长度，所以不需要使用一个成员变量标识字符串长度；
 *  StringBuilder、StringBuffer可变，char\[ \]只是容器，需要用一个int型的成员变量标识实际存储的字符个数，即字符串长度

append()的操作流程

*  先确保char\[ \]容量足够。容量不足时自动扩容，扩容时会复制到新的char\[ \]中，然后改变value的指向
 *  再在内置的char\[ \]上修改内容。此时容量是保证够的，直接在char\[ \]上进行修改内容，不改变value指向

内置char\[ \]的扩容机制如下

> 如果所需容量大于 原容量\*2 + 2，则扩容为实际所需容量（将要存储的字符长度），否则扩容为 原容量\*2 + 2

#### 字符串修改的性能问题 ####

String不可变，每次修改字符串都是创建新串返回，性能是不是比StringBUffer、StringBuilder差得多？并不是。

String str = "xxx";
    str += "xxx1";
    str += "xxx2";

编译器会自动优化代码，修改String会转换为：创建一个StringBuilder，使用StringBuilder进行字符串的（1个或多个）修改操作，修改完成后将StringBuilder转换为String返回。

这样看String的修改性能也不错，但编译器不够智能，优化有限

String str = "xxx";
    for (int i = 0; i < 10; i++) { 
        str += "xxx";
    }

比如这段代码，编译器会优化为：在循环体中，创建一个StringBuilder，使用StringBuilder进行字符串的修改，转为String返回。每次循环都会创建一个新的StringBuilder对象，性能显然不行。

不要太依靠编译器的优化，尽量自己优化代码

StringBuilder sb = new StringBuilder("xxx");
    for (int i = 0; i < 10; i++) { 
        sb.append("xxx");
    }

#### 字符串、数组的相互转换 ####

//字符串切割为数组，参数指定分割符
    String str = "张三&&李四&&王五";
    String[] arr = str.split("&&");
    
    
    //数组连接成字符串，第二个参数指定连接符
    
    //方式一，使用 org.apache.commons.lang.StringUtils
    String str1 = StringUtils.join(arr, "&&");
    
    //方式二、使用 org.apache.poi.util.StringUtil
    String str2 = StringUtil.join(arr, "&&");