Java基础：Java常用API

以你之姓@ 2021-11-09 01:08 432阅读 0赞

**一、JAVA常用API  
java.lang.Math**

提供sin, cos, tan, exp, log, log10 等类方法，PI和E等类字段

**java.lang.String（StringBuilder线程不安全，StringBuffer线程安全）**

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

**java.util.Scanner**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 1]  
**for each循环**

for(variable : collection) statement

collection这一集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象

**java.util.Arrays**

![在这里插入图片描述][20190807124737122.png]

数组名.length 数组长度

**java.util.Radom**

![在这里插入图片描述][20190807124806722.png]  
**java.lang.Object**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 2]  
**java.lang.Class**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 3]  
**断言**

assert 条件;

assert 条件:表达式;

**二、JAVA集合框架**

Java集合类库将接口和实现分离。当程序使用集合时，一旦构建了集合就不需要知道究竟使用了哪种实现。因此，只有在构建集合对象时，使用具体的类才有意义。可以使用接口类型存放集合的引用。利用这种方法，一旦改变想法，可以轻松使用另外一种不同的实现，只需在对象创建处修改即可。

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

**java.util.Collection**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 5]  
**java.util.Iterator**

![在这里插入图片描述][20190807124959209.png]

**Java库中具体集合**

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArrayList</td> 
   <td>一种可以动态增长和缩减的索引序列</td> 
  </tr> 
  <tr> 
   <td>LinkedList</td> 
   <td>一种可以在任何位置进行高效插入和删除操作的有序序列</td> 
  </tr> 
  <tr> 
   <td>ArrayDeque</td> 
   <td>一种用循环数组实现的双端队列</td> 
  </tr> 
  <tr> 
   <td>HashSet</td> 
   <td>一种没有重复元素的无序集合</td> 
  </tr> 
  <tr> 
   <td>TreeSet</td> 
   <td>一种有序集</td> 
  </tr> 
  <tr> 
   <td>EnumSet</td> 
   <td>一种包含枚举类型值的集合</td> 
  </tr> 
  <tr> 
   <td>LinkedHashSet</td> 
   <td>一种可以记住元素插入次序的集</td> 
  </tr> 
  <tr> 
   <td>PriorityQueue</td> 
   <td>一种允许高效删除最小元素的集合</td> 
  </tr> 
  <tr> 
   <td>HashMap</td> 
   <td>一种存储键/值关联的数据结构</td> 
  </tr> 
  <tr> 
   <td>TreeMap</td> 
   <td>一种键值有序排列的映射表</td> 
  </tr> 
  <tr> 
   <td>EnumMap</td> 
   <td>一种键值属于枚举类型的映射表</td> 
  </tr> 
  <tr> 
   <td>LinkedHashMap</td> 
   <td>一种可以记住键/值项添加次序的映射表</td> 
  </tr> 
  <tr> 
   <td>WeakHashMap</td> 
   <td>一种其值无用武之地后可以被垃圾回收期回收的映射表</td> 
  </tr> 
  <tr> 
   <td>IdentityHashMap</td> 
   <td>一种用==而不是用equals比较键值的映射表</td> 
  </tr> 
 </tbody> 
</table>

**1、List**

List接口扩展自Collection，它可以定义一个**允许重复**的有序集合，从List接口中的方法来看，List接口主要是增加了面向位置的操作，允许在指定位置上操作元素，同时增加了一个能够双向遍历线性表的新列表迭代器ListIterator。List接口有动态数组（ArrayList类）和双端链表（LinkedList类）两种实现方式。

**java.util.List**

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

**java.util.ListIterator**

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

**java.util.ArrayList**

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

**java.util.LinkedList**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 9]

**2、Set**

Set接口扩展自Collection，它与List的不同之处在于，规定Set的实例**不包含重复的元素**。在一个规则集内，一定不存在两个相等的元素。AbstractSet是一个实现Set接口的抽象类，Set接口有三个具体实现类，分别是散列集HashSet、链式散列集LinkedHashSet和树形集TreeSet。

**java.util.HashSet**

![在这里插入图片描述][20190807130107636.png]

**java.util.LinkedHashSet**

