Java基础（十二）集合（Collection）容器及Collection子接口：List（列表）、Set（散列）、Queue（队列）及实现类重点详解

最新推荐文章于 2023-04-04 15:42:22 发布

张艳霞zhangyx

最新推荐文章于 2023-04-04 15:42:22 发布

阅读量278

点赞数

分类专栏： Java 文章标签：链表 java 数据结构

本文链接：https://blog.csdn.net/acsdds/article/details/108148320

版权

Java 专栏收录该内容

33 篇文章 3 订阅

订阅专栏

集合（Collection)

1.概念：可以存储多个数据（对象）且长度可变的容器

<E>---泛型，限定元素的数据类型，由于泛型的限定结婚元素类型只支持引用数据类型。
int[] arr;---arr的类型是数组类型（引用类型），元素类型是int类型
Collection<String> c;//c的数据类型是引用数据类型，元素类型是String类型
Collection<Integer>c1;//可以直接存储int类型数据  1  23 78

2.Collection是集合的顶级接口

子接口：List（列表）、Set（散列）、Queue（队列）

List(列表)

3个特点：有序（存放数据有序）、允许存储重复元素、支持下标进行操作

Collection常用功能代码演示：

package cn.tedu.collection;

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

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        //向上造型的对象
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("abc");
        list.add("bc");
        list.add("ac");
        list.add("ab");

        //插入元素
        //最大支持下标值为元素个数值
        //list.add(3,"123");

        //根据下标删除元素
        //最大支持删除下标是元素个数-1
        //list.remove(2);

        //根据指定内容来删除元素
        //当指定内容没有找到时没有影响（不做任何操作）
        //list.remove("a1b");

        //清空集合
        //list.clear();

        //判断指定内容是否包含在元素中
        //System.out.println(list.contains("ac"));//true

        //根据指定下标来获取元素
        //System.out.println(list.get(0));

        //返回指定类第一次出现的下标值
        //System.out.println(list.indexOf("ab"));

        //判断是否是一个空集合
        //System.out.println(list.isEmpty());//false

        //替换元素
        /*list.remove(0);
        list.add(0,"123");//将第一个元素替换*/
        //list.set(0,"123");

        //返回元素个数
        System.out.println(list.size());//5

        //截取子列表(左包右不包）
        System.out.println(list.subList(1,3));

        //把集合元素放到数组中来返回
       /* Object[] os=list.toArray();
        for (Object o:os){
            //把数组每个元素；类型转成String类型
            String str=(String) o;
        }*/
        //创建数组对象指定返回数组类型
        //给定数组长度只要大于等于0即可
        String[] ss=list.toArray(list.toArray(new String[0]));

        //保证存放数据有序
        System.out.println(list);
    }
}

实现类：ArrayList、LinkedList、Vector、Stack

ArrayList（顺序表）

底层由数组实现数据存储，默认初始容量为10.底层根据右移运算进行扩容，每次扩容是在原容量的基础上增加一半。线程不安全的集合。
练习：用数组实现ArraysList（代码见上一篇博文）

LinkedList（链表）

底层是由节点（静态内部类）实现数据存储，通过地址值的指向来维系节点。底层内存不连续，不需要扩容。线程不安全的集合。
在这里插入图片描述

Vector（向量）

a.最早的集合；类
b.底层基于数组实现数据存储，默认的初始容量为10.
c.底层根据三目运算符进行扩容，如果增量值大于0每次扩容的值就是增量的值如果增量不大于0每次扩容的值就是原容量的值。
d.线程安全的集合

package cn.tedu.collection.list;

import java.util.Vector;

public class VectorDemo {
    public static void main(String[] args) {
        //如果指定增量的值每次扩容的值就是增量的值
        //如果不指定增量，每次扩容就是在原来的基础上增加一倍
        Vector<String> vector=new Vector<>(10,5);
        //添加元素
        for (int i=1;i<=11;i++){
            vector.add("a");
        }

        //返回当前容量
        System.out.println(vector.capacity());
    }
}

