java中集合类

java中的集合的结构：

|-----Collection（元素为单个对象）

　　|-----Set （中的元素是不可以重复的）

　　　　|-----hashset：无序的

　　　　　　用哈希表实现的set，判断是不是相同的依据是 ：hashcode方法和equals方法。

　　　　|-----treeset方法：有序的

　　　　　　顺序依据元素实现的Comparable接口或者集合创建时传入的comparator中的规则。

　　　　　　两者实现的方法是根据compareTo（e）方法的返回值的正负或者comparator中的compare（e1，e2）返回值的正负。返回正时，（第一个参数）大于；返回负时，（第一个参数）小于；返回0时认为相等。注：这里并没有用到equals方法等。

 

　　|-----list：（按照存入的先后顺序存储，元素是可以重复的）

　　　　|-----Linkedlist：按照链表实现的list，自有功能为对头尾元素进行操作。特点是查询慢，修改快。

　　　　|-----arraylist：按照数组实现的list，自有的方法中有索引index的操作。特点是查询快，修改慢。

　　　　|-----vector：jdk1.0时代的arraylist。

 

|-----Map（存储的为key value对）

　　|-----hashmap 哈希表实现，判断是不是相同的依据是 ：hashcode方法和equals方法。

　　|-----treemap tree实现，顺序依据元素实现的Comparable接口或者集合创建时传入的comparator中的规则。

遍历的时候可以通过keyset返回 存放为key值的set集合，然后通过key的迭代方法得到每个key的时候，调用map的get方法得到value的值。

或者是entryset返回map.entry<k,v>的格式，这个也是set的结构，只不过这个set存放的是map的键值的关系。再通过map.entry的方法实现操作。（entry为map的内部接口。）

  1 package Collection;
  2 
  3 import java.util.HashMap;
  4 import java.util.Iterator;
  5 import java.util.Map;
  6 import java.util.Set;
  7 import myutil.SOP;
  8 
  9 public class TestMap1 {
 10 
 11     /**
 12      * @param args
 13 */
 14     public static void main(String[] args) {
 15         // TODO Auto-generated method stub
 16         HashMap<Student, String> hm = new HashMap<Student, String>();
 17         hm.put(new Student("no1", 21), "bejing");
 18         hm.put(new Student("no2", 22), "tianjin");
 19         hm.put(new Student("no3", 20), "shanghai");
 20         hm.put(new Student("no4", 25), "taiyuan");
 21         hm.put(new Student("no1", 22), "taiyuan");
 22         hm.put(new Student("no3", 20), "bejing");
 23 //        SOP.sop(hm);
 24         SOP.sop("===================");
 25         
 26         
 27         //通过keyset获得key迭代
 28         Set<Student> c=hm.keySet();
 29         for(Iterator<Student> it = c.iterator();it.hasNext();){
 30             Student s = it.next();
 31 //            SOP.sop(s+"111---"+hm.get(s));
 32         }
 33         SOP.sop("===================");
 34         //通过map.entry迭代
 35         Set<Map.Entry<Student, String>> sme = hm.entrySet();
 36         Iterator<Map.Entry<Student, String>> itme = sme.iterator();
 37         while(itme.hasNext()){
 38             Map.Entry<Student, String> me = itme.next();
 39             Student s = me.getKey();
 40             String str = me.getValue();
 41 //            SOP.sop(s+"222"+str);
 42         }
 43         //通过增强for循环遍历，不可以获得索引值，最好不要修改值
 44         for(Student s : hm.keySet()){
 45 //            SOP.sop(s);
 46         }
 47         
 48         for(Map.Entry<Student, String> me :hm.entrySet()){
 49             SOP.sop(me);
 50         }
 51     }
 52 
 53 }
 54 
 55 class Student implements Comparable<Student>{
 56     private String name;
 57     private int age;
 58     public Student() {
 59     }
 60     public Student(String name,int age) {
 61         this.name = name;
 62         this.age = age;
 63     }
 64     public String getName() {
 65         return name;
 66     }
 67     public void setName(String name) {
 68         this.name = name;
 69     }
 70     public int getAge() {
 71         return age;
 72     }
 73     public void setAge(int age) {
 74         this.age = age;
 75     }    
 76     public String toString() {
 77         return "name:"+this.name+",age:"+age+"--";
 78     }
 79     //用来对hash比较
 80     public int hashCode() {
 81         return this.name.hashCode()+this.age;
 82     }
 83     
 84     public boolean equals(Object o) {
 85         if(!(o instanceof Student))
 86             throw new RuntimeException("你输入的类型不对");
 87         Student s = (Student)o;
 88         if (this.age == s.age) {
 89             if (this.name.equals(s.name)) {
 90                 return true;
 91             }
 92         }
 93         return false;
 94     }
 95     
 96     
 97     //用来对tree比较。
 98     public int compareTo(Student o) {
 99         int i = new Integer(this.age).compareTo(new Integer(o.age));
100         if (i==0) {
101             return this.name.compareTo(o.name);
102         }
103         return i;
104     }
105 }

 

总结：hash都是通过hashcode+equals方法判断是不是相等。tree都是通过comparable接口或者comparator类判断大小。

转载于:https://www.cnblogs.com/zr-714/archive/2012/03/21/2409864.html