包装类及常用工具类

java包装类以及常用工具类简介

==与equals()区别

1.运算符==的使用：

1. 可以使用在基本数据类型变量和引用数据类型变量中。

2. 如果比较的是基本数据类型变量，比较两个变量保存的数据是否相等(不一定类型要相同)

3. 如果比较的是引用数据类型变量，比较两个对象的地址值是否相同。即两个引用是否指向同一个对象实体

   注：==符号使用时，必须保证左右两边的变量类型一致。

2.equals()方法的使用

1. 是一个方法，而非运算符

2. 只能适用于引用数据类型

3. Objective类中equals()的定义

   

        public boolean equals(Object obj) {
           return (this == obj);
       }
   

   说明Objective类中定义的equals()和==的作用是相同的，比较两个引用是否指向同一个对象实体。

4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后比较的不是两个引用的地址是否相等，而是比较两个对象的"实体内容"是否相同。

   重写的原则：比较两个对象的实体内容是否相同。

3.重写equals()方法

通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同，那么，我们就需要对Object类中的equals()进行重写。

手动实现equals()方法：

自动生成equals：

右击source–>generate hashCode() and equals()

java包装类

由于java中的数据类型int，double等不是对象，所以无法通过向上转型得到Object提供的方法，而像String却可以，原因是String是一个对象而不是一个类型。java提供包装类就是为了解决，基本数据类型因为上述的特性，无法参与转型，泛型，反射等过程的问题。包装类根据名称可以得知，就是将基本的数据类型以及一些辅助方法包装到类中。

java所有包装类都存放在java.lang包下，java中的包装类被final修饰因而不允许被继承且没有子类。

装箱：

• 基本数据类型的值转换成对应包装类的对象
• 每个包装类的构造方法都可以接收各自数据类型的变量

1.自动装箱

int t1=2;
Integer t2=t1;
System.out.println("int类型变量t1="+t1);
System.out.println("Integer类型对象t2="+t2);

2.手动装箱

Integer t3=new Integer(t1);
System.out.println("Integer类型对象t3="+t3);

拆箱：包装类的对象转换成对应的基本数据类型的值

1.自动拆箱

int t4=t2;
System.out.println("Integer类型对象t2="+t2);
System.out.println("自动拆箱后，int类型变量t4="+t4);

2.手动拆箱

int t5=t2.intValue();
System.out.println("手动拆箱后，int类型变量t5="+t5);

1.java中的数据类型

基本数据类型没有属性，方法，无法对象化交互

通过包装类，可以使得基本数据类型拥有属性，方法，可以对象化交互。

