Collection集合、List、泛型、删除List中的元素

于 2022-07-16 12:03:11 发布
阅读量384 收藏
点赞数
文章标签： 大数据 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44216665/article/details/125804034
版权
本文详细介绍了Java中的Collection接口及其子接口List，包括ArrayList、LinkedList和Vector等，强调了List的有序性和允许重复元素的特点。此外，文章还探讨了泛型的使用，以及在List中如何安全地删除元素，提到了迭代器的重要性和操作注意事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. Collection

Collection接口: 用来存储单列数据 {"张三","李四","王五"}

        List接口: 存储的元素是有序的

                ArrayList

                LinkedList

                Vector

        Set接口: 存储的元素无序，且不允许重复

                 HashSet

                 TreeSet

Map接口: 用来存储成对的数据 {"卧龙":"诸葛亮", "及时雨":"宋江", "黑旋风":"李逵"}

         HashMap:

        TreeMap:

        LinkedHashMap:

        HashTable:

        Properties:

Collection是一个接口，有两个子接口 List / Set size()

/ isEmpty() / contains(Object o) / iterator() / toArray() add(E e) / addAll() / remove(Object o) / removeAll() / clear()

        容器: 可以用来存储多个数据的结构

        数组特点:

        1. 存储的元素类型是兼容的 Person[] people = {new Person(),new Student()};

        2. 长度是固定的，不允许修改 int[] nums = new int[3];

        3. 存储的元素有序，可以通过下标来操作元素 nums[0] = 10; System.out.println(nums[1]);

        数组的缺点:

        1. 长度是固定的，不能很方便的对元素进行增删操作 (ArrayList)

        2. 不好描述成对的数据，使用数组统计字符出现的次数 (HashMap)

2. List集合

Collection中的常用几个子类（java.util.List集合、java.util.Set集合）。

List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。

List接口特点：

  1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。

  2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

  3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();  // 多态

        list.add("ok");
        list.add("hello");
        list.add(5);
        list.add("yes");
        list.add(3.14);
        list.add("ok");
        list.add(true);
        list.add("good");
        list.add(new Person());
        System.out.println(list);

        list.add(1, "hi");
        System.out.println(list);

        list.set(2, "no");
        System.out.println(list);

        list.remove("ok");  // 只会移除第一次出现的元素
        System.out.println(list);

        list.remove(1);
        System.out.println(list);

        System.out.println(list.get(2));

        list.clear();
        System.out.println(list);

        int[] nums = {1, 2, 3, 4};
        String[] names = {"张三", "李四"};
        double[] x = {4.56, 3.25};
    }
}

3. 泛型

泛型是JDK1.5出现的，一般用在集合里，规定元素的类型

public class GenericDemo {
    public static void main(String[] args) {
        // 创建了一个 List,规定了里面的元素只能是 String 类型
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("good");
        // list.add(3); 编译报错，List里只能存储字符串类型

        // List<Person> people = new ArrayList<Student>();  声明泛型时，不能使用多态
        List<Person> people = new ArrayList<>();
        people.add(new Person());
        people.add(new Student());

        // List<int> nums = new ArrayList<>();  泛型里只能使用引用数据类型，不能使用基本数据类型
        List<Integer> nums = new ArrayList<>();
        nums.add(4);
        nums.add(3);
        nums.add(7);
        // nums.add("hello");

    }
}

3.1 使用泛型

语法格式：

修饰符 class 类名<代表泛型的变量>{ }

例如，API中的ArrayList集合

class ArrayList<E>{
    public boolean add(E e){}
    public E get(int index){}

}

使用泛型：在创建对象的时候确定泛型

public class GenericDemo {
    public static void main(String[] args) {
        // 创建了一个 List,规定了里面的元素只能是 String 类型
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("good");
        // list.add(3); 编译报错，List里只能存储字符串类型

        // List<Person> people = new ArrayList<Student>();  声明泛型时，不能使用多态
        List<Person> people = new ArrayList<>();
        people.add(new Person());
        people.add(new Student());

        // List<int> nums = new ArrayList<>();  泛型里只能使用引用数据类型，不能使用基本数据类型
        List<Integer> nums = new ArrayList<>();
        nums.add(4);
        nums.add(3);
        nums.add(7);
        // nums.add("hello");

    }
}

自定义泛型的使用

1. 泛型可以定义在类上,也可以定义在方法上

2. 自定义泛型通常会配合泛型通配符来使用。

        泛型声明 不支持多态，可以使用 ? 通配符来对泛型进行设定

        ? super X 规定了泛型的下限，能够接收 X 以及 X 的父类

        ? extends X 规定了泛型的上限，能够接收 X 以及 X 的子类

public class MyGenericDemo {
    public static void main(String[] args) {
        Demo<String> d = new Demo<>();
        d.test1("good");
        // d.test1(4);
        d.test3();
        d.test4(4);
        d.test4(new Person());
        d.test4("yes");


        List<Student> students = new ArrayList<>();
        List<Person> people = new ArrayList<>();
        List<Animal> animals = new ArrayList<>();
        // foo1(students);  List<Person> people = new ArrayList<Student>();

        foo2(students);
        foo2(new ArrayList<Integer>());
        foo2(new ArrayList<Boolean>());
        foo2(new ArrayList<String>());

        foo3(people);
        foo3(animals);
        foo3(new ArrayList<Object>());
        // foo3(students);

        foo4(people);
        foo4(students);
        // foo4(animals);
    }

    public static void foo1(List<Person> people) {
    }

    public static void foo2(List<?> list) {
    }

