java之集合的4个带All的方法,利用迭代器遍历集合,接口List(实现类LinkedList,ArrayList和Vector的部分方法)

最新推荐文章于 2023-12-08 19:46:30 发布

时光仍在

最新推荐文章于 2023-12-08 19:46:30 发布

阅读量437

点赞数

分类专栏： java 文章标签：利用迭代器遍历集合 List的特有方法 List的实现类LinkedList类和ArrayList类利用迭代器遍历去除集合中重复元素的方法

本文链接：https://blog.csdn.net/KongLingLei_08225/article/details/82430505

版权

java 专栏收录该内容

38 篇文章 1 订阅

订阅专栏

一.接口Collection的带All的方法
1.containsAll :调用者完全包含被判断的集合的元素时才会返回true

代码例子:

public class Kll {
    //注解@SuppressWarnings(压制警告)
    //rawtypes :保持原有类型
    //unchecked:不检查容器中储存的元素类型
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        //创建两个集合,并添加元素
        Collection sb1 = new ArrayList<>();
        sb1.add("a");
        sb1.add("b");
        sb1.add("c");
        sb1.add("d");
        sb1.add("m");

        Collection sb2 = new ArrayList<>();
        sb2.add("a");
        sb2.add("b");
        sb2.add("c");
        //sb2.add("d");
        //containsAll方法测试
        boolean b1 = sb1.containsAll(sb2);
        System.out.println(b1);
        System.out.println(sb1);
        System.out.println(sb2);
    }
}

2.retainAll 仅保留两个集合的交集 .
调用者集合的元素变化时返回true,否则返回false.
谁调用这个方法就保留那个集合中的相同元素.

代码例子:

public class Kll {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        Collection sb1 = new ArrayList<>();
        sb1.add("a");
        sb1.add("b");
        sb1.add("r");
        sb1.add("x");

        Collection sb2 = new ArrayList<>();
        sb2.add("a");
        sb2.add("b");
        sb2.add("c");
        sb2.add("h");
        sb2.add("f");
        //retainAll方法   
        boolean b1 = sb1.retainAll(sb2);
        System.out.println(b1);
        System.out.println(sb1);
        System.out.println(sb2);
    }
}

3.removeAll
删除是两个集合的交集
谁调用这个方法就是在哪儿个集合中删除

代码例子:

public class Kll {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        //创建两个集合 添加 a b c d
        Collection sb1 = new ArrayList<>();
        sb1.add("a");
        sb1.add("b");
        sb1.add("c");
        sb1.add("d");

        Collection sb2 = new ArrayList<>();
        sb2.add("a");
        sb2.add("b");
        sb2.add("c");
        sb2.add("d");
        sb2.add("m");

        //removeAll方法
        sb1.removeAll(sb2);
        System.out.println(sb1);
        System.out.println(sb2);
    }
}

4.//addAll方法

add和addAll 的区别:
addAll 把传入的集合中的所有元素添加到调用的集合中(从后边开始添加)
add 是把整个传入的集合当做一个元素添加进去

public class Kll {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        //创建两个集合 添加 a b c d
        Collection sb1 = new ArrayList<>();
        sb1.add("a");
        sb1.add("b");
        sb1.add("c");
        sb1.add("d");

        Collection sb2 = new ArrayList<>();
        sb2.add("a");
        sb2.add("b");
        sb2.add("c");
        sb2.add("d");
        //addAll方法
        sb1.add(sb2);
        boolean b1 = sb1.addAll(sb2);
        System.out.println(sb1);    
    }
}

二.利用迭代器遍历集合
1.利用迭代器遍历集合(重点)

迭代器中相当于有一个指针默认指向首元素的上面
当调用hasNext()时会判断指针的下一个位置有没有元素是不会改变指针的位置
调用next方法时会获取下一个元素的值并且会将指针向下挪动一个位置
注意: 迭代遍历时循环中只能调用一次next方法

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

/*
 * 利用迭代器遍历集合(重点)
 */
public class DKll {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
    //创建集合 添加元素
        Collection sb = new ArrayList<>();
        sb.add("a");
        sb.add("b");
        sb.add("c");
        sb.add("d");

