JAVA中集合

JAVA中得集合类型

• List:有序集合，可以放重复的数据
  • 主要有两个实现ArrayList 和LinkedList
  • ArrayList:查询数据比较快，添加和删除数据比较慢，是基于可变数组的

		ArrayList arrayList = new ArrayList();//面向具体编程写法
		/**这两种创建对象的方法更加灵活*/
		List arrayList = new ArrayList();//面向接口写法
		Collection c = new ArrayList();

• LinkedList:查询数据比较慢，添加和删除数比较快，基于链表结构

  		LinkedList arrayList = new LinkedList();//面向具体编程写法
  		/**这两种创建对象的方法更加灵活*/
  		List arrayList = new LinkedList();//面向接口写法
  		Collection c = new LinkedList();

• Set: 无序集合，不能放重复数据

  • 哈希表
    -哈希表是一种数据结构，哈希表能够提供快速存取操作。哈希表是基于数组的，一旦创建将不能扩展。
  • HashSet
    • HashSet 中的数据是无序的不可重复的.向 HashSet 中插入数据的时候，他会调用对象的hashCode 得到该对象的哈希码，然后根据哈希码计算出该对象插入到集合中的位置

		Set hashSet = new HashSet();
		hashSet.add(1);
		hashSet.add(2);
		hashSet.add(3);
		for(Iterator iter = hashSet.iterator();iter.hasNext()){
		  System.out.println(iter.next());
		  //输出为 2 1 3
		}

• equals 和 hashCode
  • equals相等，hashcode一定相等
  • 两个对象 equals 不相等，那么它的 hashcode 并不要求它不相等，但一般建议不相等
  • hashcode 相等不代表两个对象相等（采用 equals 比较）

		public class HashSetTest05 { 
		  
		  public static void main(String[] args) { 
			   Person p1 = new Person(); 
			   p1.name = "小明"; 
			   p1.age = 12; 
		   
			   Person p2 = new Person(); 
			   p2.name = "小张"; 
			   p2.age = 30; 
		 
			   Person p3 = new Person(); 
			   p3.name = "小明"; 
			   p3.age = 23; 
			   System.out.println(" p1 equals p2,"  + p1.equals(p2)); 
			   System.out.println(" p1 equals p3,"  + p1.equals(p3)); 
			   
			   Set set = new HashSet(); 
			   set.add(p1); 
			   set.add(p2); 
			   set.add(p3); 
			   
			   for (Iterator iter=set.iterator(); iter.hasNext();) { 
			    Person p = (Person)iter.next(); 
			    System.out.println(" name="  + p.name + " , age="  + p.age); 
			   } 
			   
			   System.out.println(" p1.hashCode="  + p1.hashCode()); 
			   System.out.println(" p2.hashCode="  + p2.hashCode()); 
			   System.out.println(" p3.hashCode="  + p3.hashCode()); 
			  }  
			} 
     class Person { 
		  String name; 		  
		  int age; 	  
		  //覆盖 hashCode 
		  public int hashCode() { 
		   return (name==null)?0:name.hashCode();  
		  } 
		   //覆盖 equals 
		  public boolean equals(Object obj) { 
		   if (this == obj) { 
		    return true;  
		   } 
		   if (obj instanceof Person) { 
		    Person p = (Person)obj; 
		    return this.name.equals(p.name); 
		   } 
		   return false; 
		  } 
		} 

---

	     person{"name=小明"，age=12} 			person{"name=小张"，age=30}
		  			7788888									8848848

---

因为覆盖了 equals 和 hashCode，当 hashCode 相同，它会调用 equals 进
行比较，如果equals 比较相等将不加把此元素加入到 Set 中，但 equals 比较不相等会重新根据hashCode 换算位置仍然会将该元素加入进去的。

• TreeSet
  • TreeSet 可以对 Set 集合进行排序，默认自然排序（即升序），但也可以做客户化的排序

		Set set = new TreeSet();
		set.add(1);
		set.add(2);
		set.add(3);
		//输出结果为 1 2 3

