Java中常用的API

小鱼儿 2024-03-30 15:08 97阅读 0赞

#### 文章目录 ####

*  前言
 *  一、java.lang
 *   *  String
     *  StringBuilder
     *  Integer
     *  parseXXX
     *  Math
     *  Object
     *  System
     *  Throwable
     *  Thread
     *  Runnable/接口
     *  Class< T >
     *  reflect.Field
     *  reflect.Constructor < T >
     *  reflect.Method
     *  ClassLoader
 *  二、java.util
 *   *  Scanner
     *  Objects
     *  Date(瞬时)
     *  Calendar(日历)
     *  Random
     *  数据结构相关
 *  三、java.text
 *   *  DateFormat
     *  日期工具类
 *  四、java.io
 *   *  File
     *  FileFilter
     *  OutputStream
     *  FileOutputStream
     *  InputStream
     *  FileInputStream
     *  Reader
     *  FileReader
     *  Writer
     *  FileWriter
     *  BufferedOutputStream
     *  BufferedInputStream
     *  BufferedWriter
     *  BufferedReader
     *  OutputStreamWriter
     *  InputStreamReader
     *  ObjectOutputStream
     *  ObjectInputStream
     *  PrintStream
 *  五、java.net
 *   *  Socket
     *  ServerSocket
 *  六、java.sql
 *   *  DriverManager
     *  Connection/接口
     *  Statement/接口
     *  ResultSet/接口
     *  PreparedStatement/接口
 *  七、javax.sql
 *   *  DataSource/接口

--------------------

## 前言 ##

`java中有很多常用的API，它们提供了便捷的使用方法和工具类，让我们来看一看java中常用的API吧：`

String、StringBuffer、StringBuilder、Number、Radom、Math、System、包装类  
Arrays、Collections这些类有很多常用的API，还有日期时间的API，下面我将总结一些常用的API。  
可以参考下边的网站：  
[WiKi][]  
[MaTools][]

--------------------

## 一、java.lang ##

### String ###

**构造方法：**

*  `String()`：初始化新创建的String对象，以使其表示空字符序列。
 *  `String(char[] value)`：通过当前参数中的字符数组来构造新的String。
 *  `String(byte[] bytes)`：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。  
    双引号直接写的字符串在常量池当中，new的不在池当中。地址值不同.
 *  `String(byte[] bytes, int offset, int length)`：通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。//把字节数组的一部分转换为字符串。
 *  `String(char[] value, int offset, int count)`：分配一个新的 String，它包含取自字符数组参数一个子数组的字符。//把字符数组的一部分转换为字符串。  
    把字节/字符数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数 count:转换的字符个数

**判断功能的方法:**

*  `boolean equals(Objectan Object)`：将此字符串与指定对象进行比较。
 *  `boolean equalsIgnoreCase(String anotherString)`：将此字符串与指定对象进行比较，忽略大小写。  
    Object是”对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

**获取功能的方法:**

*  `int length()`：返回此字符串的长度。
 *  `String concat(String str)`：将指定的字符串连接到该字符串的末尾。
 *  `char charAt(int index)`：返回指定索引处的char值。
 *  `int indexOf(String str)`：返回指定子字符串第一次出现在该字符串内的索引。
 *  `String substring(int beginIndex)`：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
 *  `String substring(int beginIndex, int endIndex)`：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

**转换功能的方法:**

*  `char[] toCharArray()`：将此字符串转换为新的字符数组。
 *  `byte[] getBytes()`：使用平台的默认字符集将该String编码转换为新的字节数组。
 *  `String replaceAll(String regex, String replacement)`：成功则返回替换的字符串，失败则返回原始字符串。其中regex为匹配此字符串的正则表达式；replacement为用来替换每个匹配项的字符串。
 *  `String replace(CharSequence target, CharSequencere placement)`：将与target匹配的字符串使用replacement字符串替换。  
    CharSequence是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

**分割功能的方法:**

*  `String[] split(String regex)`：将此字符串按照给定的regex（规则）拆分为字符串数组。
 *  split方法的参数其实是一个“正则表达式”，如果按照英文句点“.”进行切分，必须写"."。

**将基本数据型态转换成String的static方法：**

*  `String.valueOf(boolean b)` : 将 boolean 变量 b 转换成字符串。
 *  `String.valueOf(char c)` : 将 char 变量 c 转换成字符串。
 *  `String.valueOf(char[] data)` : 将 char 数组 data 转换成字符串。
 *  `String.valueOf(char[] data, int offset, int count)` : 将 char 数组 data 中 由 data\[offset\] 开始取 count 个元素 转换成字符串。
 *  `String.valueOf(double d)` : 将 double 变量 d 转换成字符串。
 *  `String.valueOf(float f)` : 将 float 变量 f 转换成字符串。
 *  `String.valueOf(int i)` : 将 int 变量 i 转换成字符串。
 *  `String.valueOf(long l)` : 将 long 变量 l 转换成字符串。
 *  `String.valueOf(Object obj)` : 将 obj 对象转换成 字符串, 等于 obj.toString()。

**将String转换成基本数据型态的方法：**  
详情参考parseXxx系列方法。

### StringBuilder ###

> java.lang.StringBuilder字符串缓冲区 可变字符序列

**构造方法：**

*  `StringBuilder()`：构造一个空的StringBuilder容器。
 *  `StringBuilder(String str)`：构造一个StringBuilder容器，并将字符串添加进去。

**常用方法：**

*  `StringBuilder append(...)`：添加任意类型数据的字符串形式，并返回当前对象自身。  
    连锁编程：bu.append(“abc”).append(1).append(true).append(8.8).append(‘中’);
 *  `String toString()`：将当前StringBuilder对象转换为String对象。  
    StringBuilder和String可以相互转换：String->StringBuilder：StringBuilder//StringBuilder->String：toString

**1：JDK5.0后提供了StringBuilder，等价StringBuffer 。  
2：区别：StringBuilder线程不安全，StringBuffer线程安全， StringBuilder类是单线程，不提供同步，理论上效率更高**

### Integer ###

> java.lang.Integer 装箱与拆箱（其他类型有类似方法）

**装箱(基本类型的数据->包装类)**

**构造方法：**

*  `Integer(int value)`：构造一个新分配的 Integer 对象，它表示指定的 int 值。（过时）
 *  `Integer(String s)`：构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。  
    （传递的字符串，必须是基本类型的字符串，否则会抛出异常 “100” 正确 “a” 抛异常）

**静态方法:**

*  `static Integer valueOf(int i)`：返回一个表示指定的 int 值的 Integer 实例。
 *  `static Integer valueOf(String s)`：返回保存指定的 String 的值的 Integer 对象。

**进制转换静态方法：**

*  `static String toBinaryString(int i)`：返回数字i的二进制数字符串。
 *  `static String toOctalString(int i)`：返回数字i的八进制数字符串。
 *  `static String toHexString(int i)`：返回数字i的十六进制数字符串。
 *  `static int parseInt(String s)`： 将字符串参数s解析为带符号的十进制整数。
 *  `static int parseInt(String s, int radix)`： 将整数字符串s（radix用来指明s是几进制）转换成10进制的整数。

**拆箱：(包装类->基本类型的数据)**

**成员方法:**

*  `int intValue()`：以 int 类型返回该 Integer 的值。

### parseXXX ###

> 静态方法 基本类型与字符串之间的转换

**基本类型转换成字符串：**

*  基本类型直接与””相连接即可；如：34+“”
 *  `static String toString(int i)` 返回一个表示指定整数的 String 对象。  
    包装类的静态方法toString(参数),不是Object类的toString() 重载
 *  `static String valueOf(int i)` 返回 int 参数的字符串表示形式。  
    String类的静态方法valueOf(参数)

字符串转换成基本类型（Character除外）：

*  `static byte parseByte(String s)`：将字符串参数转换为对应的byte基本类型。
 *  `static short parseShort(String s)`：将字符串参数转换为对应的short基本类型。
 *  `static int parseInt(String s)`：将字符串参数转换为对应的int基本类型。
 *  `static long parseLong(String s)`：将字符串参数转换为对应的long基本类型。
 *  `static float parseFloat(String s)`：将字符串参数转换为对应的float基本类型。
 *  `static double parseDouble(String s)`：将字符串参数转换为对应的double基本类型。
 *  `static boolean parseBoolean(String s)`：将字符串参数转换为对应的boolean基本类型。

### Math ###

> Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

**静态常量：**

*  `static final double PI = 3.141……`(精确到19位)
 *  `static double exp(double a)` :返回Euler的数字 e ，其值 double值。

**基本运算的方法:**

*  `static double abs(double a)`：返回double值的绝对值。
 *  `static double ceil(double a)`：向上取整，返回大于等于参数的最小的整数。
 *  `static double floor(double a)`：向下取整，返回小于等于参数最大的整数。
 *  `static long round(double a)`：返回最接近参数的long。(相当于四舍五入方法)
 *  `static int max(int a, int b)` ：返回a与b中较大值。
 *  `static int min(int a, int b)`：返回a与b中较小值。
 *  `static double cos(double a)`：返回角度的三角余弦值。
 *  `static double acos(double a)`：返回值的反余弦值; 返回的角度在0.0到pi的范围内。
 *  `static double expm1(double x)`：返回 e^x -1。
 *  `static double log(double a)`：返回 double值的自然对数（基数 e ）。
 *  `static double log10(double a)`：返回 double值的基数10对数。
 *  `static double pow(double a, doubl b)` ：a^b
 *  `static double sqrt(double a)` ：返回 double值的正确舍入正平方根。
 *  `static double toDegrees(double angrad)`：将以弧度测量的角度转换为以度为单位测量的近似等效角度。
 *  `static double toRadians(double angdeg)`：将以度为单位测量的角度转换为以弧度为单位测量的近似等效角度。

### Object ###

> public class Object  
> Class Object是类Object结构的根。 每个班都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。