2.包装类与基本数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-muvRCMf4-1632296203517)(http://bed.thunisoft.com:9000/ibed/2021/03/30/BzVfRCgam.png)]

以上给出的包装类又分为两种子类型：

• 对象型包装类（Object直接子类）：Character、Boolean。
• 数值型包装类（Number直接子类）：Byte、Short、Integer、Float、Double、Long。
  Number是一个抽象类，里面一共定义了六个操作方法：intValue()、shortValue()、byteValue()、floatValue()、longValue()、doubleValue()。

3.基本数据类型和字符串之间的转换

//基本数据类型转换为字符串

int t1=2;
String t2=Integer.toString(t1);
System.out.println("int类型转换为String类型对象t2="+t2);

//字符串转换为基本数据类型

//1.包装类的parse方法

int t3=Integer.parseInt(t2);

//2.包装类的valueOf，先将字符串转换为包装类，再通过自动拆箱完成基本类型转换。

int t4=Integer.valueOf(t2);
System.out.println("String类型转换为int类型变量t3="+t3);
System.out.println("String类型转换为int类型变量t4="+t4);

4.包装类对象的初始值

Integer one=new Integer(100);
Integer two=new Integer(100);
System.out.println("one==two的结果"+(one==two));    //false

原因：两个引用指向的是由new关键字开辟的不同的内存空间

Integer three=100; //自动装箱
System.out.println("three==100的结果:"+(three==100));   //自动拆箱 true

原因：比较的是整数数值

Integer four=100； //相当于执行Integer four=Integer.valueOf(100);
System.out.println("three==four的结果: "+(three==four));  //true    

原因：three和four指向缓存区的同一块空间

Integer five=200;
System.out.println("five==200的结果:"+(five==200));       //true

原因：比较的是整型数值

Integer six=200;
System.out.println("five==six的结果: "+(five==six));		//false

原因：缓冲池(对象常量池)的大小为一个字节(8个bit位，长度为2^8位，范围是-128~127)，因而200超过了127，包装类对象就自己在缓冲池外面赋值。

注意：八种数据类型除了Float和Double都可以应用对象常量池的概念。

Double d1=Double.valueOf(100);
System.out.println("d1==100的结果: "+(d1==100));  //true

原因：比较的是整型数值

Double d2=Double.valueOf(100);
System.out.println("d1==d2的结果: "+(d1==d2));    //false

原因：Double不具备对象常量池的概念

Mybatis日志管理

1.日志相关概念

​ 日志文件是用于记录系统操作事件的记录文件或文件集合。

​ 日志保存历史数据，是诊断问题以及理解系统活动的重要依据。

在pom.xml中添加logback依赖：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cVJ6ayqG-1632296203520)(http://bed.thunisoft.com:9000/ibed/2021/03/30/BzaRiTSIz.png)]

日志输出级别(优先级高到低)

• error：错误-系统的故障日志
• warn：警告-存在风险或使用不当的日志
• info：一般性消息
• debug：程序内部用于调试信息
• trace：程序运行的跟踪信息

2.logback的配置介绍

基本结构： 以开头，后面有零个或多个元素，有零个或多个元素，有最多一个元素。

2.1 logger、appender及layout

• logger作为日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志对象，也可以定义日志类型、级别。
• appender主要用于指定日志输出的目的地，目的地可以是控制台、文件、远程套接字服务器、 MySQL、PostreSQL、 Oracle和其他数据库、 JMS和远程UNIX Syslog守护进程等。
• layout 负责把事件转换成字符串，格式化的日志信息的输出。

2.2有效级别及级别的继承

Logger 可以被分配级别。级别包括：TRACE、DEBUG、INFO、WARN 和 ERROR。root logger 默认级别是 DEBUG。

2.3根节点configuration包含的属性

• scan: 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
• scanPeriod: 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
• debug: 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

2.4根节点configuration的子节点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sGbYLDVs-1632296203522)(http://bed.thunisoft.com:9000/ibed/2021/03/31/C00KT1vea.png)]

2.5子节点property

用来定义变量值，它有两个属性name和value，通过定义的值会被插入到logger上下文中，可以使“${}”来使用变量。

例如：

<configuration scan="true" scanPeriod="60 seconds" debug="false"> 
　　　　　　<property name="APP_Name" value="myAppName" /> 
　　　　　　<contextName>${APP_Name}</contextName> 
</configuration>

2.6子节点timestamp

获取时间戳字符串，他有两个属性key和datePattern

• key: 标识此 的名字；
• datePattern: 设置将当前时间（解析配置文件的时间）转换为字符串的模式，遵循java.txt.SimpleDateFormat的格式。

2.7子节点appender

负责写日志的组件，它有两个必要属性name和class。

• name指定appender名称
• class指定appender的全限定名（类名全称）

ConsoleAppender 把日志输出到控制台，有以下子节点：

• ：对日志进行格式化。
• ：字符串System.out(默认)或者System.err

2.8子节点logger

用来设置某一个包或具体的某一个类的日志打印级别、以及指定。仅有一个name属性，一个可选的level和一个可选的addtivity属性。

可以包含零个或多个元素，标识这个appender将会添加到这个loger

• name: 用来指定受此loger约束的某一个包或者具体的某一个类。
• level: 用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL和OFF，还有一个特殊值INHERITED或者同义词NULL，代表强制执行上级的级别。 如果未设置此属性，那么当前loger将会继承上级的级别。
• addtivity: 是否向上级loger传递打印信息。默认是true。同一样，可以包含零个或多个元素，标识这个appender将会添加到这个loger。

2.9子节点root

它也是元素，但是它是根logger,是所有的上级。只有一个level属性，因为name已经被命名为"root",且已经是最上级了。

• level: 用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL和OFF，不能设置为INHERITED或者同义词NULL。 默认是DEBUG。

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">

    <!-- define动态获取LOG_HOME, TAS为${TAS_HOME}/logs, tomcat为${CATALINA_HOME}/logs, springboot为相对于jar路径的logs目录, 如需其他路径可自行配置property-->
    <!--<property name="LOG_HOME" value="/opt/thunisoft/logs"/>-->
    <define name="LOG_HOME" class="com.thunisoft.logback.LogbackHomeGetProperty" />
    <define name="IP" class="com.thunisoft.logback.LogbackIpGetProperty" />
    <define name="PORT" class="com.thunisoft.logback.LogbackPortGetProperty" />
<!--    将状态信息监听器设置为无操作监听器-->
    <statusListener class="ch.qos.logback.core.status.NopStatusListener" />

    <property name="APP_NAME" value="HomeworkFE5"/>

    <!-- 控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <Target>System.out</Target>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss:SSS , GMT+8} %m [%c:%L]-[%p] %n</pattern>
        </encoder>
    </appender>
    <!-- 正常日志输出文件 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!--        被写入的文件名，可以是相对目录，也可以是绝对目录，如果上级目录不存在会自动创建，没有默认值-->
        <File>${LOG_HOME}/${APP_NAME}_stdout.log</File>
