集合的简述

集合结构图：

 

List

List就是列表，用来存储一组数据的数据结构

List是可变长的数据结构，可以知道List里面存有多少个数据

List里面可以保存不同类型的数据

List是有序的列表，数据可以重复

ArrayList

ArrayList是采用数组方式实现的

读和遍历速度比较快，插入和删除数据比较慢

• List的基本使用

常用方法：add（） get（） size（）

        //用ArrayList创建一个List类的的对象 
       List list = new ArrayList();//默认长度为10，会自动扩展 
        //add（）向列表末尾添加元素        
        list.add(5);//存在0位        
        list.add("abc");//存在1位 
        list.add(null);//存在2位 
        list.add(5);//存在3位
        //size（）是返回列表的实际的个数
        System.out.println(list.size());
        //get() 返回指定下标的元素，下标从0开始
        Integer o = (Integer) list.get(0);
        //原先Object，强转为Integer
        System.out.println(o);
        String o1 = (String) list.get(1);
        System.out.println(o1);
        System.out.println("======遍历list======");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("====foreach遍历list====");
        for (Object obj:
             list) {
            System.out.println(obj);
​​​​​​​        }
​

• List的扩展方法

        //在指定下标位置插入一个数据，原来位置数据往后移一位
        list.add(2,3.14);
        //替换指定下标位置的元素
        list.set(4,true);
        //删除指定下标元素
        list.remove(3);
        //判断是否包含指定元素，返回true和false
        System.out.println("是否包含5：" + list.contains(5));
        //返回指定元素在列表中的序号，没有找到返回 -1
        System.out.println(list.indexOf(5));
        System.out.println(list.lastIndexOf(5));
        //截取子列表，左闭右开区间
        List listSub = list.subList(1, 3);
        //列表转换为数组
        Object[] array = list.toArray();
        System.out.println("数组长度："+array.length);
        //通过Arrays工具类，数组转list
        List<Object> objectList = Arrays.asList(array);​
        //清楚列表所有数据
        list.clear();
        //判断列表是否为空，为空返回true
​​​​​​​        System.out.println(list.isEmpty());

LinkedList

采取双向链表实现的，插入和删除速度快， 查询和遍历速度慢。

• 链表里面的数据是保存的地址

• 每个节点除了自身的数据的地址外，还保存了上一个和下一个节点的地址

LinkedList的一些特殊方法

LinkedList list = new LinkedList();
        list.add(5);
        //addFirst在列表的前面插入一个元素
        list.addFirst(2);
        list.addFirst(1);
        //addLast在列表的最后插入一个元素
        list.addLast(9);
​
        //getFirst获取第一个元素
        System.out.println(list.getFirst());
        //getLast获取最后一个元素
        System.out.println(list.getLast());
​
        //删除第一个节点
        list.removeFirst();
        //删除最后一个元素
        list.removeLast();
​
        //pop（）  弹出第一个元素(从列表中删除)，元素个数减一
        System.out.println("弹出元素："+list.pop());
        //push 将指定元素插入第一个节点（入栈）
        list.push(3);
​
        System.out.println("====遍历====");
        for (Object obj:list) {
            System.out.println(obj);
        }

泛型

因为List可以存储各种类型的数据，但是取出来都是Object，所以需要进行强制类型转换。

泛型就是用来解决这个问题的，在创建List对象时指定存储的类型，在add和get自动采用泛型指定的类型。

泛型的使用：

//使用泛型，定义变量的时候，类型后面跟上尖括号，尖括号写上数据类型，
        // new对象的时候，类型后面也要有尖括号，若尖括号不写，默认跟定义变量泛型一样
        //泛型只能使用引用类型，不能是基本类型
        List<String> listStr = new LinkedList<>();
        //一旦指定泛型后，相关方法的参数，返回类型都跟泛型的类型一样
        listStr.add("aaa");
        listStr.add("bbb");
        String s = listStr.get(0);
        System.out.println(s);

Set

无序集合，元素不重复， 允许存null（存一个）

没有索引（序号），不能通过下标访问，只能遍历

HsahSet常用方法：

        //创建HasSet. 默认长度为16  加载因子为0.75
        HashSet<String> set = new HashSet<>();
        set.add("Java");
        set.add("Html");
        set.add("SQL");
        set.add("Java");//重复的内容，在set里面只有一个
​
        System.out.println(set);
        System.out.println(set.size());//返回长度
​
        //遍历set的元素
        for (String str:
             set) {
            System.out.println(str);
        }
​
        //判断是否包含指定元素
        System.out.println(set.contains("Html"));//true
​
        //删除set里面 指定的元素
        set.remove("Java");
        
        //清空set
        set.clear();
​
        //判断set是否为空
        System.out.println(set.isEmpty());

TreeSet​​​​​​​  

• 红黑树

  是一种自平衡的二叉查找树

  其特征：

  1. 节点只有红色或黑色

  2. 根节点黑色

  3. 叶子节点为黑色，存NIL

  4. 一个节点为红色，则其子节点为黑色（不存在两个连续的红色）

  5. 每个节点到叶子节点的所有路径，都会包含相同数目的黑色节点

