集合的框架

集合

一、集合框架

1、collection（接口）:

int size()：返回容量

boolean isEmpty()：判空

boolean contains(Object o)：判断是否有元素

···········

1.1、List（接口）

其存储的元素是有序且可重复的

--- ArrayList:动态数组，所有元素都是连续的

集合的长度是动态变化的，下标也是动态变化的。

--- LinkedList: 双向链表

1.2 set（接口）集合 （按哈希地址值比较的）

其存储的元素是无序且不可重复的

1.2.1HashSet(哈希表)（无序，唯一）

非线程安全。

Hashset在添加对象的时候,判断其是否为同一元素对象的过程分为两步 第一步: 调用对象的hashCode()方法,如果返回值不同,即为不同对象,直接添加成功 第二步: 调用对象的equals()方法,相等则丢弃。----第一步对应着数据结构中哈希表除留余数法找元素下标？从hashmap来看，用的二进制计算的，比除留余数效率更高。

1.  
   // 其是按哈希值的顺序排列的
2.  
   HashSet<Integer> hs = new HashSet<Integer>();
3.  
   这个循环方式有两种：foreach,迭代器
4.  
    
5.  
   区别：foreach 在循环的时候不能对数组进行删除
6.  
    
7.  
   迭代器在循环的时候可以对数组进行删除
8.  
    
9.  
   //迭代器来循环set集合
10.  
    Iterator<Worker> itor = hs.iterator();
11.  
    while(itor.hasNext()) {
12.  
    Worker dw = itor.next();
13.  
    if(dw.getName().equals("郭靖")) {
14.  
    itor.remove();
15.  
    }
16.  
    }

1.2.2 TreeSet（二叉排序树）

1.  
   方式一：自然排序
2.  
         在类上实现接口：
3.  
         public class Worker implements Comparable<Worker> {}
4.  
         重写compareTo方法--规则
5.  
         public int compareTo(Worker o) {
6.  
   //这个里面写排序的规则
7.  
   if(this.getAge()-o.getAge()!=0) {
8.  
   return this.getAge()-o.getAge();
9.  
   }else if(this.salary-o.getSalary()!=0) {
10.  
    return this.getSalary()-o.getSalary();
11.  
    }
12.  
    return this.hashCode()-o.hashCode();
13.  
      }  
14.  
       方式二：匿名内部类   --自定义排序    
15.  
           TreeSet<Worker> ts = new TreeSet<Worker>(new Comparator<Worker>() {
16.  
    //这里也是写比较的规则
17.  
    @Override
18.  
    public int compare(Worker o1, Worker o2) {
19.  
    //这个里面写排序的规则
20.  
    if(o1.getAge()-o2.getAge()!=0) {
21.  
    return o1.getAge()-o2.getAge();
22.  
    }else if(o1.getSalary()-o2.getSalary()!=0) {
23.  
    return o1.getSalary()-o2.getSalary();
24.  
    }
25.  
    return o1.hashCode()-o2.hashCode();
26.  
    }
27.  
    });

如果两个排序都存在，优先采用自定义排序。

1.2.3 LinkedHashSet（extends HashSet）（哈希表里是双向链表）（有序）

1.3map

1.3.1 HashMap（哈希表？数组 链表 或 红黑树）

其没有重复的键，且值允许一条Entry的键为null，允许多条Entry 的值为null。

其主干是一个Entry数组，Entry是HashMap的基本组成单元，每个Entry包含一对key-value键值对---保存了两个对象之间映射关系的集合

对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。

1.  
   HashMap<String, String> map = new HashMap<String, String>();
2.  
3.  
   //循环键
4.  
   Set<String> ks = map.keySet();
5.  
   for(String k : ks)
6.  
      System.out.println(k map.get(k));
7.  
   //循环值
8.  
   Collection<String> vs = map.values();
9.  
   for(String v : vs)
10.  
       System.out.println(v);
11.  
    //循环键值对---大数据量时使用
12.  
    Set<Entry<String, String>> es = map.entrySet();
13.  
    for(Entry<String, String> kv : es){
14.  
       System.out.println();
15.  
    }
16.  
    //迭代器循环
17.  
    Iterator iterator = map.entrySet().iterator();
18.  
    while(iterator.hasnext()){
19.  
       Map.Entry<String, String> entry = (Map.Entry<String, String>)iterator.next();
20.  
       //iterator.next();
21.  
       System.out.println(entry.getKey() entry.getValue());
22.  
    }

1.3.2 TreeMap

按照键排序（其和TreeSet一样，需要实现comparable和comparator）

1.3.2 LinkedHashmap(数组 双向链表)

1.4迭代器

iterator: 从前往后迭代

hasNext(); //判断后面有没有下一个元素

next（）：返回下一个元素。

ListsIterator: 从后往前迭代

previous(); //返回元素下标

previousIndex();

hasPrevious();

ListIterator可以：

(1)双向移动（向前/向后遍历）.

(2)产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引.

(3)可以使用set()方法替换它访问过的最后一个元素.

(4)可以使用add()方法在next()方法返回的元素之前或previous()方法返回的元素之后插入一个元素.

1.  
   public interface Iterable<T> {  
2.  
       Iterator<T> iterator();
3.  
   }
4.  
   Collection集合及其儿子都有迭代器
5.  
   public interface Collection<E> extends Iterable<E>{}
6.  
7.  
   //反向迭代器 --- set
8.  
   public interface List<E> extends Collection<E> {
9.  
     ListIterator<E> listIterator(int index);//反向迭代器的方法
10.  
    }

这篇好文章是转载于：学新通技术网