<!--        用来设置日志的滚动策略,这里设置按照时间来滚动-->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--            日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/${APP_NAME}_stdout.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--            日志文件保留天数-->
            <maxHistory>20</maxHistory>
        </rollingPolicy>
<!--        用来设置日志的输入格式，使用“%”加“转换符”方式-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度，%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%-5level] [%-5thread] %logger{20} - %msg%n</pattern>
        </encoder>
    </appender>
    <!-- 错误日志输出文件 -->
    <appender name="FILE-ERROR"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
<!--        临界值过滤器，过滤掉低于指定临界值的日志。当日志级别等于或高于临界值时，过滤器返回NEUTRAL；当日志级别低于临界值时，日志会被拒绝。这里过滤掉所有低于error级别的日志-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>error</level>
        </filter>
        <File>${LOG_HOME}/${APP_NAME}_stderr.log</File>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/${APP_NAME}_stderr.%d{yyyy-MM-dd}.log</FileNamePattern>
            <!--日志文件保留天数-->
            <maxHistory>20</maxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%-5level] [%-5thread] %logger{20} - %msg%n</pattern>
        </encoder>
    </appender>
    <!-- 默认jdbc日志输出文件 -->
    <appender name="FILE-JDBC"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>${LOG_HOME}/${APP_NAME}_jdbc.log</File>
        <!-- 集群部署日志名建议加上ip和port -->
        <!--<File>${LOG_HOME}/${APP_NAME}_jdbc_${IP}_${PORT}.log</File>-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%-5level] [%-5thread] %logger{20} - %msg%n</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <append>true</append>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/${APP_NAME}_jdbc.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!--<fileNamePattern>${LOG_HOME}/${APP_NAME}_jdbc.%d{yyyy-MM-dd}_${IP}_${PORT}.log</fileNamePattern>-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
    </appender>
    <logger name="com.thunisoft" additivity="false">
        <level value="info" />
        <appender-ref ref="FILE" />                         //引用上面的appender
        <appender-ref ref="FILE-ERROR" />
    </logger>
    <logger name="jdbc.sqltiming" additivity="false">
        <appender-ref ref="FILE-JDBC" />
        <level value="debug" />
    </logger>
    <root>
        <level value="info" />
        <appender-ref ref="stdout" />
        <appender-ref ref="FILE" />
        <appender-ref ref="FILE-ERROR" />
    </root>
</configuration>

Apache commons常用工具类

ObjectUtils

ObjectUtils工具类会优雅的处理null输入，对于空输入通常不会抛出异常，每个方法都更详细的记录其行为。