*  `String toString()`：返回该对象的字符串表示。
 *  `boolean equals(Object obj)`：指示其他某个对象是否与此对象“相等”。
 *  `int hasCode()`：返回该对象的哈希码值。  
    HashSet集合存放自定义类型元素时，需要重写对象中的hashCode和equals方法
 *  `void wait()`：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
 *  `void wait(long timeout)`：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
 *  `void wait(long timeout, int nanos)`：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。
 *  `void notify()`：唤醒在此对象监视器上等待的单个线程。
 *  `void notifyAll()`：唤醒在此对象监视器上等待的所有线程。
 *  `Class<?> getClass()`：返回此 Object 的运行时类。
 *  `protected Object clone()`：创建并返回此对象的一个副本。
 *  `protected void finalize()`：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

### System ###

> System类包含几个有用的类字段和方法。 它不能被实例化。  
> System类提供的System包括标准输入，标准输出和错误输出流; 访问外部定义的属性和环境变量; 一种加载文件和库的方法; 以及用于快速复制阵列的一部分的实用方法。

**静态字段：**

*  `static PrintStream err`：“标准”错误输出流。
 *  `static InputStream in`：“标准”输入流。
 *  `static PrintStream out`：“标准”输出流。

**常用方法：**

*  `static long currentTimeMillis()`：返回以毫秒为单位的当前时间。//获取毫秒值形式的当前时间。

> 常用于测试程序效率

*  `static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)`：将数组中指定的数据拷贝到另一个数组中。

> src Object:源数组（原来的数组）。src Posint:源数组索引起始位置。dest Object:目标数组。dest Posint:目标数组索引起始位置。length int:复制元素个数。

*  `static void setErr(PrintStream err)`：重新分配“标准”错误输出流。
 *  `static void setIn(InputStream in)`：重新分配“标准”输入流。
 *  `static void setOut(PrintStream out)`：重新分配“标准”输出流。

### Throwable ###

> Throwable类是Java语言中所有错误和异常的Throwable类。 只有作为此类（或其一个子类）的实例的对象由Java虚拟机抛出，或者可以由Java throw语句抛出。 类似地，只有这个类或其子类可以是catch子句中的参数类型。 对于异常，编译时检查的目的Throwable和任何子类Throwable ，是不是也无论是子类RuntimeException或Error被视为检查的异常。

**常用方法：**

*  `void printStackTrace()`：打印异常的详细信息。包含了异常的类型，原因，出现的位置,在开发和调试阶段,都得使用printStackTrace。
 *  `String getMessage()`：获取发生异常的原因。提示给用户的时候，就提示错误原因。
 *  `String toString()`: 获取异常的类型和异常描述信息(不用)。

### Thread ###

线程是程序中执行的线程。 Java虚拟机允许应用程序同时执行多个执行线程。

每个线程都有优先权。 具有较高优先级的线程优先于优先级较低的线程执行。每个线程可能也可能不会被标记为守护程序。 当在某个线程中运行的代码创建一个新的Thread对象时，新线程的优先级最初设置为等于创建线程的优先级，并且当且仅当创建线程是守护进程时才是守护线程。

当Java虚拟机启动时，通常有一个非守护进程线程（通常调用某些指定类的名为main的方法）。 Java虚拟机将继续执行线程，直到发生以下任一情况：

*  已经调用了Runtime类的exit方法，并且安全管理器已经允许进行退出操作。
 *  所有不是守护进程线程的线程都已经死亡，无论是从调用返回到run方法还是抛出超出run方法的run 。

**构造方法：**

*  `Thread()`：分配一个新的线程对象。
 *  `Thread(String name)`：分配一个指定名字的新的线程对象。//thread
 *  `Thread(Runnable target)`：配一个带有指定目标新的线程对象。
 *  `Thread(Runnable target, String name)`：分配一个带有指定目标新的线程对象并指定名字。

**常用方法：**

*  `String getName()`：获取当前线程名称。
 *  `void setName(String name)`：改变线程名称，使之与参数name相同。//main
 *  `void start()`：导致此线程开始执行；Java虚拟机调用此线程的run方法。
 *  `void run()`：此线程要执行的任务在此处定义代码。

**静态方法：**

*  `static void sleep(long millis)`：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
 *  `static Thread currentThread()`：返回对当前正在执行的线程对象的引用。

### Runnable/接口 ###

> 接口 java.lang.Runnable  
> Runnable接口应由任何类实现，其实例将由线程执行。 该类必须定义一个无参数的方法，称为run 。

*  `abstract void run()`：run方法的定义。（只有这一个方法）

### Class< T > ###

> java.lang.Class< T >

**获取Class对象的方式：**

*  方法一：使用 Class.forName 静态方法。当你知道该类的全路径名时，你可以使用该方法获取 Class 类对象。但可能抛出 ClassNotFoundException 异常  
    Class<?> classBook = Class.forName(“com.fanshe.Book”);
 *  方法二：这种方法只适合在编译前就知道操作的 Class。直接通过 类名.class 的方式得到，该方法最为安全可靠，程序性能更高，这说明任何一个类都有一个隐含的静态成员变量 class  
    Class clz = Book.class;
 *  方法三：使用类对象的 getClass() 方法。  
    Book book1 = new Book();  
    Class<? extends Book> book1Class = book1.getClass();

**获取成员变量们：**

*  `Field[] getFields()`：获取所有public修饰的成员变量。
 *  `Field getField(String name)`：获取指定名称的 public修饰的成员变量。
 *  `Field[] getDeclaredFields()`：获取所有的成员变量，不考虑修饰符。
 *  `Field getDeclaredField(String name)`：获取指定名称的成员变量。

**获取构造方法们：**

*  `Constructor<?>[] getConstructors()`：获取所有public修饰的构造方法。
 *  `Constructor<T> getConstructor(类<?>... parameterTypes)`：获取指定名称的 public修饰的构造方法。
 *  `Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)`：获取所有的构造方法，不考虑修饰符。
 *  `Constructor<?>[] getDeclaredConstructors()`：获取指定名称的构造方法。

**获取成员方法们：**

*  `Method[] getMethods()`：获取所有public修饰的成员方法。
 *  `Method getMethod(String name, 类<?>... parameterTypes)`：获取指定名称的 public修饰的成员方法。
 *  `Method[] getDeclaredMethods()`：获取所有的成员方法，不考虑修饰符。
 *  `Method getDeclaredMethod(String name, 类<?>... parameterTypes)`：获取指定名称的成员方法。

**获取全类名:**

*  `String getName()`：返回此类对象表示的实体名称（类，接口，数组类，基本类型或void），作为 String 。

### reflect.Field ###

> java.lang.reflect.Field

**常用方法：**

*  `void set(Object obj, Object value)`：将指定对象参数上此字段对象表示的字段设置为指定的新值。
 *  `Object get(Object obj)`：返回指定对象上此字段表示的字段的值。
 *  `void setAccessible(boolean flag)`：将此反射对象的accessible标志设置为指示的布尔值。 //忽略访问权限修饰符的安全检查，setAccessible(true):暴力反射。

### reflect.Constructor < T > ###

> Constructor提供了一个类的单个构造函数的信息和访问。  
> Constructor允许在将实际参数与newInstance（）与底层构造函数的形式参数进行匹配时进行扩展转换，但如果发生缩小转换，则抛出IllegalArgumentException 。

**常用方法：**

*  `T newInstance(Object... initargs)`：使用此构造器对象表示的构造方法，使用指定的初始化参数创建和初始化构造函数声明类的新实例。
 *  `void setAccessible(boolean flag)`：将此反射对象的accessible标志设置为指示的布尔值。

### reflect.Method ###

**常用方法：**

*  `Object invoke(Object obj, Object... args)`：在具有指定参数的指定对象上调用此方法对象表示的基础方法。
 *  `String getName()`：返回此方法对象表示的方法的名称，如 String。

### ClassLoader ###

> 抽象类 java.lang.ClassLoader类加载器  
> 类加载器是负责加载类的对象。 ClassLoader类是一个抽象类。 给定一个类的binary name ，类加载器应该尝试定位或生成构成类的定义的数据。 典型的策略是将名称转换为文件名，然后从文件系统中读取该名称的“类文件”。  
> 每个类对象包含reference来定义它的ClassLoader。  
> 类数组类的对象不是由类加载器创建的，而是按照Java运行时的要求自动创建的。 Class.getClassLoader()返回的数组类的类加载器与其元素类型的类加载器相同; 如果元素类型是原始类型，则数组类没有类加载器。  
> 应用程序实现ClassLoader的子类 ，以扩展Java虚拟机动态加载类的方式。

**构造方法：**

*  `protected ClassLoader()`：创建使用一个新的类加载器 ClassLoader该方法返回 getSystemClassLoader()作为父类加载器。
 *  `protected ClassLoader(ClassLoader parent)`：使用指定的父类加载器创建新的类加载器以进行委派。
 *  `protected ClassLoader(String name, ClassLoader parent)`：创建具有指定名称的新类加载器，并使用指定的父类加载器进行委派。

**成员方法：**

*  `InputStream getResourceAsStream(String name)`：返回用于读取指定资源的输入流。
 *  `URL getResource(String name)`：查找具有给定名称的资源。
 *  `Enumeration< URL > getResources(String name)`：查找具有给定名称的所有资源。
 *  `String getName()`：如果未指定此类加载器，则返回此类加载器的名称或 null 。
 *  `protected Object getClassLoadingLock(String className)`：返回类加载操作的锁定对象。
 *  `protected String findLibrary(String libname)`：返回本机库的绝对路径名
 *  `protected 类<?> findClass(String name)`：查找具有指定的类 binary name 。

## 二、java.util ##

### Scanner ###

> 一个简单的文本扫描器，可以使用正则表达式解析原始类型和字符串。  
> A Scanner分隔符模式将输入打破到令牌，默认情况下匹配空格。 然后可以使用各种next方法将得到的令牌转换成不同类型的值。

**构造方法：**

*  `Scanner(InputStream source)`：构造一个新的Scanner，它生成的值是从指定的输入流扫描的。

**查看成员方法：**

*  `int nextInt()`：将输入信息的下一个标记扫描为一个int值。
 *  `String next()`：获取键盘输入的一个字符串。

