Java常用类

Java
Java
发布日期:   2022-06-14
文章字数:   9.2k
阅读时长:   42 分
阅读次数:  

目录：

  1. Object类

  2. 内部类

  3. 包装类

  4. System类

  5. 数学类Math

  6. 时间类

  7. String类

  8. DecimalFormat

  9. BigDecimal

  10. 集合工具类

  11. 1 Collections

  12. 2 CollectionUtils

  13. Objects

  14. BooleanUtils

  15. StringUtils

  16. IOUtils

  17. DigestUtils

  18. javatuples元组

参考/来源：

Object类

equals方法

「==与equals的对比」

==是一个比较运算符

  1. ==：既可以判断基本类型，又可以判断引用类型

  2. ==：如果判断的是「基本类型」，「判断的是值是否相等」。

    //==： 如果判断的是基本类型，判断的是 值 是否相等
int x1 = 10;
int x2 = 10;
double x3 = 10.0;
System.out.println(x1 == x2);//true
System.out.println(x1 == x3);//true

  3. ==：如果判断的是「引用类型」，「判断的是地址是否相等，即判断是不是同一个对象」

    package Equals;
public class Test01 {
    public static void main(String[] args) {
        //==： 如果判断的是引用类型，判断的是地址是否相等，即判断是不是同一个对象
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a==c);// ? true
        System.out.println(b==c);// true
        B obj = a;
        System.out.println(obj==c);// true
    }
}

class B{}
class A extends B{}

  4. equals方法是Object类中的方法，「只能判断引用类型」。默认判断的是地址是否相等，「子类(Object类是所有类的父类)往往重写该方法，用于判断内容是否相等」。

    /*
Object类 equals()方法原码

//默认判断地址是否一样
    public boolean equals(Object obj) {
        return (this == obj);
    }
    
子类往往重写该方法，用于判断内容是否相等  String类中的equals()方法原码（重写了父类equals()方法）
*/
    public boolean equals(Object anObject) {
        if (this == anObject) { // 如果是同一个对象(地址相同)
            return true; // 返回true
        }
        if (anObject instanceof String) { // 判断类型
            String anotherString = (String)anObject; // 向下转型
            int n = value.length;
            if (n == anotherString.value.length) { // 如果长度相同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) { // 比较每一个字符
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true; // 如果两个字符串每一个字符都相同，则返回true
            }
        }
        return false;
    }

hashCode方法

  1. 提高具有哈希结构的容器的效率
  2. 两个引用，如果指向的是同一个对象，则哈希值肯定一样
  3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
  4. 哈希值主要根据地址号来！不能将哈希值完全等价于地址
  5. 在后面的集合中hashCode如果需要的话，也会重写
package hashCode;
public class HashCode {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hashCode()="+ aa.hashCode());
        System.out.println("aa2.hashCode()="+ aa2.hashCode());
        System.out.println("aa3.hashCode()="+ aa3.hashCode());
    }
}

class AA{}
/*
aa.hashCode()=460141958 
aa2.hashCode()=1163157884 
aa3.hashCode()=460141958
*/

toString方法

默认返回：全类名 + @ + 哈希值的十六进制

/*
    Object toString()原码
    //(1)getClass().getName() 类的全类名（包名+类名）
    //(2)Integer.toHexString(hashCode()) 将hashCode的值转成16进制字符串
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 */

「子类往往重写toString方法，用于返回对象的属性信息（快捷键：alt + insert），当然我们也可以自己定制。」

当我们输出一个对象时，toString()方法会被默认调用

finzlize方法

finzlize方法：当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。

  1. 当对象被回收时，系统自动调用该对象的finzlize方法。子类可以重写该方法，做一些释放资源的操作
  2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会时候垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finzlize方法。

垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制。

内部类

「概念」：在一个类内部再定义一个完整的类。

一般情况下类与类之间是相互独立的，内部类的意思就是打破这种独立思想，让一个类成为另一个类的内部信息，和成员变量、成员方法同等级别。

「内部类的好处：」

把一个类写在外面和写在里面最终达到的结果都一样，那我们为什么还要使用内部类，岂不是多此一举吗？

「采用内部类这种技术，可以隐藏细节和内部结构，封装性更好，让程序的结构更加合理！如果类很多且都暴露在外面，那么类与类之间的调用就会十分繁琐！」

成员内部类

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
        System.out.println("这是外部类方法！");
        System.out.println(OuterName);
    }
    //内部类
    public class InnerClass{
        //成员变量
        private String InnerNme;
        //构造方法
        public InnerClass() {
            InnerNme = "Inner Class";
        }
        //成员方法
        public void display(){
            System.out.println("这是内部类方法！");
            System.out.println(InnerNme);
        }
    }
    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();//这是外部类方法！null

        // 这个类是内部类，已经不是独立的类了，因此不能像外部类一样直接创建！
        //InnerClass innerClass = new InnerClass(); 行不通
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成员方法/变量 只是加了个前缀
        innerClass.display();// 这是内部类方法！
    }
}