//如果一个类没有重写toString方法本身，将会通过Object类的toString方法获取对象的字符串对象
String s1 = ObjectUtils.identityToString(null);
String s2 = ObjectUtils.identityToString("");
String s3 = ObjectUtils.identityToString(Boolean.TRUE);
System.out.println(s1);                                 //null
System.out.println(s2);                                 //java.lang.String@3d646c37
System.out.println(s3);                                 //java.lang.Boolean@41cf53f9

public static int compare(T c1, T c2)

int result = ObjectUtils.compare(12,12);
System.out.println(result);                             //0，表示相等
int result2 = ObjectUtils.compare(12,13);
System.out.println(result2);                            //-1，后面那个数大
int result3 = ObjectUtils.compare(12,null);             
System.out.println(result3);                            //1，前面那个数大

public static T firstNonNull(T… values)

String result = ObjectUtils.firstNonNull(null,null);
System.out.println(result);                              //null
String result1 = ObjectUtils.firstNonNull(null,"");
System.out.println(result1);                             //""
String result2 = ObjectUtils.firstNonNull(null,"baojianjia");
System.out.println(result2);                             //baojianjia
String result3 = ObjectUtils.firstNonNull();  
System.out.println(result3);                             //null

ArrayUtils

导包：

import org.apache.commons.lang3.ArrayUtils;

• 提供了八种基本数据类型和包装类以及各种类型的长度为0的空数组。所以以后需要长度为0的数组，可以不用new了，直接用以下代码

final int[] EMPTY_INT_ARRAY = new int[0];
final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];

• toString：将一个数组转换成String,用于打印数组

 int[] arr = { 1, 2, 3, 4, 5 };
 String arrString = Arrays.toString(arr);
 System.out.println(arr);          //输出为内存地址:[I@31221be2
 System.out.println(arrString );   //[1, 2, 3, 4, 5]

 int[] arr= { 1, 2, 3, 4, 5 };
 ArrayUtils.reverse(arr);		   //逆向输出一个数组
 System.out.println(Arrays.toString(arr)); //[5, 4, 3, 2, 1]

• hashCode：相同个数、相同顺序的数组hashCode会是一样的