Stack（栈结构）

遵循先进后出（FILO）
栈顶元素—最后存放的元素
栈底元素—第一个存放的元素
入栈/压栈—存放元素
出栈/弹栈—获取元素
父类是Vector类

package cn.tedu.collection.list;

import java.util.Stack;

public class StakeDemo {
    public static void main(String[] args) {
        //创建栈结构的对象
        Stack<String> s=new Stack<>();
        //入栈
        s.push("abc");
        s.push("bc");
        s.push("ac");
        s.push("ab");
        //返回栈顶元素并不删除
        System.out.println(s.peek());//ab
        //返回栈顶元素并删除
        System.out.println(s.pop());//ab
        //判断是否是空栈
        System.out.println(s.empty());//false
        //从栈顶往栈底来查找指定内容返回所在的位置（从1开始计数）
        System.out.println(s.search("ac"));//2
        //保证和List接口的特点保持一致
        //保证数据存放有序
        System.out.println(s);
    }
}

Set（散列）

不能存储重复元素、无序

实现类：HashSet、LinkedHashSet、TreeSet

在这里插入图片描述

HashSet

底层基于HashMap（基于数组+链表）实现数据存储，不能存储重复元素，不能保证元素存储的顺序恒久不变。默认初始容量为16，默认加载因子为0.75，每次扩容是在原来的基础上增加一倍。线程不安全的集合。
加载因子越大，某个桶中的节点数越多导致查询效率低
加载因子越小，扩容频繁，让rehash操作频繁导致大量的内存使用造成浪费。
当某个桶中节点个数大于8个时扭转成二叉树来提高查询效率（jdk1.8出现的）

LinkedHashset:记录下存储元素对象的位置(LinkedHashMap)

TreeSet

默认给存储元素对象进行排序
类实现Comparable接口产生对象才能存储到TreeSet中，需要指定排序规则（重写compareTo方法），才能进行排序。

代码演示：

package cn.tedu.collection.set;

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        /*//创建集合对象
        TreeSet<String> t=new TreeSet<>();
        //添加元素
        t.add("abc");
        t.add("bc");
        t.add("ac");
        t.add("ab");
        t.add("1abc");
        t.add("a2bc");

        System.out.println(t);*/


        //创建集合对象
        TreeSet<Hero> t=new TreeSet<>();
        //添加元素
        t.add(new Hero("花花",'男',18888));
        t.add(new Hero("妲己",'女',48888));
        t.add(new Hero("后裔",'男',38888));
        t.add(new Hero("貂蝉",'女',28888));
        t.add(new Hero("鲁班",'男',58888));

        //System.out.println(t);
        //遍历输出---集合对象
        for(Hero s:t){
            System.out.println(s);
        }


        }
    }
//代表英雄的类
//只有类实现Comperable接口产生对象才能存储到TreeSet中
    class Hero implements Comparable<Hero>{
    //属性
        String name;
        char gender;
        //英雄的熟练度---分数
        int score;

        //有参构造
        public Hero(String name,char gender,int score){
            this.name=name;
            this.gender=gender;
            this.score=score;
        }

    @Override
    public String toString() {
        return "Hero{" +
                "name='" + name + '\'' +
                ", gender=" + gender +
                ", score=" + score +
                '}';
    }

    //指定排序规则

    @Override
    public int compareTo(Hero o) {
            //根据英雄的分数进行排序（升序）
        return o.score-this.score;
    }
}

执行结果：
在这里插入图片描述

Queue（队列）

遵循先进先出原则
队头元素–第一个存放的元素
队尾元素–最后一个存放的元素

package cn.tedu.collection.set;

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

public class QueueDemo {
    public static void main(String[] args) {
        //创建队列对象
        Queue<String> q=new LinkedList<>();
        //获取队头元素但并不删除
        //没有元素（报错）--NoSuchElementException
        //System.out.println(q.element());
        //没有元素--返回null
        System.out.println(q.peek());
    }
}