成员内部类（非静态内部类）的使用就是将内部类作为外部类的的一个成员变量/成员方法来使用，所以必须依赖于外部类的对象才能调用，用法和成员变量/成员方法一致！

局部内部类

局部内部类：基本的内部类还可以在一个方法体中定义

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
        class InnerClass {
            public void print(){
                System.out.println("这是一个局部内部类方法！");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }

    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}

静态内部类

静态内部类的构造不需要依赖于外部类对象，类中的静态组件都不需要依赖于任何对象，可以直接通过「类本身」进行构造.

package NeiBuLei;
public class OuterClass {
    //成员变量
    private String OuterName;
    //成员方法
    public void display(){
        System.out.println("这是外部类方法！");
        System.out.println(OuterName);
    }
    //静态内部类
    public static class InnerClass{
        private String InnerName;
        public InnerClass() {
            InnerName = "Inner Class";
        }

        //成员方法
        public void display(){
            System.out.println("这是静态内部类方法！");
            System.out.println(InnerName);
        }
    }

    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        // 静态内部类的构造不依赖与外部类，可以直接通过类本身进行构造！
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }
}

匿名内部类

匿名内部类：没有名字的内部类，主要应用与接口的实现。

public static void main(String[] args){
  new Thread(new Runable(){
    @override
    public void run(){
      //....
    }
  }).start();
}

「匿名内部类的好处：」

我们定义接口之后，「它的实现类不需要去单独创建一个文件去写它的实现」，我们可以把这个实现类的操作写到我们调用的地方就可以了！写起来更加简洁、方便。

「匿名内部类的缺点：」

耦合度太高了！

包装类

// 都在java.lang包中
byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean

  • 包装类的意义：

    1. 让基本数据类型有面向对象的特征

    2. 「封装了字符串转化成基本数据类型的方法（重点）」

  • 常用类

    1. Integer.parseInt()
    2. Long.paseLong()
    3. Double.parseDouble()
public class Test {
    public static void main(String[] args) {
        
//        Integer i = new Integer(10);// 创建包装类对象
//        Integer ii = 10; // 自动打包
//        System.out.println(i+10); // 在使用上，int 和Integer 其实没有区别，可以互相使用
//        System.out.println(ii+10);
//        int j = ii;// 自动解包
//        System.out.println(j+100);

        String a = "12";
        String b = "34";
        System.out.println(a+b); // 1234
    // 转型:
        // 字符串转成int的唯一方案
        int c = Integer.parseInt(a);
        int d = Integer.parseInt(b);
        System.out.println(c+d); // 46
        
        // 字符串转成double类型
        String e = "1.25";
        double f = Double.parseDouble(e);
        System.out.println(f*6); // 7.5

        // 转成long类型
        long l = Long.parseLong("1234567");
        System.out.println(l);
    }
}

System类

  • 标准输出

    System.out.println("hello");

  • 设置健值对到系统内存中

    可以利用此方法，调整Spring框架配置文件中的属性

    public class setPropertyDemo {
    static {
        setValue();
    }


    private static void setValue() {
        System.setProperty("name", "张三");
        System.setProperty("age", "15");
    }

    public static void main(String[] args) {
        System.out.println(System.getProperty("name"));
        System.out.println(System.getProperty("age"));
        System.out.println(System.getProperty(""));
    }
}

数学类Math

数学类的方法都是静态方法，可以直接引用——Math.方法()

「常用数学类方法：」

  1. abs()：获取绝对值
  2. max()：求最大值
  3. min()：求最小值
  4. pow()：求次幂
  5. round()：四舍五入
  6. sqrt()：求平方根

时间类

Date和Calendar类 在java.util包中， SimpleDateFormat类 在java.text包

Date 日期类

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d); // 系统时间
        //get...()——获取年月日.....
        System.out.println(d.getYear()+1900); // 从1900年开始算的
        System.out.println(d.getMonth()+1); // 月份从0开始计算
        System.out.println(d.getDate()); // 天数
        System.out.println(d.getHours());// 小时

        //getTime()——获取到时间的毫秒形式 返回的是long
        System.out.println(d.getTime());
    }
}

  • new Date() 可以获取到系统时间

  • getTime() 能获取到时间的long形式，可以用来计算时间差

Calendar 日历类

  • get() 获取到时间的某一部分

  • set() 设置时间 - -> 计算时间：系统已经帮我们设置好了，不用担心二月有多少天等问题，计算时间十分方便

注：Calendar 日历类是抽象类，因此不可以去new对象。虽然抽象类不能创建对象，但是jdk官方提供了一个实例对象的操作：

Calendar rightNow = Calendar.getInstance();

我们通过这条代码就是直接造了一个Calender的对象

package date;
import java.util.Calendar;
public class TestCalendar {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
//        System.out.println(cal);
        
