【JAVA学习】集合初步

于 2024-12-31 16:25:11 发布
阅读量667 收藏 10
点赞数 16
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/PANSS__/article/details/144098171
版权

目录

集合体系架构

Collection集合

常用功能

三种遍历方式

1）迭代器遍历  只能遍历集合

2）增强for循环

3)Lambda表达式

几种遍历方法的区别

Map集合（键值对集合）

概述

常用方法

集合体系架构

Collection 单列集合  每个元素（数据）只包含一个值

Map 双列集合 每个元素包含两个值（键值对)

Collection集合

示例：

import java.util.*;

public class Test5 {

    public static void main(String[] args) {

        // ArrayList
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Apple"); // 可重复
        System.out.println("ArrayList: " + list);
        //输出结果：[Apple, Banana, Cherry, Apple]

        // HashSet
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Apple"); // 不重复
        System.out.println("HashSet: " + set);
        //输出结果：[Apple, Banana, Cherry]

        // LinkedHashSet
        Set<String> linkedSet = new LinkedHashSet<>();
        linkedSet.add("Apple");
        linkedSet.add("Banana");
        linkedSet.add("Cherry");
        linkedSet.add("Apple"); // 不重复但保持插入顺序
        System.out.println("LinkedHashSet: " + linkedSet);
        //输出结果：[Apple, Banana, Cherry]

        // TreeSet
        Set<String> treeSet = new TreeSet<>();
        treeSet.add("Apple");
        treeSet.add("Cherry");
        treeSet.add("Banana");
        treeSet.add("Apple"); // 不重复且自动排序
        System.out.println("TreeSet: " + treeSet);
        //输出结果：[Apple, Banana, Cherry]
    }
}

常用功能

三种遍历方式

1）迭代器遍历  只能遍历集合

Iterator<E> iterator():得到迭代器对象，默认指向当前集合的索引0

Iterator迭代器中的常用方法：

bool hasNext()：询问当前位置是否有元素存在，存在则返回true,不存在返回false

E next()：获取当前位置的元素，并同时将迭代器对象指向下一个元素处

示例：

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

public class Test5 {
    public static void main(String[] args) {

        // 创建一个List实例
        List<String> list = new ArrayList<>();

        // 向列表中添加元素
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");

        // 通过调用list的iterator()方法获取迭代器
        Iterator<String> iterator = list.iterator();

        // 使用迭代器遍历列表
        while (iterator.hasNext()) {  // 检查是否还有下一个元素
            String element = iterator.next();  // 获取当前元素并移动到下一个位置
            System.out.println(element);  // 打印出当前元素
        }
    }
}

2）增强for循环

