Java的学习日志（八）——集合

最新推荐文章于 2023-06-13 16:55:10 发布
最新推荐文章于 2023-06-13 16:55:10 发布
阅读量190 收藏
点赞数
分类专栏： JAVA 文章标签： java 列表 数据结构 类 redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FFFPAG/article/details/104519312
版权

集合

使用集合的步骤

  1. 创建集合对象

  2. 创建元素对象

  3. 将元素对象添加到集合对象中

  4. 遍历集合

List集合

List接口中的成员方法

  • public boolean add(E , e);
    将数据添加到集合的末尾，这里的E是泛型的意思
  • public E get (int index);
    根据索引，获取其对应的元素
  • public int size();
    获取集合的长度

List集合实例

测试类：

package Demo1;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        Student s1 = new Student(41,"乔峰");
        Student s2 = new Student(41,"乔峰");
        Student s3 = new Student(38,"虚竹");
        Student s4 = new Student(26,"段誉");
        //3.将元素对象添加到集合对象中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //获取索引为2的元素
        Object obj = list.get(2);
        System.out.println("索引为2的元素是：" + obj);
        //获取集合的元素个数
        System.out.println("集合的长度为：" + list.size());
        System.out.println("---------------------");
        //4.遍历集合
        for (int i = 0; i < list.size() ; i++) {
            Object obj2 = list.get(i);
            System.out.println("索引为" + i + "的元素是：" + obj2);
        }
    }
}


package Demo1;

public class Student {
    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

运行结果：

索引为2的元素是：Student{age=38, name='虚竹'}
集合的长度为：4
---------------------
索引为0的元素是：Student{age=41, name='乔峰'}
索引为1的元素是：Student{age=41, name='乔峰'}
索引为2的元素是：Student{age=38, name='虚竹'}
索引为3的元素是：Student{age=26, name='段誉'}

Set

特点：
不可重复，无序
Set集合保证元素的唯一性依赖：equals（）和hashCode（）两个方法
如果未在类中重置这两个方法，默认调用的是Object类中的这两个方法
而Object类中equals（）方法默认比较的是地址值是否相同
格式：Set<T> set = new HahSet<>();

测试类：

package Set;


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

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        Set<Student> set = new HashSet<>();
        //2.创建元素对象
        Student s1 = new Student("小一",11);
        Student s2 = new Student("小尔",12);
        Student s3 = new Student("小散",13);
        Student s4 = new Student("小思",14);
        Student s5 = new Student("小悟",15);

        //3.将集合对象添加到元素对象中
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        //4.遍历集合
        System.out.println(set);
        System.out.println("-----------------------");

        System.out.println("通过迭代器实现");
        //通过迭代器遍历Set集合
        //A.通过集合对象获取其对应
        Iterator<Student> it = set.iterator();
        //B.判断迭代器中是否元素
        while(it.hasNext()){
            //C.如果有，就获取元素
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------");

        
        //通过增强for遍历Set集合
        System.out.println("通过增强for遍历Set集合:");
        for (Student student : set) {
            System.out.println(student);
        }
    }
}

学生类：

package Set;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student(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;
    }

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

运行结果：


[Student{name='小思', age=14}, Student{name='小悟', age=15}, Student{name='小一', age=11}, Student{name='小尔', age=12}, Student{name='小散', age=13}]
-----------------------
通过迭代器实现
Student{name='小思', age=14}
Student{name='小悟', age=15}
Student{name='小一', age=11}
Student{name='小尔', age=12}
Student{name='小散', age=13}
-----------------------
通过增强for遍历Set集合:
Student{name='小思', age=14}
Student{name='小悟', age=15}
Student{name='小一', age=11}
Student{name='小尔', age=12}
Student{name='小散', age=13}

Map

特点：
双列集合，元素由键值对（Entry）构成：key - - value
key不可重复，value可以重复

应用：Map<T1,T2> map = new HahMap<>();

成员方法：

  • V put(K key,V value); 添加元素（键值对的形式，元素第一次添加，返回null，重复添加，会用新值覆盖旧值，并返回旧值
  • V get(Object key); 根据键获取其对应的值
  • Set<K> keySet(); 获取所有键的集合

遍历步骤：

  1. 获取所有键的集合 keySet（）
  2. 遍历所有的键，获取到每一个键 迭代器，增强for
  3. 根据键，获取指定的值 get（）

测试类：