public static void main(String[] args) {
    Integer[] inArr = new Integer[]{1, 2, 3};
    Integer[] inArr2 = new Integer[]{1, 2, 3};
    System.out.println(ArrayUtils.hashCode(inArr));  //862547
    System.out.println(ArrayUtils.hashCode(inArr2)); //862547

    inArr = new Integer[]{1, 2, 3};
    inArr2 = new Integer[]{1, 3, 3};
    System.out.println(ArrayUtils.hashCode(inArr));  //862547
    System.out.println(ArrayUtils.hashCode(inArr2)); //862584

• isEquals：该方法已经被废弃。取代的为java自己的java.util.Objects.deepEquals(Object, Object)

Integer[] inArr = new Integer[]{1, 2, 3};
Integer[] inArr2 = new Integer[]{1, 2, 3};
System.out.println(Objects.deepEquals(inArr, inArr2));  //true

inArr = new Integer[]{1, 2, 3};
inArr2 = new Integer[]{1, 3, 3};
System.out.println(Objects.deepEquals(inArr, inArr2));  //false

• toArray：可以简便的构建一个数组。

Integer[] integers = ArrayUtils.toArray(1, 2, 3);
Serializable[] serializables = ArrayUtils.toArray(1, 2, "3");

• nullToEmpty：将null转换为空的数组,如果数组不为null,返回原数组,如果数组为null,返回一个空的数组

• toObject/toPrimitive：可以实现int[]和Integer[]数组之间的互转

  Integer[] inArr = new Integer[]{1, 2, 3};
  int[] ints = ArrayUtils.toPrimitive(inArr);
  Integer[] integers = ArrayUtils.toObject(ints);
  

ClassPathUtils

处理类路径的一些工具类

1.toFullyQualifiedName(Class<?> context, String resourceName)

String str= ClassPathUtils.toFullyQualifiedName(test.class, "bjj"); 
// 返回一个由class包名+resourceName拼接的字符串
System.out.println(str);                             //com.huayu.test.bjj     

2.toFullyQualifiedName(Package context, String resourceName)

String str= ClassPathUtils.toFullyQualifiedName(test.class.getPackage(), "bjj");
//返回一个由class包名+resourceName拼接的字符串
System.out.println(str);							 //com.huayu.test.bjj

3.toFullyQualifiedPath(Class<?> context, String resourceName)

String str= ClassPathUtils.toFullyQualifiedPath(test.class, "bjj");
//返回一个由class包名+resourceName拼接的字符串
System.out.println(str);							 //com/huayu/test/bjj

4.toFullyQualifiedPath(Package context, String resourceName)

String str= ClassPathUtils.toFullyQualifiedPath(test.class, "bjj");
//返回一个由class包名+resourceName拼接的字符串
System.out.println(str);                             //com/huayu/test/bjj

ClassUtils

用于对Java类的操作

 System.out.println(ClassUtils.getPackageName(test.class));    //com.huayu.test,获取包名
 System.out.println(ClassUtils.getShortClassName(test.class)); //test,获取类名
 List<Class<?>> allSuperclasses = ClassUtils.getAllSuperclasses(ArrayList.class); //获取到该类的所有父类
 System.out.println(ArrayUtils.toString(allSuperclasses));                                            //[class java.util.AbstractList, class java.util.AbstractCollection, class java.lang.Object]

 System.out.println(ClassUtils.isPrimitiveOrWrapper(Object.class));    //false
 System.out.println(ClassUtils.isPrimitiveOrWrapper(Integer.class));   //true
 System.out.println(ClassUtils.isPrimitiveOrWrapper(int.class));       //true

 System.out.println(ClassUtils.isPrimitiveWrapper(Object.class));     //false,检测是否为包装类
 System.out.println(ClassUtils.isPrimitiveWrapper(Integer.class));    //true
 System.out.println(ClassUtils.isPrimitiveWrapper(int.class));        //false

 System.out.println(Object.class.isPrimitive());                  //false检测是否为基本类型
 System.out.println(Integer.class.isPrimitive());                 //false 
 System.out.println(int.class.isPrimitive());                     //true

StringUtils

StringUtils 方法是 null 安全的(即如果输入参数 String 为 null 则不会抛出 NullPointerException ，而是做了相应处理。

1. public static boolean isEmpty(String str)

   判断某字符串是否为空，为空的标准是 str==null或str.length()==0

   System.out.println(StringUtils.isEmpty(null));             //true
   System.out.println(StringUtils.isEmpty(""));               //true
   System.out.println(StringUtils.isEmpty(" "));              //false,在 StringUtils 中空格作非空处理
   System.out.println(StringUtils.isEmpty("   "));            //false
   System.out.println(StringUtils.isEmpty("bjj"));            //false
   System.out.println(StringUtils.isEmpty(" bjj "));          //false
   

2. public static boolean isBlank(String str)

   判断某字符串是否为空或长度为0或由空白符(whitespace) 构成

   System.out.println(StringUtils.isBlank(null));           //true
   System.out.println(StringUtils.isBlank(""));             //true
   System.out.println(StringUtils.isBlank(" "));            //true
   System.out.println(StringUtils.isBlank("\t \n \f \r"));  //true,对于制表符、换行符、换页符和回车符
   StringUtils.isBlank("bjj");						   //false
   StringUtils.isBlank(" bjj ");                            //false
   

3. public static int ordinalIndexOf(String str, String searchStr, int ordinal)

   返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置, 如果 str=null 或 searchStr=null 或 ordinal<=0 则返回-1

System.out.println(StringUtils.ordinalIndexOf("baojianjia","jian",1));   //3
System.out.println(StringUtils.ordinalIndexOf("baojianjia","ji",2));     //7
System.out.println(StringUtils.ordinalIndexOf("baojianjia","jian1",1));  //-1
System.out.println(StringUtils.ordinalIndexOf("baojianjia","",1));       //0
System.out.println(StringUtils.ordinalIndexOf("baojianjia","  ",1));     //-1

4. public static int indexOf(String str, String searchStr, int startPos)

   返回字符串 searchStr 从 startPos 开始在字符串 str 中第一次出现的位置。

   System.out.println(StringUtils.indexOf("baojianjia","ji",0));     //3
   

EnumUtils

用于读取枚举中的code和value值

枚举介绍

平时我们在定义周一到周日的常量时，会使用所谓的int枚举模式，代码如下:

public class DayDemo {
        public static final int MONDAY =1;
        public static final int TUESDAY=2;
        public static final int WEDNESDAY=3;
        public static final int THURSDAY=4;
        public static final int FRIDAY=5;
        public static final int SATURDAY=6;
        public static final int SUNDAY=7;
    }

存在的问题就是如果需要定义的常量比较多，那么定义的int值容易雷同，更容易记混淆。因而提倡使用枚举类型，代码如下:

public enum Day {                                             //定义一个枚举类
    MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SARURDAY,SUNDAY  //
}

public class test {                                           //直接引用枚举类
    public static void main(String[] args) {
        Day day=Day.MONDAY;
        System.out.println(day);
    }
    }

使用关键字enum定义的枚举类型，在编译期后，将会被转换成为一个实实在在的类，而在该类中，会存在每个在枚举类型中定义好常量的对应实例对象，如上述的MONDAY枚举类型对应public static final Day MONDAY;

public class test {
    public static void main(String[] args) {
        Day[] days=new Day[]{Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY,
                Day.THURSDAY, Day.FRIDAY, Day.SATURDAY, Day.SUNDAY};
        for (int i = 0; i <days.length ; i++) {
            System.out.println("day["+i+"].ordinal():"+days[i].ordinal());   
            //获取的是枚举变量在枚举类中声明的顺序
        }

        System.out.println("-------------------------------------");
        //通过compareTo方法比较,实际上其内部是通过ordinal()值比较的
        System.out.println("days[0].compareTo(days[1]):"+days[0].compareTo(days[1]));
        System.out.println("days[0].compareTo(days[1]):"+days[0].compareTo(days[2]));

        //获取该枚举对象的Class对象引用,当然也可以通过getClass方法
        Class<?> clazz = days[0].getDeclaringClass();
        System.out.println("clazz:"+clazz);

        System.out.println("-------------------------------------");

        //name()
        System.out.println("days[0].name():"+days[0].name());
        System.out.println("days[1].name():"+days[1].name());

        System.out.println("-------------------------------------");

        System.out.println("days[0].toString():"+days[0].toString());
        System.out.println("days[1].toString():"+days[1].toString());

        System.out.println("-------------------------------------");

        Day d=Enum.valueOf(Day.class,days[0].name());
        Day d2=Day.valueOf(Day.class,days[0].name());
        System.out.println("d:"+d);
        System.out.println("d2:"+d2);
    }
    }

相关方法

getEnum(Class enumClass, String enumName) 通过类返回一个枚举，可能返回空
getEnumList(Class enumClass) 通过类返回一个枚举集合
getEnumMap(Class enumClass) 通过类返回一个枚举map
isValidEnum(Class enumClass, String enumName) 验证enumName是否在枚举中，返回true false

public static void main(String[] args) {
    Day[] days=new Day[]{Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY,
            Day.THURSDAY, Day.FRIDAY, Day.SATURDAY, Day.SUNDAY};
    Day day=EnumUtils.getEnum(Day.class,"MONDAY");   //通过类返回一个枚举，可能返回空
    System.out.println("day="+day);

    List<Day> dayList=EnumUtils.getEnumList(Day.class);           //通过类返回一个枚举集合
    dayList.stream().forEach(
            day1 -> System.out.println("day1 = "+day1)
    );
    Map<String,Day>dayMap=EnumUtils.getEnumMap(Day.class);        //通过类返回一个枚举map
    dayMap.forEach((k, v) -> System.out.println("key：" + k + ",value：" + v));

    boolean result = EnumUtils.isValidEnum(Day.class, "MONDAY"); //验证enumName是否在枚举中，返回true false
    System.out.println("result = " + result);
    boolean result1 = EnumUtils.isValidEnum(Day.class, null);
    System.out.println("result1 = " + result1);

}

加密Base64

在开发中总会遇到加密的情况，比如登录的用户名和密码会通过加密后存储到数据库中，其实就是将实际的用户名和密码通过另外一种算法进行编码，隐藏了真正的内容，还有就是文本存储到数据库中的时候文本内容太大，那么就可以对文本内容进行编码比如Base64后存储到数据库中。

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

• **基本：**输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。
• **URL：**输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。
• **MIME：**输出隐射到MIME友好格式。输出每行不超过76字符，并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

 public static void main(String[] args) {
            try {

                // 使用基本编码
       String base64encodedString = Base64.getEncoder().encodeToString("baojianjia".getBytes("utf-8"));
       System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);

                // 解码
       byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
       String decodeStr = new String(base64decodedBytes);

       System.out.println("原始字符串: " + new String(base64decodedBytes, "utf-8"));
       System.out.println("Base64解码后为:"+decodeStr);
       base64encodedString = Base64.getUrlEncoder().encodeToString("baojianjia".getBytes("utf-8"));
       System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);

       StringBuilder stringBuilder = new StringBuilder();

       for (int i = 0; i < 10; ++i) {
            stringBuilder.append(UUID.randomUUID().toString());
           }

       byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
       String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
       System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);
            }catch(UnsupportedEncodingException e){
                System.out.println("Error :" + e.getMessage());
            }
        }

