java常用类库——util包

以你之姓@ 2021-12-17 06:07 289阅读 0赞

### 文章目录 ###

*   *  util包
     *   *  集合
         *   *  Collection
             *  Iterator
             *  集合的比较
             *   *  子接口比较
                 *  List实现类比较
                 *  Set实现类比较
                 *  Map实现类比较
             *  Collections
         *  数组
         *   *  Arrays
         *  时间
         *   *  Date
             *  Calendar
         *  UUID

## util包 ##

java.util包含集合框架，旧集合类，事件模型，日期和时间设施，国际化和其他实用程序类（字符串tokenizer，随机数生成器和位数组）。

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

### 集合 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxNTgwOA_size_16_color_FFFFFF_t_70]

**集合**：是java提供的一种容器，可以用来存储多个数据

集合和数组都是容器，那么他们的区别是什么？

*  数组长度是固定的。集合的长度是可变的。
    
    int\[ \] arr = new int\[10\]
    
    Student\[ \] arr = new Student\[3\]
    
    List list = new ArrayList<>();
 *  数组中存储的是同一类型的元素，可以存储基本数据类型值，集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合存储。
    
    注意：集合不能存储基本数据类型，比如：存储的是1,2等数字，其实存储的是Integer对象

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

#### Collection ####

Collection接口是集合层次结构中的根节点，Collection接口继承自超级接口Iterable,是Collection层次结构中的根接口。Collection表示一组对象，这些对象也被称为Collection的元素。一些Collection允许有重复的元素（例如List），但是另一些则不允许有重复的元素，即为无序的（如Set）。JDK不提供此接口的任何直接实现—它会提供更为具体的子接口(如Set和List),。此接口用来传递Collection,并在需要时最大普遍性的地方操作这些Collection。

**注意**：因为Collection继承了Iterable接口，所以实现Collection的类可以通过迭代器遍历，如：list的子类，set的子类，但是Map就不可以，若使用迭代器遍历，可以一边遍历一边通过迭代器对象删除元素。

Collection是所有单列集合的父接口，因此Collection中定义单列集合List和Set通用的一些方法，这些方法可用于操作所有单列集合

Collection提供了一些通用的方法：

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td>add(E e)</td> 
   <td>集合添加元素</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>addAll(Collection&lt;? extends E&gt; c)</td> 
   <td>将指定集合的全部元素添加到新的集合中</td> 
  </tr> 
  <tr> 
   <td>void</td> 
   <td>clear()</td> 
   <td>删除集合中全部元素</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>contains(Object o)</td> 
   <td>集合中是否包含某个元素</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>containsAll(Collection&lt;?&gt; c)</td> 
   <td>判断集合中是否包含指定集合中的全部元素</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>equals(Object o)</td> 
   <td>比较两个对象是否相等</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>isEmpty()</td> 
   <td>判断集合是否为空</td> 
  </tr> 
  <tr> 
   <td>Iterator</td> 
   <td>iterator()</td> 
   <td>返回此集合中元素的迭代器</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>remove(Object o)</td> 
   <td>从集合中移除指定元素</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>removeAll(Collection&lt;?&gt; c)</td> 
   <td>从集合中移除指定集合中的所有元素</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>size()</td> 
   <td>返回集合中元素的数量</td> 
  </tr> 
  <tr> 
   <td>Object[ ]</td> 
   <td>toArray()</td> 
   <td>将集合中的元素，存储到数组中</td> 
  </tr> 
 </tbody> 
</table>

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

#### Iterator ####

Collection继承了Iterable接口，那么就像上面提到了只要是实现了Collection接口的集合都可以使用迭代器，迭代器就是循环遍历集合中元素。查看Iterable接口jdk中只有一句：实现此接口允许对象成为“for-each loop”语句的目标。其实for-eache循环底层还是迭代器。

如何获取迭代器？

我们发现Collection接口中提供了一个方法Iterator()返回值就是一个Iterator，它的泛型与集合的泛型一致。