package Map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        //键：学生的编号，值：具体的学生对象
        Map<Integer,Student> map = new HashMap<>();
        //2.创建元素对象
        Student s1 = new Student("小一",11);
        Student s2 = new Student("小尔",12);
        Student s3 = new Student("小散",13);
        //3.将元素对象添加到集合中
/*        Student stu1 = map.put(1,s1);
        System.out.println("stu1:" + stu1);
        Student stu2 = map.put(1,s2);
        System.out.println("stu2:" + stu2);*/
        map.put(1,s1);
        map.put(2,s2);
        map.put(3,s3);

        //根据键，获取值
        Student stu3 = map.get(2);
        System.out.println("key:" + 2 + ", value:" + stu3);

        //打印集合
        System.out.println(map);
        System.out.println("-----------------------");

        //4.遍历集合
/*        //迭代器实现
        //获取所有键的集合
        Set<Integer> keys = map.keySet();
        //遍历所有的键，获取带每一个键
        //获取迭代器对象
        Iterator<Integer> it = keys.iterator();
        while(it.hasNext()){
            //如果迭代器中有数据，就获取
            Integer key = it.next();
            //根据键,获取值
            Student value = map.get(key);
            System.out.println("key:" + key + "……value:" + value);
        }*/

        //通过增强for实现
        Set<Integer> keys = map.keySet();
        for (Integer key : keys) {
            //key就是双列集合中的每一个键
            Student value = map.get(key);
            System.out.println("key:" + key + "……value:" + value);
            
        }
        
    }
}

学生类：

package Map;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

运行结果：

key:2, value:Student{name='小尔', age=12}
{1=Student{name='小一', age=11}, 2=Student{name='小尔', age=12}, 3=Student{name='小散', age=13}}
-----------------------
key:1……value:Student{name='小一', age=11}
key:2……value:Student{name='小尔', age=12}
key:3……value:Student{name='小散', age=13}

增强For循环

格式：

for（元素的数据类型 变量名 : 要遍历的数组或者集合对象）{
	//循环体，变量也就是元素
}

快捷方式：iter-->回车

增强for的底层依赖的是迭代器（iterator）

测试类：

package 增强for循环;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add(10);
        list.add(10);
        list.add(20);
        list.add(30);
        //4.遍历集合
        for (Object obj : list) {
            //obj是集合中的元素，其本身应该是Integer类型的数据
            Integer ii = (Integer)obj;
            System.out.println(ii);
        }
    }
}

Collections工具类

针对集合进行操作的工具类

  • sort（List <T>） 根据元素的自然顺序，将指定列表按升序排序
  • max（Collection<T>） 返回集合的最大元素
  • reverse（List <T>） 反转List集合元素
  • shuffle（List<T>） 使用默认的随机源置换指定的列表

实例：

package Collections工具类;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        list.add(1);
        list.add(3);
        list.add(5);
        list.add(2);
        list.add(4);
        list.add(6);

        System.out.println("没有操作集合前：" + list);
        System.out.println("--------------------------");

        //获取集合中的最大元素
        Integer max =  Collections.max(list);
        System.out.println("集合中的最大元素为：" + max);
        System.out.println("--------------------------");

    /*    //对集合进行升序排序
        Collections.sort(list);
        System.out.println("升序排序后的集合为：" + list);
        System.out.println("--------------------------");

        //对集合中的数据进行反转
        Collections.reverse(list);
        System.out.println("反转后的集合为：" + list);
        System.out.println("--------------------------");*/

        //对集合中的数据进行降序排序
        Collections.sort(list);
        Collections.reverse(list);
        System.out.println("对集合进行降序排序后：" + list);
        System.out.println("--------------------------");

        //随机置换，相当于洗牌
        Collections.shuffle(list);
        System.out.println("随机置换后的集合：" + list);
    }
}

运行结果：

没有操作集合前：[1, 3, 5, 2, 4, 6]
--------------------------
集合中的最大元素为：6
--------------------------
对集合进行降序排序后：[6, 5, 4, 3, 2, 1]
--------------------------
随机置换后的集合：[5, 6, 3, 4, 2, 1]

迭代器

对过程的重复，称为迭代。
迭代器是遍历collection集合的通用方式，可以在对集合遍历的同时进行添加，删除等操作。
列表迭代器是List体系独有的遍历方法，可以在集合遍历的同时进行添加，删除等操作，但是必须通过调用列表迭代器的方法来实现

常用方法：

  • next（）：返回迭代的下一个元素对象
  • hasNext（）：如果仍有元素可以迭代，则返回true

实例：

  1. 普通迭代器
