您现在的位置是：首页 > Java

当前栏目

Java基础：Java常用API

JAVA 接口基础 API

2023-02-26 12:32:27 时间

**一、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

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Java基础：Java常用API

相关文章