java集合框架

1 、java集合概述

为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），java提供了集合类。集合类主要用于保存个盛装其他的数据，因此也被称之为容器类。
集合类与数组不一样，数组的元素既可以是基本类似，也可以是对象（实际上保存的是对象的引用变量）；而集合只能保存对象（实际上只保存对象的引用变量）
集合类主要Collection和Map两个接口。

2 、Collection和Iterator接口

2.1、 Collection接口

Collection的接口是List、set和Queue接口的父接口，该接口里面的方法既可以用于操作Set集合‘也可以用于操作List和Queue集合’。

boolean add（Object o）

该方法用于向集合中添加一个元素。如果集合的对象被添加操作改变了，则返回true。

boolean addAll（Collection c）

该方法用与吧集合c中的所有元素添加到指定集合里。如果集合对象被添加操作改变了，则返回true。

void clear（）

清除集合中所有的元素

boolean contains（Object o）

返回集合里是否包含指定的元素。

boolean containsAll（Collection c）

返回集合里是否包含集合c中的所有元素，否则返回false。

boolean isEmpty（）

返回集合是否为空。当集合长度为0时返回true，否则返回false。

Iterator iterator（）

返回一个Iterator对象，用于遍历集合里面的元素

boolean remove（Object o）

删除集合元素中的指定元素o，当集合中包含了一个或者多个元素o时，这些元素都将被删除，该方法返回true。

boolean removeAll（Collection c）

从集合中删除集合c里面包含的所有元素，如果删除了一个或者一个以上的元素，该方法返回true。

boolean retainAll（Collection c）

从集合里删除集合c里不包含的所有元素，相当于调用该方法的集合变成该方法的集合减去集合c

int size（）

返回集合里元素的个数

Object[] toArray()

该方法用于把集合装换成一个数组所有集合元素变成对应数组元素。

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

public class demo1 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //添加元素
        c.add("孙悟空");
        //虽然集合里面不能放基本类型的值，但是Java支持自动开箱
        c.add(6);
        System.out.println("c集合中元素的个数："+c.size());
        //删除指定元素
        c.remove(6);
        System.out.println("c集合中元素的个数："+c.size());
        //判断是否包含指定字符串
        System.out.println("c集合是否包含\"孙悟空\"字符串"+c.contains("孙悟空"));
        c.add("轻量级javaEE实战");
        System.out.println("c集合的元素"+c);
        Collection book = new ArrayList();
        book.add("轻量级javaEE实战");
        book.add("疯狂java");
        System.out.println("c集合手否包含book集合"+ c.containsAll(book));
        //用c集合减去books集合里面的元素
        c.removeAll(book);
        System.out.println("c集合中的元素"+c);
        //删除c集合里面所有的元素
        c.clear();
        System.out.println("c集合中的元素"+c);
        //book集合里面只剩下c集合里面也包含的元素
        book.retainAll(c);
        System.out.println("book集合中的元素"+book);
    }
}

运行结果

3、Set集合

set集合不允许包含相同的元素，且在set中，数据是无序的，线程不安全的。Set判断两个对象是否相同不是使用==运算元素，而是根据equals（）方法。

3.1 HashSet

HashSet是set接口的典型实现，大多数试试使用set集合就是在实现这个类。HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找的性能
HashSet有以下特点：

• 不能保证元素的排列顺序，顺序有可能会发生改变
• HashSet不是同步的，如果多个线程同时访问一个HashSet集合时，则必须通过代码来保证其同步。
• 集合元素的值可以是null

当HashSet集合中存入一个元素时，HashSet会调用该对象的hashcode()方法来得到该对象的hashCode值，然后根据HashCode值来决定该对象在hashSet中的存取位置。如果两个元素通过equals（）方法比较返回true，但是它们的HashCode值不同，HashSet将会把他们存储在不同的位置依然可以添加成功
如果需要把某个类的对象保存到HashSet集合中，重写这个类的equals（）方法和HashCode（）方法时，应该尽量保证两个对象通过equals（）方法比较返回true时，他们的HashCode（）方法返回值也相等。

3.2 TreeSet

TreeSet可以确保集合元素处于排序状态。与HashSet集合相比，TreeSet采用红黑树的数据结构来存储。Treeset好提供了如下几个额外的方法。

• Comparator comparator（）：如果TreeSet采用了定制排序，则该方法返回定制排序所使用的Comparator；如果TreeSet使用了自然排序则返回null。
• Object first（）：返回几个中的第一个元素。
• Object last（）：返回集合中的最后一个元素。
• Object lower（Object e）：返回几个钟位于指定元素之前的元素。
• Object higher（）：返回集合中位于指定元素之后的元素。