package 迭代器;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
   public static void main(String[] args) {
       //需求：通过迭代器遍历List集合
       //1.创建集合对象
       List list = new ArrayList();
       //2.创建元素对象
       //3.将元素对象添加到集合对象中
       list.add("a");
       list.add("b");
       list.add("c");
       //4.遍历集合
       //迭代器的用法
/*        //1、根据集合对象获取其对象的迭代器对象
       Iterator it = list.iterator();
       //2、判断迭代器中是否有元素
       while (it.hasNext()){//如果迭代器中有元素，就一直迭代
           //3、如果有就获取元素
           String s = (String)it.next();
           System.out.println(s);
       }*/
       System.out.println("-----------------------");
       //需求：判断集合中如果有字符串“b”，就在其后面添加一个字符串“java”
       //1、根据集合对象获取其对象的迭代器对象
       Iterator it = list.iterator();
       //2、判断迭代器中是否有元素
       while (it.hasNext()){//如果迭代器中有元素，就一直迭代
           //3、如果有就获取元素
           String s = (String)it.next();
           if ("b".equals(s)) { //这样写可以避免空指针异常
               //能走到这里，说明集合中有元素b
               list.add("java");//ConcurrentModificationException错误
           }
           System.out.println(s);
       }
   }
  1. 列表迭代器
package 迭代器;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test1 {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        //需求：判断集合中如果有字符串“b”，就在其后面添加一个字符串“java”
        //1、根据集合对象获取其对象的迭代器对象
        ListIterator lit = list.listIterator();;
        //2、判断迭代器中是否有元素
        while (lit.hasNext()) {
            //3、如果有就获取元素
            String s = (String)lit.next();
            if ("b".equals(s)) { //这样写可以避免空指针异常
                //能走到这里，说明集合中有元素b
                lit.add("java");
            }
            System.out.println(s);
        }
        System.out.println("-----------------");
        //打印新的集合中的值
        System.out.println(list);
    }
}

运行结果：

a
b
c
-----------------
[a, b, java, c]

总结：
普通的迭代器在遍历的过程中不能添加或删除元素，否则会报：并发修改异常；
列表迭代器在遍历的过程中可以修改集合中的元素（添加或删除等），但必须使用列表迭代器的方法

泛式

格式：List<数据类型> list = new ArrayList<数据类型>();
实例：