迭代器Iterator常用方法：

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td>hasNext()</td> 
   <td>是否有更多元素</td> 
  </tr> 
  <tr> 
   <td>E</td> 
   <td>next()</td> 
   <td>获取下一个元素</td> 
  </tr> 
  <tr> 
   <td>void</td> 
   <td>remove()</td> 
   <td>移除元素</td> 
  </tr> 
 </tbody> 
</table>

**注意**：集合在for循环中边遍历边删除的情况必须使用迭代器循环实现，如果使用for循环边遍历边删除元素那么就会报ConcurrentModificationException异常

增强for循环底层仍然是迭代器

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

#### 集合的比较 ####

##### 子接口比较 #####

<table> 
 <thead> 
  <tr> 
   <th>List</th> 
   <th>Set</th> 
   <th>Map&lt;k,v&gt;</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Collection的子接口</td> 
   <td>Collection的子接口</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>1.有序，有下标<br>2.元素可重复</td> 
   <td>1.无序<br>2.元素不可重复</td> 
   <td>1.键值对一一对应<br>2.key不可重复，value可以重复</td> 
  </tr> 
 </tbody> 
</table>

List和Set都继承了Collection接口，都是是单列集合，Map是双列集合。

Map集合中有一些操作键值对的方法：

put(key, value) 向map中添加元素

get(key) 通过key获取value的值

keySet() 获取所有key的Set集合

values() 获取Collection即value的集合

entrySet() 返回值是键值对的set集合Set<Map.Entry<k,v>>

java.util.Map.Entry<K,V>接口,就是键值对，我们常用于遍历map集合时可以通过entrySet获取到键值对的集合Map.Entry<k,v>,再通过接口提供的两个方法分别获取键值对的key和value，即getKey() 和 getValue()

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

##### List实现类比较 #####

<table> 
 <thead> 
  <tr> 
   <th>ArrayList</th> 
   <th>LinkedList</th> 
   <th>Vector</th> 
   <th>Queue</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>底层是数组结构：查询快，增删慢<br>因为数组有下标，且是连续的，所以查询速度较快<br>查看ArrayList集合底层源码发现，每次添加 元素都是数组复制的过程，每次添加一个元素都会创建一个比原数组长度大一的新数组，将原有数组的元素复制到新数组中，并添加新元素，所以ArrayList增删慢</td> 
   <td>底层双向链表结构：查询速度较慢，但是增删快；<br>因为LinkedList实现了Deque接口，所以可以模拟队列(先进先出)，因此有offer()入列，poll()出列，也可以模拟堆栈(先进后出)，因此有压栈push(),弹栈pop()，当然因为LinkedList集合是双向列表那么就有一些操作列表首尾元素的方法，比如：addFrist()，addLast()，getFirst()，getLast()等方法</td> 
   <td>1.0版本单列表集合<br>类似ArrayList，但是因为线程安全，效率低，被ArrayList替代</td> 
   <td>1,0版本，继承了Vector栈：特点：后进先出，常用的方法就是pop()出栈也叫弹栈，即删除顶部对象，push()压栈，将对象添加到</td> 
  </tr> 
  <tr> 
   <td>多线程，不安全，效率高</td> 
   <td>多线程，不安全，效率高</td> 
   <td>单线程，安全，效率低</td> 
   <td>单线程，线程安全，效率低</td> 
  </tr> 
 </tbody> 
</table>

**建议**：如果程序中查询比较多，那么使用ArrayList

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

##### Set实现类比较 #####

**哈希值**：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来的地址，不是数据实际存储的物理地址）

在Object类有一个方法，可以获取对象哈希值——int hashCode 返回对象的哈希码值

hashCode方法的源码：public native int hashCode(); 其中native代表该方法调用的是本地操作系统的方法

**哈希表：**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxNTgwOA_size_16_color_FFFFFF_t_70 1]

**注意**：如果同一个哈希值下面挂载的对象超过8个就将此哈希值下的对象转换成红黑树。哈希表=数组+链表或者数组+红黑树