        /*
 假设当天：
        2021
        8
        10
         */
  cal.set(Calendar.DATE,cal.get(Calendar.DATE)+31); // 计算时间(这里用天数计算的) 
        
        // 获取Calendar创建的对象里的所有内容
        System.out.println(cal.get(Calendar.YEAR)); // 2021 年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：从0开始的  结果：为10月
        System.out.println(cal.get(Calendar.DATE)); // 日
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));// 小时
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));
    }
}

注：cal.setTime(d); 把Date转化成Calendar

package date;
import java.util.Calendar;
import java.util.Date;
public class TestCalendar {
    public static void main(String[] args) {
        Date d = new Date();
        Calendar cal = Calendar.getInstance();
        cal.setTime(d);// 把Date转化成Calendar
        System.out.println(cal);
        System.out.println(cal.get(Calendar.YEAR)); //  年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：从0开始的
        System.out.println(cal.get(Calendar.DATE)); // 日        
    }
}

SimpleDateFormat 格式化时间类

Date，Calendar通过引用也可以进行时间的格式化，但比较繁琐，而SimpleDateFormat类是专门帮我们格式化时间的工具类，它在java.text包中。

【时间格式】：yyyy-MM-dd HH:mm:ss

SimpleDateFormat类有两大常用方法：

  • format(Date)：

    format(Date) 帮我们把时间转成字符串，字符串的格式为SimpleDateFormat类定义对象时设置的时间格式

    package Simple;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d); //Thu Aug 12 08:40:08 CST 2021  不美观

  //                  设置格式化时间的模式，我们常用yyyy-MM-dd HH:mm:ss这个模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 时间格式
        String s = sdf.format(d); // 格式化时间
        System.out.println(s); // 2021-08-12 08:45:09
    }
}

  • parse(String)：

    parse(String) 帮我们把字符串转化成时间

    package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个时间(yyyy-MM-dd HH:mm:ss)：");
        String s = sc.nextLine();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       Date d =  sdf.parse(s); // 把字符串转成时间
        System.out.println(d);        
        /*
        请输入一个时间(yyyy-MM-dd HH:mm:ss)：
        2021-08-12 12:25:21
        Thu Aug 12 12:25:21 CST 2021
         */
    }
}

计算时间差

计算思路：

  1. 格式化时间
  2. 先将字符串转化成long类型时间
  3. 计算毫秒级别时间差，取绝对值
  4. 毫秒级别时间差转成秒级别
  5. 秒级别时间差转成分钟级别
  6. 分钟级别时间差转化显示成xx小时xx分钟
package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDiff {
    public static void main(String[] args) throws ParseException {
        String s1 = "2021-08-12 12:00:00"; // 开始时间
        String s2 = "2021-08-12 14:35:00"; // 结束时间
        //格式化时间
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        //将字符串转成时间形式
        Date d1 = sdf.parse(s1);
        Date d2 = sdf.parse(s2);

        //计算时间差:先要获取时间毫秒形式（long类型） 再做差
        long long1 = d1.getTime();
        long long2 = d2.getTime();
        long diffTime = Math.abs(long1 - long2);

        // 秒级别时间差
        long diffSec = diffTime / 1000;

        // 分级别时间差
        long diffMin = diffSec / 60;

        //显示 xx小时xx分钟
        long displayHours = diffMin / 60; // 小时
        long displayMin = diffMin % 60; //分钟
        System.out.println("您学习的时长为："+displayHours+"小时"+displayMin+"分钟");
    }
}

String类

DecimalFormat

DecimalFormat：对小数进行格式化，保留几位小数。与格式化时间联想记。

. 表示小数点

0和# 表示数位，保留几位就几个0或者#

import java.text.DecimalFormat;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        double d= 10/3.0;
        System.out.println(d);//3.3333333333333335
        
        // . 表示小数点
        // 0和#表示数字

        // 保留两位小数                        格式
        DecimalFormat df = new DecimalFormat(".00"); // 或者.##
        String s = df.format(d); // 把 d 转成上面设置的格式
        System.out.println(s);//3.33
   }
}

BigDecimal

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。

一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String)和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。

BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。BigDecimal都是不可变的（immutable）的， 在进行每一次四则运算时，都会产生一个新的对象 ，所以在做加减乘除运算时要记得要保存操作后的值。

常用构造函数

  • BigDecimal(int)

    创建一个具有参数所指定整数值的对象

  • BigDecimal(double)

    创建一个具有参数所指定双精度值的对象

  • BigDecimal(long)

    创建一个具有参数所指定长整数值的对象

  • BigDecimal(String)

    创建一个具有参数所指定以字符串表示的数值的对象

BigDecimal a =new BigDecimal(0.1);  
System.out.println("a values is:"+a);  
System.out.println("=====================");  
BigDecimal b =new BigDecimal("0.1");  
System.out.println("b values is:"+b);  
/*
out
a values is:0.1000000000000000055511151231257827021181583404541015625  
=====================  
b values is:0.1
*/

