Java集合，集合的方法，集合的遍历

最新推荐文章于 2023-11-27 10:39:28 发布
最新推荐文章于 2023-11-27 10:39:28 发布
阅读量160 收藏
点赞数
文章标签： java 单元测试 tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55299825/article/details/120002015
版权

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.atgui.java;

import org.junit.Test;

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

/**
 * 一、集合框架的概述
 * 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
 * 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt,.jpg,.avi,数据库中的)
 * <p>
 * 2.1数组在存储多个数据方面的特点：
 * >一旦初始化以后，其长度就确定了。
 * >数据一旦定义好，其元素的类型也就确定了，我们也就只能操作指定类型的数据了。
 * 比如：String[] arr;int[] arr;Object[] arr2;
 * <p>
 * 2.2数组在存储多个数据方面的缺点：
 * >一旦初始化以后，其长度就不可修改
 * >数组中提供的方法非常有限，对于添加、删除、插入数据等操作非常不便，同时效率不高
 * >获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
 * >数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
 * <p>
 * 二、集合框架
 * /---Collection接口：单列集合，用来存储一个一个的对象
 * /---List接口：存储有序的、可重复的数据。--->”动态数组“
 * /---ArrayList、LinkedList、Vector
 * /---Set接口：存储无序的、不可重复的数据 --->高中讲的”集合“（无序性，确定性，互异性）
 * /---HashSet、LinkedHashSet、TreeSet
 * <p>
 * /----Map接口：双列集合，用来存储一对(key - value)一对的数据 --->高中函数：y=f(x)
 * 一个key不可能对应多个value，一个value可以对应多个key
 * /-----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
 * <p>
 * 三、Collection接口中的方法的使用
 *
 * @author shkstart
 * @create 2021-08-30 17:41
 */
public class CollectionTest {
    @Test
    public void test1() {
        Collection coll = new ArrayList();//编译看左边，执行看右边。：多态
        //add(Object e):将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());
        //size();
        System.out.println(coll.size());
        //addAll():将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll.size());//6
        System.out.println(coll);
        //isEmpty():判断当前集合是否为空
        boolean empty = coll.isEmpty();
        System.out.println(empty);
        //clear():清空当前集合
        coll.clear();
        System.out.println(coll);

    }

}


package com.atgui.java;

import org.junit.Test;

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

/**
 * Collection接口中声明的方法的测试
 * <p>
 * 结论：
 * 向Collection接口的实现类的对象中添加obj时，要求obj所在类要重写equals()
 *
 * @author shkstart
 * @create 2021-08-30 22:29
 */
public class CollectionTest1 {


    @Test
    public void test1() {
        //contains()
        Collection coll = new ArrayList();//多态
        coll.add(123);//自动装箱
        coll.add(456);
        coll.add(new String("Tom"));
//        Person p = new Person("Jerry", 20);
//        coll.add(p);
        coll.add(new Person("Jerry", 20));


        //1.contains(Object obj):判断当前集合中是否包含obj

        //我们在判断时会调用obj对象所在类的equals()
        boolean contains = coll.contains(123);
        System.out.println(contains);

        System.out.println(coll.contains(new String("Tom")));//String重写了equals  true
//        System.out.println(coll.contains(p));
        System.out.println(coll.contains(new Person("Jerry", 20)));//false  Object的equals并未重写

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

    }

    @Test
    public void test2() {
        //3.remove(Object obj):从当前集合中移除obj元素
        Collection coll = new ArrayList();//多态
        coll.add(123);//自动装箱
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 20));
        coll.add(false);

        boolean remove = coll.remove(123);
        System.out.println(coll);
        System.out.println(remove);
        coll.remove(new Person("Jerry", 20));
        System.out.println(coll);

        //4.removeAll(Collection coll1):差集：从当前集合中移除coll1中的元素
        Collection coll1 = Arrays.asList(123, 4567);
        coll1.removeAll(coll);
        System.out.println(coll);
    }

    @Test
    public void test3() {
        Collection coll = new ArrayList();//多态
        coll.add(123);//自动装箱
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 20));
        coll.add(false);