<table> 
 <thead> 
  <tr> 
   <th>HashSet</th> 
   <th>LinkedHashSet</th> 
   <th>TreeSet</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>底层是哈希表结构：查询速度快<br>特点：元素不重复，且没有顺序，可能存取顺序不同</td> 
   <td>底层是哈希表+链表<br>特点：元素不重复，保存了元素的存储顺序</td> 
   <td>底层是二叉树<br>特点：可以排序<br>实体类实现Comparable接口重写compareTo方法；<br>接口Comparator自定义比较器</td> 
  </tr> 
  <tr> 
   <td>线程不安全，效率高</td> 
   <td>线程不安全，效率高</td> 
   <td>线程不安全，效率高</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

**HashSet去重原理**：首先比较元素的hashCode()哈希值是否存在，如果不存在，那么将元素存储，如果存在，再通过equals()方法表元素内容是否一致，如果一致不存储，不一致则存储。HashSet底层使用的HashMap，只取了hashMap的key。

**注意**：jdk提供的数据类型String，Integer等类都重写了hashCode和equals方法，所以当这些数据存入HashSet集合中时都会去重，**但是如果存储自定的类型的数据需要去重的话，就必须重写hashCode()和equals()方法**。比如：hashSet集合中要存储Student对象（名字和年龄都相同就是同一个人），且需要去重，那么就需要Student类重写hashCode和equals方法。

如下图描述：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxNTgwOA_size_16_color_FFFFFF_t_70 2]

**LinkedHashSet**继承了HashSet，只是底层结构不同，LinkedHashSet底层结构为哈希表+链表，链表记录了元素的存储顺序，保证元素有序，LinkedHashSet去重原理与HashSet相同。

**TreeSet的两种排序和去重方法**

**方法一：Comparable**

**TreeSet**会对存储的元素按照自然顺序排序，也就是存入TreeSet的元素必须实现Comparable这个接口，我们常用的数据类型如：String，Integer，Date等都实现了此接口，所以如果我们要存储自定义的实体，那么该实体必须实现Comparable接口。

什么是自然顺序？
    	java.lang.Comparable<T>  public interface Comparable<T>该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。 因为String实现了接口Comparable<T>，那么String中的compareTo方法按照字典顺序比较字符串，基于字符串中每个字符的Unicode值； 因为Integer实现了Comparable<T>接口，那么Integer中的compareTo方法比较的是Integer对象，按照数值从小到大排序。
    	接口Comparable<T>中有一个方法compareTo(T o)，将此对象(即调用compareTo方法的对象)与指定的对象(即o)进行比较以进行排序。返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。 我们一般分别返回-1，0, 1。

如果没有实现那么就会报异常：java.lang.ClassCastException: com.xrds.springbootdemo.bean.PersonBean cannot be cast to java.lang.Comparable 例如：

//PersonBean没有实现Comparable接口   
    public static void main(String[] args) {
        
            PersonBean p1 = new PersonBean("张三",20);
            PersonBean p2 = new PersonBean("李四",25);
            PersonBean p3 = new PersonBean("王五",30);
            PersonBean p4 = new PersonBean("王五",30);
    
            Set<PersonBean> treeSet = new TreeSet<>();
            treeSet.add(p1);
            treeSet.add(p2);
            treeSet.add(p3);
            treeSet.add(p4);
            System.out.println(treeSet.size());
        }
    结果：
    Exception in thread "main" java.lang.ClassCastException: com.xrds.springbootdemo.bean.PersonBean cannot be cast to java.lang.Comparable
    	at java.util.TreeMap.compare(TreeMap.java:1294)
    	at java.util.TreeMap.put(TreeMap.java:538)
    	at java.util.TreeSet.add(TreeSet.java:255)
    	at com.xrds.springbootdemo.business.collection.MyTreeSet.main(MyTreeSet.java:25)
    Process finished with exit code 1

自定义实体类实现了Comparable接口，那么就需要重写compareTo方法，可以根据实体类的属性进行排序和去重。例如学生实体类通过年龄从小到大排序和去重。

@Override
        public int compareTo(Student o) {
        
            if (this.age > o.age){
        
                return 1;
            }else if (this.age < o.age)){
        
                return  -1;
            }
            return 0;
        }

**方法二：Comparator**

TreeSet不仅可以通过实体类实现Comparable接口实现排序和去重，也可以自定义比较器，即TreeSet有参构造函数TreeSet(Comparator<? super E> comparator) 参数就是Comparator接口的实现类，可以创建一个Comparator的实现类，也可以通过匿名内部类实现排序和去重。例如：

