java容器详细解析

前言：在java开发中我们肯定会大量的使用集合，在这里我将总结常见的集合类，每个集合类的优点和缺点，以便我们能更好的使用集合。下面我用一幅图来表示

其中淡绿色的表示接口，红色的表示我们经常使用的类。

1：基本概念

java容器类类库的用途是保存对象，可以将其分为2个概念。

1.1：collection

一个独立元素的序列，这些元素都服从一条或多条规则。其中list必须按照插入的顺序保存元素、set不能有重复的元素、queue按照排队规则来确定对象的产生顺序（通常也是和插入顺序相同）

1.2：map

一组成对的值键对对象，允许用键来查找值。arraylist允许我们用数字来查找值，它是将数字和对象联系在一起。而map允许我们使用一个对象来查找某个对象，它也被称为关联数组。或者叫做字典。

2：list

list承诺可以将元素维护在特定的序列中。list接口在collection的基础上加入了大量的方法，使得可以在list中间可以插入和移除元素。下面主要介绍2种list

2.1：基本的arraylist

它的优点在于随机访问元素快，但是在中间插入和移除比较慢

那么现在我们就一起来看看为什么arraylist随机访问快，而插入移除比较慢。先说关于arraylist的初始化。

arraylist有三种方式进行初始化如下

private transient object[] elementdata;
public arraylist() {
    this(10);
  }
 public arraylist(int initialcapacity) {
    super();
    if (initialcapacity < 0)
      throw new illegalargumentexception("illegal capacity: "+
initialcapacity);
    this.elementdata = new object[initialcapacity];
  }
 public arraylist(collection<? extends e> c) {
    elementdata = c.toarray();
    size = elementdata.length;
    // c.toarray might (incorrectly) not return object[] (see 6260652)
    if (elementdata.getclass() != object[].class)
      elementdata = arrays.copyof(elementdata, size, object[].class);
  }

我们可以看出arraylist其实就是采用的是数组（默认是长度为10的数组）。所有arraylist在读取的时候是具有和数组一样的效率，它的时间复杂度为1。

插入尾部就是elementdata[size++] = e;当然中间会进行扩容。现在主要说插入中间为什么相对来说比较慢源码如下

public void add(int index, e element) {
    rangecheckforadd(index);//验证（可以不考虑）
    ensurecapacityinternal(size + 1); // increments modcount!!（超过当前数组长度进行扩容）
    system.arraycopy(elementdata, index, elementdata, index + 1,
             size - index);(核心代码)
    elementdata[index] = element;
    size++;
  }

system.arraycopy(elementdata, index, elementdata, index + 1)第一个参数是源数组，源数组起始位置，目标数组，目标数组起始位置，复制数组元素数目。那么这个意思就是从index索性处每个元素向后移动一位，最后把索引为index空出来，并将element赋值给它。这样一来我们并不知道要插入哪个位置，所以会进行匹配那么它的时间赋值度就为n。

2.2：linkedlist

它是通过代价较低在list中间进行插入和移除，提供了优化的顺序访问，但是在随机访问方面相对较慢。但是他的特性功能要比arraylist强大的多。支持queue和stack

listedlist采用的是链式存储。链式存储就会定一个节点node。包括三部分前驱节点、后继节点以及data值。所以存储存储的时候他的物理地址不一定是连续的。

我们看下它的中间插入实现

从代码我们可以看出先获取插入索引元素的前驱节点，然后把这个元素作为后继节点，然后在创建新的节点，而新的节点前驱节点和获取前驱节点相同，而后继节点则等于要移动的这个元素。所以这里是不需要循环的，从而在插入和删除的时候效率比较高。

我们在来看看查询（我们可以分析出它的效率要比arraylist低了不少）

3：set

set也是一个集合，但是他的特点是不可以有重复的对象，所以set最常用的就是测试归属性，很容易的询问出某个对象是否存在set中。并且set是具有和collection完全一样的接口，没有额外的功能，只是表现的行为不同。

3.1：hashset

hashset查询速度比较快，但是存储的元素是随机的并没有排序，下面我写一段程序看一下