//      5.retainAll(Collection coll1):交集：获取当前集合和coll集合的交集，并且赋值给当前集合
//        Collection coll1 = Arrays.asList(123,456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);
        //6.equals(Object obj);要想返回true,需要当前集合和形参集合的元素都相同
        Collection coll1 = new ArrayList();//多态
        coll1.add(123);//自动装箱
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(new Person("Jerry", 20));
        coll1.add(false);
        System.out.println(coll1.equals(coll));
    }

    @Test
    public void test4() {
        Collection coll = new ArrayList();//多态
        coll.add(123);//自动装箱
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry", 20));
        coll.add(false);
        //7.hashCode()返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //8.集合---->数组：toArray();
        Object[] objects = coll.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        //拓展：数组---->集合:调用Arrays类的静态方法asList()
        List<String> strings = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(strings);

        List<int[]> arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1.size());//1,识别为一个元素

        List arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());//2

        //iterator():返回Iterator接口的实例，用于遍历集合元素，放在IteratorTest.java中测试

    }

}

Iterator

package com.atgui.java;

import org.junit.Test;

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

/**
 * 集合元素的遍历操作，使用迭代器Iterator接口
 * 1.内部的方法：hasNext()和next()的方法
 * <p>
 * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
 * 3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove();
 *
 * @author shkstart
 * @create 2021-08-31 8:46
 */
public class IteratorTest {
    @Test
    public void test1() {
        Collection coll1 = new ArrayList();//多态
        coll1.add(123);//自动装箱
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(new Person("Jerry", 20));
        coll1.add(false);

        Iterator iterator = coll1.iterator();

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

    }

    @Test
    public void test2() {
        Collection coll1 = new ArrayList();//多态
        coll1.add(123);//自动装箱
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(new Person("Jerry", 20));
        coll1.add(false);

        //错误方式一
//        Iterator iterator = coll1.iterator();
//        while ((iterator.next()) != null){
//            System.out.println(iterator.next());
//        }
        //错误方式二
        //集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前
//        while (coll1.iterator().hasNext()){
//            System.out.println(coll1.iterator().next());
//        }
    }

    @Test
    public void test3() {
        Collection coll1 = new ArrayList();//多态
        coll1.add(123);//自动装箱
        coll1.add(456);
        coll1.add(new String("Tom"));
        coll1.add(new Person("Jerry", 20));
        coll1.add(false);

        //删除集合中”Tom“
        Iterator iterator = coll1.iterator();
        while (iterator.hasNext()) {
            //next()：指针下移，将下移以后集合位置上的元素返回
            Object obj = iterator.next();
            if ("Tom".equals(obj)) {
                iterator.remove();
            }
        }
        Iterator iterator1 = coll1.iterator();//这里需要重新调用iterator方法，因为指针在上面已经指到最后了
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }

    }

}

HashSet：底层是数组+链表

在这里插入图片描述

package com.atgui.jav1;

import com.atgui.java.Person;
import org.junit.Test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
 * /---Collection接口：单列集合，用来存储一个一个的对象
 *      /---Set接口：存储无序的、不可重复的数据 --->高中讲的”集合“（无序性，确定性，互异性）
 *          /---HashSet:作为Set接口的主要实现类：线程不安全的：可以存储null值
 *              /---LinkedHashSet:作为HashSet的子类：遍历其内部数据时，可以按照添加的顺序遍历
 *           /---TreeSet:可以按照添加对象指定属性，进行排序。
 *
 * 1.Set接口中没有额外的定义新的方法，使用的都是Collection中声明过的方法
 * 2.向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
 *     要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码(Hash值)
 *      重写两个方法的小技巧：对象中用作equals()方法比较的Field，都应该用来计算hashCode
 * @author shkstart
 * @create 2021-08-31 15:26
 */
