JAVA--浅谈集合

写在前面：

请多多指正。

集合类概述

参考文献

/article/8712427.html

java集合类图



上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等。

　　所有的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含hashNext(),next(),remove()三种方法。它的一个子接口LinkedIterator在它的基础上又添加了三种方法，分别是add(),previous(),hasPrevious()。也就是说如果是先Iterator接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会在遍历到，通常无序集合实现的都是这个接口，比如HashSet，HashMap；而那些元素有序的集合，实现的一般都是LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个元素，比如ArrayList。

（PS：本段属于转载）

以下为楼主自己总结的集合类的继承关系图（Ps：集合类下方为常用方法）



Collection接口

Collection接口是层次结构中的根接口，构成Collection的单位为元素。Collection接口通常不能直接使用（可以向继承自它的集合添加元素），但它提供了添加元素、删除元素、管理数据的方法，这对于继承自它的List集合和Set集合是通用的。

代码实例：

/**
*
*/
package test集合;

import java.util.*;
/**
* @author 寒
*
*/
public class Muster {

/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection<String > list = new ArrayList<>();   //实例集合类元素
list.add("a");                                  //向集合中添加元素
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();          //创建迭代器
while(it.hasNext()){
String str = (String )it.next();
System.out.println(str);
}
List<String > list2 = new ArrayList<>();
list2.addAll(list);
int i = (int)(Math.random() * (list2.size() - 1));
System.out.println("随机读取集合中的元素：" + list2.get(i));
for(int j = 0 ;j < list2.size() ; j ++){
System.out.println(list2.get(j));
}
}

}

List集合

List集合包括了List接口以及List接口的所有实现类，List集合中的元素允许重复，各元素的顺序就是对象插入的顺序，类似于数组，同样可以进行随机访问集合中的元素（不同的是由于实例的方法不同会有不同的效率）。

两种实现方法：

1.ArrayList

以可变数组的方式保存所有的元素，包括null，可以根据索引位置对集合进行快速的随机访问，但是进行插入对象和删除对象的时候速度较慢。

2. LinkedList

采用链表的结构保存对象，随机访问的时候由于链表的结构实现导致效率较低，但是在插入对象和删除对象的时候效率很高。

实现示例：

List<E> list = new ArrayList<>();
List<E> list = new LinkedList<>();

具体实例：

/**
*
*/
package test集合;

import java.util.*;
/**
* @author 寒
*
*/
public class Muster {

/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection<String > list = new ArrayList<>();   //实例集合类元素
list.add("a");                                  //向集合中添加元素
list.add("c");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();          //创建迭代器
while(it.hasNext()){
String str = (String )it.next();
System.out.println(str);
}
List<String > list2 = new ArrayList<>();
list2.addAll(list);
int i = (int)(Math.random() * (list2.size() - 1));
System.out.println("随机读取集合中的元素：" + list2.get(i));
for(int j = 0 ;j < list2.size() ; j ++){
System.out.println(list2.get(j));
}
}

}

Set集合

Set集合构造方法内含约束条件，不能传入重复的Collection对象值，在进行操作的时候也必须谨慎，若不小心修改某一元素导致与其他某一元素重复，将会引发一些问题。

Set接口的实现方法有两种：

1.HashSet

由哈希表支持，并不能保证该顺序恒久不变。此类允许使用null元素

2.TreeSet

不仅实现了Set接口，还实现了java.util.SortedSet接口，因此TreeSet类中在遍历集合时按照自然顺序递增排序，也可以按照指定的选择器递增排序。



Ps：存入TreeSet集合的Set集合必须实现Commparable接口，该接口中的compareTo（Object o）方法比较此对象与指定对象的顺序，如果该对象小于、等于或者大于指定对象，则分别返回负整数、0、正整数（可以修改返回，实现递减哦）。

代码实例：

/**
*
*/
package test集合;

