浅谈集合框架二 List、Set常用方法

　　最近刚学完集合框架，想把自己的一些学习笔记与想法整理一下，所以本篇博客或许会有一些内容写的不严谨或者不正确，还请大神指出。初学者对于本篇博客只建议作为参考，欢迎留言共同学习。

　　之前有介绍集合框架的体系概念（http://www.cnblogs.com/yjboke/p/8761195.html），本篇介绍一下常用方法及常用工具类。

---

Collection→List→ArrayList：

　增（add）、删（remove）、改（set）、查（get）。

List<String> alist = new ArrayList<String>();
    alist.add("abc1");                   //.add        增加
    alist.add("abc2");
    alist.add("abc3");
    alist.add("abc4");
    System.out.println(alist.get(2));   //.get         查询                
    System.out.println(alist.remove(1));//.remove      删除元素，并输出删除元素
    alist.set(1,"a");                   //.set         修改
    System.out.println(alist);        

Collection→List→LinkedList：

除了以上介绍的增删改查方法外还有LinkedList的特有方法。

//在首末添加元素

addFirst（）；

addLast（）；

//获取首末元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException

getFirst（）；

getLast（）；

//获取首末元素，但会删除元素，如果集合中没有元素，会出现NoSuchElementException

removeFirst（）；

removeLast（）：

//判断是否包含元素，如果包含返回true

isEmpty

-------------------------------------在JDK1.6出现了替代方法：----------------------------------------------------

//添加元素

offerFirst（）；

offerLast（）；

//获取元素，但不会删除元素，如果集合中没有元素，会返回null

peekFirst（）；

peekLast（）；

//获取元素，但会删除元素，如果集合中没有元素，会返回null

pollFirst（）；

pollLast（）；

alist.addFirst("abc1");               　　 　　　 　//.addFirst在集合前添加  
        alist.addLast("abc4");                　　//.addLast在集合后方添加
        System.out.println(alist);   　　　　　　　//输出结果为：[abc3, abc2, abc1, abc4]
        System.out.println(alist.getFirst());    //获得首个元素
        System.out.println(alist.getLast()); 　　//获得最后的元素
        System.out.println(alist.removeFirst());//删除首个元素，并输出元素值
        System.out.println(alist.removeLast()); //删除最后的元素，并输出元素值

---

Collection→Set→HashSet：

添加：add（添加元素）；addAll（添加集合中所有元素）

删除：remove（删除元素）；

查询集合长度：size

查询是否存在：contains

HashSet<String> set1 = new HashSet<String>();    　　　　　//定义Set集合set1
        HashSet<String> set2 = new HashSet<String>();    //定义Set集合set2
        
        set1.add("abc1");           　　　　　　　　　　　　//add：将set集合中添加元素
        set1.add("abc2");
        set1.add("abc3");
        set1.add("abc3");           　　 　　　　　　　　　//添加重复元素不会添加进去，
        set2.addAll(set1);            　　　　　　　　　　//addAll:将集合set1添加到set2中
        System.out.println(set1);    　　　　　　　　　　 //输出内容为：[abc1, abc3, abc2] 无序
        System.out.println(set2);    　　　　　　　　　　 //输出内容为：[abc1, abc3, abc2] 和set1相同
        set1.remove("abc2");        　　　　　　　　　　  //remove：删除元素
        System.out.println(set1);    　　　　　　　　　　 //输出内容为：[abc1, abc3]
　　　　 System.out.println(set1.size());　　　　　　　　  //输出内容为：2   set1的长度
　　　　 System.out.println(set1.contains("abc1"));　　　//输出内容为：true

 使用HashSet存储自定义对象，包含重写hashCode和equals的方法：

　　首先定义一个手机类（Phone），包含价格（price）和名称（name）；

class Phone{
    
    private int price;
    private String name;
    
    Phone(int price,String name) {
        super();
        this.name = name;
        this.price = price;
    }
    
