集合和集合框架

学集合的主要目的是要看懂源码和根据实际情况选择使用合适的集合

一：集合

集合是指把具有相同性质的一类东西聚合在一起，有点类似数组，但是又和数组不同。

集合和数组的区别：

(1)数组长度固定，而集合长度是动态变化的。

(2)一个数组只能存储一种数据类型，而集合可以存储多种数据类型。

(3)使用数组进行增加/删除元素比较麻烦，而集合提供了add、remove、set、get等方法，使得增加删除都很方便。

集合是一个容器

Collection是单列集合，Map是双列集合

(1)List、Set、Queue的差异

List集合是有序的，有下标的，可重复的

Queue集合有序的，有下标，可重复

Set集合是无序的，没有下标，不可重复

(2)List的主要实现类是：ArrayList、LinkedList、Vector  

ArrayList底层是通过数组实现的

LinkedList底层是通过链表实现的

Vector底层是通过数组实现的

(3)Set的实现类是：Hash Set、LinkedHashSet、TreeSet     

Hash Set底层是通过哈希表实现的

LinkedHashSet是通过链表+哈希表实现的

TreeSet底层是通过树结构实现的

二：Collection常用的方法（不常用的没列举）

    int size();                                            //计算集合的长度
    boolean isEmpty();                                     //判断集合是否为空
    boolean contains(Object o);                            //判断集合里面是否包含指定对象
    Iterator<E> iterator();                                //返回一个迭代器
例如：
public class Demo {
    public static void main(String[] args) {
        Collection<String> arr = new ArrayList<>();
        arr.add("你好");
        arr.add("撕裂");
        arr.add("OK");
        Iterator<String> iterator = arr.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next()+" ");
        }
    }
}
 
    Object[] toArray();                                    //将集合转变为数组
例如：
public class Demo {
    public static void main(String[] args) {
        Collection<String> arr = new ArrayList<>();
        arr.add("你好");
        arr.add("撕裂");
        arr.add("OK");
        Object[] array = arr.toArray();
        for (Object s:
             array) {
            System.out.print(s+" ");
        }
    }
}
 
    boolean add(E e);                                      //向集合中添加元素
    boolean remove(Object o);                              //删除集合中指定的元素
    boolean containsAll(Collection<?> c);                  //判断是否包含集合中的所有元素
    boolean addAll(Collection<? extends E> c);             //将集合c的所有元素添加进集合
    boolean removeAll(Collection<?> c);                    //删除集合中所有集合c中的元素
    boolean retainAll(Collection<?> c);                    //删除集合除开在集合c以外的所有元素，如果删除以后的集合发生了改变就返回true，否者返回false
    void clear();                                          //清空集合
    boolean equals(Object o);                              //判断元素和指定元素是否相等
    int hashCode();                                        //返回此集合的哈希代码值

三：集合框架(非常重要)

 

 四.Collections工具类

Collections是一个操作Set、List、Map等集合的工具类。Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改操作

下面列举常用的Collections方法

reverse(List):反转List中元素的顺序
shuffle(List):堆List集合元素进行随机排序
sort(List):根据元素的自然顺序对指定List集合元素按升序排序
sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
swap(List,int,int):将指定list集合中i处元素和j处元素进行交换
Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最大元素
Object min(Collection):根据元素的自然顺序，返回给定集合中的最小元素
Object min(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最小元素
int frequency(Collection,Object):返回集合中指定元素出现的次数
void copy(List dest,List src):将src中的类容复制到dest中(要求dest的长度要不小于src的长度，否者会抛出数组下标越界异常)
boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List对象的所有旧值
 
 
public class Collections_ {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("曹植");
        list.add("曹丕");
        list.add("关羽");
        list.add("张飞");
        list.add("关羽");
        List<Integer> list1 = new ArrayList<>();
        list1.add(2);
        list1.add(1);
        list1.add(12);
        list1.add(0);
 
 
 
        //reverse(List):反转List中的元素
        System.out.print(list+" ");
        Collections.reverse(list);
        System.out.print(list+" ");
 
        //shuffle(List):堆List集合元素进行随机排序
        for (String s:
             list) {
            Collections.shuffle(list);
            System.out.print(list+" ");
        }
 
        //sort(List):根据元素的自然顺序对指定List集合元素按升序排序
        Collections.sort(list1);
        System.out.print(list1+" ");
 
        //sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
        Collections.sort(list1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.print(list1+" ");
 
 
        //swap(List,int,int):将指定list集合中i处元素和j处元素进行交换
        Collections.swap(list,1,3);
        System.out.print(list+" ");
 
        //Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
        Integer max = Collections.max(list1);
        System.out.println(max);
 
 
        //Object max(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最大元素
        Integer max1 = Collections.max(list1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(max1);
 
 
        //int frequency(Collection,Comparator):返回集合中指定元素出现的次数
        System.out.println(Collections.frequency(list,"关羽"));
 
 
        //void copy(List dest,List src):将src中的类容复制到dest中(要求dest的长度要不小于src的长度，否者会抛出数组下标越界异常)
        List<Integer> list3 = new ArrayList<>();
        for (int i = 0; i < list1.size(); i++) {
            list3.add(0);
        }
        Collections.copy(list3,list1);
        System.out.print(list3+" ");
 
        //boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List对象的所有旧值
        Collections.replaceAll(list,"关羽","诸葛亮");
        System.out.print(list+" ");
    }
}