3.2.1、通过comparable接口定制规则

TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小，然后将集合元素按照升序排列，这种方法就是自然排序。
例：

通过重写compareTo方法来规定排序排序

public class User implements Comparable<User>{
    private int Id;
    private String Name;
    private int Salary;

    public int getSalary() {
        return Salary;
    }

    public void setSalary(int salary) {
        Salary = salary;
    }

    public User(int id, String name, int salary) {
        this.Id = id;
        this.Name = name;
        this.Salary = salary;
    }

    public int getId() {
        return Id;
    }

    public void setId(int id) {
        Id = id;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    @Override
    public int compareTo(User o) {
        if (this.Id ==o.getId())
            return 0;
        else if (this.Id > o.getId())
            return 1;
        else return -1;
    }
}

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

public  class demo1{
        public static void main(String[] args) {
                Set<User> set = new TreeSet<>();

                set.add(new User(03,"张三",5000));
                set.add(new User(02,"李四",800));
                set.add(new User(01,"王五",400));
                set.add(new User(04,"孙悟空",5003));
                set.add(new User(01,"猪八戒",7000));

                for (User user : set) {
                        System.out.println(user.getId()+" "+user.getName()+" "+user.getSalary());
                }

        }
}

3.2.2、comparator接口

通过comparator接口实现定制排序，该接口包含一个int compare（T o1，T o2）方法，该方法就是比较o1,o2的大小：如果该方法返回正整数，则表明o1大于o2；如果该方法返回0，则表明o1等于o2；如果该方法返回负整数，则表明o1小于o2。

import java.util.Comparator;

public class MyComparator implements Comparator<User> {
    @Override
    public int compare(User user, User t1) {
        if(user.getSalary()==t1.getSalary())
            return 0;
        else if(user.getSalary()>t1.getSalary())
            return 1;
        else
            return -1;
    }
}

public class User {
    private int Id;
    private String Name;
    private int Salary;
    public User(int id, String name, int salary) {
        this.Id = id;
        this.Name = name;
        this.Salary = salary;
    }
    public int getSalary() {
        return Salary;
    }

    public void setSalary(int salary) {
        Salary = salary;
    }



    public int getId() {
        return Id;
    }

    public void setId(int id) {
        Id = id;
    }

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }
}

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

public  class demo1{
        public static void main(String[] args) {
                Set<User> set = new TreeSet<>(new MyComparator());

                set.add(new User(03,"张三",5000));
                set.add(new User(02,"李四",800));
                set.add(new User(01,"王五",400));
                set.add(new User(04,"孙悟空",5003));
                set.add(new User(05,"猪八戒",7000));

                for (User user : set) {
                        System.out.println(user.getId()+" "+user.getName()+" "+user.getSalary());
                }
        }
}

4、List集合

List集合代表一个元素有序，可以重复的集合，每个集合都有其对应的顺序索引。

4.1、List接口

List是collection接口里面的子接口，可以使用collection接口里面的全部方法，而且由于；List是有序集合，因此List集合里面增加了一些根据索引来操作集合元素的方法

void add（int index，Object element）

将元素element插入到List集合的index处。

boolean addAll（int index，Collection c）

将集合c所包含的所有元素都插入到List集合的index处。

Object get（int index）

返回集合index处索引处的元素

int indexOf（Object o）

返回对象o在list集合中第一次出现的位置索引

int lastIndexOf（Object o）

返回对象o在list最后一次出现的位置索引

Object remove(int index)

删除并返回index出的元素

Object set(int index, Object element)

将index索引处的元素替换成element对象，返回新的元素

List subList(index fromIndex,int toIndex)

返回从索引fromIndex（包括）到索引toIndex（不包括）处所有元素组成的子集合

public class ListTest {
    public static void main(String[] args) {
        List books = new ArrayList();
        //向books里面添加5个元素
        books.add(new String("疯狂的Java"));
        books.add(new String("golang语言"));
        books.add("轻量级Java EE企业应用实战");
        books.add("疯狂的Python");
        books.add("颈椎病预防与治疗");
        System.out.println(books);
        //将新的字符串位置插入到第二个位置
        books.add(1,"spring-boot");
        System.out.println(books);
        //删除第三个元素
        books.remove(2);
        System.out.println(books);
        //判断指定元素在集合中的位置
        System.out.println(books.indexOf("疯狂的Python"));
        //将第二个对象替换成新的字符串对象
        books.set(1,"c语言");
        System.out.println(books);
        //将books集合的第二个元素到第四个元素截取成一个子集合
        List booksTow = books.subList(1,3);
        System.out.println(booksTow);

    }
}

