Java集合框架

一、集合：

集合是Java API所提供的一系列类的实例，可以用于动态存放多个对象

为什么要使用集合？数组的长度是固定的，存满了就不能存了。集合可以存储不同类型的对象，而且它的容量可以随着对象数量的增加，自动扩大。

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

二、List集合

List：存储的对象是有序，可以重复的

功能：除了继承Collection接口提供的功能之外，支持带下标的操作

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

增加方法：
（1）、void add(int index,E element)添加指定的对象到index的位置
（2）、boolean addAll(int index,Collection<? extends E> c)
删除方法：
（1）、E remove(int index) 删除指定位置的对象，并返回次对象
修改方法：
（1）、E set(int index,E element)更换指定位置的对象
查询方法：
（1）、ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）
（2）、ListIterator<E> listIterator(int index) 返回指定位置的对象
（3）、E get(int index) 得到指定位置的对象
注意：在迭代的过程中对集合进行添加，删除，修改，会发生ConcurrentModificationException异常

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

1、ArrayList：使用的数据结构是数组，线程不安全的，查找速度快，增删速度慢

示例：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo {
    
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("你好");
        list.add("你好吗？");
        list.add("我很好");
        System.out.println(list);

        list.add(1, "不是很好");
        System.out.println(list);

        // 删除指定下标的元素
        System.out.println("成功删除:" + list.remove(1));
        System.out.println(list);

        // 修改
        list.set(1, "大家好！！！");
        System.out.println(list);

        List sub = list.subList(1, 2);
        System.out.println(sub);
        System.out.println(list.get(1));

        // 遍历集合
        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("-------------");
        for (Iterator it1 = list.iterator(); it1.hasNext();) {
            System.out.println(it1.next());
        }
        System.out.println("-------------");
        for (Object obj : list) {
            System.out.println(obj);
        }
        System.out.println("-----------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 清空
        while (!list.isEmpty()) {
            list.remove(0);
        }
        System.out.println(list.size());

    }

}

2、LinkedList：使用的数据结构是链表，线程不安全的，查找速度慢，增删速度快

示例：

import java.util.LinkedList;

public class Demo {
    public static void main(String[] args) {
        LinkedList link = new LinkedList();
        link.addFirst("001");
        link.addFirst("002");
        link.addFirst("003");
        link.addFirst("004");

        System.out.println(link);

        System.out.println("getFirst:" + link.getFirst());
        System.out.println("get后的集合" + link);
        System.out.println("peekFirst:" + link.peekFirst());
        System.out.println("peek后的集合" + link);
        System.out.println("pop()" + link.pop());
        System.out.println("pop后的集合" + link);

        while (!link.isEmpty()) {
            System.out.println(link.removeFirst());
        }
        System.out.println("删除后集合中的元素");
        System.out.println(link);
        // 集合中元素为空
        System.out.println("getFirst:" + link.getFirst());// 抛出NoSuchElementException
        System.out.println("peekFirst:" + link.peekFirst());// null

    }
}

3、Vector：使用的数据结构是数组，线程安全的，查找速度快，增删速度慢,被ArrayList替代了

示例：

import java.util.Enumeration;
import java.util.Vector;

public class Demo {
    /*
     * Vector:被ArrayList替代
     * 
     * 效率低，线程安全的
     */
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("张三");
        v.add("李四");
        v.add("王五");
        for (Object o : v) {
            System.out.println(o);
        }

        Enumeration elements = v.elements();
        // 遍历
        while (elements.hasMoreElements()) {
            Object o = elements.nextElement();
            System.out.println(o);
        }
    }

}

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

三、Set集合

Set：存储的对象是无序的，不可以重复的

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

1、HashSet：底层使用的数据结构是哈希表，线程不安全的

　　确定唯一性的原理：

　　1、向集合中添加对象时，会先和集合中已经存在的对象比较哈希值

　　2、若哈希值不同，则直接添加到集合中

　　3、若哈希值相同，则再调用equals()方法，此方法返回false时，则将对象添加到集合中，反之不添加

　　注意：哈希值相同不一定是同一个对象，同一个对象哈希值肯定相同

示例：