package 泛型;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        //1.创建集合对象
        List list1 = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list1.add("a");
        list1.add("b");
        list1.add("c");
        //4.遍历集合
        for (Object obj : list1) {
            String s = (String)obj;
            System.out.println(s);
        }
        System.out.println("----------------");
        
        //演示泛式
        //1.创建集合对象
        List<String> list2 = new ArrayList<String>(); //在JDK5以后后面的String可省略
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list2.add("abc");
        list2.add("bcd");
        list2.add("cde");
        //4.遍历集合
        for (Object obj : list2) {
            System.out.println(obj);
        }
    }
}
FFFPAG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java集合（一）：集合的概念
qq_46291038的博客
07-16 1379
一、集合 1.概念：存储对象的容器。 * 数组和集合区别: * 长度: * 数组一旦创建长度不可改变 * 集合长度可变 * 存储元素: * 数组可以存储基本数据类型和引用数据类型 * 集合只能存储引用类型 集合就是由若干个确定的元素所构成的整体； 集合就是存储对象的容器，可以存储任意数量、任意类型的对象 在数学中我们经常遇到集合的概念： ·有限集合：一个班所有的同学构成的集合 一个网站所有的商品构成的集合 ·无限集合：全体自然数集合...
黑马程序员-JAVA基础学习日志——通篇大总结及学习方法思想
无码骑兵的博客
09-07 5580
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   Java基础知识总结          回首是为了更好向前，天空没有翅膀的痕迹，而我已飞过，人总是这样，害怕回首，又时常回首，看看走过的路是直是弯，踩下的脚印是深是浅，回首昨天的风雨，眺望远方的灿烂。几多感慨，几多愁，放下包袱，轻装前行... 写代码： 1，明确需求。我要做什么？
java集合类
ygy7mxy6的博客
02-20 543
JAVA集合概念 　　Java集合是使程序能够存储和操纵元素不固定的一组数据。 所有Java集合类都位于java.uti包中。 与Java数组不同，Java集合中不能存放基本数据类型，只能存放对象的引用。但是在JDK5.0以后的版本当中，JAVA增加了 “自动装箱”和“自动拆箱”的机制，比如如果要存入一个INT类型的数据，JVM会把数据包装成Integer然后再存
JAVA中的集合的概念
金字塔顶的蜗牛博客
04-06 1031
为什么要使用集合类 当你事先不知道要存放数据的个数，或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。 理解集合类 集合类存放于java.util包中。 集合类存放的都是对象的引用，而非对象本身，出于表达上的便利， 我们称集合中的对象就是指集合中对象的引用（reference)。 集合类型主要有3种：set(集）、list(列表）和map(映射)。 (1)集
java集合概念_如何理解java中的集合概念
weixin_39524147的博客
02-17 233
什么是集合？Java集合类存放在java.util包中，是一个用来存放对象的容器。注意：1.集合只能存放对象。比如你存入一个int型数据66放入集合中，其实它是自动转换成Integer类后存入的，Java中每一种基本数据类型都有对应的引用类型。2.集合存放的都是对象的引用，而非对象本身。所以我们称集合中的对象就是集合中对象的引用。对象本身还是放在堆内存中。3.集合可以存放不同类型，不限数量的数据类...
JAVA集合的基本概念
weixin_41609030的博客
04-13 403
JAVA集合的概念总结-单列集合集合我们首先分为单列集合和键值对集合（双列集合）单列集合ArrayList集合 初始容量为10 底层是可变数组，特点是查询快，增删慢。查询快的原因就是应为底层是数组，具有 索引！LinkedList集合是线程不安全的，但是效率高，底层是链表，特点是增删快，查询慢，原因是应为没有索引，所以查询慢！set集合只是个人总结，如有不全，或者错误，希望大家指出！谢谢 集合我们...
JAVA-SE入门学习——第七讲常用API及异常
06-08
【JAVA-SE入门学习——第七讲常用API及异常】 在Java编程中，API（Application Programming Interface）是开发者用来实现特定功能的一系列预先定义好的类、方法和接口的集合。Java中的API主要指的是JDK（Java ...
我的java学习日志day01
01-03
【Java学习日志Day01】——初识Java与编程环境搭建 在开始我们的Java学习之旅之前，首先要明确Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）于1995年发布。Java的设计理念是...
2021Java大厂面试题——大厂真题之字节跳动-Java初级.pdf
01-29
1. **协议簇**：TCP/IP实际上是一组协议的集合，包括但不限于TCP、IP、UDP等。 2. **跨平台兼容性**：TCP/IP协议不依赖于任何特定的硬件或操作系统，适用于各种网络环境。 3. **统一的地址分配**：TCP/IP通过IP地址...
JAVA实训项目——雷霆战机源代码
12-23
【JAVA实训项目——雷霆战机源代码】是一个针对Java编程学习者设计的实际操作项目，旨在帮助学生深入了解游戏开发的原理和技巧。在这个项目中，你将接触到如何使用Java语言构建一个简单但具有完整功能的飞行射击游戏...
java中的集合
qq_42208662的博客
08-17 580
java集合
Java中的集合
最新发布
weixin_52071901的博客
06-13 8204
java-api，day01
java 集合的概念以及集合框架介绍
侯春强的博客
08-14 648
1 集合的概念 集合框架是为表示和操作"多个对象"而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。 接口：即表示集合的抽象数据类型。接口提供了让我们对集合中所表示的内容进行单独操作的可能。 实现：也就是集合框架中接口的具体实现。实际它们就是那些可复用的数据结构。 算法：在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算
JAVA集合概念
Sean的博客
08-09 295
List、Set、Map是这个集合体系中最主要的三个接口。 其中List和Set继承自Collection接口。 Set不允许元素重复。HashSet和TreeSet是两个主要的实现类。 List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。 Map也属于集合系统，但和Collection接口不同。
Java集合的概念
daiyuntao841226的专栏
04-06 874
// java集合，在数组中只能存放相同类型的数据，数组一旦创建，其长度不能被改变，为了使程序能方便的存储和操纵 // 数目不固定的一组数据，jdk类库提供了java集合，集合类位于java.util包中， // 集合中不能存放基本类型数据，而只能存放对象的引用， // Set：不按特定方式排序，并且没有重复对象，他的有些实现类能对集合中的对象按特定方式排序 // List：集合中的对象按
异常处理与日志规约——阿里巴巴Java开发手册
在Java开发中，异常日志处理是非常关键的一部分，因为它关乎到程序的稳定性和可维护性。以下是一些关于异常处理的重要知识点： 1. **异常分类与处理**：强制规定，对于Java类库中的RuntimeException，如`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FFFPAG

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值