java_集合

简要说明

java中的集合所在包为java.util.*。

集合相当于一个容器，常见的数组，它是存储相同数据类型的，长度固定，而集合存储的是对象的引用，长度是可变的。

常见的集合类有：List集合，Set集合，Map集合。可以看下图的关系图

 

List集合和Set集合实现了Collection接口。而Map集合时单独的。

Collection接口

Collection表示一组对象（或者成为元素），一些Collection中可以有重复元素，另一些是不能的，一些事有序的，一些事无序的。

JDK中规定，不能直接实现此接口，可以使用它的子接口去实现，比如,List和Set子接口。下面是一段简单的实例，其中的ArrayList实现List接口，后面会讲到，而Iterator是专门对Collection进行迭代的迭带器。

(Copy Code)

public static void main (String [] args)
{
 Collection<String> listCollection = new ArrayList<String>();
 listCollection.add("1");
 listCollection.add("2");
 listCollection.add("3");
 Iterator<String> it = listCollection.iterator();// 创建迭代器
 while (it.hasNext())
 {
  System.out.println((String)it.next());
 }
}

List集合

List集合包含List接口以及List接口的所有实现类，List集合中的元素允许有重复，各元素的顺序就是按对象插入的顺序。像数组一样，可以使用索引号访问元素。

List接口

List接口实现了Collection接口，拥有Collection的所有方法。此外还添加了2个很重要的方法：

• get(int index) :获取指定索引处的元素
• set(int index,Object obj) ：将集合中指定索引位置的元素更改为指定的对象

List接口的实现类

常用的有ArrayList和LinkedList

• ArrayList类：实现了可变的数组，允许所有类型元素，包括null值。根据索引位置对集合中的元素进行快速的随机访问，缺点是根据索引位置进行插入和删除的效率慢。
• LinkedList类 ：使用链表结构保存对象，此结构使它的优点就是ArrayList的缺点，它的缺点就是ArrayList的优点，两者互补的，所以根据实际情况，选择合适的来实现List集合。

下面是一个简单的实例

List接口实现类(Copy Code)

public static void main (String [] args)
{
  // ArrayList
  List<Integer> list = new ArrayList<Integer>();//用ArrayList类实现List接口
  list.add(1);//添加元素
  list.add(2);
  list.add(3);

  System.out.println("List集合中的元素为：");
  for (int i = 0 ; i < list.size(); i++)
  {
    System.out.println(list.get(i));//通过List集合新增的方法get(int index)获取指定索引处的元素
  }
  list.set(2 , 4);//通过List集合新增的方法set(int index,Object obj) 更改索引处的元素为指定的Object

  System.out.println("更改后的List集合中的元素为：");
  for (int i = 0 ; i < list.size() ; i++)
  {
    System.out.println(list.get(i));// 通过List集合新增的方法get(int index)获取指定索引处的元素
  }

  // LinkedList
  List<Integer> list2 = new LinkedList<Integer>();
  list2.add(4);
  list2.add(5);
  list2.add(6);

  System.out.println("List集合中的元素为：");
  for (int i = 0 ; i < list2.size() ; i++)
  {
    System.out.println(list2.get(i));
  }
  list2.set(2 , 7);// 通过List集合新增的方法set(int index,Object obj) 更改索引处的元素为指定的Object

  System.out.println("更改后的List集合中的元素为：");
  for (int i = 0 ; i < list2.size() ; i++)
  {
    System.out.println(list2.get(i));// 通过List集合新增的方法get(int index)获取指定索引处的元素
  }
}

List集合的索引号和数组一样，从0开始的。

Set集合

Set集合中的对象是不按特定方式排序的。Set集合不能有重复对象。

Set集合有Set接口和Set接口的实现类组成。

和List集合同样实现Collection接口。

Set接口的实现类有HashSet类和TreeSet类

• HashSet类，实现Set接口，由哈希表（实际为一个HashMap实例）支持。它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变，它允许使用null元素，当然不能有重复对象。
• TreeSet类，不仅实现了Set接口，还实现了java.lang.SortedSet接口，所以在遍历集合时会按照自然顺序递增排序，当然可以根据指定比较器自定义排序。

TreeSet中新增的某个方法就是comparator(),返回对此Set元素进行排序的比较器。如果使用默认的自然排序，则返回null。

下面是实例

TreeSet类实现Set集合(Copy Code)

//Comparable此接口强行对实现它的每个类的对象进行 整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
public class TreeSetDemo implements Comparable<Object>
{
 String nameString;
 long id;

 public TreeSetDemo (String name , long id)
 {
  super();
  this.id = id;
  this.nameString = name;
 }

 public String getNameString ()
 {
  return this.nameString;
 }

 public void setNameString (String nameString)
 {
  this.nameString = nameString;
 }

 public long getId ()
 {
  return this.id;
 }

 public void setId (long id)
 {
  this.id = id;
 }

