JavaSE学习笔记26-集合（Collection）

集合

Java 中的集合（Collection）是 Java 标准库中非常重要的一部分，用于存储和操作一组对象。Java 集合框架（Java Collections Framework）提供了一套丰富的接口和类，用于处理各种数据结构，如列表、集合、队列、映射等。以下是 Java 集合框架的详细介绍：

1. 集合框架的核心接口

Java 集合框架的核心接口位于 java.util 包中，主要包括以下几种：

(1) Collection 接口

• 是所有集合类的根接口。

• 定义了集合的基本操作，如添加、删除、遍历等。

• 主要子接口：

  • List：有序集合，允许重复元素。

  • Set：无序集合，不允许重复元素。

  • Queue：队列，遵循先进先出（FIFO）或优先级规则。

(2) Map 接口

• 存储键值对（key-value pairs）。

• 键不允许重复，值可以重复。

• 主要实现类：

  • HashMap：基于哈希表实现，无序。

  • TreeMap：基于红黑树实现，键有序。

  • LinkedHashMap：基于哈希表和链表实现，保持插入顺序。

2. 常用集合类

以下是 Java 集合框架中常用的实现类：

(1) List 接口的实现类

• ArrayList：

  • 基于动态数组实现。

  • 支持快速随机访问，但插入和删除元素较慢。

  • 线程不安全。

• LinkedList：

  • 基于双向链表实现。

  • 插入和删除元素较快，但随机访问较慢。

  • 可以用作队列或栈。

• Vector：

  • 类似于 ArrayList，但线程安全。

  • 性能较低，通常不推荐使用。

(2) Set 接口的实现类

• HashSet：

  • 基于哈希表实现。

  • 无序，不允许重复元素。

  • 性能较高。

• TreeSet：

  • 基于红黑树实现。

  • 元素有序（自然顺序或自定义顺序）。

  • 性能略低于 HashSet。

• LinkedHashSet：

  • 基于哈希表和链表实现。

  • 保持插入顺序。

(3) Queue 接口的实现类

• LinkedList：

  • 可以用作队列或双端队列。

• PriorityQueue：

  • 基于堆实现。

  • 元素按优先级排序。

(4) Map 接口的实现类

• HashMap：

  • 基于哈希表实现。

  • 键无序，性能较高。

• TreeMap：

  • 基于红黑树实现。

  • 键有序。

• LinkedHashMap：

  • 基于哈希表和链表实现。

  • 保持插入顺序或访问顺序。

3. 集合的常用操作

以下是集合的常见操作示例：

(1) List 示例

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

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 遍历列表
        for (String fruit : list) {
            System.out.println(fruit);
        }

        // 获取元素
        System.out.println("第一个元素: " + list.get(0));

        // 删除元素
        list.remove("Banana");
        System.out.println("删除后的列表: " + list);
    }
}

(2) Set 示例 

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

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");

        // 尝试添加重复元素
        set.add("Apple");

        // 遍历集合
        for (String fruit : set) {
            System.out.println(fruit);
        }
    }
}

 (3) Map 示例

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

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 10);
        map.put("Banana", 20);
        map.put("Cherry", 30);

        // 遍历映射
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // 获取值
        System.out.println("Apple 的数量: " + map.get("Apple"));
    }
}

4. 集合的线程安全性

• 大多数集合类（如 ArrayList、HashMap）是线程不安全的。

• 如果需要线程安全的集合，可以使用以下方式：

  • Collections.synchronizedList()：将 List 转换为线程安全的集合。

  • Vector：线程安全的 List 实现（不推荐使用）。

  • ConcurrentHashMap：线程安全的 Map 实现。

  • CopyOnWriteArrayList：线程安全的 List 实现。

5. 集合的排序

• 自然排序：

  • 集合中的元素必须实现 Comparable 接口。

  • 例如：TreeSet 和 TreeMap 会自动对元素进行排序。

• 自定义排序：

  • 使用 Comparator 接口实现自定义排序规则。

  • 例如：Collections.sort(list, comparator)。

6. 集合的性能比较

 练习代码1-平均气温

输入周一到周日七天的温度，输出这周的平均温度，这周温度最高的是哪天，最低的是哪天

使用List接口的ArrayList来存储最高和最低气温

package com.chao.array;
import java.util.*;