输出结果：
Base64 编码字符串 (基本) :YmFvamlhbmppYQ==
原始字符串: baojianjia
Base64解码后为:baojianjia
Base64 编码字符串 (URL) :YmFvamlhbmppYQ==
Base64 编码字符串 (MIME) :ZTQyN2Q4NmYtMDlmMi00ZWU5LWFiMjMtNjY5OTA3ZmRjYzQ1ODcyYjljZmUtMGY3MC00OTMwLWI5
M2MtNzlhZWJjOGMzMzYwZWY4ODdhMTMtYjJlOS00OTYxLWFmOTQtOTk0NjMwNTQyM2EzMjEwYjU5
YjYtNTYxYS00MzE2LTlmNWUtMDdmMzgwOTg1YmFmN2ZiOWJlYmYtZmYzNS00MTRmLWI2NjEtNzdm
NTYzMDllMDBhZDdmN2E2NWUtZDQyNi00MWQ4LTk1NDgtOGUzNmM2OTU5Y2ZkMDA0MDc2MDMtZWE1
Ny00ZjkwLTk2MTAtM2JkMGExZDg3NTgyNjEyYTM4ZDMtM2U2NS00ZWZiLThlMDMtYjM4MWExN2M4
YjNmNmViNzE3MjgtMjMyNy00MTAxLTk2NmQtYWM5YjM0MzZhMjE0ZmY4MjQzYWQtZGE2NC00N2Yy
LWE4MTctNGZlZTU1MWIwNWNk