LinkedHashSet是用一个链表实现来扩展HashSet类，它支持对规则集内的元素**排序**。HashSet中的元素是没有被排序的，而LinkedHashSet中的元素可以按照它们插入规则集的顺序提取。

**java.util.TreeSet**  
TreeSet扩展自AbstractSet，并实现了**NavigableSet**，AbstractSet扩展自AbstractCollection，树形集是一个有序的Set，其底层是一颗树,用红黑树实现，这样就能从Set里面提取一个有序序列了。在实例化TreeSet时，我们可以给TreeSet指定一个比较器Comparator来指定树形集中的元素**顺序**。树形集中提供了很多便捷的方法。

**3、队列**

**java.util.Queue(接口)**

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

**java.util.Deque**

接口Deque，是一个扩展自Queue的双端队列，它支持在两端插入和删除元素，Deque接口由ArrayDeque和LinkedList这两个类实现，所以通常我们可以使用LinkedList来创建一个队列。PriorityQueue类实现了一个优先队列，优先队列中元素被赋予优先级，拥有高优先级的先被删除。

**java.util.ProrityQueue**

优先级队列中的元素可以按任意顺序插入，却总是按照排序的顺序进行检索。优先级队列由堆实现。堆是一个可以自我调整的二叉树，对树执行添加和删除操作，可以让最小元素移动到根（最小堆），而不必花费时间对元素进行排序

**4、Map接口**

Map，图，是一种存储键值对映射的容器类，在Map中键可以是任意类型的对象，但不能有重复的键，每个键都对应一个值，真正存储在图中的是键值构成的条目。

**java.util.Map<K,V>**

![在这里插入图片描述][20190807130256838.png]

**java.util.HashMap<K,V>**  
HashMap是基于哈希表的Map接口的非同步实现，继承自AbstractMap，AbstractMap是部分实现Map接口的抽象类。在之前的版本中，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当链表中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

**java.util.LinkedHashMap<K,V>**

LinkedHashMap继承自HashMap，它主要是用链表实现来扩展HashMap类，HashMap中条目是没有顺序的，但是在LinkedHashMap中元素既可以按照它们插入图的顺序排序，也可以按它们最后一次被访问的顺序排序。

**java.util.TreeHashMap<K,V>**

TreeMap基于红黑树数据结构的实现，键值可以使用Comparable或Comparator接口来排序。TreeMap继承自AbstractMap，同时实现了接口NavigableMap，而接口NavigableMap则继承自SortedMap。SortedMap是Map的子接口，使用它可以确保图中的条目是排好序的。在实际使用中，如果更新图时不需要保持图中元素的顺序，就使用HashMap，如果需要保持图中元素的插入顺序或者访问顺序，就使用LinkedHashMap，如果需要使图按照键值排序，就使用TreeMap。

**5、其他集合类**

下面主要介绍一下其它几个特殊的集合类，Vector、Stack、HashTable、ConcurrentHashMap以及CopyOnWriteArrayList。

**java.util.Vector**

用法上，Vector与ArrayList基本一致，不同之处在于Vector使用了关键字synchronized将访问和修改向量的方法都变成同步的了，所以对于不需要同步的应用程序来说，类ArrayList比类Vector更高效。

**java.util.Stack**

Stack，栈类，是Java2之前引入的，继承自类Vector。

**java.util.HashTable**

HashTable和前面介绍的HashMap很类似，它也是一个散列表，存储的内容是键值对映射，不同之处在于，HashTable是继承自Dictionary的，HashTable中的函数都是同步的，这意味着它也是线程安全的，另外，HashTable中key和value都不可以为null。

**java.util.ConcurrentHashMap**

ConcurrentHashMap是HashMap的线程安全版。同HashMap相比，ConcurrentHashMap不仅保证了访问的线程安全性，而且在效率上与HashTable相比，也有较大的提高。

**java.util.CopyOnWriteArrayList**

CopyOnWriteArrayList，是一个线程安全的List接口的实现，它使用了ReentrantLock锁来保证在并发情况下提供高性能的并发读取。

**java.util.CopyOnWriteArraySet**

CopyOnWriteArraySet，是一个线程安全的set接口的实现，它使用了ReentrantLock锁来保证在并发情况下提供高性能的并发读取。

