Collection List Set SortedSet ArrayList LinkedList HashSet LinkedHashSet TreeSet的认识及用法

 

package com.semovy.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.SortedSet;
import java.util.TreeSet;

/**
*
* @author semovy@gmail.com
*  Collection
*  |        |
*  List    Set______________________________________________
*  |__________                      |       |               |
*  |          |                     |       |               |
*  ArrayList  LinkedList        HashSet   LinkedHashSet     SortedSet
*                                                           |
*                                                           TreeSet
*/
public class CollectionTest {
/* Set容器中的对象是唯一的,所以加入Set容器的对象,必须重新equals()方法.作为唯一性的标识
* HashSet的排序规则是利用HashTable,所以HashSet容器的对象必须重新定义hashCode()方法
* 利用hashCode()方法,可以让快速找到容器中的对象,在比较两加入到容器中的对象是否相同时,会比较
* hashCode()方法返回是否相同,如果相同,则再利用equals()方法比较,如果两者都相同,则被看作相同的对象
* String 对象的hashCode(),equals已经被重新定义
*/
public static void main(String[] args)
{
  //String 对象的hashCode(),equals已经被重新定义
  //结果重复的内容对象被除去,并按按照hashCode()升序排序
  Collection<String> colStr = new HashSet<String>();
  colStr.add("ArrayList");
  colStr.add("LinkedList");
  colStr.add("HashSet");
  colStr.add("LinkedHashSet");
  colStr.add("LinkedSortedSet");
  colStr.add("ArrayList");
  CollectionTest ct = new CollectionTest();
  ct.display(colStr);
  //自定义类Employee.如果没有重新定义hashCode(),equals()方法,则不会除去重复内容的对象,不会自动按hashCode()排序
  Collection<Employee> colEmp = new HashSet<Employee>();
  colEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  colEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  colEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  colEmp.add(new Employee(4,"no.4","joke","note1"));
  colEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(colEmp);
  //LinkedHashSet,既去除了内容重复的对象,又按时插入容器时的顺序,被迭代.
  Collection<Employee> linkedEmp = new LinkedHashSet<Employee>();
  linkedEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  linkedEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  linkedEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  linkedEmp.add(new Employee(4,"no.4","joke","note1"));
  linkedEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(linkedEmp);
  //SortedSet接口,可以去除重复,并有比较器.
  SortedSet<String> ss = new TreeSet<String>();
  ss.add("1");
  ss.add("2");
  ss.add("3");
  ss.add("4");
  ss.add("4");
  ct.display(ss);
 
  //  SortedSet接口,可以去除重复,并有比较器.
  SortedSet<Employee> treeEmp = new TreeSet<Employee>(
    new Comparator<Employee>()//使用Employee泛型,匿名内部类比较器
    {
    
     public int compare(Employee arg0, Employee arg1) {
     
      return arg1.getName().compareTo(arg0.getName());//按照名称比较降序排序
     }
    
    }
    );
  treeEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  treeEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  treeEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  treeEmp.add(new Employee(4,"no.4","joke","note1"));
  treeEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(treeEmp);
 
  //SortedSet接口,可以去除重复,并有比较器.比较器名为comparatorById
  ComparatorById comparatorById = new ComparatorById();
  SortedSet<Employee> treeEmp1 = new TreeSet<Employee>(comparatorById);
  treeEmp1.add(new Employee(1,"no.1","semovy","he is a hero."));
  treeEmp1.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  treeEmp1.add(new Employee(3,"no.3","韦善茂","来自中国"));
  treeEmp1.add(new Employee(4,"no.4","joke","note1"));
  treeEmp1.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(treeEmp1);
 
  System.out.println();
  System.out.println(treeEmp1.last().toString());
  System.out.println(treeEmp1.first().toString());
 
  //用List接口的实现
  //ArrayList.基于数组的实现,添加与删除的效率慢于LinkedList,
  //LinkedList基于双向链表的实现 ,添加与删除的效率快于ArrayList,但迭代遍历的效率不如ArrayList
  List<Employee> empList = new ArrayList<Employee>();
  empList.add(new Employee(1,"no.1","semovy","he is a hero."));
  empList.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  empList.add(new Employee(3,"no.3","韦善茂","来自中国"));
  empList.add(new Employee(4,"no.4","joke","note1"));
  empList.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(empList);
 
  Employee[] arrEmp = empList.toArray(new Employee[0]);
  Arrays.sort(arrEmp, comparatorById);//用Arrays.sort静态方法排序,比较器是comparatorById
 
  ct.display(arrEmp);
 
  LinkedList<Employee> linkedListEmp = new LinkedList<Employee>();
  linkedListEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  linkedListEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  linkedListEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  linkedListEmp.add(new Employee(4,"no.4","joke","note1"));
  linkedListEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(linkedListEmp);
 
  ListIterator<Employee> ll =  linkedListEmp.listIterator();
  while(ll.hasNext())
  {
   Employee em = ll.next();
   System.out.println("index:" + ll.nextIndex());
   if(em.getId() == 3)
    ll.remove();//删除刚跨过的元素
  }
  ct.display(linkedListEmp);
}

/**
  * display all the objects in Collection
  * @prama Conllection
  */
public void display(Collection c)//用for循环集合
{
  System.out.println();
  for(Object obj : c)
   System.out.println(obj.toString() + " ");
}
public void display(Object[] arr)//用for循环数组
{
  System.out.println();
  for(Object obj : arr)
   System.out.println(obj.toString() + " ");
}
}
/**
* 比较器接口Comparator 按id.升序
*/
class ComparatorById implements Comparator<Employee>
{
public int compare(Employee e1 ,Employee e2)
{
  return e1.getId() - e2.getId();//按照id比较升序排序
}
}

//==============================================================================
结果:

ArrayList
HashSet
LinkedSortedSet
LinkedHashSet
LinkedList

[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

1
2
3
4

[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]
[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
index:1
index:2
index:3
index:3
index:4

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]