初识大数据，一文掌握大数据必备知识文集(2)

🏆作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。
🏆多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。
🎉欢迎 👍点赞?评论?收藏

大数据知识专栏学习

大数据知识云集	访问地址	备注
大数据知识点(1)	https://blog.csdn.net/m0_50308467/article/details/134999017	大数据专栏
大数据知识点(2)	https://blog.csdn.net/m0_50308467/article/details/135109787	大数据专栏

🏆初识大数据应用知识

🔎一、初识大数据应用知识(2)

🍁 01、Hive有索引吗？

Hive 没有索引。

Hive 是基于 Hadoop 的一个数据仓库工具，它使用 MapReduce 来处理数据。MapReduce 是一种分布式计算框架，它可以将大规模数据集分解成更小的任务，并在多个计算机上并行处理这些任务。Hive 使用 SQL 语句来查询数据，但它不使用传统的关系数据库索引。

传统的关系数据库使用索引来提高查询性能。索引是数据库中数据的快速访问路径。当用户发出查询时，数据库会使用索引来快速找到所需的数据。

Hive是建立在Hadoop上的数据仓库工具，它提供了类似于SQL的查询语言来处理大规模数据。Hive本身并不直接支持索引，但可以通过Hive的分区和分桶功能来实现类似索引的效果。

分区是将数据按照某个列的值进行划分，将数据存储在不同的目录中，以提高查询效率。例如，可以按照日期对数据进行分区，这样可以只查询特定日期范围内的数据，而不需要扫描整个数据集。

分桶是将数据按照某个列的哈希值进行划分，将数据存储在不同的桶中。分桶可以用于加速连接操作，因为连接操作只需要在相同桶中的数据之间进行，而不需要扫描整个数据集。

虽然Hive没有内置的索引功能，但可以通过合理地使用分区和分桶来达到类似索引的效果，提高查询性能。不过需要注意的是，分区和分桶需要在数据加载之前进行定义，并且对已经存在的数据进行分区和分桶的操作可能会比较复杂。

🍁 02、Hbase行键列族的概念，物理模型，表的设计原则？

HBase是一个分布式的面向列的NoSQL数据库，它的数据模型与传统的关系型数据库有所不同。在HBase中，行键（Row Key）和列族（Column Family）是两个重要的概念。

1. 行键（Row Key）：

   • 行键是HBase表中每条记录的唯一标识符，它由一个或多个列组成。
   • 行键的设计应该是唯一的，且能够有效地组织数据。通常情况下，行键的设计应该考虑数据的访问模式和查询需求。
   • 行键的排序方式对HBase的性能有重要影响，因为HBase是按照行键的字典顺序进行存储和检索数据的。
   • 行键的长度应该尽量控制在合理范围内，过长的行键会增加存储和查询的开销。

2. 列族（Column Family）：

   • 列族是HBase表中一组相关的列的集合，它们通常表示一个实体的一个属性。
   • 列族在物理存储上是连续存放的，HBase会将同一个列族的数据存储在一起，以提高查询性能。
   • 列族在创建表时需要预先定义，并且在表的生命周期中不能更改。

HBase表的物理模型如下图所示：

HBase表的设计原则如下：

1. 行键设计原则：

   • 行键应该具有唯一性，不同行的行键应该是不同的。
   • 行键的设计应该考虑数据的访问模式和查询需求，以便能够高效地检索数据。
   • 行键的排序方式对HBase的性能有影响，应该根据实际情况选择适当的排序方式。

2. 列族设计原则：

   • 列族应该是相关的列的集合，它们通常表示一个实体的一个属性。
   • 列族的设计应该尽量避免过度设计，避免将过多的列放在同一个列族中。
   • 列族的数量应该适中，过多的列族会增加存储和查询的开销。

3. 表的大小和预分区：

   • 表的大小应该适中，过大的表会增加管理和维护的复杂性。
   • 针对大表，可以考虑进行预分区，将数据分散存储在多个Region中，以提高查询和并发处理的性能。

通过遵循这些设计原则，可以创建高效、可扩展的HBase表，并满足不同的数据访问和查询需求。

🍁 03、Spark为什么要持久化，一般什么场景下要进行persist操作？

Spark 持久化是指将 Spark 中的数据以某种方式保存到外部存储系统中，以便在后续的计算中可以直接使用，而不需要重新计算。Spark 持久化可以提高 Spark 程序的性能，因为它可以避免在后续计算中重复计算已经计算过的数据。