import java.util.HashSet;
import java.util.Iterator;

public class Demo15 {

    public static void main(String[] args) {
        HashSet<Person> hs = new HashSet<Person>();
        hs.add(new Person("张三", 20));
        hs.add(new Person("张三1", 20));
        hs.add(new Person("张三2", 20));
        hs.add(new Person("张三3", 20));
        hs.add(new Person("张三", 20));

        // 遍历--迭代器
        Iterator it = hs.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }

    static class Person {
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + "]";
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }

    }
}

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

2、TreeSet：底层使用的数据结构是二叉树，线程不安全的

　　确保唯一性的方式：依据compareTo()或compare()的返回值是否为0

　　方式1：让存入集合中的对象具备可比较性

　　（1）、类实现Comparable接口

　　（2）、实现接口的compareTo(Object o)方法

　　方式2：让集合具备排序功能

　　（1）、创建Comparator接口对象，并实现其方法compare(Object o1,Object o2)方法

　　（2）、在创建TreeSet的构造方法中传入Comparator对象

示例：

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/*
 * TreeSet:底层使用的数据结构是二叉树，线程不安全。会对存入集合的对象进行排序。
 * 
 * 保证加入集合的对象是可排序的：
 * 1）让自定义的类实现Comparable接口，int compareTo（）
 * 2 ）自定义比较器：
 *     创建比较器，实现Comparator接口，接口int compare（）
 *   把比较器对象作为参数传递给集合的构造方法
 * */
public class Demo16 {

    public static void main(String[] args) {
        /*
         * Set tree = new TreeSet(); tree.add(13); tree.add(8); tree.add(17);
         * tree.add(1); tree.add(11); tree.add(15); System.out.println(tree);
         */

        Set<Dog> set = new TreeSet<Dog>();
        set.add(new Dog("大黄", 3));
        set.add(new Dog("大黄1", 2));
        set.add(new Dog("大黄2", 1));
        set.add(new Dog("大黄9", 6));
        set.add(new Dog("大黄4", 6));
        System.out.println(set);
        System.out.println("---------------");
        // 创建比较器对象
        MyCompare mc = new MyCompare();
        TreeSet ts = new TreeSet(mc);
        ts.add(new Dog("大黄1", 3));
        ts.add(new Dog("大黄1", 2));
        ts.add(new Dog("大黄2", 1));
        ts.add(new Dog("大黄9", 6));

        System.out.println(ts);

    }

}

class Dog implements Comparable {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Dog() {
        super();
    }

    @Override
    public String toString() {
        return "Dog [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Dog other = (Dog) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(Object o) {
        Dog d = (Dog) o;
        if (this.age < d.age)
            return -1;
        else if (this.age > d.age)
            return 1;
        else
            return this.name.compareTo(d.name); // 年龄相同再继续比较姓名
    }

}

// 自定义比较器
// 比较名字是否相等,如果名字相同再按照年龄排序
class MyCompare implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        if (!(o1 instanceof Dog))
            throw new ClassCastException("类型转换出错");
        if (!(o2 instanceof Dog))
            throw new ClassCastException("类型转换出错");
        Dog d1 = (Dog) o1;
        Dog d2 = (Dog) o2;
        int n = d1.getName().compareTo(d2.getName());
        return n == 0 ? d1.getAge() - d2.getAge() : n;
    }
}

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class Demo18 {
    public static void main(String[] args) {
        TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>() {

            // 比较年龄，然后在比较姓名
            @Override
            public int compare(Person o1, Person o2) {
                int n = o1.getAge() - o2.getAge();
                if (n == 0) { // 年龄相等
                    return o1.getName().compareTo(o2.getName()); // 在比较姓名
                }
                return n;
            }
        });
        ts.add(new Person("张三4", 39));
        ts.add(new Person("张三1", 39));
        ts.add(new Person("张三2", 19));
        ts.add(new Person("张三3", 27));
        ts.add(new Person("张三4", 27));
        ts.add(new Person("张三4", 27));

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

    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

}

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

四、Map

Map：一个单独的接口，存储的是键值对，键不可以重复,无序的

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

特点：