public class SetTest {
    /*
    * 一、Set：存储无序的、不可重复的数据
    * 以HashSet为例说明：
    * 1.无序性:不等于随机性。存储的数据在数组中并非按照数组索引的顺序添加，而是根据哈希值决定的
    *
    * 2.不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个
    *
    * 二、添加元素的过程：以HashSet为例：
    *       我们向HashSet中添加元素a，首先调用元HashCode()方素a所在类的ha法，计算元素a的哈希值，
    *       此哈希值接着通过某种算法计算出HashSet底层数组中的存放位置(即为：索引位置)，判断数组此位置
    *       上是否已经有元素：
    *       如果此位置上没有其他元素，则元素a添加成功------>情况1
    *       如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a与元素b的hash值：
    *           如果hash值不相同，则元素a添加成功-------->情况2
    *           如果hash值相同，进而需要调用元素a所在类的equals()方法：
    *               equals()返回true,元素a添加失败
    *               equals()返回false，则元素a添加成功-------->情况3
    *
    *  对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储
    *  jdk 7: 元素a放到数组中，指向原来元素
    *  jdk 8： 原来的元素，指向元素a
    *  总结：七上八下
    *
    * */
    @Test
    public void test(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("BB");
        set.add(new Person("Tom",12));
        set.add(new Person("Tom",12));
        set.add(129);
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述## TreeSet

package com.atgui.jav1;

import com.atgui.java.Person;
import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * @author shkstart
 * @create 2021-08-31 18:54
 */
public class TreeSetTest {
    /*
    * 1.向ThreeSet中添加的数据，要求是相同类的对象
    * 2.两种排序方式：自然排序(Comparable)和定制排序(Comparator)
    * 3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不在是equals().
    * 4.定制排序中，比较两个对象是否相同的标准为：compare()返回0，不在是equals()
    * */


    @Test
    public void test1(){
        TreeSet set = new TreeSet();
        //失败，不能添加不同类的对象
//        set.add("123");
//        set.add("456");
//        set.add("AA");
//        set.add(new Person());
        //举例一
//        set.add("34");
//        set.add("-34");
//        set.add("123");
//        set.add("8");
        set.add(new Person("TOM",12));
        set.add(new Person("JERRY",12));
        set.add(new Person("JIM",12));
        set.add(new Person("MIKE",12));
        set.add(new Person("TOM1",12));


        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test2(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Person && o2 instanceof Person){
                    Person p1 = (Person) o1;
                    Person p2 = (Person) o2;
                    return Integer.compare(p1.getAge(), p2.getAge());
                }else {
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);
        set.add(new Person("TOM",12));
        set.add(new Person("JERRY",33));
        set.add(new Person("JIM",65));
        set.add(new Person("MIKE",56));
        set.add(new Person("TOM1",32));


        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

在这里插入图片描述

Map结构

五个实现类，一个接口

在这里插入图片描述
在这里插入图片描述

坚持#
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Java入门】集合框架
qq_53662373的博客
08-09 1680
集合：List、Set、Map
Java中的集合框架
xiaosao_的博客
09-19 990
Java中的集合框架
Java基础（十五）集合框架
zhufei463738313的博客
05-04 1669
一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用数组存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。数组在内存存储方面的特点数组初始化以后，长度就确定了。数组中的添加的元素是依次紧密排列的，有序的，可以重复的。数组声明的类型，就决定了进行元素初始化时的类型。不是此类型的变量，就不能添加。可以存储基本数据类型值，也可以存储引用数据类型的变量数组在存储数据方面的弊端。
Java集合框架详解（新手必看）
最新发布
qq_74095822的博客
11-27 1496
Java集合框架是一组接口、实现类和算法，用于存和操作一组对象。它提供了一种方便的方式来处理集合数据，如列表、集合、队列，映射等，以及它们的实现。它是Java编程语言的核心部分之一，提供了高效的数据结构和算法，使开发人员可以更轻松地处理集合数据.Java集合框架包括以下几个主要组件: List、Set、Queue、Deque、Map和lterator。集合框架两大分支：Collection接口和Map接口集合框架结构图。
超全Java集合框架讲解（建议收藏）
白话机器学习
08-27 955
是一个实现 Set 的一个抽象类，定义在这里可以将所有具体 Set 集合的相同行为在这里实现，避免子类包含大量的重复代码所有的 Set 也应该要有相同的hashCode()和equals()方法，所以使用抽象类把该方法重写后，子类无需关心这两个方法。// 判断两个 set 是否相等if (o == this) { // 集合本身(o instanceof Set)) { // 集合不是 set} else {// 比较两个集合的元素是否全部相同// 计算所有元素的 hashcode 总和。
Java遍历集合的三种方式
08-31
迭代器是Java集合框架提供的标准遍历方式，适用于所有的集合类型。迭代器可以安全地删除元素，而不会影响遍历过程。示例如下： ```java ListIterator<String> it = list.listIterator(); while(it.hasNext()){ ...
Java Collection集合遍历运行代码实例
08-19
Java Collection 集合遍历运行代码实例 Java Collection 集合遍历是 Java 语言中最常用的数据结构之一。Collection 是 Java 集合框架...在学习 Java 语言时，了解 Collection 集合遍历的机制和使用方法是非常重要的。
Java集合遍历实现方法及泛型通配
08-18
主要介绍了Java集合遍历实现方法及泛型通配,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java集合Set、List、Map的遍历方法
09-04
Java集合框架提供了多种接口和类，如Set、List和Map，它们各自有不同的特性和用途。本文将详细介绍如何遍历这些集合类型的实例。 首先，我们来看Set集合。Set接口代表不包含重复元素的集合，它的遍历方法主要有两种...
Java遍历集合方法分析（实现原理、算法性能、适用场合）
09-02
在Java编程中，遍历集合是一项常见的操作，用于访问并处理集合中的所有元素。Java提供了多种遍历方式，包括传统的for循环、迭代器Iterator以及增强型...在实际开发中，应根据具体需求和集合类型灵活运用这些遍历方法。
Java基础--------集合框架
热门推荐
詹煜彪9527
02-28 1万+
一. 概念 集合：通常情况下，把具有某种相同性质的一类东西，汇聚成的集体，称为集合。比如，用Java编程的所有程序员，全体中国人等。在数学中的定义是，由一个或多个确定的元素所构成的整体叫做集合。 Java中的集合：是一种...
JAVA集合框架（看完这一篇就够了）
qq_53821298的博客
03-10 994
集合：集合是一组用来存放数据对象的容器。特点：存放的数据是对象。对比数组：1、数组初始化后，其长度不可以再被改变，也就是说数组存放数据的个数是事先确定的。2、数组中对于插入元素和删除元素的操作是很繁琐的，因为涉及到了数组元素的移位操作。3、数组存放数据的方式是有序的，可重复的，而对于那些需要去掉重复数据的需求就无法满足了。但是对于数组以上的三点缺陷，在集合中就得到了很好的解决。单例集合：每次以单个对象的形式将数据存放到集合中。
java——集合框架
Why_does_it_work的博客
06-24 3503
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象下面是 Java 集合框架中所有的集合接口及其对应的特点，以表格形式展示：以上是 Java 集合框架中所有的集合接口及其对应的特点。在实际开发中，可以根据需求选择适合的集合类型来存储和处理数据。是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、
Java集合框架
qq_33485630的博客
03-18 277
集合框架了解
Java中集合篇之遍历集合的三种方式
yhb500234的博客
08-28 1762
本文列举了三种遍历集合的方法，主要是iterator迭代器、增强for循环和Lambda表达式，可以帮助我们快速的遍历集合
List、Set、Map的特点与区别
Hambur_的博客
11-29 517
List： 1.可以允许重复的对象。 2.可以插入多个null元素。 3.是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。 4.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。 ============================================= Set： 1.不允许重复对象 2. 无序容器，你无
java集合分类及常见的遍历方式
world_kun的博客
04-24 387
集合： 存储对象数据 的集合容器。 1，单列集合Collection 单例集合 的根接口 1.1 List 如果是实现了List接口的集合类，具备的特点： 有序，可重复。 ArrayList ArrayList底层是使用了Object数组实现 的。 特点： 查询速度快，增删慢。 LinkedList LinkedList底层是使用了链表数据结构实现的。特点： 查询速...
java基础--集合----单列集合和双列集合遍历
Alex十年的博客
12-22 1714
单列集合遍历（主要是ArrayList和HashSet）： 双列集合遍历（主要是HashMap）： Map是java中的接口，Map.Entry是Map的一个内部接口。 Map提供了一些常用方法，如keySet()、entrySet()等方法， keySet()方法返回值是Map中key值的集合； entrySet()的返回值也是返回一个Set集合，此集合的类型为M...
Java集合框架的概述
自强博客
06-17 442
概述： 主要介绍java的集合类（不含线程安全的部分）。它是一个使用很频繁的工具，同时还涉及相应的数据结构和算法知识。因此彻底掌握还是很有必要的。作为介绍集合框架的开篇，我想是从整个框架结构上去做一下简单的介绍。因此，这一部分可以先做个了结。学完之后，回过头来可以再根据自己的理解结合这一部分自己去总结。 一、关于java集合涉及到的基本数据结构和算法的理论（这里只是稍微提
Java集合的遍历方法有什么
06-02
Java集合的遍历方法主要有以下几种： 1. 使用for循环遍历：对于List、Set等集合类型，可以使用for循环遍历。代码示例如下： ``` List<String> list = new ArrayList(); list.add("Java"); list.add("Python"); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值