//输入一周的气温，求平均气温，哪些天大于平均气温，哪些天小于平均气温
public class AverageTemperature {
    public static void main(String args[ ]) {
        //声明用到的变量
        int count;
        double sum,average;
        sum=0;
        double [ ]temperature=new double[7];

        //创建一个 Scanner 类的对象，用它来获得用户的输入
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入七天的温度(从周一到周日)：");
        for(count=0;count<temperature.length;count++)
        {
            System.out.print(getDayOfWeek(count + 1) + "的气温：");
            //读取用户输入
            temperature[count]=sc.nextDouble();
            sum+=temperature[count];
        }
        average=sum/7;
        System.out.println("本周的平均气温为："+average);

        //寻找最高和最低气温的天数
        double maxTemp = temperature[0];//最高气温
        double minTemp = temperature[0];//最低气温
        List<String> maxDays = new ArrayList<>();
        maxDays.add("周一");
        List<String> minDays = new ArrayList<>();
        minDays.add("周一");

        for (int i = 0; i < temperature.length; i++) {
            double current = temperature[i];
            //处理最高气温
            if (current > maxTemp) {
                maxTemp = current;
                maxDays.clear();
                maxDays.add(getDayOfWeek(i + 1));
            } else if (current == maxTemp) {
                maxDays.add(getDayOfWeek(i + 1));
            }
            //处理最低气温
            if (current < minTemp) {
                minTemp = current;
                minDays.clear();
                minDays.add((getDayOfWeek(i + 1)));
            } else if (current == minTemp) {
                minDays.add(getDayOfWeek(i + 1));
            }
        }

        //输出最高气温的天数
        System.out.print("最高气温出现在：");
        for (int i = 0; i < maxDays.size(); i++) {
            if (i > 0) {
                System.out.println("、");
            }
            System.out.println(maxDays.get(i));
        }
//        System.out.println();

        // 输出最低气温的天数
        System.out.print("最低气温出现在：");
        for (int i = 0; i < minDays.size(); i++) {
            if (i > 0) {
                System.out.print("、");
            }
            System.out.print(minDays.get(i));
        }
        System.out.println();

        //比较各天气温与平均气温
        for (count = 0; count < temperature.length; count++) {
            String dayOfWeek = getDayOfWeek(count + 1);
            if (temperature[count] < average)
                System.out.println(dayOfWeek + "的气温低于平均气温");
            else if (temperature[count] > average)
                System.out.println(dayOfWeek + "的气温高于平均气温");
            else
                System.out.println(dayOfWeek + "的气温等于平均气温");
        }
    }

    // 根据天数返回星期几
    private static String getDayOfWeek(int day) {
        switch (day) {
            case 1:
                return "周一";
            case 2:
                return "周二";
            case 3:
                return "周三";
            case 4:
                return "周四";
            case 5:
                return "周五";
            case 6:
                return "周六";
            case 7:
                return "周日";
            default:
                return "";
        }
    }
}

代码整体功能

这段代码的主要功能是：

1. 输入一周七天的气温（从周一到周日）。

2. 计算平均气温。

3. 找出最高气温和最低气温对应的天数。

4. 比较每一天的气温与平均气温，输出哪些天高于、低于或等于平均气温。

5. 输出结果，包括平均气温、最高气温和最低气温对应的天数，以及每一天的气温比较结果。

代码结构

代码分为以下几个部分：

1. 变量声明和初始化。

2. 输入气温数据。

3. 计算平均气温。

4. 寻找最高气温和最低气温。

5. 输出结果。

6. 辅助方法 getDayOfWeek。

详细解释

1. 变量声明和初始化

int count;
double sum, average;
sum = 0;
double[] temperature = new double[7];

• count：用于循环计数。

• sum：用于累加七天气温的总和。

• average：用于存储平均气温。

• temperature：一个长度为7的数组，用于存储每天的气温（从周一到周日）。

2. 输入气温数据

Scanner sc = new Scanner(System.in);
System.out.println("请输入七天的温度（从周一到周日）：");

for (count = 0; count < temperature.length; count++) {
    System.out.print(getDayOfWeek(count + 1) + "的气温：");
    temperature[count] = sc.nextDouble();
    sum += temperature[count];
}

• Scanner sc = new Scanner(System.in)：创建一个 Scanner 对象，用于从控制台读取用户输入。

• System.out.println("请输入七天的温度（从周一到周日）：")：提示用户输入七天的气温。

• for 循环：

  • 循环7次（temperature.length 为7），依次输入每天的气温。

  • getDayOfWeek(count + 1)：调用辅助方法 getDayOfWeek，将天数（1到7）转换为星期几（如“星期一”）。

  • System.out.print(getDayOfWeek(count + 1) + "的气温：")：动态生成每一天的输入提示（如“星期一的气温：”）。

  • temperature[count] = sc.nextDouble()：读取用户输入的气温，并存储到 temperature 数组中。

  • sum += temperature[count]：累加每天的气温，用于后续计算平均气温。