Spark 持久化有两种方式：

• 内存持久化：将数据保存到 Spark 的内存中。内存持久化可以提高 Spark 程序的性能，因为内存访问速度比磁盘访问速度快。但是，内存持久化会消耗 Spark 的内存，如果 Spark 的内存不足，则可能会导致内存溢出。
• 磁盘持久化：将数据保存到磁盘中。磁盘持久化可以保证数据在 Spark 集群发生故障时不会丢失。但是，磁盘持久化会降低 Spark 程序的性能，因为磁盘访问速度比内存访问速度慢。

Spark 持久化通常在以下场景下使用：

• 当需要多次访问相同的数据时。
• 当数据量很大时。
• 当数据计算复杂时。
• 当 Spark 集群发生故障时，需要保证数据不会丢失。

Spark 持久化可以提高 Spark 程序的性能，但是也会增加 Spark 程序的复杂性。因此，在使用 Spark 持久化时，需要根据实际情况进行选择。

🍁 04、Hbase宕机如何处理？

HBase 宕机后，需要根据宕机原因进行处理。如果是 RegionServer 宕机，可以通过以下步骤恢复：

1. 检查 RegionServer 的状态。如果 RegionServer 的状态是 RUNNING ，则说明 RegionServer 已经恢复。如果 RegionServer 的状态是 STOPPED ，则需要手动启动 RegionServer。
2. 检查 RegionServer 上的数据。如果 RegionServer 上的数据丢失，则需要通过 HBase 的备份机制进行恢复。
3. 检查 RegionServer 上的元数据。如果 RegionServer 上的元数据丢失，则需要通过 HBase 的备份机制进行恢复。

如果是 Master 宕机，可以通过以下步骤恢复：

1. 检查 Master 的状态。如果 Master 的状态是 RUNNING ，则说明 Master 已经恢复。如果 Master 的状态是 STOPPED ，则需要手动启动 Master。
2. 检查 Master 上的数据。如果 Master 上的数据丢失，则需要通过 HBase 的备份机制进行恢复。
3. 检查 Master 上的元数据。如果 Master 上的元数据丢失，则需要通过 HBase 的备份机制进行恢复。

如果是 ZooKeeper 宕机，可以通过以下步骤恢复：

1. 检查 ZooKeeper 的状态。如果 ZooKeeper 的状态是 RUNNING ，则说明 ZooKeeper 已经恢复。如果 ZooKeeper 的状态是 STOPPED ，则需要手动启动 ZooKeeper。
2. 检查 ZooKeeper 上的数据。如果 ZooKeeper 上的数据丢失，则需要通过 HBase 的备份机制进行恢复。
3. 检查 ZooKeeper 上的元数据。如果 ZooKeeper 上的元数据丢失，则需要通过 HBase 的备份机制进行恢复。

HBase 的宕机处理需要根据具体的宕机原因进行处理。如果是 RegionServer 宕机，通常只需要启动 RegionServer 即可恢复。如果是 Master 宕机，通常需要恢复 Master 上的数据和元数据。如果是 ZooKeeper 宕机，通常需要恢复 ZooKeeper 上的数据和元数据。

🍁 05、HDFS在读取文件的时候，如果其中一个块突然损坏了怎么办？

HDFS 在读取文件的时候，如果其中一个块突然损坏了，会发生以下几种情况：

1. 如果损坏的块是唯一的副本，那么整个文件将无法读取。
2. 如果损坏的块不是唯一的副本，那么 HDFS 会从其他副本中读取数据，并将损坏的块替换为新的块。
3. 如果损坏的块是最后一个副本，那么 HDFS 会从备份中恢复数据，并将损坏的块替换为新的块。

HDFS 使用副本机制来保证数据的可靠性。当一个文件被写入 HDFS 时，会在多个节点上创建多个副本。如果其中一个节点发生故障，那么其他节点上的副本可以保证数据不会丢失。

HDFS 还使用备份机制来保证数据的可靠性。当一个文件被写入 HDFS 时，会在多个节点上创建多个副本。如果其中一个节点发生故障，那么其他节点上的副本可以保证数据不会丢失。但是，如果所有节点都发生故障，那么数据可能会丢失。

为了避免数据丢失，HDFS 还使用了其他机制来保证数据的可靠性，例如数据校验和。数据校验和是一种算法，可以检测数据是否被损坏。如果数据被损坏，那么数据校验和会检测到，并将损坏的数据替换为新的数据。