public static void main(string[] args){
    /**
     * 没有顺序可循，这是因为hashset采用的是散列（处于速度考虑）
     */
    random random=new random(47);
    set<integer> intset=new hashset<integer>();
    for (int i=0;i<10000;i++){
      intset.add(random.nextint(30));
    }
    system.out.print(intset);
  }

3.2：treeset

treeset是将元素存储红-黑树结构中，所以存储的结果是有顺序的（所以如果你想要自己存储的集合有顺序那么选择treeset）

public static void main(string[] args){
    random random=new random(47);
    set<integer> intset=new treeset<integer>();
    for (int i=0;i<10000;i++){
      intset.add(random.nextint(30));
    }
    system.out.print(intset);
  }

关于linkedhashset后面再说。

4：queue

queue是队列，队列是典型的先进先出的容器，就是从容器的一端放入元素，从另一端取出，并且元素放入容器的顺序和取出的顺序是相同的。linkedlist提供了对queue的实现，linkedlist向上转型为queue。其中queue有offer、peek、element、pool、remove等方法

offer是将元素插入队尾，返回false表示添加失败。peek和element都将在不移除的情况下返回对头，但是peek在对头为null的时候返回null，而element会抛出nosuchelementexception异常。poll和remove方法将移除并返回对头，但是poll在队列为null，而remove会抛出nosuchelementexception异常，以下是例子