ConcurrentLinkedQuerue是一个先进先出的队列。它是非阻塞队列。

ConcurrentSkipListMap可以在高效并发中替代SoredMap（例如用Collections.synchronzedMap包装的TreeMap）。

ConcurrentSkipListSet可以在高效并发中替代SoredSet（例如用Collections.synchronzedSet包装的TreeMap）。

**6、泛型集合算法**

**6.1 排序**

![在这里插入图片描述][20190807130406485.png]  
**6.2 查找**

![在这里插入图片描述][20190807130418972.png]  
**6.3 其他**

![在这里插入图片描述][20190807130434472.png]  
**三、并发部分API**

**java.lang.Runnable**

void run() 必须覆盖这个方法

**java.lang.Thread**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 11]  
**锁对象**

ReentrantLock myLock = new ReentrantLock();
    mylock.lock();
    try{
         critical section
    }finally{
         mylock.unlock();
    }

**条件对象**

private ReetranLock mylock = new ReetranLock();
    private Condition sufficientFunds = mylock.newCondition()
    public void transfer(int from, int amount)
    {
        mylock.lock();
        try{
             while(account[from] < amount){
                  sufficientFunds.await();
              }
              ...
              sufficientFunds.singalAll();
          }finally{
              mylock.unlock();
          }
    }

**synchronized关键字（内置锁）**  
格式1：synchronized 方法

格式2：synchronized（obj）\{\}

**使用synchronized如何设置条件变量**

![在这里插入图片描述][20190807130552703.png]

**volatile域**  
volatile只提供可见性（在线程工作内存中被修改后立即写入到主存中），不提供原子性。  
使用final变量可以保证可见性：构造函数完成时即不变，未完成构造期间对其他线程不可见。

**java.lang.ThreadLocal**  
作用：将内存共享变量变为线程拷贝变量

**Executor类执行器**  
1）调用Executors类（工厂类）中静态工厂方法newCacherThreadPool  
2）调用submit提交Runnable或Callable对象  
3）当不再提交任何任务时，调用shutdown  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 12]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70]: /images/20211108/6be1143d5cf247a8bb65f3df4142659e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 1]: /images/20211108/3ce792d42ac241768743462fc9d0b50f.png
[20190807124737122.png]: /images/20211108/be8723a4a9b848c3a075206864b15749.png
[20190807124806722.png]: /images/20211108/02d5f5ec97ee40dcb7cd77c4a3fce286.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 2]: /images/20211108/791484ab370e4aa889c532bcbf1de896.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 3]: /images/20211108/449bb58dd2924bd8afc414d6ae82c928.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 4]: /images/20211108/a9ca4def798c4c75b806420f5bbecdd7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 5]: /images/20211108/9d48b08095f04c2b8f9886d3ffb5618f.png
[20190807124959209.png]: /images/20211108/6a2d3aecf4d74ebabc1d97a62c4055e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 6]: /images/20211108/bbd5165dcfc64cf883f4e1040b062b9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 7]: /images/20211108/75e9ab731de64e8daf4eb47b1c0959a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 8]: /images/20211108/895f676230cf40038daaa6e84d99a8fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 9]: /images/20211108/9d0fbbe9b0d349359a06c54b7047c88c.png
[20190807130107636.png]: /images/20211108/420cdb4fe8ab4fbfb8dca81ca2352895.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 10]: /images/20211108/04d4a500256a49c3945a62e1f1982e10.png
[20190807130256838.png]: /images/20211108/bba434d3e1d84809a3e9e62878914281.png
[20190807130406485.png]: /images/20211108/1955e27a810b4296bac7a8174fc9bad7.png
[20190807130418972.png]: /images/20211108/0f5a80944e5a482db6f4aefc5c99441a.png
[20190807130434472.png]: /images/20211108/cb68df362adc4f6ab3b6aeda7ac91ede.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 11]: /images/20211108/c65dc629bb9245729b04bb9c3f6d166b.png
[20190807130552703.png]: /images/20211108/2a28db334e434453847f3657ff7c1206.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x0aGlyZG9uZWw_size_16_color_FFFFFF_t_70 12]: /images/20211108/1ea6943a83694a54a610ed45786a8f3e.png