结果原因分析：

  1. 参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。
  2. String 构造方法是完全可预知的：写入newBigDecimal(“0.1”)将创建一个BigDecimal，它正好等于预期的 0.1。因此，比较而言， 通常建议优先使用String构造方法。
  3. 当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。

常用方法

  • 「add(BigDecimal)」

BigDecimal对象中的值相加，返回BigDecimal对象

  • 「subtract(BigDecimal)」

BigDecimal对象中的值相减，返回BigDecimal对象

  • 「multiply(BigDecimal)」

BigDecimal对象中的值相乘，返回BigDecimal对象

  • 「divide(BigDecimal)」

BigDecimal对象中的值相除，返回BigDecimal对象

  • 「toString()」

将BigDecimal对象中的值转换成字符串

  • 「doubleValue()」

将BigDecimal对象中的值转换成双精度数

  • 「floatValue()」

将BigDecimal对象中的值转换成单精度数

  • 「longValue()」

将BigDecimal对象中的值转换成长整数

  • 「intValue()」

将BigDecimal对象中的值转换成整数

  • CompareTo(bigdemical)

    java中对BigDecimal比较大小一般用的是bigdemical的compareTo方法

    int a = bigdemical.compareTo(bigdemical2)

    返回结果分析：

    a = -1,表示bigdemical小于bigdemical2；  
a = 0,表示bigdemical等于bigdemical2；  
a = 1,表示bigdemical大于bigdemical2；

    举例：a大于等于b。

    new bigdemica(a).compareTo(new bigdemical(b)) >= 0

格式化

由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。

以利用BigDecimal对货币和百分比格式化为例。首先，创建BigDecimal对象，进行BigDecimal的算术运算后，分别建立对货币和百分比格式化的引用，最后利用BigDecimal对象作为format()方法的参数，输出其格式化的货币值和百分比。

NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用  
NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用  
percent.setMaximumFractionDigits(3); //百分比小数点最多3位  
  
BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额  
BigDecimal interestRate = new BigDecimal("0.008"); //利率  
BigDecimal interest = loanAmount.multiply(interestRate); //相乘  
  
System.out.println("贷款金额:\t" + currency.format(loanAmount));  
System.out.println("利率:\t" + percent.format(interestRate));  
System.out.println("利息:\t" + currency.format(interest));

结果：

贷款金额: ￥15,000.48 利率: 0.8% 利息: ￥120.00

BigDecimal格式化保留2为小数，不足则补0：

public class NumberFormat {  
  
    public static void main(String[] s){  
        System.out.println(formatToNumber(new BigDecimal("3.435")));  
        System.out.println(formatToNumber(new BigDecimal(0)));  
        System.out.println(formatToNumber(new BigDecimal("0.00")));  
        System.out.println(formatToNumber(new BigDecimal("0.001")));  
        System.out.println(formatToNumber(new BigDecimal("0.006")));  
        System.out.println(formatToNumber(new BigDecimal("0.206")));  
    }  
    /**  
     * @desc 1.0~1之间的BigDecimal小数，格式化后失去前面的0,则前面直接加上0。  
     * 2.传入的参数等于0，则直接返回字符串"0.00"  
     * 3.大于1的小数，直接格式化返回字符串  
     * @param obj传入的小数  
     * @return  
     */  
    public static String formatToNumber(BigDecimal obj) {  
        DecimalFormat df = new DecimalFormat("#.00");  
        if(obj.compareTo(BigDecimal.ZERO)==0) {  
            return "0.00";  
        }else if(obj.compareTo(BigDecimal.ZERO)>0&&obj.compareTo(new BigDecimal(1))<0){  
            return "0"+df.format(obj).toString();  
        }else {  
            return df.format(obj).toString();  
        }  
    }  
}  
/*
out
3.44  
0.00  
0.00  
0.00  
0.01  
0.21
*/

除法异常

java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result

「原因分析：」

通过BigDecimal的divide方法进行除法时当不整除，出现无限循环小数时，就会抛异常：java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.

divide方法设置精确的小数点，如：divide(xxxxx,2)

工具类

import java.math.BigDecimal;  
  
/**  
 * 用于高精确处理常用的数学运算  
 */  
public class ArithmeticUtils {  
    //默认除法运算精度  
    private static final int DEF_DIV_SCALE = 10;  
  
    /**  
     * 提供精确的加法运算  
     *  
     * @param v1 被加数  
     * @param v2 加数  
     * @return 两个参数的和  
     */  
  
    public static double add(double v1, double v2) {  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.add(b2).doubleValue();  
    }  
  
    /**  
     * 提供精确的加法运算  
     *  
     * @param v1 被加数  
     * @param v2 加数  
     * @return 两个参数的和  
     */  
    public static BigDecimal add(String v1, String v2) {  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        return b1.add(b2);  
    }  
  