3. 计算平均气温

average = sum / 7;
System.out.println("平均气温为：" + average);

• average = sum / 7：计算七天的平均气温。

• System.out.println("平均气温为：" + average)：输出平均气温。

4. 寻找最高气温和最低气温

double maxTemp = temperature[0];
double minTemp = temperature[0];
List<String> maxDays = new ArrayList<>();
maxDays.add(getDayOfWeek(1));
List<String> minDays = new ArrayList<>();
minDays.add(getDayOfWeek(1));

for (int i = 1; i < temperature.length; i++) {
    double current = temperature[i];
    // 处理最高气温
    if (current > maxTemp) {
        maxTemp = current;
        maxDays.clear();
        maxDays.add(getDayOfWeek(i + 1));
    } else if (current == maxTemp) {
        maxDays.add(getDayOfWeek(i + 1));
    }
    // 处理最低气温
    if (current < minTemp) {
        minTemp = current;
        minDays.clear();
        minDays.add(getDayOfWeek(i + 1));
    } else if (current == minTemp) {
        minDays.add(getDayOfWeek(i + 1));
    }
}

• maxTemp 和 minTemp：分别用于存储最高气温和最低气温的初始值（初始值为第一天的气温）。

• maxDays 和 minDays：分别用于存储最高气温和最低气温对应的天数（星期几）。

• for 循环：

  • 从第二天开始遍历气温数组。

  • 处理最高气温：

    • 如果当前气温 current 大于 maxTemp，则更新 maxTemp，并清空 maxDays 列表，将当前天数加入列表。

    • 如果当前气温等于 maxTemp，则将当前天数加入 maxDays 列表。

  • 处理最低气温：

    • 如果当前气温 current 小于 minTemp，则更新 minTemp，并清空 minDays 列表，将当前天数加入列表。

    • 如果当前气温等于 minTemp，则将当前天数加入 minDays 列表。

5. 输出结果

// 输出最高气温的天数
System.out.print("最高气温出现在：");
for (int i = 0; i < maxDays.size(); i++) {
    if (i > 0) {
        System.out.print("、");
    }
    System.out.print(maxDays.get(i));
}
System.out.println();

// 输出最低气温的天数
System.out.print("最低气温出现在：");
for (int i = 0; i < minDays.size(); i++) {
    if (i > 0) {
        System.out.print("、");
    }
    System.out.print(minDays.get(i));
}
System.out.println();

// 比较各天气温与平均气温
for (count = 0; count < temperature.length; count++) {
    String dayOfWeek = getDayOfWeek(count + 1);
    if (temperature[count] < average)
        System.out.println(dayOfWeek + "的气温低于平均气温");
    else if (temperature[count] > average)
        System.out.println(dayOfWeek + "的气温高于平均气温");
    else
        System.out.println(dayOfWeek + "的气温等于平均气温");
}

• 输出最高气温的天数：

  • 遍历 maxDays 列表，输出所有最高气温对应的星期几。

  • 如果有多天，用顿号（“、”）分隔。

• 输出最低气温的天数：

  • 遍历 minDays 列表，输出所有最低气温对应的星期几。

  • 如果有多天，用顿号（“、”）分隔。

• 比较各天气温与平均气温：

  • 遍历气温数组，依次比较每一天的气温与平均气温。

  • 根据比较结果，输出“低于”、“高于”或“等于”平均气温。

6. 辅助方法 getDayOfWeek

private static String getDayOfWeek(int day) {
    switch (day) {
        case 1:
            return "星期一";
        case 2:
            return "星期二";
        case 3:
            return "星期三";
        case 4:
            return "星期四";
        case 5:
            return "星期五";
        case 6:
            return "星期六";
        case 7:
            return "星期日";
        default:
            return "";
    }
}

• 功能：将天数（1到7）转换为对应的星期几（如“星期一”）。

• 实现：

  • 使用 switch 语句，根据输入的 day 值返回对应的星期几。

  • 如果 day 不在1到7范围内，返回空字符串（不会发生，因为输入已经限制为7天）。

总结

这段代码通过以下步骤实现了功能：

1. 输入数据：动态生成中文提示词，逐天输入气温。

2. 计算平均气温：累加气温并计算平均值。

3. 寻找最高和最低气温：遍历数组，记录最高和最低气温及其对应的天数。

4. 输出结果：格式化输出平均气温、最高气温和最低气温的天数，以及每一天的气温比较结果。