序号	方法名 & 描述
1	static Base64.Decoder getDecoder() 返回一个 Base64.Decoder ，解码使用基本型 base64 编码方案。
2	**static Base64.Encoder getEncoder() ** 返回一个 Base64.Encoder ，编码使用基本型 base64 编码方案。
3	static Base64.Decoder getMimeDecoder() 返回一个 Base64.Decoder ，解码使用 MIME 型 base64 编码方案。
4	**static Base64.Encoder getMimeEncoder() ** 返回一个 Base64.Encoder ，编码使用 MIME 型 base64 编码方案。
5	static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) 返回一个 Base64.Encoder ，编码使用 MIME 型 base64 编码方案，可以通过参数指定每行的长度及行的分隔符。
6	**static Base64.Decoder getUrlDecoder() ** 返回一个 Base64.Decoder ，解码使用 URL 和文件名安全型 base64 编码方案。
7	**static Base64.Encoder getUrlEncoder() ** 返回一个 Base64.Encoder ，编码使用 URL 和文件名安全型 base64 编码方案。

DigestUtils

DigestUtils是一个加密工具类。

String s = DigestUtils.md5Hex("baojianjia"); //使用Apache commons中已经封装好的工具类
System.out.println(s);                             //1f86333ee2f2c3c46b16a0e6af961f70

FileUtils