    /**  
     * 提供精确的加法运算  
     *  
     * @param v1    被加数  
     * @param v2    加数  
     * @param scale 保留scale 位小数  
     * @return 两个参数的和  
     */  
    public static String add(String v1, String v2, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                    "The scale must be a positive integer or zero");  
        }  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();  
    }  
  
    /**  
     * 提供精确的减法运算  
     *  
     * @param v1 被减数  
     * @param v2 减数  
     * @return 两个参数的差  
     */  
    public static double sub(double v1, double v2) {  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.subtract(b2).doubleValue();  
    }  
  
    /**  
     * 提供精确的减法运算。  
     *  
     * @param v1 被减数  
     * @param v2 减数  
     * @return 两个参数的差  
     */  
    public static BigDecimal sub(String v1, String v2) {  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        return b1.subtract(b2);  
    }  
  
    /**  
     * 提供精确的减法运算  
     *  
     * @param v1    被减数  
     * @param v2    减数  
     * @param scale 保留scale 位小数  
     * @return 两个参数的差  
     */  
    public static String sub(String v1, String v2, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                    "The scale must be a positive integer or zero");  
        }  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();  
    }  
  
    /**  
     * 提供精确的乘法运算  
     *  
     * @param v1 被乘数  
     * @param v2 乘数  
     * @return 两个参数的积  
     */  
    public static double mul(double v1, double v2) {  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.multiply(b2).doubleValue();  
    }  
  
    /**  
     * 提供精确的乘法运算  
     *  
     * @param v1 被乘数  
     * @param v2 乘数  
     * @return 两个参数的积  
     */  
    public static BigDecimal mul(String v1, String v2) {  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        return b1.multiply(b2);  
    }  
  
    /**  
     * 提供精确的乘法运算  
     *  
     * @param v1    被乘数  
     * @param v2    乘数  
     * @param scale 保留scale 位小数  
     * @return 两个参数的积  
     */  
    public static double mul(double v1, double v2, int scale) {  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return round(b1.multiply(b2).doubleValue(), scale);  
    }  
  
    /**  
     * 提供精确的乘法运算  
     *  
     * @param v1    被乘数  
     * @param v2    乘数  
     * @param scale 保留scale 位小数  
     * @return 两个参数的积  
     */  
    public static String mul(String v1, String v2, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                    "The scale must be a positive integer or zero");  
        }  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();  
    }  
  
    /**  
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到  
     * 小数点以后10位，以后的数字四舍五入  
     *  
     * @param v1 被除数  
     * @param v2 除数  
     * @return 两个参数的商  
     */  
  
    public static double div(double v1, double v2) {  
        return div(v1, v2, DEF_DIV_SCALE);  
    }  
  
    /**  
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指  
     * 定精度，以后的数字四舍五入  
     *  
     * @param v1    被除数  
     * @param v2    除数  
     * @param scale 表示表示需要精确到小数点以后几位。  
     * @return 两个参数的商  
     */  
    public static double div(double v1, double v2, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException("The scale must be a positive integer or zero");  
        }  
        BigDecimal b1 = new BigDecimal(Double.toString(v1));  
        BigDecimal b2 = new BigDecimal(Double.toString(v2));  
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /**  
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指  
     * 定精度，以后的数字四舍五入  
     *  
     * @param v1    被除数  
     * @param v2    除数  
     * @param scale 表示需要精确到小数点以后几位  
     * @return 两个参数的商  
     */  
    public static String div(String v1, String v2, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException("The scale must be a positive integer or zero");  
        }  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v1);  
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();  
    }  
  
    /**  
     * 提供精确的小数位四舍五入处理  
     *  
     * @param v     需要四舍五入的数字  
     * @param scale 小数点后保留几位  
     * @return 四舍五入后的结果  
     */  
    public static double round(double v, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException("The scale must be a positive integer or zero");  
        }  
        BigDecimal b = new BigDecimal(Double.toString(v));  
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }  
  
    /**  
     * 提供精确的小数位四舍五入处理  
     *  
     * @param v     需要四舍五入的数字  
     * @param scale 小数点后保留几位  
     * @return 四舍五入后的结果  
     */  
    public static String round(String v, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                    "The scale must be a positive integer or zero");  
        }  
        BigDecimal b = new BigDecimal(v);  
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();  
    }  
  
    /**  
     * 取余数  
     *  
     * @param v1    被除数  
     * @param v2    除数  
     * @param scale 小数点后保留几位  
     * @return 余数  
     */  
    public static String remainder(String v1, String v2, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                    "The scale must be a positive integer or zero");  
        }  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();  
    }  
  
    /**  
     * 取余数  BigDecimal  
     *  
     * @param v1    被除数  
     * @param v2    除数  
     * @param scale 小数点后保留几位  
     * @return 余数  
     */  
    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {  
        if (scale < 0) {  
            throw new IllegalArgumentException(  
                    "The scale must be a positive integer or zero");  
        }  
        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);  
    }  
  
    /**  
     * 比较大小  
     *  
     * @param v1 被比较数  
     * @param v2 比较数  
     * @return 如果v1 大于v2 则 返回true 否则false  
     */  
    public static boolean compare(String v1, String v2) {  
        BigDecimal b1 = new BigDecimal(v1);  
        BigDecimal b2 = new BigDecimal(v2);  
        int bj = b1.compareTo(b2);  
        boolean res;  
        if (bj > 0)  
            res = true;  
        else  
            res = false;  
        return res;  
    }  
  
   public static BigDecimal doubleAdd(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2);
    }
  
    public static BigDecimal floatAdd(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.add(b2);
    }
  
    public static BigDecimal doubleSub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2);
    }
  
    public static BigDecimal floatSub(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.subtract(b2);
    }

    public static BigDecimal doubleMul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2);
    }
    public static BigDecimal floatMul(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return b1.multiply(b2);
    }

    public static BigDecimal doubleDiv(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        // 保留小数点后两位 ROUND_HALF_UP = 四舍五入
        return b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);
    }
  
    public static BigDecimal floatDiv(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        // 保留小数点后两位 ROUND_HALF_UP = 四舍五入
        return b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);
    }
  
    /**
     * 比较v1 v2大小
     * @param v1
     * @param v2
     * @return v1>v2 return 1  v1=v2 return 0 v1<v2 return -1
     */
    public static int doubleCompareTo(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return  b1.compareTo(b2);
    }
  
    public static int floatCompareTo(float v1, float v2) {
        BigDecimal b1 = new BigDecimal(Float.toString(v1));
        BigDecimal b2 = new BigDecimal(Float.toString(v2));
        return  b1.compareTo(b2);
    }
}