    public int getPrice(){
        return price;
    }
    public void setPrice(int price){
        this.price = price;
    }
    
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    
    public String toString(){
        return "Phone:price = "+price + ",name = " + name;                 //输出格式
    }
    //复写hashCode方法
    public int hashCode(){
        final int prime = 31;
        int result = 1;
        result = prime * result + price;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    //复写equals方法
    public boolean equals(Object obj){
        
        if(!(obj instanceof Phone)){
            throw new ClassCastException("类型不匹配");                    //也可写为：return false;
        }
        Phone p = (Phone)obj;
        System.out.println(this.name + " and " + p.name + "重复了");        //如果重复数据则打印输出
        return this.name.equals(p.name) && this.price==p.price;
    }
}

　　创建一个HashSet集合，并添加数据并输出，添加重复数据进行验证：

public static void main(String[] args) {
        HashSet<Phone> hs = new HashSet<Phone>();                //定义HashSet集合
        hs.add(new Phone(4888, "xiaomi"));
        hs.add(new Phone(8388, "iphoneX"));
        hs.add(new Phone(8388, "iphoneX"));
        hs.add(new Phone(3288, "vivo"));                            //重复数据
        //迭代器输出
        for(Iterator<Phone> it = hs.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }

　　输出结果为：

iphoneX and iphoneX重复了
Phone:price = 4888,name = xiaomi
Phone:price = 3288,name = vivo
Phone:price = 8388,name = iphoneX

--------------------------------------------------------------------------------------------------------------

Collection→Set→TreeSet：

　　操作元素方式与HashSet相同，但TreeSet是有序的，现介绍TreeSet如何存储自定义对象。

　　现封装一个Person类，其中有年龄和姓名两种属性，实现Comparable接口使元素具备比较性，并创建一个比较器。

class Person implements Comparable{                //注：Comparable接口可让Person类具备比较性
    
    private int age;
    private String name;
    
    Person(int age,String name) {
        super();
        this.name = name;
        this.age = age;
    }
    
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    
    public String toString(){
        return "年龄为 ： "+age + ",姓名为： " + name;                 //输出格式
    }
    //比较器
    public int compareTo(Object obj){
        if(!(obj instanceof Person)){
            throw new ClassCastException("不是人");        //可用：return false;代替
        }
        Person p = (Person)obj;
        if(this.age > p.age){
            return 1;                                    //比较大小进行排序
        }
        if (this.age == p.age) {
            return this.name.compareTo(p.name);         //如果年龄相同则比较姓名，返回1、0、-1
        }
        return -1;
    }
43　}

创建一个TreeSet集合，并添加数据进行验证。

public static void main(String[] args) {
        TreeSet<Person> hs = new TreeSet<Person>();                //定义HashSet集合
        hs.add(new Person(4888, "xiaomi"));
        hs.add(new Person(8388, "iphoneX"));
        hs.add(new Person(8388, "iphoneX"));                    //重复数据
        hs.add(new Person(3288, "vivo"));                            
        //迭代器输出
        for(Iterator<Person> it = hs.iterator();it.hasNext();){
            Person per = (Person)it.next();
            System.out.println(per.getAge() + "....." + per.getName() );
        }
    }

输出结果为：

3288.....vivo
4888.....xiaomi
8388.....iphoneX

另：在不改变当前代码的前提下要求按照姓名排序。可定义一个类，实现Comparator接口，覆盖compare方法。

class MyCompars implements Comparator{
    
    public int compare(Object o1,Object o2){
        Person s1 = (Person) o1;
        Person s2 = (Person) o2;
        int num = s1.getName().compareTo(s2.getName());
        //当名称相同时，比较年龄大小进行排序。
        if(num == 0){
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));     //与下方注释的方法意义相同。
            /*if (s1.getAge() > s2.getAge()) {
                num = 1;
            }
            if(s1.getAge() == s2.getAge()){
                num = 0;
            }
            return -1;*/
        }
        return num;
    }
}

然后将其传入到集合中：

public static void main(String[] args) {
        TreeSet<Person> hs = new TreeSet<Person>(new MyCompars());                //定义HashSet集合
        hs.add(new Person(4888, "xiaomi"));
        hs.add(new Person(8388, "iphoneX"));
        hs.add(new Person(8188, "iphoneX"));                    //重复数据
        hs.add(new Person(3288, "vivo"));                            
        //迭代器输出
        for(Iterator<Person> it = hs.iterator();it.hasNext();){
            Person per = (Person)it.next();
            System.out.println(per.getAge() + "....." + per.getName() );
        }
    }

输出结果为：

8188.....iphoneX
8388.....iphoneX
3288.....vivo
4888.....xiaomi

总结：当元素自身不具备比较性或者所具备的比较性不是自己所需要的，就可以让容器自身具备比较性。当两种排序都存在时，以比较器为主。