 /**
  * @param args
  */
 public static void main (String [] args)
 {
  TreeSetDemo treeSetDemo = new TreeSetDemo("张三" , 12);
  TreeSetDemo treeSetDemo1 = new TreeSetDemo("张三55" , 13);
  TreeSetDemo treeSetDemo2 = new TreeSetDemo("张三44" , 19099);
  TreeSetDemo treeSetDemo3 = new TreeSetDemo("张三33" , 90);
  TreeSet<Object> treeSet = new TreeSet<Object>();
  treeSet.add(treeSetDemo);
  treeSet.add(treeSetDemo1);
  treeSet.add(treeSetDemo2);
  treeSet.add(treeSetDemo3);
  // treeSet.comparator();
  Iterator<Object> iterator = treeSet.iterator(); // 创建Set集合的迭代器

  System.out.println("Set集合中的所有元素是");
  while (iterator.hasNext())
  {
   TreeSetDemo tr = (TreeSetDemo) iterator.next();
   System.out.println(tr.nameString + "  " + tr.id);
  }

  // headSet截取排在treeSetDemo2前面的对象
  iterator = treeSet.headSet(treeSetDemo2).iterator();
  System.out.println("截取前面部分的集合");
  while (iterator.hasNext())
  {
   TreeSetDemo tree = (TreeSetDemo) iterator.next();
   System.out.println(tree.id + "  " + tree.nameString);
  }

  // subSet 截取排在treeSetDemo2 和 treeSetDemo3 之间的对象
  iterator = treeSet.subSet(treeSetDemo1 , treeSetDemo3).iterator();
  System.out.println("截取前面部分的集合");
  while (iterator.hasNext())
  {
   TreeSetDemo tree = (TreeSetDemo) iterator.next();
   System.out.println(tree.id + "  " + tree.nameString);
  }
 }


 @Override
 public int compareTo (Object o)
 {
  TreeSetDemo treeSetDemo = (TreeSetDemo) o;
  int result = id > treeSetDemo.id  1 : (id == treeSetDemo.id  0 : -1);
  return result;
 }

}

存入TreeSet类实现Set集合的类必需实现Comparable接口。重写的compareTo方法，指定了对象与指定对象的排序顺序。

Map集合

Map没有实现Collection接口，它提供的是一种键(Key)值(Value)对的映射，一个Key对应一个value，不能有相同的key。

Key还决定了存储对象在映射中的存储位置，注意的是不是根据key本身去实现，而是根据散列技术进行处理的，产生一个散列码的整数值，相当于一个偏移量，对应分配给映射的内存区域的起始位置，以此来决定存储在映射中的存储位置。

Map集合有Map接口和实现它的类组成。

Map接口中有几个常用的方法

• put(Key k,value v)：向集合中添加指定键值对
• get(Object key)：根据指定的key获取对应的value
• keySet()；返回集合中所有key对象形成的set集合
• values()；返回集合中所有value对象形成的Collection对象

下面是一个实例

HashMap类实现Map集合(Copy Code)

public static void main (String [] args)
{
  Map<String, String> map = new HashMap<String, String>();
  map.put("李" , "19");
  map.put("张" , "26");
  map.put("黄" , "23");
 
  Set<String> set = map.keySet(); // 返回Map中所有键对象形成的Set集合
 
  Iterator<String> iterator = set.iterator();// 创建迭代器
 
  System.out.println("Key 中的集合元素:");
  while (iterator.hasNext())
  {
   System.out.println(iterator.next());
  }
 
  Collection<String> coll = map.values(); // 返回Map中所有值对象形成的Collection集合
 
  iterator = coll.iterator();
  System.out.println("values中的元素:");
  while (iterator.hasNext())
  {
   System.out.println(iterator.next());
  }
}

Map集合允许value为null，而且么有个数限制，如：map.put("a" , null);

Map接口的实现类

可分为HashMap类和Treemap类。HashMap对添加和删除映射关系的效率比TreeMap高（通过哈希码对其内部进行映射关系查找），但TreeMap中的对象是存在一定顺序的。、

• HashMap类：基于哈希表的Map接口实现，允许使用null键和null值，但必需唯一。
• TreeMap类：不仅实现了Map接口，还实现了java.util.SortedMap接口，因此集合中的元素是存在一定顺序的。在添加和删除映射关系上的性能没有HashMap好。由于它是根据键对象按照一定顺序排列的，所以不允许key为null

下面是一个实例

Map实例(Copy Code)

public class MapDemo2
{
 public MapDemo2 (String e_id , String e_name)
 {
  this.e_idString = e_id;
  this.e_nameString = e_name;
 }

 String e_idString;
 String e_nameString;

 public String getE_idString ()
 {
  return this.e_idString;
 }

 public void setE_idString (String eIdString)
 {
  this.e_idString = eIdString;
 }

 public String getE_nameString ()
 {
  return this.e_nameString;
 }

 public void setE_nameString (String eNameString)
 {
  this.e_nameString = eNameString;
 }

 public static void main (String [] args)
 {
  Map<String, String> map = new HashMap<String, String>();// HashMap实现Map接口
  MapDemo2 demo = new MapDemo2("001" , "张三");
  MapDemo2 demo1 = new MapDemo2("004" , "张si");
  MapDemo2 demo2 = new MapDemo2("003" , "张wu");

  // 添加键值对
  map.put(demo.getE_idString() , demo.getE_nameString());
  map.put(demo1.getE_idString() , demo1.getE_nameString());
  map.put(demo2.getE_idString() , demo2.getE_nameString());

  // 获取map集合种哦所有Key的Set集合
  Set<String> set = map.keySet();

  Iterator<String> iterator = set.iterator();
  System.out.println("HashMap类实现的Map集合，无序");
  while (iterator.hasNext())
  {
   // 获取Key
   String str = (String) iterator.next();
   // 根据Key获取对应的value
   String nameString = (String) map.get(str);
   System.out.println(str + " " + nameString);
  }

  // TreeMap

  TreeMap<String, String> treeMap = new TreeMap<String, String>();
  // .将指定映射中的所有映射关系复制到TreeMap中。
  treeMap.putAll(map);
  Iterator<String> iterator2 = treeMap.keySet().iterator();
  System.out.println("treeMap类实现的Map集合，键对象升序");
  while (iterator2.hasNext())
  {
   String str = (String) iterator2.next();// 获取Key
   String nameString = (String) map.get(str); // 根据Key获取对应的value
   System.out.println(str + " " + nameString);
  }
 }
}