HDFS 是分布式文件系统，它使用了多种机制来保证数据的可靠性。这些机制包括副本机制、备份机制和数据校验和。这些机制可以保证数据在发生故障时不会丢失。

🍁 06、HDFS在上传文件的时候，如果其中一个DataNode突然挂掉了怎么办？

HDFS 在上传文件的过程中，如果其中一个 DataNode 突然挂掉了，HDFS 会根据其容错机制来处理：

1. 副本机制：HDFS 会在上传文件时将文件分割成多个块，并在不同的 DataNode 上创建副本。如果其中一个 DataNode 挂掉，其他副本仍然可用，HDFS 会从其他副本中读取数据，并完成文件的上传。

2. 数据重复：在上传文件时，HDFS 会确保每个块都有足够数量的副本。如果某个 DataNode 挂掉，HDFS 会自动将该 DataNode 上的块复制到其他正常运行的 DataNode 上，以保证副本数量达到设定的要求。

3. 自动故障检测和恢复：HDFS 会定期检测 DataNode 的健康状态。如果某个 DataNode 挂掉，HDFS 会自动检测到该故障，并将该 DataNode 标记为不可用。然后，HDFS 会启动数据块的复制过程，将该 DataNode 上的块复制到其他可用的 DataNode 上，以保证数据的可靠性。

4. 块重复检测：HDFS 会定期检测数据块的一致性，以确保所有副本中的数据一致。如果某个副本的数据与其他副本不一致，HDFS 会自动将不一致的副本替换为正确的副本，以保证数据的一致性。

总之，HDFS 在上传文件时会采取多种机制来应对 DataNode 挂掉的情况。这些机制包括副本机制、数据重复、自动故障检测和恢复，以及块重复检测。这些机制可以保证数据在上传过程中不会丢失，并确保数据的可靠性和一致性。

🍁 07、请简述Hadoop怎样实现二级排序(对key和value进行双排序)？

Hadoop 可以通过以下两种方式实现二级排序：

1. 使用 sort 命令。 sort 命令可以对输入文件进行排序，可以指定多个排序字段。如果指定了多个排序字段，则会先按照第一个排序字段进行排序，然后再按照第二个排序字段进行排序。
2. 使用 MapReduce 程序。 MapReduce 程序可以对输入数据进行分区和排序。在分区阶段，可以使用 Partitioner 类来指定分区规则。在排序阶段，可以使用 SortComparator 类来指定排序规则。

以下是一个使用 MapReduce 程序实现二级排序的示例：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class SecondarySort {

    public static class Map extends Mapper<Object, Text, Text, IntWritable> {

        private Text key = new Text();
        private IntWritable value = new IntWritable();

        @Override
        public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
            String[] tokens = value.toString().split(",");
            key.set(tokens[0]);
            value.set(Integer.parseInt(tokens[1]));
            context.write(key, value);
        }
    }

    public static class Reduce extends Reducer<Text, IntWritable, Text, IntWritable> {

        private Text key = new Text();
        private IntWritable value = new IntWritable();

        @Override
        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable value : values) {
                sum += value.get();
            }
            key.set(key.toString() + "," + sum);
            context.write(key, value);
        }
    }

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "SecondarySort");
        job.setJarByClass(SecondarySort.class);

        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));

        job.waitForCompletion(true);
    }
}

运行该程序，可以将输入文件按照第一个字段进行分区，然后按照第二个字段进行排序。

🍁 08、Mapreduce和Hive的ql语言需要掌握哪些内容？

MapReduce 和 Hive 的 QL 语言需要掌握以下内容：

• 基本语法
• 数据类型
• 函数
• 条件语句
• 循环语句
• 分组和聚合
• 连接
• 外连接
• 子查询
• 视图
• 窗口函数
• 分区
• 分桶
• 排序
• 过滤
• 自定义函数
• 自定义 UDF
• 自定义 UDA

掌握这些内容，可以编写 MapReduce 和 Hive 的 QL 程序，解决各种数据处理问题。

🍁 09、Hadoop数据倾斜及解决办法？

Hadoop 数据倾斜是指在 MapReduce 作业中，某些 Map 任务处理的数据量远远大于其他 Map 任务，导致整个作业的执行效率降低。数据倾斜主要有以下几个原因：