​​​​​​​

 

TreeSet的特性：

• TerrSet采用红黑树结构来实现

• 不能为null

• 不能添加重复元素

• 添加的元素会被排序，遍历出来的按顺序排列

• TreeSet的元素必须要实现Comparable（可比较）一个接口（）

常用的方法：

        TreeSet<Integer> set = new TreeSet<>();
        set.add(20);
        set.add(25);
        set.add(8);
        set.add(16);
        set.add(20);
​
        //返回元素的个数
        System.out.println("元素个数：" + set.size());
​
        //返回排序后第一个元素 fiest
        System.out.println("返回第一个元素first：" + set.first());
        //返回排序后最后一个元素 last
        System.out.println("返回最后一个元素last：" + set.last());
​
        //返回 比 指定元素 大 但最小元素
        System.out.println("ceiling:" + set.ceiling(18));
        //返回 比 指定元素 小 但最大元素
        System.out.println("floor:" + set.floor(18));
​
        for (Integer i:
             set) {//自动进行排序
            System.out.println(i);
        }
​
        //删除指定的对象
        set.remove(20);
        //清空所有元素
        set.clear();
        //判断是否为空（没有元素）
        System.out.println("是否为空" + set.isEmpty());

TreeSet存放自定义的类型

• 定义Egg类 必须实现Comparable

public class Egg implements Comparable<Egg>{
        //实现compareTo方法
    @Override
    public int compareTo(Egg o) {
        if (this.weight > o.weight){
            return 1;//当对象大于当前参数，返回 1 --升序排列（降序返回-1）
        }else if(this.weight < o.weight){
            return -1;//当对象小于当前参数，返回 -1 （降序返回1）
        }else {//当对象等于当前参数，返回 0
            return 0;
        }
    }
}
​




/*测试代码*/
public class TreeSetDemo {
    public static void main(String[] args) {
​
        /*      TreeSet存放自定义的对象     */
        TreeSet<Egg> eggs = new TreeSet<>();
        eggs.add(new Egg(50));
        eggs.add(new Egg(49.0F));
        eggs.add(new Egg(70.8F));
        eggs.add(new Egg(41));
​
        for (Egg egg: eggs) {
            System.out.println(egg);
        }
    }
}

哈希表 hash table

    哈希表，散列表，是一种高效数据结构

    要保存的数据称为值，根据hash算法给每个值算出一个hash code

    保存数据用hash code跟值一一对应。

hash toble保存数据的原理

根据hash code从表里查找是否存在：

• 不存在就当成新的值保存。

• 存在，判断equals是否相等：falsh，直接添加；true，说明两个值是一样的，不添加。

Hash code的结论：

• 两个值的hash code相同，equals不一定相同

          String str1 = "通话";
          String str2 = "重地";
          System.out.println(str1.hashCode());//1179395
          System.out.println(str2.hashCode());//1179395
          //两值hashcode相同，但equals 地址不同
          System.out.println(str1.equals(str2));//false

• 两值equals相同，hash code不一定相同

• hash code相同，equals相同，两值一定相同

Map

• 保存键值对数据（key-value）

• key不能重复，value可以重复

• key和value都可以为null

• map不适用Collections接口

HashMap

采用数组 + 链表 + 红黑树的数据结构来实现的

先根据hash code保存数组中

如果出现hash碰撞，用链表； 链表长超过8用红黑树

 

基本方法的使用：

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class HashMapDemo {
    public static void main(String[] args) {
        //HashMap<> 键和值 有两个类型; HashMap<>默认长度16，加载因子0.75
        HashMap<String,String> map = new HashMap<>();
        map.put("yyds","永远单身");//put 添加数据，第一个参数是key，第二个是value
        map.put("emo","抑郁了");
        map.put("u1s1","有一说一");
​
        //返回map里的元素个数
        System.out.println(map.size());
​
        //遍历map
        System.out.println("========value=======");
        Collection<String> values = map.values();//以Collection数据类型返回所有的value
        for (String str:values) {
            System.out.println(str);
        }
        System.out.println("=======key====");
        Set<String> strings = map.keySet();//以set数据类型返回所有key
        for (String str: strings) {
            System.out.println(str);
        }
        System.out.println("=========Entry=========");
        //Entry接口 , 能遍历出key 和 value      entrySet
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String,String> entry: entries) {
            System.out.println(entry.getKey()+","+entry.getValue());
        }
        
        
        //根据指定key查询对象value
        System.out.println(map.get("yyds"));
​
        //判断map中是否存在 Key 或 Value
        System.out.println("是否存在yyds：" + map.containsKey("yyds"));
        System.out.println("是否存在value：" + map.containsValue("永远单身"));
​
        //删除指定key的元素
        map.remove("yyds");
        System.out.println("是否存在yyds：" + map.containsKey("yyds"));
​
        //清除所有元素
        map.clear();
        //是否为空
        System.out.println("isEmpty：" + map.isEmpty());
​
    }
}