1、创建Comparator接口对象，并实现其方法compare(Object o1,Object o2)方法

2、存入HashMap中的映射对的“键”的类型必须是引用类型（除数组外）

3、所以存入HashMap中的映射对的“键”如果是自定义的类,应该重写hashCode()和equals()方法

4、常用String作为Map的“键”

方法：

1、添加

①V   put(K key, V value) 　//将指定的“键-值”对存入Map中

②void putAll(Map<? extends K,? extends V> m)

2、删除

①void putAll(Map<? extends K,? extends V> m)

②void  clear();　  //清空Map中的所有“键-值”对。

3、获取

①V   get(Object key);　　//返回指定键所映射的值

②Set<K>  keySet(); 　  //返回此Map中包含的键的Set集。

③int  size();　  //获得些Map中“键-值”对的数量。

④Set<Entry<K, V>> entrySet() 返回此Map的键-值对内容的Set集合

⑤Collection<V> values();　  //返回此Map中包含的值的Collection集。值是可重复的.

4、判断

①boolean  isEmpty();　　//判断此Map中是否有元素。

②boolean  containsKey(Object key);   //判断此Map是否包含指定键的“键-值”对。

③boolean  containsValue(Object value);//判断此Map是否包含指定值的“键-值”对。

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

1、HashMap：保证键唯一的原理和HashSet一样，hashCode(),equals()

2、TreeMap：是根据键来排序的,保证键唯一的原理和TreeSet相同,依据 compareTo()或compare()的返回值是否为0，为0就认为是重复键

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

Map.Entry接口：

Map.Entry是Map中内部定义的一个static接口，专门用来保存key-value的内容

Set<Map.Entry<Cat, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Cat, String>> it = entrySet.iterator();
        while (it.hasNext()) {
            Map.Entry<Cat, String> en = it.next();
            System.out.println(en.getKey() + "---" + en.getValue());
        }

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

五、Collection接口

说明：是List接口和Set接口的父接口

1、添加方法

（1）、boolean add(Object o) 增加对象到集合中

（2）、boolean addAll(Collection<? extends E> c)  增加所有其它集合中对象

2、删除方法

（1）、boolean remove(Object o)  从集合中删除对象

（2）、boolean removeAll(Collection<?> c) 从集合中删除所有指定集合包含的对象

（3）、void clear() 清空集合

3、判断方法

（1）、boolean contains(Object o)  判断是否集合中是否包含指定对象

（2）、boolean containsAll(Collection<?> c) 判断集合是否包含指定集合中所有对象

（3）、boolean isEmpty() //判断集合是否为空

（4）、boolean equals(Object o) 判断集合是否与某对象相同

4、获取方法

（1）、Iterator<E> iterator() //获取集合中的对象

（2）、int size() //获取集合中对象的个数

5、转换方法

（1）、 Object[] toArray() 将集合转换成数组

示例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo3 {
    /*
     * 遍历集合：---Iterator迭代器，判断是否存在下一个元素（hasNext（）），如果存在，取出（next（）） Iterator接口
     */
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add("anc");
        col.add("aaa");
        col.add("ddd");
        col.add("eeee");

        // 获取集合对象的迭代器
        Iterator it = col.iterator();
        // 判断是否存下一个元素
        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);// 获得元素

            // col.remove(o);// 抛异常

            it.remove();// 删除next最后一次获取的对象，如果使用迭代器遍历集合，必须使用迭代器的remove方法删除元素
        }
        System.out.println("------------");
        for (Object o : col) {
            System.out.println(o);
        }

    }

}

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

六、Iterator接口

作用：遍历集合中的对象

原理：先对元素进行判断，判断是否有内容，如果有内容则把内容取出

特点：只能读取和删除，不能添加、修改 

方法：（1）boolean hasNext() 是否存在下一个对象（2）E next() 获取下一个对象（3）void remove() 删除最近next之后获取的对象

eg:

                // 获取集合对象的迭代器
        Iterator it = col.iterator();
        // 判断是否存下一个元素
        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);// 获得元素
            it.remove();// 删除next最后一次获取的对象，如果使用迭代器遍历集合，必须使用迭代器的remove方法删除元素
        }