Java小白一文讲清Java中集合相关的知识点（一）

Kerwin要坚持日更

于 2024-09-01 21:42:33 发布

阅读量395

点赞数 8

分类专栏： JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/Kerwin_D/article/details/141720742

版权

JavaSE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

集合

诞生缘由

数组

长度开始时必须指定，而且一旦指定，不能更改
保存的必须为同一类型元素
使用数组进行增/删元素所需要编写的代码–比较麻烦

Person[] pers = new Person[1];
pers[0] = new Person();
//此时增加新的Person对象呢？
Person[] pers2 = new Person[pers.length+1]；//新创建数组
for(){}//拷贝pers数组的元素到pers2
pers2[pers2.length-1]=new Person();//添加新对象

//可见很麻烦，所以，集合诞生了

集合介绍

可以动态保存任意多个对象，使用比较方便
提供了一系列方便的操作对象的方法—add、remove、set、get等
使用集合添加，删除新元素所需要编写的代码—简洁

集合的框架体系

单列集合

两个重要的子接口List Set ,他们的实现子类都是单列集合

在这里插入图片描述

双列集合

Map的实现子类都是双列集合，以K-V 形式存放
在这里插入图片描述

Collection接口和常用方法

collection实现子类可以存放多个元素，每个元素可以是Object
有些collection的实现类，可以存放重复的元素，有些不可以
Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

常用方法

接口不能实例化，所以以下的举例以实现了Collection接口的ArrayList类来举例

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

public class Journey {
    @SuppressWarnings({"all"})//抑制所有的警告
    public static void main(String[] args) {
        //以ArrayList实现类来演示
        List list = new ArrayList();
        //add 添加单个元素
        list.add("jack");
        list.add(10);//此中有一个自动装箱的过程=(new Integer(10));
        list.add(true);
        System.out.println("List = "+list);//List = [jack, 10, true]

        //remove 删除指定元素
        list.remove(0);//指定删除某个索引对应的元素
        System.out.println("List = "+list);//List = [10, true]
        list.remove(true);//指定删除某个内容
        System.out.println("List = "+list);//List = [10]

        //contains 查找某个元素是否存在
        System.out.println(list.contains("jack"));//false

        //size  获取元素的个数
        System.out.println(list.size());//1

        //isEmpty 判断是否为空
        System.out.println(list.isEmpty());//false

        //clear  清空
        list.clear();
        System.out.println(list.size());//0

        //addAll  添加多个元素,就是可以把装有多个元素的集合再套进另一个集合中，实现原先的集合添加多个元素
        list.add("essence");
        List list2 = new ArrayList();
        list2.add("kerwin");
        list2.add(false);
        list2.add(1110);

        list.addAll(list2);
        System.out.println("此时的list1 = "+list);//此时的list1 = [essence, kerwin, false, 1110]

        //containsAll 查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//true  list中包含有多个元素的集合list2

        //removeAll   删除多个元素
        list.removeAll(list2);
        System.out.println("list = "+list);//list = [essence]

    }
}

Collection接口遍历元素方式

使用Iterator迭代器实现

介绍

Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
Iterator的结构
Iterator仅用于遍历集合，Iterator本身并不存放对象

在这里插入图片描述


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Journey {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();//向上转型，父类型引用指向子类型对象
        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("水浒传","施耐庵",5.1));
        col.add(new Book("西游记","吴承恩",63.5));

        System.out.println("col"+col);
        /**
         * 不间断，输出很长的一行
         *  col[Book{name='三国演义', author='罗贯中', price=10.1},
         * Book{name='水浒传', author='施耐庵', price=5.1},
         * Book{name='西游记', author='吴承恩', price=63.5}]
         */
        //现在我们希望能够遍历集合
        //1.先得到col 对应的迭代器
        Iterator iterator = col.iterator();
        //2.使用while循环遍历
        while(iterator.hasNext()){//判断是否还有数据，这里脑海中要浮现出iterator的结构哈
            //返回下一个元素，类型是Object
            Object obj = iterator.next();
            System.out.println("obj="+obj);//这里默认调的是obj对应的toString方法
            //这里会有动态绑定机制，像这里就是绑定到了Book类的toString方法；
            //此中的编译类型确实是Object,但是运行类型是取绝于你真正存放的类型，这里是存放的Book类型嘛

        }
        //经过迭代器后，输出三行
//        obj=Book{name='三国演义', author='罗贯中', price=10.1}
//        obj=Book{name='水浒传', author='施耐庵', price=5.1}
//        obj=Book{name='西游记', author='吴承恩', price=63.5}

        //顺便一提，上面的while循环的框架可以通过快捷键itit就可以快速生成
        //生成如下：

/*        while (iterator.hasNext()) {
            Object obj =  iterator.next();

        }*/

        //3.当退出while循环之后，这时iterator指向最后的元素
        //此时，再取元素
//         iterator.next();
        // 会报NoSuchElementException 异常
        //4.如果希望再次遍历，那么需要重置我们的迭代器
         iterator = col.iterator();
        System.out.println("==========第二次遍历=====");
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("obj="+ obj);
            
        }
        /**
         * ==========第二次遍历=====
         * obj=Book{name='三国演义', author='罗贯中', price=10.1}
         * obj=Book{name='水浒传', author='施耐庵', price=5.1}
         * obj=Book{name='西游记', author='吴承恩', price=63.5}
         */
    }
}
@SuppressWarnings({"all"})
class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

使用增强for循环实现

增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator,本质一样，只能用以遍历集合或数组

基本语法

for( 元素类型元素名：集合名或数组名){

访问元素

}

import java.util.ArrayList;
import java.util.Collection;

public class Journey {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();//向上转型，父类型引用指向子类型对象

        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("水浒传","施耐庵",5.1));
        col.add(new Book("西游记","吴承恩",63.5));

        //使用增强for循环遍历
        //增强for 其底层还是迭代器
        for(Object book : col){
            System.out.println(book);
        }
        //输出如下
        /**
         * Book{name='三国演义', author='罗贯中', price=10.1}
         * Book{name='水浒传', author='施耐庵', price=5.1}
         * Book{name='西游记', author='吴承恩', price=63.5}
         */

        //这里再讲个快捷键
        //输入一个 I，即可快捷生成增强for框架
   /*
        快速生成以下框架
        for (Object o :) {

        }*/

    }
}
@SuppressWarnings({"all"})
class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

练习

在这里插入图片描述

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

public class Journey {
    public static void main(String[] args) {
        List<Dog> list = new ArrayList<>();
        Dog xiaohuang = new Dog("小黄", 15);
        Dog hei = new Dog("小嘿", 8);
        list.add(xiaohuang);
        list.add(hei);

        //迭代器遍历
        Iterator<Dog> iterator = list.iterator();
        while(iterator.hasNext()){//判断是否为空
            Object obj = iterator.next();
            System.out.println(obj);
        }

        System.out.println("增强for遍历");
        for(Object dogs : list){
            System.out.println(dogs);
        }
    }
}
@SuppressWarnings({"all"})
class Dog{
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

//输出
Dog{name='小黄', age=15}
Dog{name='小嘿', age=8}
增强for遍历
Dog{name='小黄', age=15}
Dog{name='小嘿', age=8}