### Objects ###

*  `static boolean equals(Object a, Object b)`：判断两个对象是否相等。
 *  `static < T > T requireNonNull(T obj)`：查看指定引用对象obj不是null。

### Date(瞬时) ###

> 表示特定的瞬间

**构造函数：**

*  `Date()`：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。//获取英文格式(Date日期)的当前时间。
 *  `Date(long date)`：分配Date对象并初始化此对象，以表示自从标准基准时间（1970年1月1日00:00:00 GMT）以来的指定毫秒数。//毫秒值->Date日期

**常用方法：**

*  `long getTime()`：把日期对象转换成对应的时间毫秒值。//Date日期->毫秒值
 *  `boolean after(Date when)`测试此日期是否在指定日期之后。
 *  `boolean before(Date when)`测试此日期是否在指定日期之前。
 *  `Instant toInstant()`将此 Date对象转换为 Instant 。

### Calendar(日历) ###

> 所述Calendar类是一个抽象类，可以为在某一特定时刻和一组之间的转换的方法calendar fields如YEAR ， MONTH ， DAY\_OF\_MONTH ， HOUR ，等等，以及用于操纵该日历字段，如获取的日期下个星期。 时间上的瞬间可以用毫秒值表示，该值是从1970年1月1日00:00 00：00.000 GMT（Gregorian）的Epoch的偏移量。  
> 该类还提供了用于在包外部实现具体日历系统的其他字段和方法。 这些字段和方法定义为protected 。

**Calendar静态方法：**

*  `static Calendar getInstance()`：使用默认时区和语言环境获得一个日历。（获取日历格式的当前时间。）

**常用方法：**

*  `int get(int field)`：返回给定日历字段的值。
 *  `void set(int field, int value)`：将给定的日历字段设置为给定值。
 *  `void set(int year, int month, int date)` 设置日历字段的值 YEAR ， MONTH和 DAY\_OF\_MONTH。
 *  `abstract void add(int field, int amount)`：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
 *  `Date getTime()`：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。//日历->Date日期

### Random ###

**构造方法：**

*  `Random()`：创建一个新的随机数生成器。
 *  `Random(long seed)`：使用单个long种子创建一个新的随机数生成器。

**成员方法：**

*  `int nextInt()`：返回下一个伪随机数，从该随机数生成器的序列中均匀分布 int值。
 *  `int nextInt(int n)`：返回一个伪随机数，范围在0（包括）和指定值n（不包括）之间的int值。

### 数据结构相关 ###

> 接口 java.util.Collection

会单独写一篇关于Collection的文章

## 三、java.text ##

### DateFormat ###

> 抽象 需要常用的子类java.text.SimpleDateFormat

**实现类的构造方法：**

*  `SimpleDateFormat(String pattern)`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。//获取字符串格式的当前时间。

**常用方法：**

*  `String format(Date date)`：将Date对象格式化为字符串。//Date日期->字符串
 *  `Date parse(String source)`：将字符串解析为Date对象（毫秒数）。//字符串->Date日期 //parse方法声明了一个异常叫ParseException

### 日期工具类 ###

