浅谈集合框架二 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

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