黑马程序员技术交流社区

标题: 集合类（中） [打印本页]

---

作者: mortonnnn    时间: 2015-7-18 00:36
标题: 集合类（中）
Set
特点：无序，无重复2
两大实现类：HashSet和TreeSet
HashSet，根据对象的哈希值来确定对象在元素中的储存位置，因此具有良好的存取和查找性能
TreeSet，以二叉树的方式来储存元素，可以实现对集合中的元素进行排序

public class Example01:
        public void static main(String[] args){
                HashSet set = new HashSet();
                set.add("peter");
                set.add("morton");
                set.add("mary");
                set.add("mary);
               
                Iterator it = set.iterator();
                while(it.hashNext()){
                        Object o = it.next();
                }
        }
}

对象存入HashSet类，要先调用对象的hashCode()方法来获取对象的哈希值，然后再
调用equals()来比较对象是否相等

如果自定义的对象没有重写hashCode()和equals()方法，有时候会出错：

class Person{
        String id;
        String name;

        person(String id , String name){
                this.id = id;
                this.name = name;
        }

        //重写toString方法
        public String toString(){
                return id + ":" + name;s
        }
}

class Example02 {
        public void static main(String[] args){
                HashSet set  = new HashSet();
                set.add(new Person("21","peter");
                set.add(new Person("22","mary");
                set.add(new Person("22","mary");
        }
}

这样的话，会出现重复


正确的写法：
Person {
        String id;
        String name;

        Person(String id , String name){
                this.id  = id;       
                this.name = name;
        }

        //重写toString()
        public String toString(){
                return id +  ":" + name;
        }

        //重写hashCode()
        public int hash(){
                retrun id.hashCode();
        }
       
        //重写equals()方法
        public boolean equals(Object o){
                if(this == o)
                        return false;
                if(!(o instanceof Person))
                        return false;
                Person p  = (Person) o ;
                return p.id.equals(this.id);
        }

        //equals()是所有类的一个共有方法，其重写规则为：直接比较---类型比较---强转类型比较属性


public class Example03{
        public void static main(String[] args){
                HashSet set = new HashSet();
                set.add(new Person("22","Mike");
                set.add(new Person("22","Mike");
        }
}

这样的话，就避免了重复添加两个相同对象


TreeSet：
二叉树就是每个节点最多有两个子节点的有序树
TreeSet内部使用的是自平衡的排序二叉树，其特点是储存的元素会按照大小排序以及能避免重复


HashedSet是不能重复（重写hashCode()和equals()方法），而TreeSet是比较大小(重写
compareTo(Object to)方法，或者重写比较器implements Comparator)

不重写compareTo()方法时，会自动按照常见的方式来排序（如首字母顺序）

class Example04{
        public void static main(String[] args){
                TreeSet ts = new TreeSet();
                ts.add("aaaaaaaa");
                ts.add("ccccccc");
                ts.add("bbbbbbbb");

                Iterator iterator = ts.iterator();
                while(iterator.hasNext()){
                        System.out.println(ts.next());
                }
        }
}

这样出来的是aaaaaa,bbbbb,ccccccccc

class Person {
        String id;
        String name;
       
        //构造函数
        Person(String id , String name){
                this.id = id;
                this.name = name;
        }

        //重写toString()方法
        public String toString(){
                return id + ":" + name;
        }
       
        //重写compareTo()
        public int compareTo(Object o){
                Person p = (Person) o;
                x = Integer.parseInt(this.id);
                y = Integer.parseInt(p.id);
                if((x - y ) > 0){
                        return 1;
                }
                if(x == y ){
                        return p.name.compareTo(this.name);
                }
                return -1;
        }
}

class Example05{
        public void static main(Stringp[] args){
                TreeSet set = new TreeSet();
                set.add(new Person("33","sldf");
                ...
                set.add(new Person("34","sfgg");
        }
}


还可以自己实现comparator写个自定义的比较器
class MyComparator implements comparator{
        //重写compare()方法
        public int compare(Object o1, Object o2){
        //强转为String
                String s1 = (String) o1;
                String s2 = (String) o2;
                return (s1.length - s2.length);
        }
}

public class Example06{
        public void static main(String[] args){
                //实例化TreeMap,并且传入自定义的比较器
                TreeMap tm = new TreeMap(new MyComparator);
                tm.add("sssssssssssss");
                tm.add("adfsdfa");
                tm.add("trwtwrt");
                //添加迭代器
                Iterator it = tm.iterator();
                while(it.hasNext()){
                        System.out.println(it.next());
                }
        }
}

学完collection，再看Map接口
7个常用的方法：
2boolean：
boolean containsKey(Object key)
boolean containsKey(Object value)
void put(Object key,Object value)
Object get(Object key)
//以下三个方法比较重要
Set keySet()---返回此映射包含的键的视图
Collection<v> values()---返回此映射包含的值的Collection视图
Set<Map.Entry<K,V>> entrySet()---返回此映射包含的所有键值对

注意返回值格式：
Set<Map.Entry<K,V>>
Map.Entry是Map的一个接口内部类，entry是条目的意思

和Set一样，Map接口主要有HashMap和TreeMap两个实现类
HashMap类：
public class Example15{
        public void static main(String[] args){
                Map map = new HashMap();        //创建hashmap
                map.put("1","aaa");        //储存键值对，注意Collection是add(),Map是Put()
                map.put("2","bbb");       
                map.put("3","ccc");
                map.put("4","ddd");
               
                System.out.println("1"+map.get("1"));
                System.out.println("2"+map.get("2"));
        }

}

利用entrySet()和keySet()方法可以实现Map的遍历

public class Example16{
        public void static main(String[] args){
                Map map  = new Map();       
                map.put("1","aaa");        //储存键值对，注意Collection是add(),Map是Put()
                map.put("2","bbb");       
                map.put("3","ccc");
                map.put("4","ddd");
       
                Set key  = map.keySet();
                Iterator it = key.iterator();
               
                while(it.hasNext()){
                        String s = it.next();
                        String ss = map.get(s);
                }
        }
}

第二种遍历方法：
public class Example17{
        public void static main(String[] args){
               
                Map map  = new Map();       
                map.put("1","aaa");        //储存键值对，注意Collection是add(),Map是Put()
                map.put("2","bbb");       
                map.put("3","ccc");
                map.put("4","ddd");

                Set set  = map.entrySet();
                Iterator it = set.Iterator();
                while(it.hasNext()){
                        Map.Entry me = it.next();
                        Object key = me.getKey();
                        Object value  = me.getValue();
                }
        }
}

HashMap里还有最后一个东西：LinkedHashMap
与LinkedList一样都是使用双向链表来维护内部元素的关系，使得Map元素的迭代的顺序与存入的顺序一致。。所以它的特点就是：迭代出来的元素顺序和存入的顺序一致


public class Example18 {
        public void static main(String[] args){
                Map map = new LinkedHashMap();
                map.put("1","qqq");
                map.put("2","www");
                map.put("3","eee");
               
                //获取全部键的集合
                Set keys = map.keySet();
                //获取迭代器
                Iterator it = keys.iterator();
                while(it.hasNext()){
                        Object key = it.next();
                        Object value = map.get(key);
                        System.out.println(value);
                }
        }
}
       

TreeMap:通过二叉树的原理来保证键的唯一性，与TreeSet集合存储的原理一样，因此TreeMap中所有的键都是按照某种顺序排列的,其中最关键的还是比较器
一般根据String类型来排序，String类实现了Comparable接口，因此会默认按照自然顺序进行排序，当然也可以自定义选择器。

一般情况：
class Example19{
        public void static main(String[] args){
                Map map = new TreeMap();                        //new一个TreeMap
                map.put("1","feriosa");                        //向Map中放入键值对
                map.put("2","max");
                map.put("3","nux");
               
                Set keys = map.keySet();                        //得到全部键的集合
                Iterator it  = keys.iterator();                        //得到迭代器
                while(it.hasNext()){                                //开始迭代
                        Object key = it.next();
                        Object value = map.get(key)                //得到键所对应的值
                }

        }
}

如前所述，会按照String类型来排序(默认为从小到大)

自定义选择器的情况：(从大到小)
class Example20{
        public void static main(String[] args){
                Map map = new TreeMap(new MyComparator())                //传入自定义选择器的实例
                map.put("1","feriosa");
                map.put("2","max");
                map.put("3","nux");
                       
                Set keys = map.keySet();                        //得到键的Set集合
                Iterator it = keys.iterator();                        //得到迭代器
                while(it.hasNext()){                                //开始迭代
                        Object key = keys.next();
                        Object value = map.get(key);
                        System.out.println(value);
                       
               
        }
}

class MyComparator implements Comparator {                        //自定义选择器
        public int compare(Object o1, Object o2){
                String s1 = (String) o1;
                String s2 = (String) o2;                        //强转为String类型
               
                return s1.compareTo(s2);                        //返回较大值
        }
}

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2