集合和泛型 二

Set接口：

Set接口存储一组唯一，无序的对象 HashSet是Set接口常用的实现类

HashSet的创建及方法调用：

public class TestHashSet {
    public static void main(String[] args){
        HashSet<String> hs=new HashSet<String>();
        hs.add("谁是第一个");
        hs.add("不知道");
        hs.add("我是第一个");
        System.out.println(hs);
        //Tterator迭代器
        Iterator<String> it=hs.iterator();        
        //判断是否有下一个元素，若有打印出来
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

输出结果：由结果可以看出Set集合的无序特性

 

Map接口：

Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作，最常用的实现类是HashMap

 

 Map接口常用方法：

 

HashMap集合的创建，添加数据和遍历：

public class NationalEnglish {
    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();
        m.put("CN", "中国");
        m.put("USA", "美国");
        m.put("GY", "德国");
        System.out.println(m);
        // 使用Set集合获取key值
        Set<String> set = m.keySet();
        // 使用Iterator遍历key来获取values值
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            // 打印获取的values值
            System.out.println(m.get(it.next()));
        }
        // 直接遍历values
        for (String s : m.values()) {
            System.out.println(s);
        }
        // 同时遍历key和value
        Set<Entry<String, String>> set1 = m.entrySet();
        for (Entry<String, String> ent : set1) {
            System.out.println("键值是：" + ent.getKey() + ",values是："
                    + ent.getValue());
        }
    }
}

 

通过重写一些方法，来实现一些功能：

public class Student implements Comparator<Student>{
    private String name;
    private char sex;
    private int age;
    
    public Student(){}
    public Student(String name,int age){
        this.name=name;        
        this.age=age;
    }
    //重写equals方法
    public boolean equals(Object obj){
        if(obj instanceof Student){
            Student stu=(Student) obj;
        if(this.age==stu.getAge()){
            return true;
        }else{
            return false;
        }
        }
        return false;
    }
    //重写hashCode方法
    public int hashCode(){
        return this.age;        
    }            
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }    
    //按名字排序，名字相同比较年龄
    public int compare(Student s1, Student s2) {
        if(s1.getName().equals(s2.getName())){
            return s1.getAge()-s2.getAge();//通过比较年龄排序
        }else{
            return s1.getName().compareTo(s2.getName());
        }
    }    
}

 

重写equals()和hashCode()方法，来实现去除年龄重复的测试类：

public class TestHashSet {
    public static void main(String[] args){
        //重写equals方法，来实现去除年龄重复的
        HashSet<Student> hs=new HashSet<Student>();
        Student s1=new Student("a",12);
        Student s2=new Student("b",15);
        Student s3=new Student("c",12);
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        for(Student stu:hs)
          System.out.println("名字是:"+stu.getName()+",年龄是："+stu.getAge());        
    }
}

输出结果：

通过重写compare()方法来实现根据姓名排序，若姓名重复则根据年龄排序的测试类：

public class Rewritesort {
    public static void main(String[] args){
        Student s1=new Student("小红",18);
        Student s2=new Student("张三",12);    
        Student s3=new Student("小红",15);    
        Student s4=new Student("a",22);    
        List<Student> lt=new ArrayList<Student>();
        lt.add(s1);
        lt.add(s2);
        lt.add(s3);    
        lt.add(s4);
        //根据姓名和年龄进行排序
        Collections.sort(lt,new Student());
        for(Student stu:lt){
          System.out.println(stu.getName()+"年龄是："+stu.getAge());
        }                
    }
}

 输出结果：