【集合】Collection接口、常用方法、迭代器、泛型、增强for

最新推荐文章于 2024-09-20 15:32:13 发布

Speechless_小赵啊

最新推荐文章于 2024-09-20 15:32:13 发布

阅读量59

点赞数

分类专栏： API基础文章标签： java 数据结构学习方法

本文链接：https://blog.csdn.net/qq_36028783/article/details/128686601

版权

API基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了Java集合框架的基础知识，包括集合的概念，Collection接口及其常用方法如add、size、contains等。还讨论了迭代器模式在集合遍历中的应用，以及Java1.5引入的增强for循环（新循环）的使用。最后，文章提到了泛型的引入，如何通过泛型限制集合元素的类型，提高代码安全性和效率。

摘要由CSDN通过智能技术生成

1、什么是集合：

集合和数组一样，可以保存一组数据，并且提供节操作集合元素的相关方法，使用更加方便

2、java集合框架中的相关接口：

java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的方法，下面有多种实现类，因此我们可以有更多的数据结构来选择。
Collection接口下面有两种常见的子接口：-----------------------下次课详细介绍
- java.util.List：线性表，是可以重复集合，并且有序
- java.util.Set：不可重复集合，大部分实现类是无序的

3、Collection接口的常用方法：

add()：向集合中添加一个元素，成功添加则返回true

public class CollectionDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Point(1,2));
        c.add(new Point(3,4));
        c.add(new Point(5,6));
        c.add(new Point(7,8));
        c.add(new Point(9,0));
        c.add(new Point(1,2));
        //[元素1.toString(), 元素2.toString(), 元素3.toString(), ......]
        System.out.println(c); //[(1,2), (3,4), (5,6), (7,8), (9,0), (1,2)]

size()：返回当前集合的元素个数

//size 输出集合的元素个数（size（）为0表示空集）
        System.out.println("size:"+c.size());         //size:6

isEmpty()：判断当前集合是否是空集，仅当size()为0时返回true

//isEmpty() 判断集合是否是空集（仅当size（）为0表示空集）
        System.out.println("是否是空集:"+c.isEmpty());  //是否是空集:false

clear()：清空集合

        c.clear();
        System.out.println(c);                       //[]

contains()：判断集合是否包含给定元素

/**
*  boolean contains(Object o)
* 判断当前集合是否包含给定元素(o）
* 判断依据是给定元素是否与集合元素存在equals比较为true的情况
*/
        Point p = new Point(1,2);
        boolean contains = d.contains(p);       //因为重写了hashcode和equals,所以比较的是属性值
        System.out.println("是否包含："+contains);//所以 true

remove()：从集合中删除给定元素，成功删除则返回true

/**
* boolean remove(Object o)----------一般直接调用
* 从当前集合汇总删除与给定元素equals比较为true的元素
* 若存在重复则只删除一次
*/
        d.remove(p);                            //删除d集合中p的属性值（1，2）
        System.out.println(d);                  //[(2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (1, 2)]

addAll()：将参数集合中的元素添加到当前集合中，添加后当前集合发生改变则返回true

//addAll 表示添加集合
        c1.addAll(c2);//将c2添加到c1中
        System.out.println("c1:"+c1);   //c1:[java, c++, .net, android, ios, java]
        System.out.println("c2:"+c2);   //c2:[android, ios, java]

containsAll()：判断当前集合中是否包含参数集合中的所有元素

        boolean contains = c1.containsAll(c3);  //判断c1中是否包含c3中的所有元素
        System.out.println("包含所有："+contains);//包含所有：false

retainAll()：取交集

//取交集，c1中仅保留c1与c3的共有元素，c3不变
        c1.retainAll(c3);

removeAll()：删交集

//删交集，将c1中与c3共有的元素删除，c3不变
        c1.removeAll(c3);

iterator()：获取迭代器

4、迭代器模式------集合的遍历：

Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用于遍历当前集合元素的迭代器(Iterator接口)。
java.util.Iterator接口：定义了迭代器遍历集合的相关操作，不同的集合都实现了用于遍历自身元素的迭代器实现类，但是我们不需记住它们的名字，从多态的角度把它们看成Iterator即可