• 数据分布不均匀。如果数据分布不均匀，那么某些 Map 任务处理的数据量就会远远大于其他 Map 任务。
• 数据倾斜的输入数据。如果输入数据本身就存在数据倾斜，那么 MapReduce 作业也会出现数据倾斜。
• 不合理的 MapReduce 作业设计。如果 MapReduce 作业设计不合理，也会导致数据倾斜。

数据倾斜会导致整个作业的执行效率降低，因此需要采取措施来解决数据倾斜问题。以下是一些常见的数据倾斜解决办法：

• 通过 MapReduce 作业设计来解决数据倾斜。例如，可以通过使用分区函数来均匀地分布数据，或者通过使用分桶函数来将数据分散到多个桶中。
• 通过使用 MapReduce 的二次排序来解决数据倾斜。二次排序可以将数据按照多个字段进行排序，这样可以将数据均匀地分布到多个 Map 任务中。
• 通过使用 MapReduce 的 Combiner 来解决数据倾斜。Combiner 可以将多个 Map 任务的输出结果合并成一个结果，这样可以减少 Map 任务的输出量，从而降低数据倾斜。
• 通过使用 MapReduce 的 Reducer 来解决数据倾斜。Reducer 可以将多个 Map 任务的输出结果合并成一个结果，这样可以减少 Reducer 任务的输入量，从而降低数据倾斜。

以上是一些常见的数据倾斜解决办法，具体情况需要根据实际情况来选择合适的解决办法。

🍁 10、HDFS读取文件的详细步骤有哪些？

以下是 HDFS 读取文件的详细步骤：

1. 创建一个 Configuration 对象，并设置 fs.defaultFS 属性。
2. 创建一个 FileSystem 对象。
3. 打开一个 FSDataInputStream 对象。
4. 读取文件内容。
5. 关闭 FSDataInputStream 对象。
6. 关闭 FileSystem 对象。

以下是一个使用 Java 代码实现 HDFS 读取文件的示例：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

public class HDFSReader {

    public static void main(String[] args) throws Exception {
        // 创建一个 Configuration 对象
        Configuration conf = new Configuration();

        // 设置 fs.defaultFS 属性
        conf.set("fs.defaultFS", "hdfs://localhost:9000");

        // 创建一个 FileSystem 对象
        FileSystem fs = FileSystem.get(conf);

        // 打开一个 FSDataInputStream 对象
        FSDataInputStream in = fs.open(new Path("/user/hadoop/test.txt"));

        // 读取文件内容
        byte[] buffer = new byte[1024];
        int len = in.read(buffer);
        while (len != -1) {
            System.out.println(new String(buffer, 0, len));
            len = in.read(buffer);
        }

        // 关闭 FSDataInputStream 对象
        in.close();

        // 关闭 FileSystem 对象
        fs.close();
    }
}

通过以上步骤，我们可以从 HDFS 中读取文件。

🍁 11、Sqoop在导入到MySQL中，要求不重复导入数据，如果数据存在问题，Sqoop如何处理？

当使用Sqoop将数据导入到MySQL中时，Sqoop提供了一些处理数据冲突和重复的选项。

1. 默认情况下，Sqoop会将数据导入到MySQL的目标表中，如果目标表已存在数据，Sqoop会引发一个错误并停止导入。这是为了避免数据重复导入。

2. 如果你想要覆盖目标表中的数据，可以使用 --delete-target-dir 选项。这个选项会在导入之前删除目标表的数据，然后再将新数据导入。

3. 如果你想要将新导入的数据追加到目标表中而不覆盖已有的数据，可以使用 --append 选项。这样，新数据会被追加到目标表的末尾。

4. 另外，Sqoop还提供了 --update-key 和 --update-mode 选项，用于处理数据更新。你可以指定一个或多个列作为更新键，并选择更新模式（例如，更新或插入）。这样，Sqoop会根据更新键的值判断数据是否已经存在，如果存在则更新，否则插入新数据。

需要注意的是，Sqoop在导入数据时，是按照数据源的顺序进行导入的。如果数据源中存在重复的数据，Sqoop不会自动去重，而是将重复的数据一并导入到目标表中。因此，在使用Sqoop导入数据之前，最好确保数据源中没有重复的数据，或者在导入后使用MySQL的去重机制进行处理。

总结来说，Sqoop在导入到MySQL中时，可以使用 --delete-target-dir 选项覆盖目标表数据，使用 --append 选项追加数据，或者使用 --update-key 和 --update-mode 选项处理数据更新。