    public static void foo3(List<? super Person> x) {

    }

    public static void foo4(List<? extends Person> x) {
    }
}

class Demo<T> {  // 泛型可以定义在类里，在整个类里都可以访问
    public void test1(T t) {
        System.out.println(t.getClass());
    }

    public T test2() {
        // T t = new T();
        return null;
    }

    public <M> M test3() {  // 在方法上声明一个泛型
        return null;
    }

    public <E> void test4(E e) {
        System.out.println(e.getClass());
    }

}
public class MyGenericTest {
    public static void main(String[] args) {
        Student[] students = {
                new Student("张三", 18, 93),
                new Student("李四", 17, 95),
                new Student("王五", 16, 84),
                new Student("赵六", 19, 96)
        };
        /*Arrays.sort(students, new Comparator<Person>() {  // 可以使用父类的属性进行排序
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });*/

        // public static <T> void sort(T[] a, Comparator<? super T> c)
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {  // 也可以使用本类的属性进行排序
                return o1.getScore() - o2.getScore();
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

4. 迭代器

List<Integer> numbers = new ArrayList<>();
        numbers.add(4);
        numbers.add(7);
        numbers.add(8);
        numbers.add(2);
        numbers.add(5);
        numbers.add(3);

使用迭代器遍历

Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
    Integer x = iterator.next();
    System.out.println(x);
}

使用增强for循环（for each循环） 进行遍历

for (Integer num : numbers) {
    System.out.println(num);
}

String[] arr = {"hello", "good", "ok", "yes", "no"};
/*for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}*/
for (String s : arr) {  // 使用增强for循环也可以对数组进行遍历
    System.out.println(s);
}

案例：遍历集合

public class IteratorDemo {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(4);
        numbers.add(7);
        numbers.add(8);
        numbers.add(2);
        numbers.add(5);
        numbers.add(3);

        // 使用 for 循环 对List里的数据进行遍历
        /*for (int i = 0; i < numbers.size(); i++) {
            System.out.println(numbers.get(i));
        }*/

        /*int i = 0;
        while (i < numbers.size()) {
            System.out.println(numbers.get(i));
            i++;
        }*/

        // 使用迭代器进行遍历
        /*Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            Integer x = iterator.next();
            System.out.println(x);
        }*/

        // 使用增强for循环来对数组里的元素进行遍历
        for (Integer num : numbers) {
            System.out.println(num);
        }

        String[] arr = {"hello", "good", "ok", "yes", "no"};
        /*for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/
        for (String s : arr) {  // 使用增强for循环也可以对数组进行遍历
            System.out.println(s);
        }
    }
}

迭代器使用注意事项：

在使用迭代器对集合遍历时，不能再对集合进行增删操作

在 ArrayList里有一个成员变量 modCount,用来记录元素的增删次数。只要调用 add或者remove方法，modCount都会自增 迭代器里有一个变量 expectedModCount 初始值等于 modCount

但是调用 add 或者 remove方法时，只修改了 modCount,没有修改 expectedModCount 如果一定要在使用迭代器时删除元素，不能直接调用集合的 remove方法，需要调用 迭代器的remove方法

public class IteratorTest {
    public static void main(String[] args) {
        List<String> heroes = new ArrayList<>();

        heroes.add("张飞");
        heroes.add("赵云");
        heroes.add("关羽");
        heroes.add("刘备");
        heroes.add("王昭君");
        heroes.add("虞姬");
        heroes.add("项羽");
        heroes.add("鲁班");

        Iterator<String> iterator = heroes.iterator();

        while (iterator.hasNext()) {
            String h = iterator.next();
            if (h.equals("刘备")) {
                // 在使用迭代器遍历集合时，不能使用 add 或者 remove 方法修改集合元素的个数
                // heroes.add(2,"后羿");
                // heroes.remove(h);
                iterator.remove();
            }
        }
        System.out.println(heroes);
    }
}

5. 删除List中的元素

public class DeleteDemo {
    public static void main(String[] args) {
        List<String> heroes = new ArrayList<>();
        heroes.add("孙悟空");
        heroes.add("猪八戒");
        heroes.add("唐僧");
        heroes.add("唐僧");
        heroes.add("沙和尚");
        heroes.add("太上老君");
        heroes.add("二郎神");
        heroes.add("唐僧");
        heroes.add("哮天犬");
        System.out.println(heroes);

        /*
        报错，在增强for循环里，不能直接对集合进行增删操作
        for (String hero : heroes) {
            if (hero.equals("唐僧")) {
                heroes.remove(hero);
            }
        }*/

       /* while (heroes.contains("唐僧")) {
            heroes.remove("唐僧");
        }*/

        /*Iterator<String> iterator = heroes.iterator();
        while (iterator.hasNext()) {
            if (iterator.next().equals("唐僧")) {
                iterator.remove();
            }
        }*/

        /*for (int i = 0; i < heroes.size(); i++) {
            if (heroes.get(i).equals("唐僧")) {
                heroes.remove(i);
                i--;  // 删除数据以后，再次查看第 i 个元素
            }
        }*/

        /*for (int i = heroes.size() - 1; i >= 0; i--) {
            if (heroes.get(i).equals("唐僧")) heroes.remove(i);
        }*/

        // removeIf 使用Predicate匿名内部类,在test方法里，返回要删除的元素的条件

        /*heroes.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.equals("唐僧");
            }
        });*/
        heroes.removeIf(s -> s.equals("唐僧"));
        // heroes.removeIf(s -> s.length() == 3);
        System.out.println(heroes);
    }
}

守猪_待兔
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值