当对对象进行排序时，必须实现Comparator接口

		public class TreeSetTest { 
		/**法一：实现Comparable接口*/
  
		  public static void main(String[] args) { 
			   Person p1 = new Person(); 
			   p1.name = "小张"; 
			   p1.age = 20; 
			   
			   Person p3 = new Person(); 
			   p3.name = "小李"; 
			   p3.age = 40; 
			   
			   Person p2 = new Person(); 
			   p2.name = "小可";
			   Set<Person> set = new TreeSet<Person>(); 
			   set.add(p1);
			   set.add(p2);
			   set.add(p3);
			   Iterator iter = set.iterator();
			   while(iter.hasNext()){
			   		Person p = (Person)iter.next(); 
   				 	System.out.println(" name="  + p.name + " , age="  + p.age);
			   }
			   
			  }  
			} 
		class Person implements Comparable{
			String name;
			int age;
			public int comparaTo(Object o){
				if (o istanceof Person{
				   Person p = (Person)o;
				   //升序
				   return (this.age - p.age);
				   //降序
				   return (p.age - this.age);
				}
			}
		}
		/**
		 匿名内部类实现Comparator接口
		*/
		
		public static void main(String[] args) { 
			   Person p1 = new Person(); 
			   p1.name = "小张"; 
			   p1.age = 20; 
			   
			   Person p3 = new Person(); 
			   p3.name = "小李"; 
			   p3.age = 40; 
			   
			   Person p2 = new Person(); 
			   p2.name = "小可";
			   Set<Person> set = new TreeSet(new Comparator(){
               public int compare(Object o1, Object o2) { 
				     if (!(o1 instanceof Person)) { 
				      	throw new IllegalArgumentException("非法参数，o1="  + o1); 
				     } 
				     if (!(o2 instanceof Person)) { 
				      	throw new IllegalArgumentException("非法参数，o2="  + o2); 
				     } 
				     Person p1 = (Person)o1; 
				     Person p2 = (Person)o2; 
				     return p1.age - p2.age; 
				    }   
			   }); 
			   Iterator iter = set.iterator();
			   while(iter.hasNext()){
			   		Person p = (Person)iter.next(); 
   				 	System.out.println(" name="  + p.name + " , age="  + p.age);
			   }
			   
			  }  
			} 
					   

• Comparable 和Comparator的区别

  • 一个类实现了 Camparable 接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用 sort 方法排序
    Comparator可以看成一种算法的实现， 将算法和数据分离， Comparator 也可以在下面两种环境下使用：
    1、类的没有考虑到比较问题而没有实现 Comparable， 可以通过 Comparator 来实现排序而不必改变对象本身
    2、可以使用多种排序标准，比如升序、降序等

• Map:无序集合，由键值对组成，键不可以重复，但是值可以重复

  • Map 实现较常用的为HashMap，HashMap 对键对象的存取和 HashSet 一样，仍然采用的是哈希算法，所以如果使用自定类作为 Map 的键对象，必须复写equals 和 hashCode 方法
  • HashMap的遍历使用entrySet

		   Map map = new HashMap();
		   map.put("小明",1);
		   map.put("小庄",2);
		   Set entrySet = map.entrySet();
		   Iterator iter = entrySet.iterator();
		   while(iter.hasNext()){
			   Map.Entry entry = (Map.Entry) iter.next();
			   System.out.println(entry.getKey() + " , "  + entry.getValue()); 
		 }

• TreeMap
  • TreeMap 可以对 Map 中的 key 进行排序，如果 map 中的 key 采用的是自定类那么需要实现Comaprable 或 Comparator 接口完成排序

		   Map map = new TreeMap();
		   map.put("1002","小明");
		   map.put("1003","小明");
		   map.put("1001","小明");
		   map.put("1000","小明");
		   Set entrySet = map.entrySet();
		   Iterator iter = entrySet.iterator();
		   while(iter.hasNext()){
		       Map.Entry entry = (Map.Entry)iter.next();
		       System.out.println(entry.getKey() +" "+entry.getValue());
		   }

Collections 工具类

		可对集合进行排序

		List l = new ArrayList(); 
		   l.add(5); 
		   l.add(1); 
		   l.add(4); 
		   l.add(2); 
		   for (Iterator iter=l.iterator(); iter.hasNext();) { 
		    System.out.println(iter.next()); 
		   } 
		   System.out.println(" " ); 
		   
		   Collections.sort(l); 

Collection与Iterator

• Collection是List和Set的父接口，常见的方法有add()、addAll()、clear()、contains()、iterator()、remove()、toArray() 等方法
• Iterator迭代接口,通过此接口可以遍历集合中的数据，最主要的方法:
  • hasNext() 如果仍有元素可以迭代，返回true
  • next() 返回下一个迭代元素
    、