🍁 12、请说下MR中ReduceTask的工作机制？

在MapReduce中，Reduce Task是数据处理的最后一步，它负责对Mapper阶段输出的中间键值对进行合并和归约操作，并生成最终的输出结果。Reduce Task的工作机制如下：

1. 分区（Partitioning）：在Map阶段结束后，Map输出的键值对会根据键的哈希值被分配到不同的Reduce Task上进行处理。分区的目的是将具有相同键的键值对发送到同一个Reduce Task上，以便在Reduce阶段进行处理。

2. 排序（Sorting）：Reduce Task接收到分配给它的键值对后，会对键进行排序。排序的目的是将具有相同键的键值对相邻地排列在一起，以便在归约操作时更方便地处理。

3. 归约（Reducing）：Reduce Task对排序后的键值对进行归约操作。归约操作是对具有相同键的键值对进行合并和计算的过程。Reduce Task会依次处理每个键，并将具有相同键的值进行合并、计算或其他操作，生成最终的输出结果。

4. 输出（Output）：归约操作完成后，Reduce Task将最终的输出结果写入到指定的输出文件或输出目录中。输出结果可以是单个文件或多个文件，具体取决于配置和需求。

Reduce Task的工作机制可以有效地处理大规模数据集，实现分布式计算和数据处理。通过合理的分区、排序和归约操作，Reduce Task可以将Mapper阶段输出的中间结果进行合并和计算，生成最终的结果输出。

🍁 13、Hadoop的TextInputFormat作用是什么，如何自定义实现？

Hadoop的TextInputFormat是Hadoop中的一个输入格式类，用于处理文本文件。它将文本文件划分为一行一行的记录，并将每一行的偏移量作为键，行内容作为值。

TextInputFormat的作用是将文本文件拆分为多个InputSplit，每个InputSplit对应一个Mapper任务。每个Mapper任务负责处理一个InputSplit中的数据。

要自定义实现TextInputFormat，可以继承org.apache.hadoop.mapreduce.lib.input.TextInputFormat类，并重写其中的一些方法。以下是一个简单的自定义TextInputFormat的示例：

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.JobContext;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.LineRecordReader;

public class CustomTextInputFormat extends FileInputFormat<LongWritable, Text> {

    @Override
    public RecordReader<LongWritable, Text> createRecordReader(InputSplit split, TaskAttemptContext context) {
        return new CustomLineRecordReader();
    }

    @Override
    protected boolean isSplitable(JobContext context, Path filename) {
        // 设置是否可拆分为多个InputSplit，默认为true，表示可拆分
        return super.isSplitable(context, filename);
    }

    public static class CustomLineRecordReader extends RecordReader<LongWritable, Text> {
        private LineRecordReader lineRecordReader;

        public CustomLineRecordReader() {
            lineRecordReader = new LineRecordReader();
        }

        @Override
        public void initialize(InputSplit split, TaskAttemptContext context) throws IOException, InterruptedException {
            lineRecordReader.initialize(split, context);
        }

        @Override
        public boolean nextKeyValue() throws IOException, InterruptedException {
            return lineRecordReader.nextKeyValue();
        }

        @Override
        public LongWritable getCurrentKey() throws IOException, InterruptedException {
            return lineRecordReader.getCurrentKey();
        }

        @Override
        public Text getCurrentValue() throws IOException, InterruptedException {
            return lineRecordReader.getCurrentValue();
        }

        @Override
        public float getProgress() throws IOException, InterruptedException {
            return lineRecordReader.getProgress();
        }

        @Override
        public void close() throws IOException {
            lineRecordReader.close();
        }
    }
}

在自定义的CustomTextInputFormat类中，我们继承了FileInputFormat，并重写了createRecordReader方法，返回一个自定义的RecordReader。在CustomLineRecordReader类中，我们使用了LineRecordReader作为底层的记录读取器。

通过自定义TextInputFormat，我们可以实现更复杂的文本文件处理逻辑，例如自定义的记录分隔符、自定义的键值对分隔符等。

🍁 14、Hbase内部机制是什么？

HBase是建立在Hadoop之上的分布式列存储数据库，它的内部机制主要包括以下几个方面：

1. 数据模型：HBase采用了基于列的数据模型，数据以表的形式存储，每个表可以包含多个列族，每个列族可以包含多个列。数据按照行键进行索引，行键是表中每条记录的唯一标识符。