集合工具类

Collections

排序

在工作中经常有对集合排序的需求。

看看使用Collections工具是如何实现升序和降序的：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
Collections.sort(list);//升序
System.out.println(list);
Collections.reverse(list);//降序
System.out.println(list);

执行结果：

[1, 2, 3]
[3, 2, 1]

获取最大或最小值

有时候需要找出集合中的最大值或者最小值，这时可以使用Collections的max和min方法。例如：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);
Integer max = Collections.max(list);//获取最大值
Integer min = Collections.min(list);//获取最小值
System.out.println(max);
System.out.println(min);

执行结果：

3
1

转换线程安全集合

我们都知道，java中的很多集合，比如：ArrayList、LinkedList、HashMap、HashSet等，都是线程不安全的。

换句话说，这些集合在多线程的环境中，添加数据会出现异常。

这时，可以用Collections的synchronizedxxx方法，将这些线程不安全的集合，直接转换成线程安全集合。例如：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);

List<Integer> integers = Collections.synchronizedList(list);//将ArrayList转换成线程安全集合
System.out.println(integers);

它的底层会创建SynchronizedRandomAccessList或者SynchronizedList类，这两个类的很多方法都会用synchronized加锁。

返回空集合

有时，我们在判空之后，需要返回空集合，就可以使用emptyList方法，例如：

private List<Integer> fun(List<Integer> list) {
    if (list == null || list.size() == 0) {
        return Collections.emptyList();
    }
    //业务处理
    return list;
}

二分查找

binarySearch方法提供了一个非常好用的二分查找功能，只用传入指定集合和需要找到的key即可。例如：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);

int i = Collections.binarySearch(list, 3);//二分查找
System.out.println(i );

执行结果：

2

转换成不可修改集合

为了防止后续的程序把某个集合的结果修改了，有时候我们需要把某个集合定义成不可修改的，使用Collections的unmodifiablexxx方法就能轻松实现：

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);

List<Integer> integers = Collections.unmodifiableList(list);
integers.add(4);
System.out.println(integers);

执行结果：

Exception in thread "main" java.lang.UnsupportedOperationException
 at java.util.Collections$UnmodifiableCollection.add(Collections.java:1055)
 at com.sue.jump.service.test1.UtilTest.main(UtilTest.java:19)

CollectionUtils

在Spring的org.springframework.util包和apache的org.apache.commons.collections包都含有CollectionUtils

apache的包下的CollectionUtils工具类，因为它的工具更多更全面，以其为例

集合判空

通过CollectionUtils工具类的isEmpty方法可以轻松判断集合是否为空，isNotEmpty方法判断集合不为空。

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);

if (CollectionUtils.isEmpty(list)) {
    System.out.println("集合为空");
}

if (CollectionUtils.isNotEmpty(list)) {
    System.out.println("集合不为空");
}

对两个集合进行操作

有时候我们需要对已有的两个集合进行操作，比如取交集或者并集等。

List<Integer> list = new ArrayList<>();
list.add(2);
list.add(1);
list.add(3);

List<Integer> list2 = new ArrayList<>();
list2.add(2);
list2.add(4);

//获取并集
Collection<Integer> unionList = CollectionUtils.union(list, list2);
System.out.println(unionList);

//获取交集
Collection<Integer> intersectionList = CollectionUtils.intersection(list, list2);
System.out.println(intersectionList);

