集合小议

最新推荐文章于 2024-10-13 23:27:44 发布

@998

最新推荐文章于 2024-10-13 23:27:44 发布

阅读量129

点赞数 1

分类专栏：集合文章标签： java

本文链接：https://blog.csdn.net/m0_54355376/article/details/113865562

版权

集合专栏收录该内容

1 篇文章 0 订阅

订阅专栏

集合

集合，其实就是数组的加强版，当我们使用数组时，因为数组的底层被final修饰，所以一个数组一旦被创建之后，他的长度不再可以改变。而当我们需要对数组内容进行一些操作时，往往需要再创立一个新的数组，将以前修改后的数组存入到新的数组中，这就使我们在操作产生了大大的不方便。
而集合的出现，就大大的解决了这一问题，他可以快速的进行增删涂改。
集合中有两大顶层接口。1.Collection接口 2.map接口
对于集合我们一般采用学习顶层使用底层的方法

Collection接口集合

在这里插入图片描述
Collection接口的集合常用的方法
1.add（参数）`

 public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(5);     //添加元素
        System.out.println(arr);
    }

把给定的对象添加到当前集合当中
2.clear（）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(5);     //添加元素
        System.out.println(arr);    //打印集合，打印出来的是集合的内容，不是地址
        arr.clear();        //调用clear方法，清空集合
        System.out.println(arr);    //重新打印
    }

清空集合中所有的元素
3.remove（参数）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(5);     //添加元素
        arr.add(6);     //添加元素
        arr.add(7);     //添加元素
        System.out.println(arr);    //打印集合，打印出来的是集合的内容，不是地址
        arr.remove(1);          //删除索引值为1的元素
        System.out.println(arr);    //再次打印
    }

把给定的对象在当前集合中删除，参数为索引值
4.contains（参数）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(5);     //添加元素
        arr.add(6);     //添加元素
        arr.add(7);     //添加元素
        System.out.println(arr);    //打印集合，打印出来的是集合的内容，不是地址
        if(arr.contains(6)){        //判断是否含有元素6
            System.out.println("含有此元素");
        }else{
            System.out.println("没有此元素");
        }
    }

判断集合中是否包含给定的对象
返回值是一个布尔值
5.isEmpty（）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(5);     //添加元素
        arr.add(6);     //添加元素
        arr.add(7);     //添加元素
        System.out.println(arr);    //打印集合，打印出来的是集合的内容，不是地址
        if(arr.isEmpty()){
            System.out.println("此集合为空");
        }else{
            System.out.println("此集合内含有元素");
        }
    }

判断当前集合是否为空
返回值是一个布尔值，集合为空输出true。
6.size（）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(5);     //添加元素
        arr.add(6);     //添加元素
        arr.add(7);     //添加元素
        System.out.println(arr);    //打印集合，打印出来的是集合的内容，不是地址
        int length=arr.size();
        System.out.println(length);
    }

返回集合中元素个数
7.toArray（）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(5);     //添加元素
        arr.add(6);     //添加元素
        arr.add(7);     //添加元素
        System.out.println(arr);    //打印集合，打印出来的是集合的内容，不是地址
        Integer[] a=new Integer[arr.size()];   //创建数组，数组的长度和arr长度相同
        arr.toArray(a);             //将集合中的元素传递到数组中
        System.out.println(a);      //打印数组打印出来的是地址
    }

把集合中的元素存放在数组中参数是存放的位置（数组），当无参是参数默认为object，这是传递给其他数组会出现超纲现象
8.addAll（）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        ArrayList<Integer> ar=new ArrayList<Integer>();
        arr.add(3);
        arr.add(4);
        arr.add(5);
        arr.addAll(ar);
        System.out.println(arr);    //打印集合，打印出来的是集合的内容，不是地址
    }

复制集合中的元素到该集合中，参数为需要被复制的集合
9.shuffle（）

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(3);             //存储元素
        arr.add(4);
        arr.add(5);
        System.out.println(arr);        //打印集合，打印出来的是集合的内容，不是地址
        Collections.shuffle(arr);       //  打乱集合中元素的顺序
        System.out.println(arr);    //再次打印集合，
    }

参数中存入一个集合，将会打乱集合中元素的顺序
10.sort()

    public static void main(String[] args) {
        ArrayList<Integer> arr=new ArrayList<Integer>();  //创建集合Collection的实现类
        arr.add(4);//存储元素
        arr.add(3);             
        arr.add(5);
        System.out.println(arr);        //打印集合，打印出来的是集合的内容，不是地址
        Collections.sort(arr);       //  调整集合中的顺序，默认是升序
        System.out.println(arr);    //再次打印集合，
    }

将参数中的集合进行排序，默认是升序
参数中的集合必须为List接口，不能为set接口，因为set接口无序
当参数中的集合的元素为自定义类时，系统不知道按照什么方法排序
此时进行排序系统将会报错，我们需要重写方法
首先先在自定义类中实现接口comparable重写方法comparTo方法
comparTo（参数类型名称）
参数类型为我们自定义方法，我们只需要改写返回值即可，用this.自定义类属性
和参数名称.自定义属性，自定义属性是谁则我们按照谁来排列。如果返回值是this.自定义类属性
-参数名称.自定义属性，那么将会按照从小到大的顺序排列。如果是参数名称-this.自定义属性
那么将会按照从大到小的顺序来排列。（抽象可以理解为this代表的是小，this在前则小到大
this在后则代表大到小）
但是作为底层接口的Collection，其含有抽象方法，所以我们不能直接使用，一般对他的实现类进行使用，其实现类继承了他的方法。所以我们学习顶层使用底层。
Collection接口一般分为两大类
1.List接口
2.Set接口
他们在使用中各自具有各自独特的优势

List

接口特点
1.有序，你存入的是什么顺序，他读取出来的就是什么顺序
2.可以存储重复的元素
3，每个元素都有对应的索引，可以用for循环进行遍历

ArrayList集合

集合的底层是一个数组
特点
1.查询快增删慢,增删时系统内部会自动对底层数组进行操作，创建新的数组，然后存入经过操作后的数组
2.线程不安全，但是其效率高

LinkedList

底层是链表结构，
链表由一片片构成，每一片中含有三个数据，
1.这一片的地址
2.这一片中所存储的内容
3.下一片的地址
当读取数据时，从第一片开始，找到第一片所存储的下一片地址，根据地址找到下一片。
当修改数据时，他会找到需要修改部分的上一片地址，和需要修改部分的下一片地址，如果需要删除则直接通过修改存入的地址跨过删除部分即可，不需要再重建建立新的数组。
特点
1.增删快，查询慢
2.线程不安全，效率高

Set

特点，存入的数据是无序的，底层是一个哈希表，不可存储重复的元素
哈希表，是数组加红黑树组成的
在这里插入图片描述
方格子中存储的是哈希值，然后以哈希值为根，延伸出来红黑树
存入数据时，会先判断所存入数据的哈希值，如果方格子中有此哈希值，则
寻找此哈希值的树，看树中是否有该数据，如果有则不再进行存入，如果没有则存入此树中。如果存数据时方格子中没有该哈希值，则此时直接在方格子中存入新的哈希值，然后延伸出来树，在树中存入数据。这也是为什么存入的数据无序和不能重复的原因
Set接口的集合，没有索引值
因此我们遍历Set接口的集合一般采用迭代器，或者增强for

LinkedHashSet

他的底层是由哈希表加上链表组成，因为存入数据时，链表中会根据存入数据的类型来一片片的存入地址，因此他有序

Map接口集合

Map接口的集合是双列集合
他们在存储时都是成对存储的一个是k值，一个是v值
存储的k值不可以重复，存储的v值可以重复
同样是学习顶层使用底层
常用方法
put方法

    public static void main(String[] args) {
        LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
        map.put(5,7);       //存入数据
        map.put(4,7);       //存入的数据与第一次存入的数据v值相同，不受影响
        map.put(3,6);
        map.put(5,8);       //存入的数据与第一次存入的数据k值相同，将会替换掉第一次存入的数据
        System.out.println(map);
    }

在集合中存储一对元素，当存储元素的k值重复时，新的v值将会替换重复的旧的
v值和他对应的元素并且会有一个返回值返回被替换掉的v值
如果没有重复，那么将返回空值，如果k值重复则不影响
remove（）方法

    public static void main(String[] args) {
        LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
        map.put(5,7);       //存入数据
        map.put(4,7);       //存入的数据与第一次存入的数据v值相同，不受影响
        map.put(3,6);
        map.put(5,8);       //存入的数据与第一次存入的数据k值相同，将会替换掉第一次存入的数据
        System.out.println(map);        //打印集合，打印出来的是集合的内容
        map.remove(3);      //删除k值为3的那一对元素
        System.out.println(map);        //再次打印
    }

在集合中删除元素，参数为要删除的元素的key值，如果存在则返回被删除的
v值，如果不存在则返回空值
get（）方法

    public static void main(String[] args) {
        LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
        map.put(5,7);       //存入数据
        map.put(4,7);
        map.put(3,6);
        System.out.println(map);        //打印集合，打印出来的是集合的内容
        int a=map.get(4);       //获取k值为4的那对元素的v值，存入a中
        System.out.println(a);  //打印a
    }

获取集合中的元素，获取的是v值
参数中填写k值，通过k去找v（抽象的理解为k是钥匙）
Containskey（）

   public static void main(String[] args) {
        LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
        map.put(5,7);       //存入数据
        map.put(4,7);
        map.put(3,6);
        System.out.println(map);        //打印集合，打印出来的是集合的内容
        if(map.containsKey(4)){
            System.out.println("有k值为4的元素");
            System.out.println("他的v值为"+map.get(4));
        }else{
            System.out.println("没有k值为4的元素");
        }
    }

参数中填写k值，用来判断集合中是否需含有这个k值，返回值是一个布尔值
如果有则返回ture，如果没有则返回false
Keyset（）方法

    public static void main(String[] args) {
        LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
        map.put(5,7);       //存入数据
        map.put(4,7);
        map.put(3,6);
        System.out.println(map);
        for(int a:map.keySet()){        //采用增强for遍历keySet
            System.out.println(map.get(a));
        }
    }

将集合中的key值储存在一个set集合中，返回值是一个set集合
这个方法方便我们来对map集合进行遍历
遍历set集合中的key然后用key作为参数来采用get方法来对
集合中的v值进行遍历
entrySet（）方法

    public static void main(String[] args) {
        LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();
        map.put(5,7);       //存入数据
        map.put(4,7);
        map.put(3,6);
        System.out.println(map);
        for(Map.Entry<Integer,Integer> a:map.entrySet()){        //采用增强for遍历keySet
            System.out.print(a.getKey());               //获取Entry集合中的k
            System.out.println(a.getValue());       //获取Entry集合中的v
        }
    }

Map接口的集合中k与v之间的连接是有一个纽带的，当我们在往集合中存储
对象时，集合内部就会创建一个Entry集合在集合中存储纽带。
这个方法也可进行集合的遍历
方法的返回值是一个set集合，将纽带存储在set中，我们先遍历set
将set存储的纽带存储在一个新的map.entry集合中 ,通过调用map.entry
中的getkey和getvalue方法来遍历