/**
     * 日期时间工具类
     *
     * @author JourWon
     * @date 2020/12/5
     */
    public class DateUtils {
        
    
        /**
         * 显示年月日时分秒，例如 2015-08-11 09:51:53.
         */
        public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
    
        /**
         * 显示年月日时分，例如 2015-08-11 09:51.
         */
        public static final String NO_SECOND_DATETIME_PATTERN = "yyyy-MM-dd HH:mm";
    
        /**
         * 仅显示年月日，例如 2015-08-11.
         */
        public static final String DATE_PATTERN = "yyyy-MM-dd";
    
        /**
         * 仅显示时分秒，例如 09:51:53.
         */
        public static final String TIME_PATTERN = "HH:mm:ss";
    
        /**
         * 显示年月日时分秒(由/分割)，例如 2015/08/11 09:51:53.
         */
        public static final String DATETIME_PATTERN_WITH_SLASH = "yyyy/MM/dd HH:mm:ss";
    
        /**
         * 显示年月日(由/分割)，例如 2015/08/11.
         */
        public static final String DATE_PATTERN_WITH_SLASH = "yyyy/MM/dd";
    
        /**
         * 显示年月日时分秒(无符号)，例如 20150811095153.
         */
        public static final String UNSIGNED_DATETIME_PATTERN = "yyyyMMddHHmmss";
    
        /**
         * 仅显示年月日(无符号)，例如 20150811.
         */
        public static final String UNSIGNED_DATE_PATTERN = "yyyyMMdd";
    
        /**
         * 仅显示年(无符号)，例如 2015.
         */
        private static final String YEAR_PATTERN = "yyyy";
    
        /**
         * 仅显示年月，例如 2015-08.
         */
        private static final String MONTH_PATTERN = "yyyy-MM";
    
        /**
         * 仅显示年月(无符号)，例如 201508.
         */
        private static final String UNSIGNED_MONTH_PATTERN = "yyyyMM";
    
        /**
         * 一天的开始时间，仅显示时分秒
         */
        private static final String START_TIME = "00:00:00";
    
        /**
         * 一天的结束时间，仅显示时分秒
         */
        private static final String END_TIME = "23:59:59";
    
        /**
         * 每天的毫秒数.
         */
        public static final long MILLISECONDS_PER_DAY = 86400000L;
    
        /**
         * 每小时毫秒数.
         */
        public static final long MILLISECONDS_PER_HOUR = 3600000L;
    
        /**
         * 每分钟毫秒数.
         */
        public static final long MILLISECONDS_PER_MINU = 60000L;
    
        /**
         * 每秒的毫秒数.
         */
        public static final long MILLISECONDS_PER_SECONDS = 1000L;
    
        /**
         * 每分钟秒数.
         */
        public static final long SECONDS_PER_MINUTE = 60L;
    
        /**
         * 每小时秒数.
         */
        public static final long SECONDS_PER_HOUR = 3600L;
    
        /**
         * 每天秒数.
         */
        public static final long SECONDS_PER_DAY = 86400L;
    
        /**
         * 每周秒数.
         */
        public static final long SECONDS_PER_WEEK = 604800L;
    
        /**
         * 每个月秒数，默认每月30天.
         */
        public static final long SECONDS_PER_MONTH = 2592000L;
    
        /**
         * 每年秒数，默认每年365天.
         */
        public static final long SECONDS_PER_YEAR = 31536000L;
    
        /**
         * 每周的天数.
         */
        public static final long DAYS_PER_WEEK = 7L;
    
        /**
         * 春天;
         */
        public static final Integer SPRING = 1;
    
        /**
         * 夏天;
         */
        public static final Integer SUMMER = 2;
    
        /**
         * 秋天;
         */
        public static final Integer AUTUMN = 3;
    
        /**
         * 冬天;
         */
        public static final Integer WINTER = 4;
    
        /**
         * 星期日;
         */
        public static final String SUNDAY = "星期日";
    
        /**
         * 星期一;
         */
        public static final String MONDAY = "星期一";
    
        /**
         * 星期二;
         */
        public static final String TUESDAY = "星期二";
    
        /**
         * 星期三;
         */
        public static final String WEDNESDAY = "星期三";
    
        /**
         * 星期四;
         */
        public static final String THURSDAY = "星期四";
    
        /**
         * 星期五;
         */
        public static final String FRIDAY = "星期五";
    
        /**
         * 星期六;
         */
        public static final String SATURDAY = "星期六";
    
        /**
         * 获取当前日期和时间字符串.
         *
         * @return String 日期时间字符串，例如 2015-08-11 09:51:53
         */
        public static String getDateTimeStr() {
        
            return format(new Date(), DATETIME_PATTERN);
        }
    
        /**
         * 获取当前日期字符串.
         *
         * @return String 日期字符串，例如2015-08-11
         */
        public static String getDateStr() {
        
            return format(new Date(), DATE_PATTERN);
        }
    
        /**
         * 获取当前时间字符串.
         *
         * @return String 时间字符串，例如 09:51:53
         */
        public static String getTimeStr() {
        
            return format(new Date(), TIME_PATTERN);
        }
    
        /**
         * 获取当前年份字符串.
         *
         * @return String 当前年份字符串，例如 2015
         */
        public static String getYearStr() {
        
            return format(new Date(), YEAR_PATTERN);
        }
    
        /**
         * 获取当前月份字符串.
         *
         * @return String 当前月份字符串，例如 08
         */
        public static String getMonthStr() {
        
            return format(new Date(), "MM");
        }
    
        /**
         * 获取当前天数字符串.
         *
         * @return String 当前天数字符串，例如 11
         */
        public static String getDayStr() {
        
            return format(new Date(), "dd");
        }
    
        /**
         * 获取当前星期字符串.
         *
         * @return String 当前星期字符串，例如 星期二
         */
        public static String getDayOfWeekStr() {
        
            return format(new Date(), "E");
        }
    
        /**
         * 获取指定日期是星期几
         *
         * @param date 日期
         * @return String 星期几
         */
        public static String getDayOfWeekStr(Date date) {
        
            String[] weekOfDays = {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            int num = calendar.get(Calendar.DAY_OF_WEEK) - 1;
            return weekOfDays[num];
        }
    
        /**
         * 获取当前小时字符串.
         *
         * @return String 当前小时字符串，例如09
         */
        public static String getHourStr() {
        
            return format(new Date(), "HH");
        }
    
        /**
         * 获取当前分钟字符串.
         *
         * @return String 当前分钟字符串，例如51
         */
        public static String getMinuteStr() {
        
            return format(new Date(), "mm");
        }
    
        /**
         * 获取当前秒钟字符串.
         *
         * @return String 当前秒钟字符串，例如53
         */
        public static String getSecondStr() {
        
            return format(new Date(), "ss");
        }
    
        /**
         * 获取日期时间字符串
         *
         * @param date    需要转化的日期时间
         * @param pattern 时间格式
         * @return String 日期时间字符串，例如 2015-08-11 09:51:53
         */
        public static String format(Date date, String pattern) {
        
            return new SimpleDateFormat(pattern).format(date);
        }
    
        /**
         * 时间戳转换为日期时间字符串
         *
         * @param timestamp 时间戳
         * @param pattern   日期格式 例如DATETIME_PATTERN
         * @return String 日期时间字符串，例如 2015-08-11 09:51:53
         */
        public static String getDateTimeStr(long timestamp, String pattern) {
        
            return new SimpleDateFormat(pattern).format(timestamp);
        }
    
        /**
         * 日期字符串转换为日期(java.util.Date)
         *
         * @param dateStr 日期字符串
         * @param pattern 日期格式 例如DATETIME_PATTERN
         * @return Date 日期
         */
        public static Date parse(String dateStr, String pattern) {
        
            Date date = null;
            SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
            dateFormat.setLenient(false);
            try {
        
                date = dateFormat.parse(dateStr);
            } catch (ParseException e) {
        
                e.printStackTrace();
            }
            return date;
        }
    
        /**
         * 获取指定日期num年数之后的日期.
         *
         * @param num 间隔年数(负数表示之前)
         * @return Date 日期
         */
        public static Date addYears(Date date, int num) {
        
            return add(date, num, Calendar.YEAR);
        }
    
        /**
         * 获取当前日期指定年数之后的日期.
         *
         * @param num 间隔年数(负数表示之前)
         * @return Date 日期
         */
        public static Date addYears(int num) {
        
            return add(new Date(), num, Calendar.YEAR);
        }
    
        /**
         * 获取当前日期num月数之后的日期.
         *
         * @param num 间隔月数(负数表示之前)
         * @return Date 日期
         */
        public static Date addMonths(Date date, int num) {
        
            return add(date, num, Calendar.MONTH);
        }
    
        /**
         * 获取当前日期指定月数之后的日期.
         *
         * @param num 间隔月数(负数表示之前)
         * @return Date 日期
         */
        public static Date addMonths(int num) {
        
            return add(new Date(), num, Calendar.MONTH);
        }
    
        /**
         * 获取指定日期num周数之后的日期.
         *
         * @param date 日期
         * @param num  周数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addWeeks(Date date, int num) {
        
            return add(date, num, Calendar.WEEK_OF_YEAR);
        }
    
        /**
         * 获取当前日期指定周数之后的日期.
         *
         * @param num 周数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addWeeks(int num) {
        
            return add(new Date(), num, Calendar.WEEK_OF_YEAR);
        }
    
        /**
         * 获取指定日期num天数之后的日期.
         *
         * @param date 日期
         * @param num  天数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addDays(Date date, int num) {
        
            return add(date, num, Calendar.DAY_OF_MONTH);
        }
    
        /**
         * 获取当前日期指定天数之后的日期.
         *
         * @param num 天数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addDays(int num) {
        
            return add(new Date(), num, Calendar.DAY_OF_MONTH);
        }
    
        /**
         * 获取指定日期num小时之后的日期.
         *
         * @param date 日期
         * @param num  小时数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addHours(Date date, int num) {
        
            return add(date, num, Calendar.HOUR_OF_DAY);
        }
    
        /**
         * 获取当前日期指定小时之后的日期.
         *
         * @param num 小时数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addHours(int num) {
        
            return add(new Date(), num, Calendar.HOUR_OF_DAY);
        }
    
        /**
         * 获取指定日期num分钟之后的日期.
         *
         * @param date 日期
         * @param num  分钟数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addMinutes(Date date, int num) {
        
            return add(date, num, Calendar.MINUTE);
        }
    
        /**
         * 获取当前日期指定分钟之后的日期.
         *
         * @param num 分钟数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addMinutes(int num) {
        
            return add(new Date(), num, Calendar.MINUTE);
        }
    
        /**
         * 获取指定日期num秒钟之后的日期.
         *
         * @param date 日期
         * @param num  秒钟数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addSeconds(Date date, int num) {
        
            return add(date, num, Calendar.SECOND);
        }
    
        /**
         * 获取当前日期指定秒钟之后的日期.
         *
         * @param num 秒钟数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addSeconds(int num) {
        
            return add(new Date(), num, Calendar.SECOND);
        }
    
        /**
         * 获取指定日期num毫秒之后的日期.
         *
         * @param date 日期
         * @param num  毫秒数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addMilliSeconds(Date date, int num) {
        
            return add(date, num, Calendar.MILLISECOND);
        }
    
        /**
         * 获取当前日期指定毫秒之后的日期.
         *
         * @param num 毫秒数(负数表示之前)
         * @return Date 新的日期
         */
        public static Date addMilliSeconds(int num) {
        
            return add(new Date(), num, Calendar.MILLISECOND);
        }
    
        /**
         * 获取当前日期指定数量日期时间单位之后的日期.
         *
         * @param date 日期
         * @param num  数量
         * @param unit 日期时间单位
         * @return Date 新的日期
         */
        public static Date add(Date date, int num, int unit) {
        
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(unit, num);
            return calendar.getTime();
        }
    
        /**
         * 计算两个日期之间相隔年数.
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @return int 相隔年数，向下取整
         */
        public static int getYearsBetween(Date startDate, Date endDate) {
        
            return getMonthsBetween(startDate, endDate) / 12;
        }
    
        /**
         * 计算两个日期之间相隔月数.
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @return int 相隔月数，向下取整
         */
        public static int getMonthsBetween(Date startDate, Date endDate) {
        
            int months;
            int flag = 0;
    
            Calendar startCalendar = Calendar.getInstance();
            startCalendar.setTime(startDate);
            Calendar endCalendar = Calendar.getInstance();
            endCalendar.setTime(endDate);
    
            if (endCalendar.equals(startCalendar)) {
        
                return 0;
            }
    
            if (startCalendar.after(endCalendar)) {
        
                Calendar temp = startCalendar;
                startCalendar = endCalendar;
                endCalendar = temp;
            }
            if (endCalendar.get(Calendar.DAY_OF_MONTH) < startCalendar.get(Calendar.DAY_OF_MONTH)) {
        
                flag = 1;
            }
    
            if (endCalendar.get(Calendar.YEAR) > startCalendar.get(Calendar.YEAR)) {
        
                months = ((endCalendar.get(Calendar.YEAR) - startCalendar.get(Calendar.YEAR))
                        * 12 + endCalendar.get(Calendar.MONTH) - flag)
                        - startCalendar.get(Calendar.MONTH);
            } else {
        
                months = endCalendar.get(Calendar.MONTH)
                        - startCalendar.get(Calendar.MONTH) - flag;
            }
    
            return months;
        }
    
        /**
         * 计算两个日期之间相隔周数.
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @return long 相隔周数，向下取整
         */
        public static long getWeeksBetween(Date startDate, Date endDate) {
        
            return getDaysBetween(startDate, endDate) / DAYS_PER_WEEK;
        }
    
        /**
         * 计算两个日期之间相隔天数.
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @return long 相隔天数，向下取整
         */
        public static long getDaysBetween(Date startDate, Date endDate) {
        
            return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_DAY;
        }
    
        /**
         * 计算两个日期之间相隔小时数.
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @return long 相隔小时数，向下取整
         */
        public static long getHoursBetween(Date startDate, Date endDate) {
        
            return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_HOUR;
        }
    
        /**
         * 计算两个日期之间相隔分钟数.
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @return long 相隔分钟数，向下取整
         */
        public static long getMinutesBetween(Date startDate, Date endDate) {
        
            return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_MINU;
        }
    
        /**
         * 计算两个日期之间相隔秒数.
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @return long 相隔秒数，向下取整
         */
        public static long getSecondsBetween(Date startDate, Date endDate) {
        
            return (endDate.getTime() - startDate.getTime()) / MILLISECONDS_PER_SECONDS;
        }
    
        /**
         * 获取当前季度.
         * 注意:3～5月为春季 1，6～8月为夏季 2，9～11月为秋季 3，12～2月为冬季 4
         *
         * @return int 当前季度数
         */
        public static int getCurrentSeason() {
        
            Calendar calendar = Calendar.getInstance();
            int month = calendar.get(Calendar.MONTH) + 1;
            int season = 0;
            if (month >= 3 && month <= 5) {
        
                season = SPRING;
            } else if (month >= 6 && month <= 8) {
        
                season = SUMMER;
            } else if (month >= 9 && month <= 11) {
        
                season = AUTUMN;
            } else if (month == 12 || month >= 1 && month <= 2) {
        
                season = WINTER;
            }
            return season;
        }
    
        /**
         * 获取当前日期与之前日期的时间间隔.
         *
         * @param date 之前的日期
         * @return String 例如 16分钟前、2小时前、3天前、4月前、5年前等
         */
        public static String getIntervalByDate(Date date) {
        
            long secondsBetween = getSecondsBetween(date, new Date());
            return getIntervalBySeconds(secondsBetween);
        }
    
        /**
         * 将以秒为单位的时间转换为其他单位.
         *
         * @param seconds 秒数
         * @return String 例如 16分钟前、2小时前、3天前、4月前、5年前等
         */
        public static String getIntervalBySeconds(long seconds) {
        
            StringBuffer buffer = new StringBuffer();
            if (seconds < SECONDS_PER_MINUTE) {
        
                buffer.append(seconds).append("秒前");
            } else if (seconds < SECONDS_PER_HOUR) {
        
                buffer.append((long) Math.floor(seconds / SECONDS_PER_MINUTE)).append("分钟前");
            } else if (seconds < SECONDS_PER_DAY) {
        
                buffer.append((long) Math.floor(seconds / SECONDS_PER_HOUR)).append("小时前");
            } else if (seconds < SECONDS_PER_WEEK) {
        
                buffer.append((long) Math.floor(seconds / SECONDS_PER_DAY)).append("天前");
            } else if (seconds < SECONDS_PER_MONTH) {
        
                buffer.append((long) Math.floor(seconds / SECONDS_PER_WEEK)).append("周前");
            } else if (seconds < SECONDS_PER_YEAR) {
        
                buffer.append((long) Math.floor(seconds / SECONDS_PER_MONTH)).append("月前");
            } else {
        
                buffer.append((long) Math.floor(seconds / SECONDS_PER_YEAR)).append("年前");
            }
            return buffer.toString();
        }
    
        /**
         * 将 Date 日期转化为 Calendar 类型日期.
         *
         * @param date 指定日期
         * @return Calendar Calendar对象
         */
        public static Calendar getCalendar(Date date) {
        
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            return calendar;
        }
    
        /**
         * 得到UTC时间，类型为字符串，格式为"yyyy-MM-dd HH:mm"
         * 如果获取失败，返回null
         *
         * @return
         */
        public static String getUTCTimeStr() {
        
            StringBuffer UTCTimeBuffer = new StringBuffer();
            // 1、取得本地时间：
            Calendar cal = Calendar.getInstance();
            // 2、取得时间偏移量：
            int zoneOffset = cal.get(Calendar.ZONE_OFFSET);
            // 3、取得夏令时差：
            int dstOffset = cal.get(Calendar.DST_OFFSET);
            // 4、从本地时间里扣除这些差量，即可以取得UTC时间：
            cal.add(Calendar.MILLISECOND, -(zoneOffset + dstOffset));
            int year = cal.get(Calendar.YEAR);
            int month = cal.get(Calendar.MONTH) + 1;
            int day = cal.get(Calendar.DAY_OF_MONTH);
            int hour = cal.get(Calendar.HOUR_OF_DAY);
            int minute = cal.get(Calendar.MINUTE);
            UTCTimeBuffer.append(year).append("-").append(month).append("-").append(day);
            UTCTimeBuffer.append(" ").append(hour).append(":").append(minute);
            try {
        
                SimpleDateFormat sdf = new SimpleDateFormat(NO_SECOND_DATETIME_PATTERN);
                sdf.parse(UTCTimeBuffer.toString());
                return UTCTimeBuffer.toString();
            } catch (ParseException e) {
        
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 将Timestamp转换为yyyy-MM-dd HH:mm:ss格式字符串
         *
         * @param timestamp
         * @return
         */
        public static String timestampToStr(Timestamp timestamp) {
        
            return timestamp.toString().substring(0, 19);
        }
    
        /**
         * 比较传进来的日期是否大于当前日期，如果传进来的日期大于当前日期则返回true，否则返回false
         *
         * @param dateStr 日期字符串
         * @param pattern 日期格式
         * @return boolean
         */
        public static boolean compareNowDate(String dateStr, String pattern) {
        
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
            try {
        
                Date date = simpleDateFormat.parse(dateStr);
                return date.after(new Date());
            } catch (ParseException e) {
        
                e.printStackTrace();
            }
            return false;
        }
    
        /**
         * 如果endDateStr>startDateStr，返回true，否则返回false
         *
         * @param startDateStr 开始日期字符串
         * @param endDateStr   结束日期字符串
         * @param pattern      日期格式
         * @return boolean
         */
        public static boolean compareDate(String startDateStr, String endDateStr, String pattern) {
        
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
            try {
        
                Date startDate = simpleDateFormat.parse(startDateStr);
                Date endDate = simpleDateFormat.parse(endDateStr);
                return endDate.after(startDate);
            } catch (ParseException e) {
        
                e.printStackTrace();
            }
            return false;
        }
    
        /**
         * 如果startDate>endDate，返回true，否则返回false
         *
         * @param startDate 开始日期字符串
         * @param endDate   结束日期字符串
         * @return boolean
         */
        public static boolean compareDate(Date startDate, Date endDate) {
        
            return endDate.after(startDate);
        }
    
        /**
         * 判断日期是否合法
         *
         * @param dateStr yyyy-MM-dd HH:mm:ss格式日期字符串
         * @return
         */
        public static boolean isValidDate(String dateStr) {
        
            boolean convertSuccess = true;
            // 指定日期格式为四位年/两位月份/两位日期
            SimpleDateFormat format = new SimpleDateFormat(DATETIME_PATTERN);
            try {
        
                // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
                format.setLenient(false);
                format.parse(dateStr);
            } catch (ParseException e) {
        
                e.printStackTrace();
                // 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
                convertSuccess = false;
            }
            return convertSuccess;
        }
    
        /**
         * 判断日期是否为月底最后一天
         *
         * @param date 日期
         * @return boolean true:是  false:否
         */
        public static boolean isLastDayofMonth(Date date) {
        
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.set(Calendar.DATE, (calendar.get(Calendar.DATE) + 1));
            if (calendar.get(Calendar.DAY_OF_MONTH) == 1) {
        
                return true;
            }
            return false;
        }
    
        /**
         * 获取本年第一天的日期字符串
         *
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getYearStartTimeStr() {
        
            return getDateTimeStr(getStartDayOfYear(new Date()));
        }
    
        /**
         * 获取指定日期当年第一天的日期字符串
         *
         * @param date
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getYearStartTimeStr(Date date) {
        
            return getDateTimeStr(getStartDayOfYear(date));
        }
    
        /**
         * 获取本年最后一天的日期字符串
         *
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getYearEndTimeStr() {
        
            return getDateTimeStr(getEndDayOfYear(new Date()));
        }
    
        /**
         * 获取指定日期当年最后一天的日期字符串
         *
         * @param date 指定日期
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getYearEndTimeStr(Date date) {
        
            return getDateTimeStr(getEndDayOfYear(date));
        }
    
        /**
         * 获取本月第一天的日期字符串
         * 格式：yyyy-MM-dd HH:mm:ss
         *
         * @return
         */
        public static String getMonthStartTimeStr() {
        
            return getDateTimeStr(getStartDayOfMonth(new Date()));
        }
    
        /**
         * 获取指定日期当月第一天的日期字符串
         *
         * @param date 指定日期
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getMonthStartTimeStr(Date date) {
        
            return getDateTimeStr(getStartDayOfMonth(date));
        }
    
        /**
         * 获取本月最后一天的日期字符串
         *
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getMonthEndTimeStr() {
        
            return getDateTimeStr(getEndDayOfMonth(new Date()));
        }
    
        /**
         * 获取指定日期当月最后一天的日期字符串
         *
         * @param date 指定日期
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getMonthEndTimeStr(Date date) {
        
            return getDateTimeStr(getEndDayOfMonth(date));
        }
    
        /**
         * 获取本周第一天的日期字符串
         *
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getWeekStartTimeStr() {
        
            return getDateTimeStr(getStartDayOfWeek(new Date()));
        }
    
        /**
         * 获取指定日期当周第一天的日期字符串
         *
         * @param date 指定日期
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getWeekStartTimeStr(Date date) {
        
            return getDateTimeStr(getStartDayOfWeek(date));
        }
    
        /**
         * 获取本周最后一天的日期字符串
         *
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getWeekEndTimeStr() {
        
            return getDateTimeStr(getEndDayOfWeek(new Date()));
        }
    
        /**
         * 获取指定日期当周最后一天的日期字符串
         *
         * @param date 指定日期
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getWeekEndTimeStr(Date date) {
        
            return getDateTimeStr(getEndDayOfWeek(date));
        }
    
        /**
         * 获取今天的开始时间字符串
         *
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getTodayStartTimeStr() {
        
            return getDateTimeStr(getTodayStartTime(new Date()));
        }
    
        /**
         * 获取指定日期的开始时间字符串
         *
         * @param date 指定日期
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getTodayStartTimeStr(Date date) {
        
            return getDateTimeStr(getTodayStartTime(date));
        }
    
        /**
         * 获取今天的结束时间字符串
         *
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getTodayEndTimeStr() {
        
            return getDateTimeStr(getTodayEndTime(new Date()));
        }
    
        /**
         * 获取指定日期的结束时间字符串
         *
         * @param date 指定日期
         * @return String 格式：yyyy-MM-dd HH:mm:ss
         */
        public static String getTodayEndTimeStr(Date date) {
        
            return getDateTimeStr(getTodayEndTime(date));
        }
    
        /**
         * 获得指定日期所在日的开始时间字符串
         *
         * @param date 指定日期
         * @return String 例如：2020-12-06 00:00:00
         */
        public static String getDateStartTimeStr(Date date) {
        
            String result = format(date, DATE_PATTERN);
            return result.concat(" ").concat(START_TIME);
        }
    
        /**
         * 获得指定日期所在日的结束时间字符串
         *
         * @param date 指定日期
         * @return String 例如：2020-12-06 23:59:59
         */
        public static String getDateEndTimeStr(Date date) {
        
            String result = format(date, DATE_PATTERN);
            return result.concat(" ").concat(END_TIME);
        }
    
        /**
         * 根据日历返回日期时间字符串
         *
         * @param calendar 日历
         * @return String 日期时间字符串
         */
        public static String getDateTimeStr(Calendar calendar) {
        
            StringBuffer buf = new StringBuffer("");
    
            buf.append(calendar.get(Calendar.YEAR));
            buf.append("-");
            buf.append(calendar.get(Calendar.MONTH) + 1 > 9 ? calendar.get(Calendar.MONTH) + 1 + ""
                    : "0" + (calendar.get(Calendar.MONTH) + 1));
            buf.append("-");
            buf.append(calendar.get(Calendar.DAY_OF_MONTH) > 9 ? calendar.get(Calendar.DAY_OF_MONTH) + ""
                    : "0" + calendar.get(Calendar.DAY_OF_MONTH));
            buf.append(" ");
            buf.append(calendar.get(Calendar.HOUR_OF_DAY) > 9 ? calendar.get(Calendar.HOUR_OF_DAY) + ""
                    : "0" + calendar.get(Calendar.HOUR_OF_DAY));
            buf.append(":");
            buf.append(calendar.get(Calendar.MINUTE) > 9 ? calendar.get(Calendar.MINUTE) + ""
                    : "0" + calendar.get(Calendar.MINUTE));
            buf.append(":");
            buf.append(calendar.get(Calendar.SECOND) > 9 ? calendar.get(Calendar.SECOND) + ""
                    : "0" + calendar.get(Calendar.SECOND));
            return buf.toString();
        }
    
        /**
         * 获取今年的第一天
         *
         * @return Calendar 日历
         */
        public static Calendar getStartDayOfYear(Date date) {
        
            Calendar calendar = Calendar.getInstance(Locale.CHINA);
            calendar.setTime(date);
            calendar.set(Calendar.DAY_OF_YEAR, 1);
            calendar.set(Calendar.HOUR_OF_DAY, 0);
            calendar.set(Calendar.MINUTE, 0);
            calendar.set(Calendar.SECOND, 0);
            return calendar;
        }
    
        /**
         * 获取今年的最后一天
         *
         * @return Calendar 日历
         */
        public static Calendar getEndDayOfYear(Date date) {
        
            Calendar calendar = Calendar.getInstance(Locale.CHINA);
            calendar.setTime(date);
            int i = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
            calendar.set(Calendar.DAY_OF_YEAR, i);
            calendar.set(Calendar.HOUR_OF_DAY, 23);
            calendar.set(Calendar.MINUTE, 59);
            calendar.set(Calendar.SECOND, 59);
            return calendar;
        }
    
        /**
         * 获取本月的第一天
         *
         * @return Calendar 日历
         */
        public static Calendar getStartDayOfMonth(Date date) {
        
            Calendar calendar = Calendar.getInstance(Locale.CHINA);
            calendar.setTime(date);
            calendar.set(Calendar.DAY_OF_MONTH, 1);
            calendar.set(Calendar.HOUR_OF_DAY, 0);
            calendar.set(Calendar.MINUTE, 0);
            calendar.set(Calendar.SECOND, 0);
            return calendar;
        }
    
        /**
         * 获取本月的最后一天
         *
         * @return Calendar 日历
         */
        public static Calendar getEndDayOfMonth(Date date) {
        
            Calendar calendar = Calendar.getInstance(Locale.CHINA);
            calendar.setTime(date);
            int i = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
            calendar.set(Calendar.DAY_OF_MONTH, i);
            calendar.set(Calendar.HOUR_OF_DAY, 23);
            calendar.set(Calendar.MINUTE, 59);
            calendar.set(Calendar.SECOND, 59);
            return calendar;
        }
    
        /**
         * 获取本周的第一天，一个星期的第一天是星期一，最后一天是星期天
         *
         * @return Calendar 日历
         */
        public static Calendar getStartDayOfWeek(Date date) {
        
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
            calendar.setFirstDayOfWeek(Calendar.MONDAY);
            calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
    
            calendar.set(Calendar.HOUR_OF_DAY, 0);
            calendar.set(Calendar.MINUTE, 0);
            calendar.set(Calendar.SECOND, 0);
            return calendar;
        }
    
        /**
         * 获取本周的最后一天，一个星期的第一天是星期一，最后一天是星期天
         *
         * @return Calendar 日历
         */
        public static Calendar getEndDayOfWeek(Date date) {
        
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
            calendar.setFirstDayOfWeek(Calendar.MONDAY);
            calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
    
            calendar.set(Calendar.HOUR_OF_DAY, 23);
            calendar.set(Calendar.MINUTE, 59);
            calendar.set(Calendar.SECOND, 59);
            return calendar;
        }
    
        /**
         * 获取今天开始时间
         *
         * @return
         */
        public static Calendar getTodayStartTime(Date date) {
        
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.set(Calendar.HOUR_OF_DAY, 0);
            calendar.set(Calendar.MINUTE, 0);
            calendar.set(Calendar.SECOND, 0);
            calendar.set(Calendar.MILLISECOND, 0);
            return calendar;
        }
    
        /**
         * 获取今天结束时间
         *
         * @return
         */
        public static Calendar getTodayEndTime(Date date) {
        
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.set(Calendar.HOUR_OF_DAY, 23);
            calendar.set(Calendar.MINUTE, 59);
            calendar.set(Calendar.SECOND, 59);
            calendar.set(Calendar.MILLISECOND, 999);
            return calendar;
        }
    
        /**
         * 根据日期范围，获取按周期划分的日期区间
         *
         * @param startDateStr 开始日期（格式：2020-11-29）
         * @param endDateStr   结束日期（格式：2020-12-02）
         * @param pattern      日期格式（支持：DATE_PATTERN，MONTH_PATTERN，YEAR_PATTERN）
         * @return List<String> 区间集合 例如：[2020-11-29,2020-11-30,2020-12-01,2020-12-02]
         */
        public static List<String> getDateStrList(String startDateStr, String endDateStr, String pattern) {
        
            Date start = parse(startDateStr, pattern);
            Date end = parse(endDateStr, pattern);
            return getDateStrList(start, end, pattern);
        }
    
        /**
         * 根据日期范围，获取按周期划分的日期区间
         *
         * @param startDate 开始日期
         * @param endDate   结束日期
         * @param pattern   日期格式（支持：DATE_PATTERN，MONTH_PATTERN，YEAR_PATTERN）
         * @return List<String> 区间集合 例如：[2020-11-29,2020-11-30,2020-12-01,2020-12-02]
         */
        public static List<String> getDateStrList(Date startDate, Date endDate, String pattern) {
        
            List<String> result = new ArrayList<>();
    
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(startDate);
            if (DATE_PATTERN.equals(pattern)) {
        
                while (startDate.before(endDate) || startDate.equals(endDate)) {
        
                    result.add(new SimpleDateFormat(DATE_PATTERN).format(calendar.getTimeInMillis()));
                    calendar.add(Calendar.DATE, 1);
                    startDate = calendar.getTime();
                }
            } else if (MONTH_PATTERN.equals(pattern)) {
        
                while (startDate.before(endDate) || startDate.equals(endDate)) {
        
                    result.add(new SimpleDateFormat(MONTH_PATTERN).format(calendar.getTimeInMillis()));
                    calendar.add(Calendar.MONTH, 1);
                    startDate = calendar.getTime();
                }
            } else if (YEAR_PATTERN.equals(pattern)) {
        
                while (startDate.before(endDate) || startDate.equals(endDate)) {
        
                    result.add(new SimpleDateFormat(YEAR_PATTERN).format(calendar.getTimeInMillis()));
                    calendar.add(Calendar.YEAR, 1);
                    startDate = calendar.getTime();
                }
            }
            return result;
        }
    
        /**
         * 获取当前日期前后num天的集合
         *
         * @param num 天数（正数：之后；负数：之前）
         * @return List<String> 前/后日期的集合（包含指定日期）
         */
        public static List<String> getDateStrList(int num) {
        
            return getDateStrList(new Date(), num, DATE_PATTERN);
        }
    
        /**
         * 获取指定日期前后num天的集合
         *
         * @param date 指定日期
         * @param num  天数（正数：之后；负数：之前）
         * @return List<String> 前/后日期的集合（包含指定日期）
         */
        public static List<String> getDateStrList(Date date, int num) {
        
            return getDateStrList(date, num, DATE_PATTERN);
        }
    
        /**
         * 获取指定日期前后num天的集合，带日期格式参数
         *
         * @param date    指定日期
         * @param num     天数（正数：之后；负数：之前）
         * @param pattern 日期格式
         * @return List<String> 前/后日期的集合（包含指定日期）  例如：[2020-11-29,2020-11-30,2020-12-01]
         */
        public static List<String> getDateStrList(Date date, int num, String pattern) {
        
            List<String> result = new ArrayList<>();
            Calendar c = Calendar.getInstance();
            c.setTime(date);
            boolean flag = false;
            if (num < 0) {
        
                num = Math.abs(num);
                flag = true;
            }
            for (int i = 0; i < num; i++) {
        
                result.add(new SimpleDateFormat(pattern).format(c.getTimeInMillis()));
                c.add(Calendar.DATE, flag ? -1 : 1);
            }
            if (flag) {
        
                Collections.reverse(result);
            }
            return result;
        }
    
        public static void main(String[] args) {
        
            System.out.println("=======================");
            System.out.println(getYearStr());
            System.out.println(getMonthStr());
            System.out.println(getDayStr());
            System.out.println(getHourStr());
            System.out.println(getMinuteStr());
            System.out.println(getSecondStr());
    
            System.out.println(getDateTimeStr());
            System.out.println(getDateStr());
            System.out.println(getTimeStr());
            System.out.println(getDayOfWeekStr());
            System.out.println(getDayOfWeekStr(parse("2020-12-05", DATE_PATTERN)));
            System.out.println(getDateTimeStr(System.currentTimeMillis(), DATETIME_PATTERN));
    
            System.out.println("=======================");
            System.out.println(parse("2020-12-31", DATE_PATTERN));
    
            System.out.println("=======================");
            System.out.println(addYears(1));
            System.out.println(addYears(new Date(), -1));
            System.out.println(addMonths(1));
            System.out.println(addMonths(new Date(), -1));
            System.out.println(addWeeks(1));
            System.out.println(addWeeks(new Date(), -1));
            System.out.println(addDays(1));
            System.out.println(addDays(new Date(), -1));
            System.out.println(addHours(1));
            System.out.println(addHours(new Date(), -1));
            System.out.println(addMinutes(1));
            System.out.println(addMinutes(new Date(), -1));
            System.out.println(addSeconds(1));
            System.out.println(addSeconds(new Date(), -1));
            System.out.println(addMilliSeconds(1));
            System.out.println(addMilliSeconds(new Date(), -1));
    
            System.out.println("=======================");
            System.out.println(getYearsBetween(parse("2020-01-30", DATE_PATTERN), parse("2021-01-29", DATE_PATTERN)));
            System.out.println(getMonthsBetween(parse("2020-01-30", DATE_PATTERN), parse("2021-01-29", DATE_PATTERN)));
            System.out.println(getWeeksBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
            System.out.println(getDaysBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
            System.out.println(getHoursBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
            System.out.println(getMinutesBetween(parse("2020-01-30", DATE_PATTERN), parse("2020-02-06", DATE_PATTERN)));
            System.out.println(getSecondsBetween(parse("2020-12-06 19:47:00", DATETIME_PATTERN), parse("2020-12-06 19:47:50", DATETIME_PATTERN)));
    
            System.out.println("=======================");
            System.out.println(getCurrentSeason());
    
            System.out.println("=======================");
            System.out.println(getIntervalByDate(parse("2020-12-06 19:30:00", DATETIME_PATTERN)));
            System.out.println(getIntervalBySeconds(604800L));
    
            System.out.println("=======================");
            System.out.println(getCalendar(new Date()));
            System.out.println(getUTCTimeStr());
    
            System.out.println("=======================");
            System.out.println(timestampToStr(new Timestamp(System.currentTimeMillis())));
    
            System.out.println("=======================");
            System.out.println(compareNowDate("2020-12-07", DATE_PATTERN));
            System.out.println(compareDate(parse("2020-12-05", DATE_PATTERN), new Date()));
            System.out.println(compareDate("2020-12-05", "2020-12-06", DATE_PATTERN));
    
            System.out.println("=======================");
            System.out.println(isValidDate("2020-02-29 23:59:00"));
            System.out.println(isLastDayofMonth(parse("2020-11-01 00:00:00", DATETIME_PATTERN)));
    
            System.out.println("=======================");
            System.out.println(getYearStartTimeStr());
            System.out.println(getYearStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getYearEndTimeStr());
            System.out.println(getYearEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getMonthStartTimeStr());
            System.out.println(getMonthStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getMonthEndTimeStr());
            System.out.println(getMonthEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getWeekStartTimeStr());
            System.out.println(getWeekStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getWeekEndTimeStr());
            System.out.println(getWeekEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getTodayStartTimeStr());
            System.out.println(getTodayStartTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getTodayEndTimeStr());
            System.out.println(getTodayEndTimeStr(parse("2019-12-06", DATE_PATTERN)));
            System.out.println(getDateStartTimeStr(parse("2020-11-01 00:00:00", DATETIME_PATTERN)));
            System.out.println(getDateEndTimeStr(parse("2020-11-01 00:00:00", DATETIME_PATTERN)));
    
            System.out.println("=======================");
            List<String> strList1 = getDateStrList(3);
            for (String s : strList1) {
        
                System.out.println(s);
            }
    
            System.out.println("=======================");
            List<String> dayList = getDateStrList(parse("2020-11-29", DATE_PATTERN), 3);
            for (String s : dayList) {
        
                System.out.println(s);
            }
    
            System.out.println("=======================");
            List<String> dateList = getDateStrList("2020-11-29", "2020-12-06", DATE_PATTERN);
            for (String s : dateList) {
        
                System.out.println(s);
            }
    
            System.out.println("=======================");
            List<String> strList = getDateStrList(parse("2020-11-29", DATE_PATTERN), parse("2020-12-06", DATE_PATTERN), DATE_PATTERN);
            for (String s : strList) {
        
                System.out.println(s);
            }
        }
    
    }

## 四、java.io ##

### File ###

> 文件和目录路径名的抽象表示。  
> java.io.File用于文件和目录的创建、查找和删除等操作

**静态成员变量：**

*  `static String pathSeparator`：与系统有关的路径分隔符，为了方便，它被表示为一个字符串。
 *  `static char pathSeparatorChar`：与系统有关的路径分隔符。

> 路径分隔符 windows:分号; linux:冒号:

*  `static String separator`：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。
 *  `static char separatorChar`：与系统有关的默认名称分隔符。

> 文件名称分隔符 windows:反斜杠\\ linux:正斜杠/

**构造方法:**

*  `File(String pathname)`：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

> String pathname:字符串的路径名称，路径可以是以文件结尾，也可以是以文件夹结尾，路径可以是相对路径，也可以是绝对路径，路径可以是存在，也可以是不存在。

*  `File(String parent, String child)`：从父路径名字符串和子路径名字符串创建新的 File实例。
 *  `File(File parent, String child)`：从父抽象路径名和子路径名字符串创建新的 File实例。

**获取功能的方法:**

*  `String getAbsolutePath()`：返回此File的绝对路径名字符串。
 *  `String getPath()`：将此File转换为路径名字符串。//其实就是tostring方法。
 *  `String getName()`：返回由此File表示的文件或目录的名称。//获取的就是构造方法传递路径的结尾部分(文件/文件夹)
 *  `long length()`：返回由此File表示的文件的长度。//获取的是构造方法指定的文件的大小,以字节为单位。

**判断功能的方法:**

*  `boolean exists()`：此File表示的文件或目录是否实际存在。
 *  `boolean isDirectory()`：此File表示的是否为目录。
 *  `boolean isFile()`：此File表示的是否为文件。

**创建删除功能的方法:**

*  `boolean createNewFile()`：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
 *  `boolean delete()`：删除由此File表示的文件或目录。
 *  `boolean mkdir()`：创建由此File表示的目录。//创建单级空文件夹。
 *  `boolean mkdirs()`：创建由此File表示的目录，包括任何必需但不存在的父目录。//既可以创建单级空文件夹，也可以创建多级文件夹，创建文件夹的路径和名称在构造方法中给出(构造方法的参数)。

**目录的遍历:**

*  `String[] list()`：返回一个String数组，表示该File目录中的所有子文件或目录。
 *  `File[] listFiles()`：返回一个File数组，表示该File目录中的所有的子文件或目录。

**listFiles()的重载方法：文件过滤器**

*  `File[] listFiles(FileFilter filter)`：返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

> FileFilter接口：用于抽象路径名(File对象)的过滤器。

*  `File[] listFiles(FilenameFilter filter)`：返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

### FileFilter ###

> FileFilter接口：用于抽象路径名(File对象)的过滤器。

*  `boolean accept(File pathname)`：测试pathname是否应该包含在当前File目录中，符合则返回true。

### OutputStream ###

> 抽象类 java.io.OutputStream字节输出流

字节输出流的基本共性功能方法：

*  `void close()`：关闭此输出流并释放与此流相关联的任何系统资源。
 *  `void flush()`：刷新此输出流并强制任何缓冲的输出字节被写出。
 *  `void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流。
 *  `void write(byte[] b, int off, int len)`：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
 *  `abstract void write(int b)`：将指定的字节输出流。

### FileOutputStream ###

> 文件输出流 java.io.FileOutputStream extends OutputStream

**构造方法：**

*  `FileOutputStream(File file)`：创建文件输出流以写入由指定的 File对象表示的文件。
 *  `FileOutputStream(String name)`：创建文件输出流以指定的名称写入文件。

**构造方法二：数据追加续写**

*  `FileOutputStream(File file, boolean append)`：创建文件输出流以写入由指定的 File对象表示的文件。
 *  `FileOutputStream(String name, boolean append)`：创建文件输出流以指定的名称写入文件。

> boolean append参数：true-创建对象不会覆盖源文件，继续在文件的末尾追加写数据。false-创建一个新文件：覆盖源文件。

**常用方法：**

*  继承自OutputStream抽象类。
 *  `write(int b)`：写出字节方法，每次可以写出一个字节数据出字节数据。
 *  `write(byte[] b)`：写出字节数组，每次可以写出数组中的数据。
 *  `write(byte[] b, int off, int len)` ：写出指定长度字节数组，每次写出从off索引开始，len个字节。

**系统中的换行：**

*  Windows系统里，每行结尾是回车+换行，即\\r\\n；
 *  Unix系统里，每行结尾只有换行，即\\n；
 *  Mac系统里，每行结尾是回车，即\\r。从 Mac OS X开始与Linux统一。

> 回车符\\r：回到一行的开头(return)  
> 换行符\\n：换行符：下一行(newline)

### InputStream ###

> 抽象类 java.io.InputStream 字节输入流

**字节输入流的基本共性功能方法：**

*  `void close()`：关闭此输入流并释放与此流相关联的任何系统资源。
 *  `abstract int read()`：从输入流读取数据的下一个字节。
 *  `int read(byte[] b)`：从输入流中读取一些字节数，并将它们存储到字节数组 b中。

### FileInputStream ###

> java.io.FileInputStream extends InputStream 文件输入流

**构造方法：**

*  `FileInputStream(File file)`：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
 *  `FileInputStream(String name)`：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

**读取字节数据：**

*  `read`：读取字节方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1。
 *  `read(byte[] b)`：使用字节数组读取，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1。

### Reader ###

> 抽象类 java.io.Reader 字符输入流

**字符输入流的基本共性功能方法：**

*  `void close()`：关闭此流并释放与此流相关联的任何系统资源。
 *  `int read()`：从输入流读取一个字符。
 *  `int read(char[] cbuf)`：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中。

### FileReader ###

> java.io.FileReader extends Reader 读取字符文件的便利类

**构造方法：**

*  `FileReader(File file)`：创建一个新的 FileReader ，给定要读取的File对象。
 *  `FileReader(String fileName)`：创建一个新的 FileReader ，给定要读取的文件的名称。
 *  `read`：读取字符数据方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取。
 *  `read(char[] cbuf)`：使用字符数组读取，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1。

### Writer ###

> 抽象类 java.io.Writer 字符输出流

**字节输出流的基本共性功能方法：**

*  `void write(int c)`：写入单个字符。
 *  `void write(char[] cbuf)`：写入字符数组。
 *  `abstract void write(char[] cbuf, int off, int len)`：写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
 *  `void write(String str)`：写入字符串。
 *  `void write(String str, int off, int len)`：写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
 *  `void flush()`：刷新该流的缓冲。
 *  `void close()`：关闭此流，但要先刷新它。

### FileWriter ###

> java.io.FileWriter extends Writer 写出字符到文件的便利类

**构造方法：**

*  `FileWriter(File file)`：创建一个新的 FileWriter，给定要读取的File对象。
 *  `FileWriter(String fileName)`：创建一个新的 FileWriter，给定要读取的文件的名称。
 *  `write(int b)`：写出字符方法，每次可以写出一个字符数据。

**关闭和刷新：**

*  `flush`：刷新缓冲区，流对象可以继续使用。
 *  `close`：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
 *  `write(char[] cbuf)和write(char[] cbuf, int off, int len)`：写出字符数组，每次可以写出字符数组中的数据，用法类似FileOutputStream。
 *  `write(String str)和write(String str, int off, int len)`：写出字符串，每次可以写出字符串中的数据，更为方便。

**续写和换行：**

*  操作类似于FileOutputStream。

### BufferedOutputStream ###

> java.io.BufferedOutputStream extends OutputStream 字节缓冲输出流

**构造方法：**

*  `BufferedOutputStream(OutputStream out)` ：创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
 *  `BufferedOutputStream(OutputStream out, int size)` :创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

> OutputStream out：字节输出流。我们可以传递FileOutputStream，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率。  
> int size：指定缓冲流内部缓冲区的大小，不指定默认。

### BufferedInputStream ###

> java.io.BufferedInputStream extends InputStream 字节缓冲输入流

**构造方法：**

*  `BufferedInputStream(InputStream in)`：创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
 *  `BufferedInputStream(InputStream in, int size)`：创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

> InputStream in：字节输入流。我们可以传递FileInputStream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率。

### BufferedWriter ###

> java.io.BufferedWriter extends Writer 字符缓冲输出流

**构造方法：**

*  `BufferedWriter(Writer out)`：创建一个使用默认大小输出缓冲区的缓冲字符输出流。
 *  `BufferedWriter(Writer out, int size)`：创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

> Writer out：字符输出流。我们可以传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率。

**特有的成员方法：**

*  `void newLine()`：写入一个行分隔符。会根据不同的操作系统，获取不同的行分隔符。

> 输出语句System.out.println();就是调用了newLine()方法。

### BufferedReader ###

> java.io.BufferedReader extends Reader 字符缓冲输入流

**构造方法：**

*  `BufferedReader(Reader in)`：创建一个使用默认大小输入缓冲区的缓冲字符输入流。
 *  `BufferedReader(Reader in, int size)`：创建一个使用指定大小输入缓冲区的缓冲字符输入流。

> Reader in：字符输入流。我们可以传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率。

**特有的成员方法：**

*  `String readLine()`：读取一个文本行。读取一行数据。

> 行的终止符号：通过下列字符之一即可认为某行已终止：换行 (‘\\n’)、回车 (‘\\r’) 或回车后直接跟着换行(\\r\\n)。返回值：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。

### OutputStreamWriter ###

> OutputStreamWriter是从字符流到字节流的桥接器：使用指定的charset将写入其中的字符编码为字节。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。  
> 每次调用write（）方法都会导致在给定字符上调用编码转换器。 生成的字节在写入底层输出流之前在缓冲区中累积。 请注意，传递给write（）方法的字符不会被缓冲。  
> 为了获得最高效率，请考虑在BufferedWriter中包装OutputStreamWriter，以避免频繁的转换器调用。

**构造方法：**

*  `OutputStreamWriter(OutputStream in)`：创建一个使用默认字符集的字符流。
 *  `OutputStreamWriter(OutputStream in, String charsetName)`：创建一个指定字符集的字符流。

> OutputStream out：字节输出流，可以用来写转换之后的字节到文件中。  
> String charsetName：指定的编码表名称，不区分大小写，可以是utf-8/UTF-8,gbk/GBK,…不指定默认使用UTF-8。

### InputStreamReader ###

> InputStreamReader是从字节流到字符流的桥接器：它使用指定的charset读取字节并将其解码为字符。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。  
> 每次调用一个InputStreamReader的read（）方法都可能导致从底层字节输入流中读取一个或多个字节。 为了实现字节到字符的有效转换，可以从基础流中提取比满足当前读取操作所需的更多字节。

**构造方法：**

*  `InputStreamReader(InputStream in)`：创建一个使用默认字符集的字符流。
 *  `InputStreamReader(InputStream in, String charsetName)`：创建一个指定字符集的字符流。

> InputStream in：字节输入流，用来读取文件中保存的字节。

### ObjectOutputStream ###

> 对象的序列化流 java.io.ObjectOutputStream extends OutputStream 将Java对象的原始数据类型写出到文件,实现对象的持久存储。

**构造方法：**

*  `ObjectOutputStream(OutputStream out)`：创建一个指定OutputStream的ObjectOutputStream。

> OutputStream out：字节输出流。

**特有方法 - 序列化操作：**

*  `final void writeObject (Object obj)`：写出对象方法，将指定的对象写出。

### ObjectInputStream ###

> 对象的反序列化流 ObjectInputStream extends InputStream 将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

**构造方法：**

*  ObjectInputStream(InputStream in)：创建一个指定InputStream的ObjectInputStream。

> InputStream in：字节输入流。

**特有方法 - 反序列化操作：**

*  `final Object readObject ()` : 读取一个对象。从 ObjectInputStream读取对象。

### PrintStream ###

> java.io.PrintStream extends OutputStream 打印流

**构造方法：**

*  `PrintStream(String fileName)`：使用指定的文件名创建一个新的打印流。
 *  `PrintStream(OutputStream out)`：输出的目的地是一个字节输出流。
 *  `PrintStream(String fileName)` ：输出的目的地是一个文件路径。

## 五、java.net ##

### Socket ###

> java.net.Socket客户端

**构造方法：**

*  `Socket(String host, int port)`:创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null，则相当于指定地址为回送地址。

> String host：服务器主机的名称/服务器的IP地址。int port：服务器的端口号。

**成员方法：**

*  `InputStream getInputStream()`：返回此套接字的输入流。如果此Scoket具有相关联的通道，则生成的InputStream的所有操作也关联该通道。关闭生成的InputStream也将关闭相关的Socket。
 *  `OutputStream getOutputStream()`：返回此套接字的输出流。如果此Scoket具有相关联的通道，则生成的OutputStream的所有操作也关联该通道。关闭生成的OutputStream也将关闭相关的Socket。
 *  `void close()`：关闭此套接字。一旦一个socket被关闭，它不可再使用。关闭此socket也将关闭相关的InputStream和OutputStream。
 *  `void shutdownOutput()`：禁用此套接字的输出流。任何先前写出的数据将被发送，随后终止输出流。

### ServerSocket ###

> java.net.ServerSocket服务端

**构造方法：**

*  `ServerSocket(int port)`：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

**成员方法：**

*  `Socket accept()`：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

## 六、java.sql ##

### DriverManager ###

> java.sql.DriverManager 驱动管理对象

**静态方法：**

*  `static void registerDriver(Driver driver)`：使用DriverManager注册给定的驱动程序。

> 写代码使用： Class.forName(“com.mysql.jdbc.Driver”);

*  `static Connection getConnection(String url)`：尝试建立与给定数据库URL的连接。
 *  `static Connection getConnection(String url, String user, String password)`：尝试建立与给定数据库URL的连接。 //获取数据库连接。

> url：指定连接的路径\[jdbc:mysql://ip地址(域名):端口号/数据库名称\]，user：用户名，password：密码。

### Connection/接口 ###

> java.sql.Interface Connection数据库连接对象

**获取执行sql 的对象：**

*  `Statement createStatement()`：创建一个 Statement对象，用于将SQL语句发送到数据库。
 *  `PreparedStatement prepareStatement(String sql)`：创建一个 PreparedStatement对象，用于将参数化SQL语句发送到数据库。（解决sql注入问题）

**管理事务：**

*  `void setAutoCommit(boolean autoCommit)`：将此连接的自动提交模式设置为给定状态。//开启事务：调用该方法设置参数为false，即开启事务。
 *  `void commit()`：使自上次提交/回滚以来所做的所有更改成为永久更改，并释放此 Connection对象当前持有的所有数据库锁。//提交事务。
 *  `void rollback()`：撤消当前事务中所做的所有更改，并释放此 Connection对象当前持有的所有数据库锁。//回滚事务。
 *  `void close()`：立即释放此 Connection对象的数据库和JDBC资源，而不是等待它们自动释放。

### Statement/接口 ###

> java.sql.Statement执行sql的对象

*  `boolean execute(String sql)` ：执行给定的SQL语句，该语句可能返回多个结果。 //可以执行任意的sql （了解）
 *  `int executeUpdate(String sql)` ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句-不常用，返回值为0

> 返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功，返回值>0的则执行成功，反之，则失败。

*  `ResultSet executeQuery(String sql)` ：执行DQL（select）语句，该语句返回单个 ResultSet对象。
 *  `void close()`：立即释放此 Statement对象的数据库和JDBC资源，而不是等待它自动关闭时发生。

### ResultSet/接口 ###

> java.sql.ResultSet 结果集对象,封装查询结果

*  `boolean next()`：游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true。
 *  getXxx(参数)：获取数据。

> Xxx：代表数据类型，如：int getInt()，String getString() 。  
> 参数：int:代表列的编号,从1开始,如:getString(1)。String:代表列名称,如:getDouble(“balance”)。

*  `void close()`：立即释放此 ResultSet对象的数据库和JDBC资源，而不是等待它自动关闭时发生。

### PreparedStatement/接口 ###

> java.sql.PreparedStatement 执行sql的对象

**给’?'赋值的方法：**

*  `void setXxx`(参数1,参数2)

> 参数1:？的位置编号 从1 开始。 参数2:？的值

*  `ResultSet executeQuery()`：执行此 PreparedStatement对象中的SQL查询，并返回查询生成的 ResultSet对象。
 *  `int executeUpdate()`：执行在该SQL语句PreparedStatement对象，它必须是一个SQL数据操纵语言（DML）语句，比如INSERT ， UPDATE或DELETE ; 或者不返回任何内容的SQL语句，例如DDL语句。

## 七、javax.sql ##

### DataSource/接口 ###

> javax.sql.DataSource数据库连接池

**成员方法：**

*  `default ConnectionBuilder createConnectionBuilder()`：创建一个新的 ConnectionBuilder实例。
 *  `Connection getConnection()`：尝试与此 DataSource对象表示的数据源建立连接。
 *  `Connection getConnection(String username, String password)`：尝试与此 DataSource对象表示的数据源建立连接。

[WiKi]: https://iowiki.com/java/lang/
[MaTools]: https://www.matools.com/api