Collection集合

集合的概念：集合是一种容器，可以存储多个数据。

集合的体系：

        LIst：

                —ArrayList：底层是数组

                —LinkedList：底层是双向链表

                —Vector：底层是数组

        Set:

                —HashSet：底层是HashMap

                          —LinkedHashSet：哈希表（数组+链表）+双向链表

                —SortedSet：

                          —TreeSet：底层是TreeMap

        Queue：栈：队列（先进先出）

                —Deque：双端队列

                        —LinkeList：双向链表

List集合：

          特点：有序、可重复。

—ArrayList: 数组

        ①特点：

                a.按顺序排列，带有索引。线程不安全！！！

                b.标号是连续的，内存的物理空间也是连续的。

        ②优缺点：

                优点：因为有下标，查询块，用的最多。

                缺点：插入删除慢。物理空间连续占内存，空间使用率低。

package T1;

import java.util.ArrayList;

public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        list.add("qwer");
        list.add("a");
        list.add("b");

        System.out.println("添加后："+list);
        list.remove("a");//指定内容删除
        list.remove(0);//指定下标删除
        System.out.println("删除："+list);
        int x=list.size();
        System.out.println("长度："+x);
    }
}
//添加后：[qwer, a, b]
//删除：[b]
//长度：1

—LinkedList：双向链表

        ①特点：线程不安全！！！

                a.链表没有下标，但是固定顺序存储，通过下一个节点引用指向。

                b.物理空间是不连续，所以空间利用率高。

                c.因为没有下标，所以访问需要从头开始。

        ②优缺点：

                优点：插入删除效率高，内存空间利用率高

                缺点：查询效率低，只能从头或尾开始。

package T1;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String>list=new LinkedList<>();
        list.add("qqq");
        list.add("www");
        System.out.println(list);
        list.addFirst("1");//头插入”1“
        list.addLast("2");//尾插入”2“
        System.out.println("插入后："+list);

        System.out.println("peek的值："+list.peek());//peek找到第一个值并返回，但不去除。——看看不动！
        System.out.println("执行peek后的list："+list);
        System.out.println("pop的值："+list.pop());//pop找到第一个值并返回，要去除。——看了还拿走！
        System.out.println("执行pop后的list："+list);
        System.out.println("是否为空："+list.isEmpty());//是否为空，Boolean
    }
}
/*
[qqq, www]
插入后：[1, qqq, www, 2]
peek的值：1
执行peek后的list：[1, qqq, www, 2]
pop的值：1
执行pop后的list：[qqq, www, 2]
是否为空：false
*/

—Vector：数组

        ①特点：与ArrayList 一样

        ②优缺点：

                优点：方法都带有锁机制，线程安全。

                缺点：效率比较低。

Set接口：

        特点：无序且唯一。

        a.物理空间不连续，没有顺序

        b.不能重复，null值也只能存一个。        

—HashSet：底层数据结构是HashMap 

        ①特点：唯一，但可以存null值，且只能存一个、无序。

        ②判断标准：equal（）比较内容相等 且 hashCode（）比较地址值相等。

           【 当equal（）判断内容相等，nashCode不相等时，仍然会存入数据，但是会存在两个不同的地方。】                      

package T1;

import java.util.HashSet;

public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<String>set=new HashSet<>();//无序且唯一
        set.add("111");
        set.add("222");
        set.add("333");
        set.add("444");
        set.add("222");//不能重复添加，值是唯一的

        set.remove("111");//删除指定内容
        System.out.println(set.contains("333"));//判断是否包含
        System.out.println(set);
        for (String N:set) {//迭代hashset
            System.out.println(N);
        }
    }
}
/*
true
[222, 333, 444]
222
333
444
*/

—LinkedHashSet：哈希表（数组+链表）+双向链表

        ①特点：有序且唯一。非线程安全！！！

        ②操作：在相关操作上和hashset相同。

package T1;

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

public class LInkedHashSet {
    public static void main(String[] args) {
        Set<String>set=new LinkedHashSet<>();
        set.add("111");
        set.add("222");
        set.add("333");
        Iterator<String>it= set.iterator();//迭代器
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}
/*
111
222
333*/

—TreeSet：底层是二叉树（红黑树）

        ①特点：唯一，没有索引。有序。

        ②父接口：SortedSet，可以排序集合。

        ③作用：对元素进行排序。

        ④遍历方式：只能通过迭代器遍历

                iterator、foreach

package PR;

import java.util.Arrays;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<String>treeSet=new TreeSet<>();
        treeSet.add("qwe");
        treeSet.add("qwe2");
        treeSet.add("qwe3");
        System.out.println(treeSet);
        System.out.println("降序："+treeSet.descendingSet());//降序 集
        treeSet.remove("qwe");
        System.out.println(treeSet);
        System.out.println("---迭代器iterator---");
        Iterator<String> it=treeSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("-----foreach-------");//要先转换为数组。
        String[]q=treeSet.toArray(new String[0]);
        for(String str:q){
            System.out.println(str);
        }
    }
}
/*
[qwe, qwe2, qwe3]
降序：[qwe3, qwe2, qwe]
[qwe2, qwe3]
---迭代器iterator---
qwe2
qwe3
-----foreach-------
qwe2
qwe3


*/

 

Queue：队列

        特点：先进先出

        底层：数组或链表

package PR;

import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {
    public static void main(String[] args) {
        Queue<String>queue=new LinkedList<>();
        queue.add("qwe");
        queue.add("rty");
        queue.offer("123");
        System.out.println(queue);
        //peek 和 element 获取不移除头数据
        System.out.println(queue.peek());
        System.out.println("peek:"+queue);//为空时，返回null
        System.out.println(queue.element());
        System.out.println("element:"+queue);//为空时，抛出NoSuchElementException异常
        //poll 和 remove 获取，并移除头数据
        System.out.println(queue.poll());//为空时，返回null
        System.out.println("poll:"+queue);
        System.out.println(queue.remove());//为空时，抛出NoSuchElementException异常
        System.out.println("remove:"+queue);
    }
}

 

—Deque:双端队列

             特点：两边可进出。

             底层：数组或链表