迭代器遍历遵循的步骤：问(hasNext())、取(next())、删(remove())，其中删除并不是必要操作

public class IteratorDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("#");
        c.add("two");
        c.add("#");
        c.add("three");
        c.add("#");
        c.add("four");
        c.add("#");
        c.add("five");
        System.out.println(c);  //[one, #, two, #, three, #, four, #, five]

/**
 * 迭代器的常用方法：
 * 1）boolean hasNext（）------------------问
 *      询问集合是否还有“下一个”元素可供迭代
 *      注意：迭代器默认开始位置在集合第1个元素之前
 *           无论调用多少次 hasNext（）方法，迭代器的位置都不会自己改变
 * 2）Object next（）---------------------取
 *      迭代器向后移动一个位置来指向集合的下一个元素并将其获取
 */
        Iterator it = c.iterator(); //获取集合c的迭代器，并将其赋予it
        while (it.hasNext()){       //若有下一个元素                                              （while循环,先判断是否符合）
            String str = (String) it.next();//获取下一个元素（因it是iterator，输出当然要的是字符串，所以要强转一下）   （循环体）
            System.out.println(str);//  while循环：（先判断是否符合）→（循环体）→（反复执行的代码）
            if ("#".equals(str)){   //若str为#号
                /** c.remove(str);    //迭代器遍历过程中，不能通过集合的方法 增删元素 */
                it.remove();        //删除next（）方法所获取的元素
            }
        }
        System.out.println(c);      //[one, two, three, four, five]

5、增强for循环/新循环：

JDK1.5时推出了一个特性：增强型for循环，也称为新循环，让我们使用相同的语法来遍历集合和数组。

语法：

for(元素类型 变量名 : 集合或数组){
    循环体
}

/** for增强 新循环的演示 */
public class NewForDemo {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four","five"};
        for (int i=0;i< array.length;i++){
            System.out.println(array[i]);
        }
//增强for循环/新循环                       //新循环/增强for循环
        for (String str : array){       //for(元素类型 变量名 ： 集合或数组){ 循环体 }
            System.out.println(str);
        }

        Collection c = new ArrayList();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        Iterator it = c.iterator();
        while (it.hasNext()){
            String str = (String)it.next();
            System.out.println(str);
        }
//增强for循环/新循环                      //新循环遍历集合---会被编译为如上的迭代器遍历
        for (Object obj : c){
            String str = (String) obj;
            System.out.println(str);
        }

6、泛型：

JDK1.5时推出了一个特性：泛型

泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法参数或返回值类型，使得我们使用时更加方便。

泛型在集合中被广泛使用，用来规定集合元素的类型
若不指定泛型的具体类型，则默认为Object

若指定了泛型的具体类型，则在获取泛型的值时，编译器会做强转操作

/** 泛型的演示  */
public class GenericDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();//<指定类型> 泛型集合
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        //c.add(new Point(1,2));
        //编译错误，Point类型违背了集合c所指定的泛型的实际类型

        //迭代器所指定的泛型类型应当与其遍历的集合的泛型一直
        Iterator<String> it = c.iterator();
        while (it.hasNext()){
            String str = it.next();     //编译器会自动补齐强转操作
            System.out.println(str);
        }

        for (String str : c){           //编译器会自动补齐强转操作
            System.out.println(str);
        }

        Collection<Point> c1 = new ArrayList<>();
        c1.add(new Point(1,2));
        c1.add(new Point(2,3));
        c1.add(new Point(3,4));
        c1.add(new Point(4,5));
        c1.add(new Point(5,6));
        c1.add(new Point(6,7));
        //c1.add("one");                  //编译错误，参数类型与集合的泛型类型不匹配

        Iterator<Point> it1 = c1.iterator();
        while (it1.hasNext()){
            Point p = it1.next();         //编译器会自动补齐强转操作
            System.out.println(it1);
        }
        for (Point p1 : c1){
            System.out.println(p1);
        }