Java 将一个集合遍历通过多线程处理

转载

编程梦想家 2024-10-22 14:48:43

文章标签 Java 将一个集合遍历通过多线程处理 java 开发语言后端 System 文章分类 Java 后端开发

Java集合框架&接口方法&集合遍历

一、集合框架的概述
二、集合框架
三、Collection接口中的方法的使用
使用Iteration接口遍历集合元素
使用foreach循环遍历集合元素

一、集合框架的概述

1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中）

2.1 数组在存储多个数据方面的特点：

一旦初始化以后，其长度就确定了。
数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
比如：String[] arr;int[] arr1;Object[] arr2;

2.2 数组在存储多个数据方面的缺点：

一旦初始化以后，其长度就不可修改。
数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

2.3集合存储的优点

解决数组存储方面的弊端(缺点)

二、集合框架

Java 将一个集合遍历通过多线程处理_Java 将一个集合遍历通过多线程处理

1.Collection接口

Java 将一个集合遍历通过多线程处理_System_02

2.Map接口

Java 将一个集合遍历通过多线程处理_后端_03

三、Collection接口中的方法的使用

抽象方法

Java 将一个集合遍历通过多线程处理_开发语言_04

Java 将一个集合遍历通过多线程处理_System_05

向Collection接口的实现类的对象中添加数据obj时，需要obj所在类要重写equals()

add(Object e):将元素e添加到集合coll中
size():获取添加的元素的个数
addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
isEmpty:判断当前集合中是否为空(size()==0)
clear():清空集合元素

public void test01() {
        Collection coll = new ArrayList();
        //1.add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //2.size():获取添加的元素的个数
        System.out.println(coll.size());//3

        //3.addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll.size()); //5
        System.out.println(coll); //[AA, 123, Mon Jan 03 20:30:18 CST 2022, 456, CC]

        //4.isEmpty:判断当前集合中是否为空(size()==0)
        System.out.println(coll.isEmpty());//false

        //5.clear():清空集合元素
        coll.clear();
        System.out.println(coll.isEmpty());//true

    }

1.contains(Object obj):判断当前集合中是否包含obj,我们在判断时会调用obj对象所在类的equals()
2.containsAll(Contain coll1):判断形参coll1中的所有元素是否都存在于当前集合中

public class CollectionTest {

    @Test
    public void test01(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(false);
        coll.add(new Person("张三",18));

        //1.contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()
        boolean contains = coll.contains(123);
        System.out.println(contains); //true
        System.out.println(coll.contains(new String("Tom"))); //true
        System.out.println(coll.contains(new Person("张三",18)));
        //false,底层调用的equals()方法，没有重写equals()方法相当于"=="比较的是地址，需要重写equals()方法

        //2.containsAll(Contain coll1):判断形参coll1中的所有元素是否都存在于当前集合中
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(coll.containsAll(coll1)); //true
    }
}

class Person{
    String name;
    int age;

    public Person() {
    }

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

    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
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

3.remove(Object obj):从当前集合中移除obj元素，，先调用equals()方法。
4.removeAll(Collection coll1):(差集)从当前集合中移除coll1中所有的元素

public void test02(){
        //3.remove(Object obj):从当前集合中移除obj元素，，先调用equals()方法。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        System.out.println(coll.remove(123)); //true
        System.out.println(coll); //[456, Person{name='Jerry', age=20}, Tom, false]

        System.out.println(coll.remove(new Person("Jerry",20))); //true
        System.out.println(coll); //[456, Tom, false]
        //4.removeAll(Collection coll1):(差集)从当前集合中移除coll1中所有的元素
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll); //[Tom, false]

    }

5.retainAll(Collection coll1): 交集：获取当前集合和coll1集合的交集，并返回给当前集合
6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同

public void test03() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);
        System.out.println(coll);//[123, 456, Person{name='Jerry', age=20}, Tom, false]