//获取交集的补集
Collection<Integer> disjunctionList = CollectionUtils.disjunction(list, list2);
System.out.println(disjunctionList);

//获取差集
Collection<Integer> subtractList = CollectionUtils.subtract(list, list2);
System.out.println(subtractList);

执行结果：

[1, 2, 3, 4]
[2]
[1, 3, 4]
[1, 3]

Objects

在jdk7之后，提供了Objects工具类，我们可以通过它操作对象。

对象判空

在java中万事万物皆对象，对象的判空可以说无处不在。Objects的isNull方法判断对象是否为空，而nonNull方法判断对象是否不为空。例如：

Integer integer = new Integer(1);

if (Objects.isNull(integer)) {
    System.out.println("对象为空");
}

if (Objects.nonNull(integer)) {
    System.out.println("对象不为空");
}

对象为空抛异常

如果我们想在对象为空时，抛出空指针异常，可以使用Objects的requireNonNull方法。例如：

Integer integer1 = new Integer(128);

Objects.requireNonNull(integer1);
Objects.requireNonNull(integer1, "参数不能为空");
Objects.requireNonNull(integer1, () -> "参数不能为空");

判断两个对象是否相等

我们经常需要判断两个对象是否相等，Objects给我们提供了equals方法，能非常方便的实现：

Integer integer1 = new Integer(1);
Integer integer2 = new Integer(1);

System.out.println(Objects.equals(integer1, integer2));

执行结果：

true

但使用这个方法有坑，比如例子改成：

Integer integer1 = new Integer(1);
Long integer2 = new Long(1);

System.out.println(Objects.equals(integer1, integer2));

执行结果：

false

获取对象的hashCode

如果你想获取某个对象的hashCode，可以使用Objects的hashCode方法。例如：

String str = new String("abc");
System.out.println(Objects.hashCode(str));

执行结果：

96354

BooleanUtils

如果你使用了布尔的包装类：Boolean，总感觉有点麻烦，因为它有三种值：null、true、false。我们在处理Boolean对象时，需要经常判空。

头疼！！！

但如果使用BooleanUtils类处理布尔值，心情一下子就愉悦起来了。

判断true或false

如果你想判断某个参数的值是true或false，可以直接使用isTrue或isFalse方法。例如：

Boolean aBoolean = new Boolean(true);
System.out.println(BooleanUtils.isTrue(aBoolean));
System.out.println(BooleanUtils.isFalse(aBoolean));

判断不为true或不为false

有时候，需要判断某个参数不为true，即是null或者false。或者判断不为false，即是null或者true。

可以使用isNotTrue或isNotFalse方法。例如：

Boolean aBoolean = new Boolean(true);
Boolean aBoolean1 = null;
System.out.println(BooleanUtils.isNotTrue(aBoolean));
System.out.println(BooleanUtils.isNotTrue(aBoolean1));
System.out.println(BooleanUtils.isNotFalse(aBoolean));
System.out.println(BooleanUtils.isNotFalse(aBoolean1));

执行结果：

false
true
true
true

转换成数字

如果你想将true转换成数字1，false转换成数字0，可以使用toInteger方法：

Boolean aBoolean = new Boolean(true);
Boolean aBoolean1 = new Boolean(false);
System.out.println(BooleanUtils.toInteger(aBoolean));
System.out.println(BooleanUtils.toInteger(aBoolean1));

执行结果：

1
0

Boolean转换成布尔值

我们有时候需要将包装类Boolean对象，转换成原始的boolean对象，可以使用toBoolean方法。例如：

Boolean aBoolean = new Boolean(true);
Boolean aBoolean1 = null;
System.out.println(BooleanUtils.toBoolean(aBoolean));
System.out.println(BooleanUtils.toBoolean(aBoolean1));
System.out.println(BooleanUtils.toBooleanDefaultIfNull(aBoolean1, false));

我们无需额外的判空了，而且还可以设置Boolean对象为空时返回的默认值。

StringUtils

是org.apache.commons.lang3包下的StringUtils工具类，给我们提供了非常丰富的方法操作字符串。

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>

字符串判空

其实空字符串，不只是null一种，还有””，” “，”null”等等，多种情况。

StringUtils给我们提供了多个判空的静态方法，例如：

 String str1 = null;
String str2 = "";
String str3 = " ";
String str4 = "abc";
System.out.println(StringUtils.isEmpty(str1));
System.out.println(StringUtils.isEmpty(str2));
System.out.println(StringUtils.isEmpty(str3));
System.out.println(StringUtils.isEmpty(str4));
System.out.println("=====");
System.out.println(StringUtils.isNotEmpty(str1));
System.out.println(StringUtils.isNotEmpty(str2));
System.out.println(StringUtils.isNotEmpty(str3));
System.out.println(StringUtils.isNotEmpty(str4));
System.out.println("=====");
System.out.println(StringUtils.isBlank(str1));
System.out.println(StringUtils.isBlank(str2));
System.out.println(StringUtils.isBlank(str3));
System.out.println(StringUtils.isBlank(str4));
System.out.println("=====");
System.out.println(StringUtils.isNotBlank(str1));
System.out.println(StringUtils.isNotBlank(str2));
System.out.println(StringUtils.isNotBlank(str3));
System.out.println(StringUtils.isNotBlank(str4));