2. 存储结构：HBase的数据存储在Hadoop分布式文件系统（HDFS）中，每个表被划分为多个Region，每个Region存储一部分数据。Region按照行键的范围进行划分，相邻的行键存储在同一个Region中。每个Region由多个存储文件（HFile）组成，HFile是一种基于块的文件格式，用于高效地存储和检索数据。

3. 分布式架构：HBase采用了分布式架构，数据存储在多个RegionServer上。每个RegionServer负责管理多个Region，处理对这些Region的读写请求。HBase利用Hadoop的分布式特性，将数据分散存储在多个RegionServer上，以实现高可靠性和高扩展性。

4. 写入流程：当写入数据到HBase时，数据首先被写入到内存中的MemStore，然后周期性地将MemStore中的数据刷写到磁盘上的HFile中。当HFile的大小达到一定阈值时，HBase会将多个HFile合并成一个更大的HFile，以减少文件数量和提高读取效率。

5. 读取流程：当从HBase中读取数据时，首先根据行键的范围确定需要读取的Region，然后从对应的RegionServer上读取数据。读取过程中，HBase会根据数据的存储位置和索引信息，直接定位到所需数据的位置，以提高读取效率。

6. 一致性和故障恢复：HBase通过ZooKeeper来实现一致性和故障恢复。ZooKeeper负责维护HBase集群的元数据信息和状态信息，当RegionServer宕机或出现其他故障时，ZooKeeper会通知其他RegionServer进行相应的故障恢复操作，以保证数据的一致性和可靠性。

总之，HBase的内部机制包括数据模型、存储结构、分布式架构、写入流程、读取流程以及一致性和故障恢复机制。这些机制共同作用，使得HBase能够高效地存储和检索大规模数据。

🍁 15、有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词？

根据给定的条件，我们可以使用以下步骤来返回频数最高的100个词：

1. 创建一个哈希表（HashMap）来存储每个词及其频数。
2. 打开文件并逐行读取文件内容。
3. 对于每一行，提取词并将其作为键存储在哈希表中。如果该词已经存在于哈希表中，则将其对应的频数加1。
4. 在读取完所有行后，遍历哈希表，选择频数最高的100个词。
5. 对选定的100个词进行排序，按照频数从高到低进行排序。
6. 返回排序后的结果，即频数最高的100个词。

由于内存限制为1M，我们可以使用最小堆（Min Heap）来存储频数最高的100个词。在遍历哈希表时，将词及其频数加入最小堆中，并保持堆的大小为100。当堆的大小达到100时，如果遇到的词的频数比堆顶元素的频数更高，则将堆顶元素弹出，并将新词加入堆中。最终，堆中剩下的100个词就是频数最高的100个词。

需要注意的是，由于内存限制较小，如果文件较大，可能需要考虑分块读取文件并进行多轮处理。

以下是一个示例代码（使用Java）：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.PriorityQueue;

public class TopWords {
    public static void main(String[] args) {
        String filePath = "path/to/your/file.txt";
        int limit = 100;

        HashMap<String, Integer> wordCount = new HashMap<>();
        PriorityQueue<WordFrequency> minHeap = new PriorityQueue<>(limit);

        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                String word = line.trim();
                wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        for (String word : wordCount.keySet()) {
            int frequency = wordCount.get(word);
            WordFrequency wf = new WordFrequency(word, frequency);

            if (minHeap.size() < limit) {
                minHeap.offer(wf);
            } else if (minHeap.peek().frequency < wf.frequency) {
                minHeap.poll();
                minHeap.offer(wf);
            }
        }

        // 反转堆中的元素顺序，使频数最高的词在堆顶
        PriorityQueue<WordFrequency> maxHeap = new PriorityQueue<>(limit, (a, b) -> b.frequency - a.frequency);
        while (!minHeap.isEmpty()) {
            maxHeap.offer(minHeap.poll());
        }

        // 输出频数最高的100个词
        while (!maxHeap.isEmpty()) {
            System.out.println(maxHeap.poll().word);
        }
    }

    static class WordFrequency {
        String word;
        int frequency;

        WordFrequency(String word, int frequency) {
            this.word = word;
            this.frequency = frequency;
        }
    }
}

请将 filePath 替换为你的文件路径，并根据需要修改 limit 的值，以确定返回的词频数。运行代码后，将打印频数最高的100个词。