代码运行结果

List判断两个对象是否相等的只要通过equals（）方法比较返回true即可

4.2 ArrayList和Vector实现类

ArrayList和Vector都是List的两个典型的实现，并且完全支持List接口的全部功能
ArrayList与Vector都是封装了一个动态的，允许再分配的Object[]数组。两者的用法几乎是相同的，不同点在于ArrayList是线程不安全的，如果超过一个线程修改了ArrayList集合，则程序必须手动保证集合的同步性；Vector是线程安全的。
LinkedList也是List的实现类，他是基于链表实现的List类，对于顺序访问集合中的元素进行了优化，特别是插入、删除元素的速度非常快。

4.3 固定长度的List

asList(Object… a)方法可以把一个数组或者指定对象转换成一个List集合。这个List是Arrays的内部类ArrayList的实例。
Arrays.ArrayList 是一个固定长度的List集合，程序只能遍历该集合里的元素，不可以增加、删除该集合里面的元素。

5 Queue集合

Queue用来模拟队列这种数据结构特征就是“先进先出”（FIFO），通常队列不允许随机访问队列中的元素
Queue的接口中定义了如下几个方法

void add(Object e)

将制定元素加入此队列的尾部

Object element（）

获取队列头部元素，但是不删除这个元素

Boolean offer（）

将指定的元素加入到此队列的尾部，当使用有容量限制的队列时，此方法通常比add（）好用

Object peek()

获取队列头部元素，但是不删除这个元素，如果这个队列为空，则返回null

Object poll()

获取这个队列的头部元素并删除，如果这个队列为空，则返回null

Object remove（）

获取队列头部元素并删除

5.1 PriorityQueue实现类

PriorityQueue是一个比较标准的队列实现类，但是他的排列顺序是按照大小，而不是先后顺序。
PriorityQueue不允许插入null元素，它还需要对队列元素进行排列，PriorityQueue有两种排列方式

• 自然排序：采用自然排序的PriorityQueue集合中的元素必须实现Comparable接口，而且应该是同一个类的多个实例，否则可能会导致ClassCastException异常
• 定制排序：创建PriorityQueue队列时，传入一个Comparator对象，该对象负责队列中所有元素进行排列。

5.2 Deque接口和ArrayDeque实现类

Deque接口是Queue接口的子接口，它代表一个双端队列，Deque接口定义了一些双端队列的方法，这些方法允许从两端来操作队列元素。

void addFrist(Object e)

将指定的元素插入该双端队列的开头

void addList（Object e）

将指定的元素插入该双端队列的末尾

Object getFirst()

获取但是不删除该双端队列的第一个元素

Object getLast（）

获取但是不删除双端队列的最后一个元素

boolean offerFirst（）

将指定元素插入到双端队列的开头

boolean offerlast（）

将指定元素插入到双端队列的结尾

Object peekFirst（）

获取但是不删除双端队列的第一个元素；如果这个队列为空，则返回null

Object peeklast（）

获取但是不删除双端队列的最后一个元素；如果这个队列为空，则返回null

Object pollFirst（）

获取并删除双端队列的第一个元素；如果这个队列为空，则返回null

Object polllast（）

获取并删除双端队列的最后一个元素；如果这个队列为空，则返回null

Object pop（）（栈方法）

pop出该双端队列所表示的栈的栈顶，相当于removeFrist（）

void push（Object e）(栈方法)

将一个元素push进该双端对列所表示的栈的栈顶，相当于addFirst（）

Object removeFirst（）

Object removeFirstOccurrence（Object o）

删除该双端对列第一次出现的元素o

removeLast（）

Object removeLastOccurrence（Object o）

删除该双端对列最后一次出现的元素o

5.3 LinkedList实现类

LinkedList也是List的实现类，他是基于链表实现的List类，对于顺序访问集合中的元素进行了优化，特别是插入、删除元素的速度非常快。除此之外，LinkedList还实现了Deque接口，因此它可以被当成双端队列来使用，自然也可以被当做栈来使用。

6、Map

map可以看成是Python中的字典的形式一样。Map用于保存具有映射关系的数据，因此Map集合中保存着两组值，一组用于保存map中的key，另一组用于保存map中的value。key和value可以是任何引用类型的数据。Map的key不允许重复。key和value之前存在一对一的关系。

void clear()

删除该Map对象中所有的key-value对

boolean containsKey（Object key）

查询map中是否包含指定的key，如果包含则返回true

boolean containsValue（Object value）

查询map中是否包含一个或者多个value，否则返回true

set entrySet（）

返回Map中包含的key-v