单列集合

单列集合

Collection：用于存储一系列符合某种规则的元素，它有三个子接口分别为List和Set和Queue

 　　　　　　　　　　　　　　　         关系图

一.List集合

List的特点：所有元素是以一种线性方式进行存储，元素有序，可重复（存入顺序和取出顺序一致）

1.ArrayList集合

（1）ArrayList介绍

ArrayList是List接口的实现类，在ArrayList内部封装了一个长度可变的数组对象，当存入的元素超过数组的长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素。

（2）优缺点：

ArrayList集合底层是使用一个数组来保存元素的，在增加或删除指定位置的元素时，会导致创建新的数组，效率低，不适合大量的增删操作。

但这种数组的结构允许程序通过索引的方式来访问元素，使用ArrayList集合查找元素方便。

（3）ArrayList集合的遍历

public class Test {
public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("Hello");
    list.add("China");
    list.add("Hello");
    //1.foreach遍历ArrayList集合
    for(String s:list) {
        System.out.println(s);
    }
    //2.迭代器遍历ArrayList集合
    Iterator<String> it = list.iterator();
    while(it.hasNext()) {
        String s = it.next();
        System.out.println(s);
    }
    //3.将list转化成数组进行遍历
    String[] arr = new String[list.size()];
    list.toArray(arr);
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
}

2.LinkedList集合

（1）LinkedList介绍

LinkedList是List的实现类，它通过双向循环链表存储元素，链表中的每一个元素都使用引用的方式记住它前一个元素和后一个元素，并将所有的元素彼此连接起来。

（2）优缺点：

LinkedList使用双向循环链表存储元素，便于元素的添加和删除，但需要分配空间存储元素的前驱和后继指针浪费存储空间

二.Set接口

Set的特点：元素无序，不重复，可以用来去重

1.HashSet集合

（1）HashSet介绍

HashSet类用散列表方法存储元素，它根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能

（2）HashSet去重原理

当向HashSet集合中添加一个元素时，首先会调用hashCode()方法来计算元素的哈希值，经过运算，算出元素在哈希表中的存储位置。

情况1：如果算出元素的存储位置目前没有任何元素存储，那么该元素就可以直接存储到该位置上。

情况2：如果算出该元素的存储位置目前已经存在其它的元素了，那么再调用对象的equals()方法与该位置的元素比较，

如果equals返回的是true，元素重复，不允许添加；如果返回false，则进行添加。

（3）HashSet应用

class Animal{
    private Integer id;
    private String type;
    public Animal(Integer id,String type) {
        this.id = id;
        this.type = type; 
    }
    //重写toString方法
    public String toString() {
        return id+":"+type;
    }
    //重写hashCode方法
    public int hashCode() {
        return id.hashCode();
    }
    //重写equals方法
    public boolean equals(Object obj) {
        //判断是否是一个对象
        if (this==obj) {
            return true;
        }
        //判断对象是否是Animal类型
        if (!(obj instanceof Animal)) {
            return false;
        }
        Animal animal = (Animal)obj;
        //判断id是否相等
        boolean b = this.id.equals(animal.id);
        return b;
    }
}
public class Test {
public static void main(String[] args) {
    HashSet hs = new HashSet();
    Animal a = new Animal(1, "cat");
    Animal b = new Animal(2, "dog");
    Animal c = new Animal(2, "dog");
    hs.add(a);
    hs.add(b);
    hs.add(c);
    System.out.println(hs);
}
}

2.TreeSet集合

（1）TreeSet介绍

TreeSet()是使用红黑树(二叉树)的原理对新添加的对象按照指定的顺序排序，每添加一个对象都会进行排序，将对象存储到二叉树中，存储原则左小右大

（2）ThreeSet应用

——自然排序：

————Integer和String对象都可以进行默认的TreeSet排序

public class Test {
public static void main(String[] args) {
    TreeSet ts = new TreeSet();
        ts.add(200);
        ts.add(100);
        ts.add(120);
        ts.add(180);
        ts.add(80);
        Iterator it = ts.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
}
}

————自定义的类必须实现Comparable<T>接口，重写Comparable接口的compareTo方法

class Animal implements Comparable<Animal>{
    private Integer id;
    private String type;
    public Animal(Integer id,String type) {
        this.id = id;
        this.type = type;
    }
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public int compareTo(Animal o) {
        //return -1;表示存放到二叉树的左边，即逆序存储
        //return 1;表示存放到二叉树的右边，即顺序存储
        //return 0；表示元素相同，仅存第一个元素多余的去除
        int n = this.id-o.id;
        int i=(n==0)?this.id.compareTo(o.id):n;
        int t=(i==0)?(this.type.length()-o.type.length()):i;
        return t;
    }
}
public class Test {
public static void main(String[] args) {
    TreeSet<Animal> ts = new TreeSet<Animal>();
    ts.add(new Animal(12, "cat"));
    ts.add(new Animal(1, "tiger"));
    ts.add(new Animal(5, "pig"));
    ts.add(new Animal(2, "dog"));
    ts.add(new Animal(2, "dog"));
    for(Animal animal:ts) {
        System.out.println(animal.getId()+":"+animal.getType());
    }
}
}

——比较器排序：

————自定义类实现Comparetor<T>接口，重写compare方法

class Animal{
    private Integer id;
    private String type;
    public Animal(Integer id,String type) {
        this.id = id;
        this.type = type;
    }
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

}
public class Test {
public static void main(String[] args) {
    TreeSet<Animal> ts = new TreeSet<Animal>(new Comparator<Animal>() {
        @Override
        public int compare(Animal o1, Animal o2) {
            //主要条件id
            int n = o1.getId()-o2.getId();
            int i=(n==0)?o1.getId().compareTo(o2.getId()):n;
            int t=(i==0)?(o1.getType().length()-o2.getType().length()):i;
            return t;
        }
    });
    ts.add(new Animal(12, "cat"));
    ts.add(new Animal(1, "tiger"));
    ts.add(new Animal(5, "pig"));
    ts.add(new Animal(2, "dog"));
    ts.add(new Animal(2, "dog"));
    for(Animal animal:ts) {
        System.out.println(animal.getId()+":"+animal.getType());
    }
}
}