java.util.Comparator<T>接口，有比较功能，对一些对象的集合施加了一个整体排序 。可以将比较器传递给排序方法（如Collections.sort或Arrays.sort ），以便对排序顺序进行精确控制。

//通过人物的年龄进行从小到大排序和去重
    public static void main(String[] args) {
        
            PersonBean p1 = new PersonBean("张三",20);
            PersonBean p2 = new PersonBean("李四",25);
            PersonBean p3 = new PersonBean("王五",30);
            PersonBean p4 = new PersonBean("王五",30);
    //匿名内部类
            Set<PersonBean> treeSet = new TreeSet<>(new Comparator<PersonBean>() {
        
                @Override
                public int compare(PersonBean o1, PersonBean o2) {
        
                    if (o1.getAge() > o2.getAge()){
        
                        return 1;
                    }else if (o1.getAge()  < o2.getAge()){
        
                        return -1;
                    }
                    return 0;
                }
            });
            treeSet.add(p1);
            treeSet.add(p2);
            treeSet.add(p3);
            treeSet.add(p4);
            for (PersonBean p:treeSet){
        
                System.out.println(p);
            }
        }

**注意**：TreeSet存储元素类型必须一致，即使泛型设置为Object，虽然add可以将元素存储，但是运行会报异常：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

public static void main(String[] args) {
        
            TreeSet<Object> treeSet = new TreeSet<>();
            treeSet.add(1);
            treeSet.add("a");
            treeSet.add("c");
            treeSet.add("1");
            treeSet.add("3");
            System.out.println(treeSet.size());
        }
    结果：
    Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    	at java.lang.String.compareTo(String.java:111)
    	at java.util.TreeMap.put(TreeMap.java:568)
    	at java.util.TreeSet.add(TreeSet.java:255)
    	at com.xrds.springbootdemo.business.collection.MyTreeSet1.main(MyTreeSet1.java:19)

**注意**：Map/Set的key为自定义对象时，必须重写hashCode和equals。 关于hashCode和equals的处理，遵循如下规则：

*  只要重写equals，就必须重写hashCode。
 *  因为Set存储的是不重复的对象，依据hashCode和equals进行判断，所以Set存储的对象必须重写这两个方法。
 *  如果自定义对象做为Map的键，那么必须重写hashCode和equals。

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

##### Map实现类比较 #####

Map实现类的比较类似Set实现类比较

<table> 
 <thead> 
  <tr> 
   <th>HashMap</th> 
   <th>TreeMap</th> 
   <th>LinkedHashMap</th> 
   <th>HashTable</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>底层是哈希表：查询速度快</td> 
   <td>底层是红黑树</td> 
   <td>底层是哈希表+链表</td> 
   <td>被HashMap取代</td> 
  </tr> 
  <tr> 
   <td>key无序且不重复</td> 
   <td>key排序和去重</td> 
   <td>key有序</td> 
   <td>key无序且不重复</td> 
  </tr> 
  <tr> 
   <td>多线程，不安全，效率高</td> 
   <td>多线程，不安全，效率高</td> 
   <td>多线程，不安全，效率高</td> 
   <td>线程安全，效率低</td> 
  </tr> 
 </tbody> 
</table>

HashMap的key去重原理与HashSet相同，都是通过hashCode()方法和equals()方法；

LinkedHashMap继承了HashMap所以key的去重原理和HashMap相同。

TreeMap的key去重原理与TreeSet相同，都是通过比较器排序和去重。

HashTable被HashMap取代，因为HashTable是线程安全的效率低。

**注意**：上面我们曾经说过，HashSet的底层是通过HashMap实现的，HashSet只是用了HashMap的key集合，所以自定义的实体类如果要作为Map集合的key，那么就需要重写hashCode()方法和equals()方法，对Map集合的key进行去重。当然TreeMap的key排序和去重与TreeSet类似。

#### Collections ####

我们发现Collections和Collection非常相似，CollectionCollection接口是集合层次结构中的根节点，Collections是包装器，就是集合的一个工具类，发现Collections中的方法都是static静态的。