public static void main(String[] args) {
    File srcDir=new File("F:\\baojianjia");        //将F盘baojianjia目录下的文件拷贝到D盘baojj
    File destDir = new File("D:\\baojj");
    try {
        FileUtils.copyDirectory(srcDir,destDir);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 public static void main(String[] args) {
        File srcFile=new File("F:\\baojianjia\\包.txt");  //拷贝文件
        File destFIle = new File("D:\\baojj\\包.txt");
        try {
            FileUtils.copyFile(srcFile,destFIle);
        } catch (IOException e) {
            e.printStackTrace();
        }
   

//本方法是将目录baojianjia，整体拷贝到目录baojj中，即在目录baojianjia下面有个子目录baojj
         File srcDir = new File("F:\\baojianjia");
        File destDir = new File("D:\\baojj");
       try {
            FileUtils.copyDirectoryToDirectory(srcDir,destDir);
        } catch (IOException e) {
            e.printStackTrace();
        }

//将text.txt文件拷贝到objective目录下，文件名保持原来的
       File srcFile = new File("F:\\baojianjia\\包.txt");
       File file = new File("D:\\baojj");
       try {
            FileUtils.copyFileToDirectory();
        } catch (IOException e) {
            e.printStackTrace();
        }
 }

  public static void main(String[] args) {
        //清空目录baojianjia下的所有内容，但是不删除baojianjia目录
        File file = new File("F:\\baojianjia");
        try {
            FileUtils.cleanDirectory(new File("F:\\baojianjia"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 public static void main(String[] args) {
        //删除目录baojianjia以及子目录子文件,即F盘下没有了baojianjia目录
        File file = new File("F:\\baojianjia");
        try {
            FileUtils.deleteDirectory(file);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

      String context=FileUtils.readFileToString(new File("F:\\baojianjia\\jianjia.txt"),"UTF-8");
      System.out.println(context);     //读取文件
    }

 public static void main(String[] args)throws Exception {
      String context=FileUtils.readFileToString(new File("F:\\baojianjia\\jianjia.txt"),"UTF-8");
      System.out.println(context);         //读取文件
      byte [] dates =FileUtils.readFileToByteArray(new File("F:\\baojianjia\\jianjia.txt"));
      System.out.println(dates.length);    //字节数
        List<String> masg=FileUtils.readLines(new File("F:\\baojianjia\\jianjia.txt"),"UTF-8");
        for (String string : masg) {
            System.out.println(string);    //逐行读取
        }

        //写出文件
        FileUtils.write(new File("F:\\baojianjia\\jianjia.txt"), "学习是一件快乐的事情\n！","UTF-8");
        FileUtils.writeByteArrayToFile(new File("F:\\baojianjia\\jianjia.txt"),"学习是一件幸福的事情！\n".getBytes("UTF-8"),true);
        FileUtils.writeStringToFile(new File("F:\\baojianjia\\jianjia.txt"), "学习是一件伟大的事情！\n",true);

        //写出列表
        List<String> list=new ArrayList<String>();
        list.add("123");
        list.add("456");
        list.add("789");
        FileUtils.writeLines(new File("F:\\baojianjia\\jianjia.txt"), list,true);

baojianjia\jianjia.txt"),“UTF-8”);
System.out.println(context); //读取文件
byte [] dates =FileUtils.readFileToByteArray(new File(“F:\baojianjia\jianjia.txt”));
System.out.println(dates.length); //字节数
List masg=FileUtils.readLines(new File(“F:\baojianjia\jianjia.txt”),“UTF-8”);
for (String string : masg) {
System.out.println(string); //逐行读取
}

    //写出文件
    FileUtils.write(new File("F:\\baojianjia\\jianjia.txt"), "学习是一件快乐的事情\n！","UTF-8");
    FileUtils.writeByteArrayToFile(new File("F:\\baojianjia\\jianjia.txt"),"学习是一件幸福的事情！\n".getBytes("UTF-8"),true);
    FileUtils.writeStringToFile(new File("F:\\baojianjia\\jianjia.txt"), "学习是一件伟大的事情！\n",true);

    //写出列表
    List<String> list=new ArrayList<String>();
    list.add("123");
    list.add("456");
    list.add("789");
    FileUtils.writeLines(new File("F:\\baojianjia\\jianjia.txt"), list,true);