public static void main(string[] args){
    queue<integer> queue=new linkedlist<integer>();
    random rand=new random();
    for (int i=0;i<10;i++){
      queue.offer(rand.nextint(i+10));
    }
    printq(queue);
    queue<character> qc=new linkedlist<character>();
    for (char c:"helloworld".tochararray()){
      qc.offer(c);
    }
    system.out.println(qc.peek());
    printq(qc);
    list<string> mystrings=new linkedlist<string>();
    mystrings.add("1");
    mystrings.get(0);
    set<string> a=new hashset<string>();
    set<string> set=new hashset<string>();
    set.add("1");
  }
  public static void printq(queue queue){
    while (queue.peek

从上面的输出的结果我们可以看出结果并不是一个顺序的，没有规则的，这个时候如果想让队列按照规则输出那么这个时候我们就要考虑优先级了，这个时候我们就应该使用priorityqueue，这个时候如果在调用offer方法插入一个对象的时候，这个对象就会按照优先级在对列中进行排序，默认的情况是自然排序，当然我们可以通过comparator来修改这个顺序（在下一篇讲解）。priorityqueue可以确保当你调用peek、pool、remove方法时，获取的元素将是对列中优先级最高的元素。ok我们再次通过代码查看

public static void main(string[] args) {
    priorityqueue<integer> priorityqueue = new priorityqueue<integer>();
    random rand = new random();
    for (int i = 0; i < 10; i++) {
      priorityqueue.offer(rand.nextint(i + 10));
    }
    queuedemo.printq(priorityqueue);
    list<integer>ints= arrays.aslist(25,22,20,18,14,9,3,1,1,2,3,9,14,18,21,23,25);
    priorityqueue=new priorityqueue<integer>(ints);
    queuedemo.printq(priorityqueue);
  }

从输出可以看到，重复是允许的，最小值拥有最高优先级（如果是string，空格也可以算作值，并且比字母具有更高的优先级）如果你想消除重复，可以采用set进行存储，然后把set作为priorityqueue对象的初始值即可。

5：map

map在实际开发中使用非常广，特别是hashmap，想象一下我们要保存一个对象中某些元素的值，如果我们在创建一个对象显得有点麻烦，这个时候我们就可以用上map了，hashmap采用是散列函数所以查询的效率是比较高的，如果我们需要一个有序的我们就可以考虑使用treemap。这里主要介绍一下hashmap的方法，大家注意hashmap的键可以是null，而且键值不可以重复，如果重复了以后就会对第一个进行键值进行覆盖。

put进行添加值键对，containskey验证主要是否存在、containsvalue验证值是否存在、keyset获取所有的键集合、values获取所有值集合、entryset获取键值对。

public static void main(string[] args){
    //map<string,string> pets=new hashmap<string, string>();
    map<string,string> pets=new treemap<string, string>();
    pets.put("1","张三");
    pets.put("2","李四");
    pets.put("3","王五");
    if (pets.containskey("1")){
      system.out.println("已存在键1");
    }
    if (pets.containsvalue("张三")){
      system.out.println("已存在值张三");
    }
    set<string> sets=pets.keyset();
    set<map.entry<string , string>> entryset= pets.entryset();
    collection<string> values= pets.values();
    for (string value:values){
      system.out.println(value+";");
    }
    for (string key:sets){
      system.out.print(key+";");
    }
    for (map.entry entry:entryset){
      system.out.println("键："+entry.getkey());
      system.out.println("值："+entry.getvalue());
    }
  }

6：iterator和foreach

现在foreach语法主要作用于数组，但是他也可以应用于所有的collection对象。collection之所以能够使用foreach是由于继承了iterator这个接口。下面我写段代码供大家查看

public class iteratorclass {
  public iterator<string> iterator(){
   return new itr();
  }
  private class itr implements iterator<string>{
    protected string[] words=("hello java").split(" ");
    private int index=0;
    public boolean hasnext() {
      return index<words.length;
    }
    public string next() {
      return words[index++];
    }
    public void remove() {
    }
  }
}
iterator iterators=new iteratorclass().iterator();
    for (iterator it=iterator;iterators.hasnext();) {
      system.out.println(iterators.next());
    }
    while (iterators.hasnext()){
      system.out.println(iterators.next());
    }

从中我们可以看出foreach循环最终是转换成 for (iterator it=iterator;iterators.hasnext();)只不过jdk帮我们隐藏我们无法查看。下面我们在来分析一个问题，关于list删除问题。我们大多肯定使用过for循环或者foreach循环去删除，但是结果很明显会出现错误，那么现在我们一起分析为啥会出现错误。

1：使用for循环删除（出现错误分析）

2：foreach循环删除（错误分析）

从上面我们得知foreach最终是会转成iterator的所以它首先会通过next来获取元素，我们看代码

请看for循环删除那段代码，没删除一次modcount会++，所以第二次在次删除的时候modcount由于增加和expectedmodcount不等所以无法获取元素也就无法删除。

3：正确的删除方式

采用迭代器代码如下

 iterator<string> iterator=userlist.iterator();
    while (iterator.hasnext()){
      iterator.next();
      iterator.remove();
    }

请记住一定要加上iterator.next();这是因为在源码中有一个lastred，通过它来记录是否是最后一个元素，如果不加上iterator.next()那么lastred=-1,在删除验证的时候有这么一段代码if (lastret < 0)throw new illegalstateexception();所以就会抛出异常。

7：collections和arrays

这里只介绍2个常用的collections.addall和arrays.aslist

addall：

aslist采用的是数组

可以看出最终转换成arraylist。

8：总结

1）：数组是将数字和对象联系起来，它保存明确的对象，查询对象时候不需要对查询结果进行转换，它可以是多维的，可以保存基本类型的数据，但是数组一旦生成，其容量不能改变。所以数组是不可以直接删除和添加元素。

2）：collection保存单一的元素，而map保存相关联的值键对，有了java泛型，可以指定容器存放对象类型，不会将错误类型的对象放在容器中，取元素时候也不需要转型。而且collection和map都可以自动调整其尺寸。容器不可以持有基本类型。

3）：像数组一样，list也建立数字索性和对象的关联，因此，数组和list都是排好序的容器，list可以自动扩容

4）：如果需要大量的随机访问就要使用arraylist，如果要经常从中间插入和删除就要使用linkedlist。

5）：各种queue和stack由linkedlist支持

6）：map是一种将对象（而非数字）与对象相关联的设计。hashmap用于快速访问，treemap保持键始终处于排序状态，所以不如hashmap快，而linkedhashmap保持元素插入的顺序，但是也通过散列提供了快速访问的能力

7）：set不接受重复的元素，hashset提供最快的访问能力，treeset保持元素排序状态，linkedhashset以插入顺序保存元素。

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持！