        //迭代器中 相当于有一个指针 默认指向 首元素的上面
        //当调用hasNext()时 会判断指针的下一个位置有没有元素  是不会改变指针的位置
        //调用next方法时 会获取下一个元素的值 并且会将指针向下挪动一个位置
        //注意: 迭代遍历时 循环中只能调用一次next方法

        //测试迭代器中的方法
        //从集合中获取迭代器
        Iterator it = sb.iterator();
        boolean b1 = it.hasNext();
        System.out.println(b1);
        int i = 0;
        //判断下一个是否有元素
        while (it.hasNext()) {          
            Object obj1 = it.next();
            System.out.println(obj1);
        }
    }
}

迭代器中hasNext()和next()在集合中的作用步骤图:
这里写图片描述
三.接口类List
接口List特有方法:
add(int index,Object obj)
索引不能超过长度size
set(index,obj)
替换当前位置
get(int index)
获取当前位置的值
remove(int index)
删除当前位置的值,按索引删除不能超过角标

public static void fun1() {
    //创建多态对象
    List list = new ArrayList<>();
    //重写的add方法(一个参数)
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    System.out.println(list);
    //索引不能超过长度size
    //List的add特有方法
    list.add(2, 30);
    System.out.println(list);
    //替换当前位置
    list.set(2, "kll");
    System.out.println(list);
    //获取当前位置的值
    Object object = list.get(2);
    System.out.println(object);
    //删除当前位置的值,按索引删除 不能超过角标
    list.remove(0);
    System.out.println(list);
}

利用List特有的get方法遍历集合:

public static void fun2() {
    List list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    // get 遍历
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
}

迭代器错误的添加集合元素方式
Iterator创建的迭代器是不能在遍历改变集合长度的
代码例子及解释如下:

public static void fun3() {
    // 需求 遍历数组(使用迭代器)
    // 如果数组中 有"b"这个元素 就添加"Oh-Yes"这个元素
    List list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    // 从集合中获取迭代器时已经获取了长度 4
    // 当前迭代器遍历集合时 系统就按长度4 进行遍历
    // 在遍历的过程中 修改集合长度 这时就发生并发修改异常ConcurrentModificationException
    Iterator iterator = list.iterator();
    while (iterator.hasNext()) {
        String object = (String)iterator.next();
        if(object.equals("b")) {
        // 并发修改异常 ConcurrentModificationException
        //增加了集合的长度
            list.add("Oh-Yes");
        }
    }
    System.out.println(list);
}

迭代器正确添加集合元素的方式
利用ListIterator 创建迭代器,并且使用迭代器自己的方法可以对集合的长度做出改变.

public static void fun4() {
    //解决迭代器错误的添加集合元素方式的方案是  使用迭代器自己的添加方法
    List list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        String object = (String)listIterator.next();
        if (object.equals("b")) {
            //使用迭代器自己的方法
            listIterator.add("Oh-Yes");
        }
    }
    System.out.println(list);
}

利用迭代器自己的方法倒着输出集合元素的方法:

//需要先遍历,把指针移到最后
public static void fun5() {
    List list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    ListIterator listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        String string = (String)listIterator.next();
        System.out.println(string);
    }
    System.out.println("-------------");
    //倒着输出
    while (listIterator.hasPrevious()) {
        String obj1 = (String)listIterator.previous();
        //Object obj2 = listIterator.previous();
        System.out.println(obj1);
    }
}

Vector类的方法
Vector :JDK1.0出现 ,线程安全 ,内部数组实现 ,被ArrayList替代.
Collection :JDK1.2出现

public static void fun6() {
    //创建Vector对象
    Vector vector = new Vector<>();
    vector.add("a");
    vector.add("b");
    vector.add("c");
    vector.add("d");
    //迭代器遍历
    Enumeration elements = vector.elements();
    while (elements.hasMoreElements()) {
        String string = (String)elements.nextElement();
        System.out.println(string);
    }
}

LinkedList类

LinkedList特点:
查询慢增删快
相对ArrayList而言 .查询慢:是因为查询,是根据地址(元素仅存相邻的地址)进行对比查询的,而ArrayList查询是根据角标,所以更快速。

