java集合框架之collection

一、Collection

1.1基本介绍

Collection代表单列集合，每个元素（数据）只包含一个值

• Collection代表单列集合，每个元素只包含单个值
• List特点：添加的元素有序，可重复，有索引
• Set特点：添加的元素无序，不重复（），无索引
  

1.2常用方法

 1.public boolean add(E e); //添加元素，添加成功返回true
 2.public void clear(); //清空集合元素
 3.public boolean isEmpty(); //判断集合是否为空，空则返回true
 4.public int size(); //返回集合的大小、
 5.public boolean contains(Object obj); //判断集合中是否包含某个元素
 6.public boolean remove(E e); //删除元素，如果有多个默认删除第一个
 7.public Object[] toArray(); //把集合转换成数组
 8.public boolean addAll(Collection<? extends E> c);//将一个集合 c 中的所有元素添加到当前集合中

二、List系列集合

List<String> list = new ArrayList<>();//初始化，经典代码，多态形式

2.1List特有方法

public void add(int index,E element); //在某个索引位置处添加元素
public E remove(int index); //根据索引删除元素，返回被删除的元素
public E get(int index); //返回集合中指定位置的元素
public E set(int index,E element); //修改索引位置处的元素，修改成功后返回原来位置处的元素

2.2ArrayList

ArrayList是基于数组实现的有以下特点：

• 查询速度快
• 删除效率低
• 添加效率极低

案例：

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

public class ArrayListDemo {
    public static void main(String[] args) {
        // 1.创建一个ArrayList对象 有索引，可重复，有序
        List<String> list = new ArrayList<>();//初始化
        
        // 2.public void add(int index,E element); 在某个索引位置处添加元素
        list.add("num1");//添加元素
        list.add("num2");
        list.add("num2");
        list.add("num3");
        //遍历
        for (String i:list) {
            System.out.printf(i+" ");
        }
        System.out.println();
        
        // 3.public E remove(int index); 根据索引删除元素，返回被删除的元素
        System.out.println(list.remove(3));//删除第4个元素
        
        // 4.public E get(int index); 返回集合中指定位置的元素
        System.out.println(list.get(1));//访问第二个元素
        
        // 5.public E set(int index,E element); 修改索引位置处的元素，修改成功后返回原来位置处的元素
        System.out.println(list.set(2,"num5"));//修改第3个元素
        System.out.println(list.size());//计算元素数量
        
        //遍历
        for (String i:list) {
            System.out.printf(i+" ");
        }
    }
}

输出结果

2.3LinkedList

LinkedList<String> stack = new LinkedList<>();//初始化

LinkedList是基于双链表实现的有以下特点：

• 查询速度慢
• 增删相对较快
• 首尾元素增删改查极快

LinkedList特有的方法：

public void addFirst(E element); //在该列表开头插入指定的元素
public void addLast(E element); //将指定的元素追加到此列表的末尾
public E getFirst(); //返回此列表中的第一个元素
public E getLast(); //返回此列表中的最后一个元素
public E removeFirst(); //从此列表中删除并返回第一个元素
public E removeLast(); //从此列表中删除并返回最后一个元素

应用案例：

• 实现数据结构中的队列操作
• 实现数据结构中的队列操作

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        // 1.创建一个LinkedList对象 有索引，可重复，有序
        LinkedList<String> stack = new LinkedList<>();//初始化
        //入栈
        stack.addFirst("num1");
        stack.addFirst("num2");
        stack.addFirst("num3");
        stack.addFirst("num4");
        System.out.println(stack);

        //出栈
        System.out.println("出栈的数是"+stack.removeFirst());
        System.out.println("出栈的数是"+stack.removeFirst());

        System.out.println(stack);
    }
}

三、Set集合

Set系列集合特点：无序：添加数据的顺序和获取出的数据顺序不一致；不重复；无索引；

• HashSet：无序、不重复、无索引。
• LinkedHashSet：有序、不重复、无索引。
• TreeSet：排序、不重复、无索引。

3.1HashSet

底层原理：
底层基于哈希表：数组+链表+红黑树
当链表长度大于>8,数组长度>=64时链表自动转为红黑树
①创建一个默认长度16的数组，默认加载因子为0.75，数组名table
②使用元素的哈希值对数组的长度求余计算出应存入的位置判断当前位置是否为null，如果是null直接存入
③如果不为null，表示有元素，则调用equals方法比较相等，则不存；不相等，则存入数组
新元素直接挂在老元素下面

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo {
    public static void main(String[] args) {
        //1.创建一个Set对象
        Set<Integer> set = new HashSet<>();//创建一个HashSet对象 无序、不重复、无索引
        //2.添加元素
        set.add(15);
        set.add(15);
        set.add(18);
        set.add(11);
        set.add(0);
        System.out.println(set);//输出结果为[0, 18, 11, 15]
    }
}

3.2LinkedHashSet

底层原理：
底层基于哈希表：数组+链表+红黑树
每个元素都额外的多了一个双链表的机制记录它前后元素的位置。

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //1.创建一个Set对象
        Set<Integer> set = new LinkedHashSet<>();//创建一个LinkedHashSet对象 有序、不重复、无索引
        //2.添加元素
        set.add(15);
        set.add(15);
        set.add(18);
        set.add(11);
        set.add(0);
        System.out.println(set);//输出结果为[15, 18, 11, 0]
    }
}

3.3TreeSet

底层是基于红黑树实现的排序。

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

public class TreeSetDemo {
    public static void main(String[] args) {
        //1.创建一个Set对象
        Set<Integer> set = new TreeSet<>();//创建一个TreeSet对象 排序、不重复、无索引
        //2.添加元素
        set.add(15);
        set.add(15);
        set.add(18);
        set.add(11);
        set.add(0);
        System.out.println(set);//输出结果为[0, 11, 15, 18]
    }
}

四、应用场景

记住元素的添加顺序

1. 需要存储重复的元素，又要频繁的根据索引查询数据？
   用ArrayList集合（有序、可重复、有索引），底层基于数组的。（常用）
2. 增删首尾数据的情况较多？
   用LinkedList集合（有序、可重复、有索引），底层基于双链表实现的。

没有重复元素，希望增删改查都快

1. 如果不在意元素顺序
   用HashSet集合（无序，不重复，无素引），底层基于哈希表实现的。（常用）
2. 如果希望记住元素的添加顺序
   用LinkedHashSet集合（有序，不重复，无索引），底层基于哈希表和双链表。
3. 如果要对元素进行排序
   用TreeSet集合，基于红黑树实现。