for(元素的数据类型 变量名 ：数组或集合）{  }

示例：

public class ArrayEnhancedForLoopExample {
    public static void main(String[] args) {

        // 定义一个字符串数组
        String[] fruits = {"Apple", "Banana", "Cherry", "Date"};

        // 使用增强for循环遍历数组
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

3)Lambda表达式

使用Collection的forEach方法来完成   default void forEach(Consume<? super T> action)  

示例：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class LambdaExpressionExample {
    public static void main(String[] args) {

        // 创建一个列表
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");

        // 使用匿名内部类实现 Consumer 接口
        Consumer<String> consumerWithAnonymousClass = new Consumer<String>() {
            @Override
            public void accept(String fruit) {
                System.out.println("Consuming: " + fruit);
            }
        };

        // 使用 Lambda 表达式实现 Consumer 接口
        Consumer<String> consumerWithLambda = (fruit) -> System.out.println("Consuming: " + fruit);

        // 使用匿名内部类遍历列表
        for (String item : list) {
            consumerWithAnonymousClass.accept(item);
        }

        // 使用 Lambda 表达式遍历列表
        for (String item : list) {
            consumerWithLambda.accept(item);
        }

        // 直接在方法中使用 Lambda 表达式
        list.forEach((fruit) -> System.out.println("Consuming: " + fruit));
    }
}

补充Lambda表达式相关知识：

函数式编程：Lambda表达式可以用于替代某些匿名内部类对象，从而让程序更简洁，可读性更好

(被重写方法的形参列表)->{

        被重写方法的方法体代码

}

注意点：1-Lambda表达式只能替代函数式接口的匿名内部类

               2-函数式接口：有且仅有一个抽象方法的接口

               3-@FunctionalInterface 该注解用于约束当前接口必须是函数式接口

Lambda表达式的省略规则：

  • 参数类型可以全部省略不写
  • 如果只有一个参数，参数类型省略的同时 "() "也可以省略，但是多个参数不能省略（）
  • 如果Lambda表达式中只有一行代码，大括号可以不写，同时省略分号 ";";如果这行代码是return语句，也必须去掉return 

Lambda表达式应用示例：

import java.util.function.*;

public class LambdaExample {
    public static void main(String[] args) {
        
        // 定义一个函数式接口
        @FunctionalInterface
        interface Calculator {
            int calculate(int a, int b);
        }

        // 使用完整的Lambda表达式
        Calculator add = (int a, int b) -> {
            return a + b;
        };
        System.out.println("Add: " + add.calculate(5, 3));

        // 省略参数类型
        Calculator subtract = (a, b) -> {
            return a - b;
        };
        System.out.println("Subtract: " + subtract.calculate(5, 3));

        // 只有一行代码时省略大括号和分号
        Calculator multiply = (a, b) -> a * b;
        System.out.println("Multiply: " + multiply.calculate(5, 3));

    }
}

几种遍历方法的区别

并发修改异常问题：遍历集合的同时又存在增删集合元素的行为时可能出现的业务异常现象

解决方案：

1）如果集合支持索引，可以使用for循环遍历，每删除数据后做i--；或者可以倒着遍历

2）可以使用迭代器遍历，并用迭代器提供的删除方法删除数据

注：增强for循环和Lambda遍历均不能修改并发异常问题，也就是说它们只适合做数据的遍历，不适合同时做增删操作

示例:

1)for循环

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

public class IndexTraversal {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        // 正向遍历并删除元素
        for (int i = 0; i < list.size(); ) {
            if (list.get(i).equals("B")) {
                list.remove(i);
            } else {
                i++;
            }
        }

        /*
        for(int i = 0; i < list.size(); i++){ 
           if (list.get(i).equals("B")) {
               list.remove(i);
               i--;
            } 
        }
        */


        System.out.println("After forward traversal: " + list);

        // 倒序遍历并删除元素
        for (int i = list.size() - 1; i >= 0; i--) {
            if (list.get(i).equals("A")) {
                list.remove(i);
            }
        }

        System.out.println("After reverse traversal: " + list);
    }
}

2）迭代器

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

public class IteratorTraversal {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        // 使用迭代器遍历并删除元素
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("B")) {
                iterator.remove();
            }
        }

        System.out.println("After iterator traversal: " + list);
    }
}

Map集合（键值对集合）

概述

键不能重复；值可以重复

需要存储一一对应的数据时，可以考虑使用Map集合来做

示例：HashMap（由键决定特点）：无序，不重复，无索引

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

public class hashMapDemo {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,Integer> map = new HashMap<>();
        //添加元素
        map.put("张三",23);
        map.put("张三",24);//覆盖
        map.put("李四",24);
        map.put("王五",25);
        map.put("赵六",26);
        map.put(null,null);
        System.out.println(map);

        //代码输出结果示例：{null=null, 李四=24, 张三=24, 王五=25, 赵六=26}
    }
}

常用方法

示例：

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

public class MapExample {
    public static void main(String[] args) {
        // 创建一个HashMap实例
        Map<String, Integer> map = new HashMap<>();

        // 添加元素
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        // 获取集合的大小
        System.out.println("Size of the map: " + map.size());

        // 判断集合是否为空
        System.out.println("Is the map empty? " + map.isEmpty());

        // 根据键获取对应值
        System.out.println("Value for key 'Two': " + map.get("Two"));

        // 根据键删除整个元素
        map.remove("Three");
        System.out.println("Map after removing 'Three': " + map);

        // 判断是否包含某个键
        System.out.println("Does the map contain key 'One'? " + map.containsKey("One"));

        // 判断是否包含某个值
        System.out.println("Does the map contain value 2? " + map.containsValue(2));

        // 获取全部键的集合
        System.out.println("Keys in the map: " + map.keySet());

        // 获取Map集合的全部值
        System.out.println("Values in the map: " + map.values());

        // 清空集合
        map.clear();
        System.out.println("Is the map empty after clearing? " + map.isEmpty());
    }
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

A林玖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值