增删快是因为:只需要改变前一个元素,后一个元素和添加进去元素内保存的地址就可以了,他们的排序就会改变成你想要的. 而ArrayList,是需要把所需改变的元素的后边的所有元素,都按顺序后移一位或者前移一位来完成增删.数据过多时,速度差会更明显。

以下是LinkedList的特有方法代码例子:

public class Kll {
    public static void main(String[] args) {
        //LinkedList 内部是链表实现的
        //LinkedList 模拟一下栈结构
        //栈特点:先入后出
        //队列特点:先入先出
        LinkedList list = new LinkedList<>();
        //添加第一个元素
        list.addFirst("a");
        list.addFirst("b");
        list.addFirst("c");
        System.out.println(list);
        //从最后添加
        list.addLast("d");
        list.addLast("e");
        list.addLast("f");
        System.out.println(list);
        //删除最后一个元素
        list.removeLast();
        System.out.println(list);


    }

ArrayList类

ArrayList 特点:
查询快增删快

判断新数组是否包含某个元素的核心：使用的是contains。

去除集合中的重复元素
代码案例：

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.ListIterator;

public class Kll {
    // 需求 在集合中存储 
    //  "a""a""a" "b""b""b" "c""c""c"
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("c");
        //去除重复数字
        ListIterator iterator = list.listIterator();
        //新建集合
        ArrayList list1 = new ArrayList<>();
        while (iterator.hasNext()) {
            Object obj1 = iterator.next();
            //判断新数组是否包含这个元素
            if (!list1.contains(obj1)) {
                //不包含添加到新数组
                list1.add(obj1);
            }
        }
        System.out.println(list1);
    }
}

以下同样是去除集合相同元素但需要重写父类Object类的equals方法的案例：
需求：在集合中存储 6个学生
分别两个花花 21岁两个小明 20岁两个小红 23岁
去除重复的
student类:


public class Student {
/*
 * 学生类(name age)
 * 私有化成员变量 有参无参
 * set/get方法 
 * toString方法
 */
    private String name;
    private int age;
    //构造方法
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //set/get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override//重写toString方法

        // TODO Auto-generated method stub
        String str = "学生名字:"+name+" 学生年龄:"+age;
        return str;
    }

    //重写equals方法
    @Override
    public boolean equals(Object obj) {
        //重写 判断两个对象相等的规则
        //人名 和 年龄 相等
        //this 和 obj比较
        //类型强转
        Student stu = (Student) obj;
        boolean rel = this.getName().equals(stu.getName()) && this.getAge() == stu.getAge();
        return rel;
    }
}

测试类：

判断新数组是否包含某个元素的核心使用的是contains。
contains方法中，依赖的是equals方法。
Object类中equals方法判断时的是对象地址是否相等
所以要重写equals方法。

public class Test {

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) {
        //  需求 在集合中存储 6个学生
        //  分别 两个 东东 18岁  两个生生 16岁 两个柳柳 20岁
        //  去除重复的
        ArrayList list = new ArrayList<>();
        list.add(new Student("花花", 21));
        list.add(new Student("花花", 21));
        list.add(new Student("小明", 20));
        list.add(new Student("小明", 20));
        list.add(new Student("小红", 23));
        list.add(new Student("小红", 23));
        ListIterator iterator = list.listIterator();
        //新建集合
        ArrayList list1 = new ArrayList<>();
        while (iterator.hasNext()) {
            Student obj1 = (Student)iterator.next();
            //判断新数组是否包含这个元素
            //本段代码 核心使用的是contains
            //点击contains方法 发现contains方法中  依赖的是equals方法
            //Object类中equals方法 判断时的是对象地址是否相等
            if (!list1.contains(obj1)) {
                //不包含添加到新数组
                list1.add(obj1);
            }
        }
        System.out.println(list1);
    }
}

时光仍在

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java之集合的4个带All的方法,利用迭代器遍历集合,接口List(实现类LinkedList,ArrayList和Vector的部分方法)

一.接口Collection的带All的方法 1.containsAll :调用者完全包含被判断的集合的元素时才会返回true代码例子:public class Kll { //注解@SuppressWarnings(压制警告) //rawtypes :保持原有类型 //unchecked:不检查容器中储存的元素类型 @SuppressWarnings...
复制链接

扫一扫

专栏目录