Collections的属性

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>属性名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>static List</td> 
   <td>EMPTY_LIST</td> 
   <td>空list集合对象</td> 
  </tr> 
  <tr> 
   <td>static Map</td> 
   <td>EMPTY_MAP</td> 
   <td>空map集合对象</td> 
  </tr> 
  <tr> 
   <td>static Set</td> 
   <td>EMPTY_SET</td> 
   <td>空set集合对象</td> 
  </tr> 
 </tbody> 
</table>

这三个属性与常用方法中emptyList()、emptyMap()和emptySet()效果一样。

我们在程序中经常为了防止出现空指针异常NullPointerException，会对集合进行判null操作，可能会通过条件语句进行判断，但是程序中条件语句增多的话，会提高代码的复杂度。

//我们发现这段代码我们有两次判空 
    public static void main(String[] args) {
        
            List<String> list = getList();
            if (CollectionUtils.isEmpty(list)){
        
                System.out.println("list集合是空的");
                return;
            }
            for (String s:list){
        
                System.out.println(s);
            } 
        }
    
        private static  List<String> getList(){
        
            List<String> list = StudentDao.selectStudentList();
            if (CollectionUtils.isEmpty(list)){
        
                return null;
            }
            //TODO对list进行一番操作,然后返回最终的list
            return list;
        }

其实我们可以减少判空次数，如下：

public static void main(String[] args) {
        
            List<String> list = getList();
            for (String s:list){
        
                System.out.println(s);
            } 
        }
    
        private static  List<String> getList(){
        
            List<String> list = StudentDao.selectStudentList();
            if (CollectionUtils.isEmpty(list)){
        
                return Collections.EMPTY_LIST;
            }
            //TODO对list进行一番操作,然后返回最终的list
            return list;
        }

常用方法：

binarySearch(List<? extends Comparable<? super T>> list, T key) 通过二分查找方式从集合中查询key的下标

binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

以上两个方法类似，二分查找必须集合中的元素是升序排序，否则结果有误，方法二在查询前需要对指定列表进行升序排序。

copy(List<? super T> dest, List<? extends T> src) 将一个集合(src)中所有元素复制到目标集合中(dest)

reverse(List<?> list) 将集合中的元素顺序反转排序

sort(List list) 集合中所有元素必须实现Comparable接口，实现升序排序