/*
        //5.retainAll(Collection coll1): 交集：获取当前集合和coll1集合的交集，并返回给当前集合
        Collection coll1 = Arrays.asList(123,456,789);
        coll.retainAll(coll1);
        System.out.println(coll); //[123, 456]
*/
        //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同
        Collection coll1 = new ArrayList(); //有序，顺序也要一样
        coll1.add(123);
        coll1.add(456);
        coll1.add(new Person("Jerry", 20));
        coll1.add(new String("Tom"));
        coll1.add(false);

        System.out.println(coll.equals(coll1)); //true
    }

7.hashCode():返回当前对象的哈希值
8.集合---->数组：toArray() 扩展：数组---->集合:调用Arrays类的静态方法asList()
9.iterator():返回Iterator接口的实例，用于遍历集合元素

public void test04(){
       Collection coll = new ArrayList();
       coll.add(123);
       coll.add(456);
       coll.add(new Person("Jerry", 20));
       coll.add(new String("Tom"));
       coll.add(false);
       //7.hashCode():返回当前对象的哈希值
       System.out.println(coll.hashCode());
       //8.集合---->数组：toArray()
       Object[] arr = coll.toArray();
       for (int i = 0; i < arr.length; i++) {
           System.out.println(arr[i]);
       }
       //扩展：数组---->集合:调用Arrays类的静态方法aslist()
       List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
       System.out.println(list);  //[AA, BB, CC]

       List arr1 = Arrays.asList(1,2,3,4,5);
       System.out.println(arr1); //[1, 2, 3, 4, 5]

       List arr2 = Arrays.asList(new Integer[]{1,2,3,4,5});
       System.out.println(arr2); //[1, 2, 3, 4, 5]
       //9.iterator():返回Iterator接口的实例，用于遍历集合元素
   }

使用Iteration接口遍历集合元素

Java 将一个集合遍历通过多线程处理_后端_06

Java 将一个集合遍历通过多线程处理_开发语言_07

集合元素的遍历操作，使用迭代器Iterator接口
内部的方法：**hasNext() 和next() **
hasNext() :判断是否还有下一个元素
next() :①指针下移，②将下移以后的集合位置上的元素返回

public void test05(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();
        //方式一：不推荐
        for (int i = 0; i < coll.size(); i++) {
            System.out.println(iterator.next());
        }
        //方式二：推荐 
        while (iterator.hasNext()){ //判断是否还有下一个元素
            System.out.println(iterator.next());//指针下移，将下移以后的集合位置上的元素返回
        }
    }

Java 将一个集合遍历通过多线程处理_Java 将一个集合遍历通过多线程处理_08

注意：1. iterator不是容器就是迭代器，只是用于遍历的，当前集合是个容器
2. 调用next()的时候指针才会向下移动，hasNext只是用于判断下一个元素是否有值，不操作指针
3.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，

内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()，，调用的是迭代器中的remove()
测试Iterator中的remove（）

public void test06(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry", 20));
    coll.add(new String("Tom"));
    coll.add(false);

    //删除集合中"Tom"
    Iterator iterator = coll.iterator();
    while (iterator.hasNext()){
        Object obj = iterator.next();
        if (obj.equals("Tom")){
            iterator.remove();
        }
    }
    //遍历集合
    Iterator iterator1 = coll.iterator();
    while (iterator1.hasNext()){
        System.out.println(iterator1.next());
    }
}

使用foreach循环遍历集合元素

Java 将一个集合遍历通过多线程处理_Java 将一个集合遍历通过多线程处理_09

public void test01(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //for (集合元素的类型 局部变量: 集合对象)
        //内部仍然调用了迭代器Iterator
        for (Object obj: coll) {
            System.out.println(obj);
        }
        //for (数组的类型 局部变量: 数组对象)
        int arr[] = new int[]{1,2,3,4};
        for (int i: arr) {
            System.out.println(i);
        }
    }

写作小常识：一般需要缩进两个汉字，我们可以用这个

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。