import java.util.Iterator;
import java.util.TreeSet;

/**
* @author 寒
*
*/
public class TestTreeSet implements Comparable<Object>{

String name;
long id;
public TestTreeSet(String name , long id ){
this.id = id;
this.name = name;
}
/* （非 Javadoc）
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
@Override
public int compareTo(Object o) {
// TODO 自动生成的方法存根
TestTreeSet tree = (TestTreeSet) o;
int result = id > tree.id ? 1:(id == tree.id ?0:-1);// 实现比较方法
return result;
}
public long getId(){
return id;
}
public String getName(){
return name;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
TestTreeSet t1 = new TestTreeSet("a" , 25);
TestTreeSet t2 = new TestTreeSet("b" , 26);
TestTreeSet t3 = new TestTreeSet("c" , 30);
TestTreeSet t4 = new TestTreeSet("d" , 10);
TestTreeSet t5 = new TestTreeSet("e" , 5);
TestTreeSet t6 = new TestTreeSet("f" , 1);
TreeSet<TestTreeSet> list = new TreeSet<>();
list.add(t1);
list.add(t2);
list.add(t4);
list.add(t3);
list.add(t5);
list.add(t6);
Iterator <TestTreeSet> it= list.iterator();
System.out.println("显示TreeSet的所有元素：");
while(it.hasNext()){
TestTreeSet one = (TestTreeSet) it.next();
System.out.println(one.getId() + " " + one.getName());
}
it = list.headSet(t4).iterator();
while(it.hasNext()){
TestTreeSet one = (TestTreeSet) it.next();
System.out.println(one.getId() + " " + one.getName());
}
TestTreeSet t8 = list.first();
System.out.println(t8.getId() + " " + t8.getName());
it = list.tailSet(t5).iterator();
while(it.hasNext()){
TestTreeSet one = (TestTreeSet) it.next();
System.out.println(one.getId() + " " + one.getName());
}
}
}

Map集合

Map接口提供了将key映射到值的对象，一个映射不能包含重复的key，每个key最多只能映射一个值，Map接口中实现了集合的常用方法，在文章首部进行了总结，此处不再列举。

Map接口的两种试下方法：

1.HashMap

基于哈希表的实现方法，此实现提供所有的可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性，HashMap通过哈希表对其内部的映射关系进行快速查找，此类不影响映射的顺序，特别是它不保证该顺序恒久不变。使用此实现进行Map集合添加和删除映射关系效率更高。

2.TreeMap

不仅实现了Map接口，还实现了java.util.SortedMap接口，因此，集合中的映射关系有一定的顺序，但在添加、删除和定位映射关系的时候，TreeMap类较之于HashMap类性能稍差，由于TreeMap类实现的Map集合中的映射关系是按照键对象按照一定的顺序排列的，因此不允许键对象是null

可以通过HashMap创建Map集合，需要顺序输出的时候，创建一个完成相同映射关系的TreeMap类实例。

代码实例：

/**
*
*/
package test集合;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
* @author 寒
*
*/
public class TestMap {

public static void main(String []args){
Map<String,String> map = new HashMap<>();
map.put("01", "李同学");
map.put("03", "魏同学");
map.put("02", "李同学");
Set<String >set = map.keySet();
Iterator <String >it = set.iterator();
System.out.println("Key集合中的元素：");
while(it.hasNext()){
System.out.println(it.next());
}
Collection <String > coll = map.values();
it = coll.iterator();
System.out.println("values集合中的元素：");
while(it.hasNext()){
System.out.println(it.next());
}

TreeMap <String ,String> tree = new TreeMap<>();
tree.putAll(map);

Iterator<String> iter = tree.keySet().iterator();
System.out.println("TreeMap 类实现的Map集合，键对象升序：");
while(iter.hasNext()){
String it1 = (String )iter.next();
String name = (String )tree.get(it1);
System.out.println(it1 + " " + name);
}
}
}