sort(List list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。

我们常用的创建集合的方式，创建的都是线程不安全的集合，比如：new ArrayList<>()，Collections提供了一些方法可以创建线程安全的集合。如下：

synchronizedList(List list) ，synchronizedMap(Map<K,V> m) ，synchronizedSet(Set s)

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

### 数组 ###

#### Arrays ####

java.util.Arrays类，该类是操作数组的一个工具类，该类包含用于操作数组的各种方法（如排序和搜索）。 该类还包含一个静态工厂，可以将数组视为列表。 如果指定的数组引用为空，则该类中的方法都抛出一个NullPointerException。Arrays类似Collections，其方法都是static静态类。

常用的方法：

asList(T… a) 将数组转换成List集合，例如：List list = Arrays.asList(“a”, “b”, “c”) 或者 List list = Arrays.asList(new String\[ \]\{“a”, “b”, “c”\})

sort(byte\[ \] a) 和 sort(byte\[\] a, int fromIndex, int toIndex)

对数组进行排序，基本数据类型按照数字顺序升序排序，自定义数据类型类似TreeSet排序方式，通过接口Comparable和接口Comparator，方法二可以指定排序范围

binarySearch(byte\[ \] a, byte\[ \] key) 和 binarySearch(char\[\] a, int fromIndex, int toIndex, char key)

以上两个方法是通过二分法查询数组，数组类型不仅仅只有byte还有char，double，int等基本数据类型，以及Object指定对象数组，其中第二个方法可以指定从数组起始下标到结束下标进行二分法查询，值得注意的是使用二分法查询必须排序。

copyOf(byte\[ \] a, int newLength) 和 copyOfRange(byte\[ \] int from, int to)

以上两个方法是复制数组，方法一将指定数组，从下标零开始复制，长度为newLength，如果数组长度小于newLength，那么用零填充，方法二将指定数组复制，并且指定复制的范围

当然Arrays也提供了equals()方法比较数组是否相同，toString()方法将指定数组转成字符串等方法

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

### 时间 ###

#### Date ####

关于时间的首先是日期**Date**

常用的方法：

compareTo(Date anotherDate) 比较两个日期

equals() 比较两个日期是否相同

getTime() 获取时间的毫秒数

关于时间我们常做的就是日期格式转成，之间通过代码学习

将日期Date转换成字符串

public static void main(String[] args) throws ParseException {
        
            //获取当前时间
            Date date = new Date();
            System.out.println("当前时间：" + date);
            //当前时间转成毫秒
            System.out.println("当前时间毫秒："+date.getTime());
    
            //将当前时间根据指定格式转成字符串形式
            SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat();
            String format1 = simpleDateFormat1.format(date);
            System.out.println("当前时间默认字符串格式："+format1);
    
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String format = simpleDateFormat.format(date);
            System.out.println("当前时间指定格式：" + format);
    
            //将字符串转成Date类型,注意：字符串格式必须与SimpleDateFormat指定日期格式一致
            String date1 = "2019-04-14";
            String date2 = "2019-04-15";
            SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd");
            Date parse1 = simpleDateFormat2.parse(date1);
            Date parse2 = simpleDateFormat2.parse(date2);
            System.out.println(parse1);
            System.out.println(parse2);
    
            //通过毫秒数比较两个日期
            if (parse1.getTime() > parse2.getTime()){
        
                System.out.println(date1+"比"+date2+"晚");
            }else {
        
                System.out.println(date1+"比"+date2+"早");
    
            }
        }
    结果：
    当前时间：Sun Apr 14 15:00:35 CST 2019
    当前时间毫秒：1555225235266
    当前时间默认字符串格式：19-4-14 下午3:00
    当前时间指定格式：2019-04-14 15:00:35
    Sun Apr 14 00:00:00 CST 2019
    Mon Apr 15 00:00:00 CST 2019
    2019-04-14比2019-04-15早

#### Calendar ####

Calendar即日历，java.util.Calendar类是一个抽象类，所以不能通过new来创建对象，而且通过getInstance()方法创建一个Calendar对象。通过Calendar操作时间更加灵活，我们可以通过代码学习Calendar。

public static void main(String[] args) {
        
            Calendar instance = Calendar.getInstance();
            System.out.println(instance);
    
            //获取当前时间，相当于Date date = new Date();
            Date time = instance.getTime();
            System.out.println("当前时间："+time);
    
            //将日期Date转成Calendar
            instance.setTime(new Date());
            System.out.println("当前时间Calendar："+instance);
    
            System.out.println("=====================================");
            //注意：设置日期是月份需要减1
            instance.set(2019,4-1,14);
            System.out.println("自定义时间年月日："+instance.getTime());
    
            //通过set(int field, int value)给指定的属性赋值，我们常用的属性
            instance.set(Calendar.YEAR,2019);
            instance.set(Calendar.MONTH,4-1);//Calendar.MONTH实际月份比设置月份大1，即设置的是4，实际输出的是5月份
            instance.set(Calendar.DATE,2);
            instance.set(Calendar.HOUR_OF_DAY,23);//Calendar.HOUR实际时间比设置的时间超出12小时，即如果设置12，实际输出的日期是第二天的0点
            instance.set(Calendar.MINUTE,59);
            instance.set(Calendar.SECOND,59);
            instance.set(Calendar.WEEK_OF_MONTH,4);
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String format = simpleDateFormat.format(instance.getTime());
            System.out.println("分别自定义年月日时分秒："+format);
    
            System.out.println("=====================================");
            //通过field获取对应value值
            Calendar instance2 = Calendar.getInstance();
            System.out.println("当前时间年份："+instance2.get(Calendar.YEAR));
            System.out.println("当前时间月份："+instance2.get(Calendar.MONTH)+1);//获取当前月份需要加1，即Calendar.MONTH获得月份加1才是本月月份
            System.out.println("当前时间日期："+instance2.get(Calendar.DATE));
            System.out.println("当前时间小时："+instance2.get(Calendar.HOUR_OF_DAY));
            System.out.println("当前时间分钟："+instance2.get(Calendar.MINUTE));
            System.out.println("当前时间秒："+instance2.get(Calendar.SECOND));
            System.out.println("当前时间周几："+instance2.get(Calendar.DAY_OF_WEEK));//获取周几，注意：周日是1，周一是2 。。。
            System.out.println("当前时间是本月第几周："+instance2.get(Calendar.WEEK_OF_MONTH));//获取本月第几周
            System.out.println("当前时间是本年第几周："+instance2.get(Calendar.WEEK_OF_YEAR));//获取本年第几周
    
    
            System.out.println("=====================================");
            //两个日期比较，如果小于0，则调用对象比指定对象早，反之晚，等于0则两个时间相同
            Calendar instance1 = Calendar.getInstance();
            instance1.set(2019,4-1,18);
            int i = instance.compareTo(instance1);
            if (i > 0){
        
                System.out.println(instance.getTime()+"比"+instance1.getTime()+"晚");
            }else if(i < 0){
        
                System.out.println(instance.getTime()+"比"+instance1.getTime()+"早");
            }else {
        
                System.out.println(instance.getTime()+"和"+instance1.getTime()+"相等");
    
            }
    
            System.out.println("=====================================");
            //add方法是根据日历的规则，将指定的时间量添加或减去给定的日历字段。
            Calendar instance3 = Calendar.getInstance();
            instance3.add(Calendar.MONTH,2);//当前时间两个月之后的时间
            instance3.add(Calendar.DATE,1);//与上一行代码合起来就是当前时间两个月另一天之后的时间
            System.out.println(instance3.getTime());
        }
    结果：
    java.util.GregorianCalendar[time=1555230036582,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=3,WEEK_OF_YEAR=16,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=104,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=20,SECOND=36,MILLISECOND=582,ZONE_OFFSET=28800000,DST_OFFSET=0]
    当前时间：Sun Apr 14 16:20:36 CST 2019
    当前时间Calendar：java.util.GregorianCalendar[time=1555230036614,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=3,WEEK_OF_YEAR=16,WEEK_OF_MONTH=3,DAY_OF_MONTH=14,DAY_OF_YEAR=104,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=20,SECOND=36,MILLISECOND=614,ZONE_OFFSET=28800000,DST_OFFSET=0]
    =====================================
    自定义时间年月日：Sun Apr 14 16:20:36 CST 2019
    分别自定义年月日时分秒：2019-04-21 23:59:59
    =====================================
    当前时间年份：2019
    当前时间月份：31
    当前时间日期：14
    当前时间小时：16
    当前时间分钟：20
    当前时间秒：36
    当前时间周几：1
    当前时间是本月第几周：3
    当前时间是本年第几周：16
    =====================================
    Sun Apr 21 23:59:59 CST 2019比Thu Apr 18 16:20:36 CST 2019晚
    =====================================
    Sat Jun 15 16:20:36 CST 2019

当然还有一些方法比如：

获取当前月份的最大日期：getActualMaximum(Calendar.DATE) 即方法instance.getActualMaximum(int field);

获取当前时区：getTimeZone()

在jdk1.8新特性中添加了一些关于时间的类：LocalDate，LocalTime等

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

### UUID ###

java.util.UUID类一个表示不可变的通用唯一标识符（UUID）的类。 UUID表示128位值。

我们常用UUID获取32数字，比如：常见的数据库主键

public static void main(String[] args) {
        
            String s = UUID.randomUUID().toString().replace("-","");
            System.out.println(s);
        }
    结果：0a523fff8cf545d29e9ea1238ee57e19

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxNTgwOA_size_16_color_FFFFFF_t_70]: /images/20211217/7b899665f4324e70b246a79971a68cf5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxNTgwOA_size_16_color_FFFFFF_t_70 1]: /images/20211217/1b26f59189cf47f4b8c2aa077ebc61db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxNTgwOA_size_16_color_FFFFFF_t_70 2]: /images/20211217/7b8474b7a7b145f49eeb822f0e66f74b.png