执行结果：

true
true
false
false
=====
false
false
true
true
=====
true
true
true
false
=====
false
false
false
true

示例中的：isEmpty、isNotEmpty、isBlank和isNotBlank，这4个判空方法你们可以根据实际情况使用。

优先推荐使用isBlank和isNotBlank方法，因为它会把" "也考虑进去。

分隔字符串

分隔字符串是常见需求，如果直接使用String类的split方法，就可能会出现空指针异常。

String str1 = null;
System.out.println(StringUtils.split(str1,","));
System.out.println(str1.split(","));

执行结果：

null
Exception in thread "main" java.lang.NullPointerException
 at com.sue.jump.service.test1.UtilTest.main(UtilTest.java:21)

使用StringUtils的split方法会返回null，而使用String的split方法会报指针异常。

判断是否纯数字

给定一个字符串，判断它是否为纯数字，可以使用isNumeric方法。例如：

String str1 = "123";
String str2 = "123q";
String str3 = "0.33";
System.out.println(StringUtils.isNumeric(str1));
System.out.println(StringUtils.isNumeric(str2));
System.out.println(StringUtils.isNumeric(str3));

执行结果：

true
false
false

将集合拼接成字符串

有时候，我们需要将某个集合的内容，拼接成一个字符串，然后输出，这时可以使用join方法。例如：

List<String> list = Lists.newArrayList("a", "b", "c");
List<Integer> list2 = Lists.newArrayList(1, 2, 3);
System.out.println(StringUtils.join(list, ","));
System.out.println(StringUtils.join(list2, " "));

执行结果：

a,b,c
1 2 3

IOUtils

我们不得不每次读取文件，或者写入文件之后，写一些重复的的代码。手动在finally代码块中关闭流，不然可能会造成内存溢出。

使用org.apache.commons.io包下的IOUtils类，会节省大量的时间。

读取文件

如果你想将某个txt文件中的数据，读取到字符串当中，可以使用IOUtils类的toString方法。例如：

String str = IOUtils.toString(new FileInputStream("/temp/a.txt"), StandardCharsets.UTF_8);
System.out.println(str);

写入文件

如果你想将某个字符串的内容，写入到指定文件当中，可以使用IOUtils类的write方法。例如：

String str = "abcde";
IOUtils.write(str, new FileOutputStream("/temp/b.tx"), StandardCharsets.UTF_8);

文件拷贝

如果你想将某个文件中的所有内容，都拷贝到另一个文件当中，可以使用IOUtils类的copy方法。例如：

IOUtils.copy(new FileInputStream("/temp/a.txt"), new FileOutputStream("/temp/b.txt"));

读取文件内容到字节数组

如果你想将某个文件中的内容，读取字节数组中，可以使用IOUtils类的toByteArray方法。例如：

byte[] bytes = IOUtils.toByteArray(new FileInputStream("/temp/a.txt"));

DigestUtils

有时候，我们需要对数据进行加密处理，比如：md5或sha256。

可以使用apache的org.apache.commons.codec.digest包下的DigestUtils类。

md5加密

如果你想对数据进行md5加密，可以使用DigestUtils的md5Hex方法。例如：

String md5Hex = DigestUtils.md5Hex("苏三说技术");
System.out.println(md5Hex);

sha256加密

如果你想对数据进行sha256加密，可以使用DigestUtils的sha256Hex方法。例如：

String md5Hex = DigestUtils.sha256Hex("苏三说技术");
System.out.println(md5Hex);

ToString方法重写

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
        </dependency>
@Override
    public String toString(){
        return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
    }

javatuples元组

可以构建一个多元素的对象.

依赖

<!-- https://mvnrepository.com/artifact/org.javatuples/javatuples -->
<dependency>
    <groupId>org.javatuples</groupId>
    <artifactId>javatuples</artifactId>
    <version>1.1</version>
</dependency>

可以使用的元组对象

unit<A> (1 element)
Pair<A,B> (2 elements)
Triplet<A,B,C> (3 elements)
Quartet<A,B,C,D> (4 elements)
Quintet<A,B,C,D,E> (5 elements)
Sextet<A,B,C,D,E,F> (6 elements)
Septet<A,B,C,D,E,F,G> (7 elements)
Octet<A,B,C,D,E,F,G,H> (8 elements)
Ennead<A,B,C,D,E,F,G,H,I> (9 elements)
Decade<A,B,C,D,E,F,G,H,I,J> (10 elements)
文章作者: 小小千千
文章链接: https://jason-qianhao.github.io/2022/06/14/java-chang-yong-lei/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 小小千千 !
Java
赏
评论
  目录