hadoop07--词频统计、级联删除、hdfs的文件读写、mapreduce的wordCount

最新推荐文章于 2022-09-11 16:07:53 发布
最新推荐文章于 2022-09-11 16:07:53 发布
阅读量659 收藏 1
点赞数
分类专栏： hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24135817/article/details/81667069
版权

一：统计6个文件的单词和单词总数

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 统计6个文件的总的词频：
 * 1.统计每一个文件的词频（每个单词出现的次数）
 * 2.合并统计总的次数
 * @author dai
 *
 */

public class WordCount01 {
    public static void main(String[] args) throws IOException {
        Map<String, Integer> map01 = readOneFile("D:\\data\\word01.txt");
        Map<String, Integer> map02 = readOneFile("D:\\data\\word02.txt");
        Map<String, Integer> map03 = readOneFile("D:\\data\\word03.txt");
        Map<String, Integer> map04 = readOneFile("D:\\data\\word04.txt");
        Map<String, Integer> map05 = readOneFile("D:\\data\\word05.txt");
        Map<String, Integer> map06 = readOneFile("D:\\data\\word06.txt");
        System.out.println(map02);


        System.out.println(map01);
        System.out.println(map03);
        System.out.println(map04);
        System.out.println(map05);
        //统计所有小文件的总的词频  将每个小文件的统计结果拿出来   放在一个大的map中进行总的统计
        Map<String, Integer> mergeAllFile = mergeAllFile(map01,map02,map03,map04,map05,map06);
        System.out.println(mergeAllFile);
    }



    /*
     * 统计每一个文件的词频  单词---次数
     *  创建一个字符流
     *  每行读取，将读取的内容进行分割，获取每一个单词
     *  结果存在map集合中：key--单词     value--出现的次数
     * 返回值：结果   map
     * 参数：String path
     *      
     */
    public static Map<String,Integer> readOneFile(String path) throws IOException{
        BufferedReader br=new BufferedReader(new FileReader(path));
        String line=null;
        Map<String,Integer> map=new HashMap<String,Integer>();
        while((line=br.readLine())!=null){
            String[] words = line.split("\t");
            //循环遍历  放在map集合中
            for(String w:words){
                //map集合中还没有放过
                if(!map.containsKey(w)){
                    map.put(w, 1);
                }else{
                    //将原来的值取出来  +1
                    int newvalue=map.get(w)+1;
                    map.put(w, newvalue);
                }
            }
        }
        return map;
    }
    /**
     * 统计所有的小文件的额总的词频
     * @return
     * 可变参数    
     * 定义的时候：
     *  类型... 可变参数的名字
     * 使用的时候：
     * 实际需要几个参数就传几个参数
     */
    public static Map<String,Integer> mergeAllFile(Map<String,Integer>...maps){
        Map<String,Integer> endMap=new HashMap<String,Integer>();
        //循环遍历可变参数所有的map   获取到每一个map
        for(Map<String,Integer> map:maps){
            //对每一个map进行循环遍历  获取到每一个单词的出现的次数
            Set<Entry<String, Integer>> entrySet = map.entrySet();
            for(Entry<String, Integer> entry:entrySet){
                String key = entry.getKey();
                Integer value = entry.getValue();
                //如果没放过  直接放进去   key  value直接不变放入
                if(!endMap.containsKey(key)){
                    endMap.put(key, value);
                }else{
                    //放过   将原来的取出来  +  新的value
                    Integer oldvalue = endMap.get(key);
                    Integer finalvalue=oldvalue+value;
                    endMap.put(key, finalvalue);
                }
            }
        }
        return endMap;
    }

}

二：统计6个文件的总的单词数


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 统计6个文件的总的词频
 * 统计每一个文件的词频（每个单词出现的次数）
 * 合并统计总的次数
 * @author dai
 *
 */

public class WordCount2 {
    public static void main(String[] args) throws IOException {
        Map<String, Integer> map01 = readOneFile("D:\\data\\word01.txt");
        Map<String, Integer> map02 = readOneFile("D:\\data\\word02.txt");
        Map<String, Integer> map03 = readOneFile("D:\\data\\word03.txt");
        Map<String, Integer> map04 = readOneFile("D:\\data\\word04.txt");
        Map<String, Integer> map05 = readOneFile("D:\\data\\word05.txt");
        Map<String, Integer> map06 = readOneFile("D:\\data\\word06.txt");
        System.out.println(map02);


        System.out.println(map01);
        System.out.println(map03);
        System.out.println(map04);
        System.out.println(map05);
        //统计所有小文件的总的词频  将每个小文件的统计结果拿出来   放在一个大的map中进行总的统计
        Map<String, Integer> mergeAllFile = mergeAllFile(map01,map02,map03,map04,map05,map06);
        System.out.println(mergeAllFile);
    }



    /*
     * 统计每一个文件单词总数
     */
    public static Map<String,Integer> readOneFile(String path) throws IOException{
        BufferedReader br=new BufferedReader(new FileReader(path));
        String line=null;
        Map<String,Integer> map=new HashMap<String,Integer>();
        int count=0;
        while((line=br.readLine())!=null){
            String[] words = line.split("\t");
            //循环遍历  放在map集合中
            for(String w:words){
                count++;
            }
        }
        map.put("总单词", count);
        return map;
    }
    /**
     * 统计所有的小文件的总单词个数
     */
    public static Map<String,Integer> mergeAllFile(Map<String,Integer>...maps){
        Map<String,Integer> endMap=new HashMap<String,Integer>();
        //循环遍历可变参数所有的map   获取到每一个map
        int count=0;
        for(Map<String,Integer> map:maps){
            //对每一个map进行循环遍历  获取到每一个单词的出现的次数
            Set<Entry<String, Integer>> entrySet = map.entrySet();
            for(Entry<String, Integer> entry:entrySet){
                String key = entry.getKey();
                Integer value = entry.getValue();
                count+=value;
            }
        }
        endMap.put("总单词", count);
        return endMap;
    }

}

三：删除HDFS集群中的所有空文件和空目录


import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

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

/**
 * 删除HDFS集群中的所有空文件和空目录   /
 *      判断给定的目录是否是空目录;
        获取给定的目录下的所有的文件或目录:
            如果是文件：
                判断文件的长度是否为0
                    0   删除
            如果是目录：
                判断是否是空目录：
                    是：删除
                    不是：递归 操作
                父目录是否是空目录

 * @author dai
 *
 */

public class DeleteEmptyFileAndDic {
    public static void main(String[] args) throws IOException, InterruptedException, URISyntaxException {
        Configuration conf=new Configuration();
        FileSystem fs=FileSystem.get(new URI("hdfs://hadoop01:9000"),conf,"hadoop");
        Path path=new Path("/");
        deleteEmpty(fs, path);
    }

    /**
     * 参数：
     * @throws IOException 
     * @throws FileNotFoundException 
     */
    public static void deleteEmpty(FileSystem fs,Path path) throws FileNotFoundException, IOException{
        //获取给定路径下的文件或目录
        FileStatus[] listStatus = fs.listStatus(path);
        //判断是否是一个空目录
        if(listStatus.length==0){
            fs.delete(path,false);
        }else{
            //不是空目录  进行循环遍历
            for(FileStatus fs1:listStatus){
                Path childpath=fs1.getPath();
                //判断是否是文件
                if(fs1.isFile()){
                    if(fs1.getLen()==0){
                        fs.delete(childpath, false);
                    }
                }else{
                    deleteEmpty(fs,childpath);
                }
            }
            //到这里 需要判断父目录是否是空
            FileStatus[] listStatus02=fs.listStatus(path);
            if(listStatus02.length==0){
                deleteEmpty(fs,path);
            }

        }
    }

}

四、从hdfs文件的任意位置开始读取一定长度到另一个文件

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Random;

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

/*
 * 从随机地方开始读，读任意长度     
 * 将hdfs的文件从随机的地方开始读   读取任意长度   
 * 读取完成的内容方法hdfs的一个指定目录下
 * 流的方式：
 *  hdfs(in)------hdfs(out)
 * 
 */
public class RandomRead {
    public static void main(String[] args) throws IOException, InterruptedException, URISyntaxException {
        Random random =new Random();
        //conf
        Configuration conf=new Configuration();
        //fs
        FileSystem fs=FileSystem.get(new URI("hdfs://hadoop01:9000"),conf,"hadoop");
        //hdfs的输入流
        FSDataInputStream in = fs.open(new Path("/testcrc01"));
        in.seek(10L);
        //hdfs的输出流
        FSDataOutputStream out = fs.create(new Path("/testRandom"));
        //参数3：需要复制的字节长度
        IOUtils.copyBytes(in, out, 15L, true);
    }

}

五、手动拷贝某个特定的数据块（比如某个文件的第二个数据块）


import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Random;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.BlockLocation;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.LocatedFileStatus;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.RemoteIterator;
import org.apache.hadoop.io.IOUtils;

/*
 * 手动拷贝某个特定的数据块（比如某个文件的第二个数据块）
 * 从hdfs-----hdfs
 */
public class ReadSecondaryBlock {
    public static void main(String[] args) throws IOException, InterruptedException, URISyntaxException {
        //conf
        Configuration conf=new Configuration();
        //fs
        FileSystem fs=FileSystem.get(new URI("hdfs://hadoop01:9000"),conf,"hadoop");
        //输入
        FSDataInputStream in = fs.open(new Path("/hadoop-2.7.6.tar.gz"));

        RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("/hadoop-2.7.6.tar.gz"), false);
        //System.out.println(listFiles.next().getLen());
        //System.out.println(listFiles.next().getLen());
        //数据块   给定的路径下有几个块就有几个长度
        BlockLocation[] blockLocations = listFiles.next().getBlockLocations();
        BlockLocation secondary=blockLocations[1];
        //获取第二个块 的偏移量
        long offset = secondary.getOffset();
        in.seek(offset);
        //获取第二个块的长度
        long length = secondary.getLength();
        //输出
        FSDataOutputStream out = fs.create(new Path("/hadoop_secondary_block"));
        IOUtils.copyBytes(in, out, length, true);
    }

}

六、第一个mapreduce程序:wordcount


import java.io.IOException;
import java.io.Serializable;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

/*
 * map函数做分的工作
 */
/**
 *  map这里：
 *      拆分出来的每一个单词   标记1   输出就可以   统计工作reduce上了

 * 输入：  k-v  这里的输入是框架写死的，固定的内容
 * KEYIN, 输入的键的类型   在这里指的是偏移量------指的是每一行起始的偏移量    long
 * VALUEIN:输入的值的类型，在这里指的是一行的内容     string
 * 例如，第一行：
 *  KEYIN：0
 * VALUEIN：hadoop   hadoop  spark   mllib   sqoop

 * 输出：  k-v  取决于用户的业务
 * KEYOUT, 输出的键的类型，这里指的是单词，可以允许重复   string类型
 * VALUEOUT  输出的值的类型  这里指的是1     int类型

 *序列化和反序列化
 *  数据需要持久化或网络传输的时候，需要Serializable
 所以所有map端、reduce传输的数据必须是经过序列化和反序列化的
 *hadoop中自定义了一套序列化和反序列化的接口：
 *
 为什么没有使用java中序列化反序列化方法？
 因为java中的序列化和反序列化接口Serializable（将类结构一并可进行序列化和反序列化）  过于臃肿

 序列化对应的类型
 *Writable
 *long-----longWritable
 *int-----intwritable
 *double---doublewritable
 *float-----floatwritable
 *
 *null-----nullwritable
 *string-----text
 */
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
    //重写map方法
    /**
     * key:输入的键，这里指的每一行的起始偏移量
     * value：指的输入的值，这里指的是每一行的内容，和key是对应的
     * context：上下文对象，用于传输使用的
     * 这个方法的调用频率：
     *  每行调用一次  文本中有几行就调用几次
     */
    @Override
    protected void map(LongWritable key,
            Text value, 
            Context context)
            throws IOException, InterruptedException {
        //拿到每一行的内容并且进行分割  
        //将text转化为String
        String line = value.toString();
        //拆分单词
        String[] words = line.split("\t");
        //循环遍历每一个单词，进行打标标记1，发送给reduce进行统一统计
        for(String w:words){
            Text k=new Text(w);
            IntWritable v=new IntWritable(1);
            context.write(k, v);
        }

    }

}



import java.io.IOException;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

/**
 * reduce输出结果：   单词，词频
 * 
 * reduce的输入：map输出的
 * KEYIN, map输出的key，指的就是单词      text类型
 * VALUEIN, map输出的value，指的就是1    IntWritable类型
 * 输出：最终写出到文件的

 * KEYOUT, 输出的key的类型，这里指的就是单词 这里的key是不可以重复的  text类型
 * VALUEOUT：输出的value的类型，这里指的就是总的词频   intwritable类型
 *
 */
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
    /**
     * 这个方法的调用频率：每组调用一次，有几组会调用几次
     * 分组规则：
     *  key相同的为一组
     * hello,1   hello,1 hadoop,1  hello,1
     * key:reduce输入的  这里指的是单词   每一组中的一个key
     * values：每一组中的所有value  <1,1,1>
     */
    @Override
    protected void reduce(Text key, 
            Iterable<IntWritable> values,
            Context context) throws IOException, InterruptedException {
        //进行词频统计
        int sum=0;
        //循环变遍历values   求和
        for(IntWritable v:values){
            //v.get()  这个是将intwritable转换为int
            sum+=v.get();
        }
        context.write(key, new IntWritable(sum));
    }
}


import java.io.IOException;

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.lib.input.CombineFileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.CombineTextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;


public class Driver {
    /**
     * 
     * @param args   参数封装的是程序运行过程中需要的参数
     * 运行程序的时候  传入的第一个参数  分装在args的第一个元素了  下标0   第二个参数封装在数组的第二个元素了
     * @throws IOException
     * @throws ClassNotFoundException
     * @throws InterruptedException
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        //加载配置文件
        Configuration conf=new Configuration();
        //启动一个job  一个map  reduce程序  这里叫做一个job
        Job job=Job.getInstance(conf);

        //指定job运行的主类
        job.setJarByClass(Driver.class);

        //指定这个job的mapper类和reduce类
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);

        //指定map的输出的key  和  value的类型
        //这里为什么还要指定     泛型的只在编译的时候有作用  运行会自动擦除   所以在这里需要指定一下
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        //指定reduce输出的key和value类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        //多个小文件运行的时候：  修改输入类
        job.setInputFormatClass(CombineTextInputFormat.class);
        //修改切片大小
        CombineTextInputFormat.setMinInputSplitSize(job, 130*1024*1024);

        //FileInputFormat.setMaxInputSplitSize(job, 100);//设置最大值    《128
        //FileInputFormat.setMinInputSplitSize(job, 130*1024*1024);//设置最下值     》128

        //指定输入路径   需要统计词频的路径
        CombineTextInputFormat.addInputPath(job,  new Path(args[0]));
        //FileInputFormat.addInputPath(job, new Path(args[0]));
        //添加输出路径    输出路径一定不能存在     怕如果存在会进行覆盖
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        //提交job
        job.waitForCompletion(true);
    }

}
戴戴0204
关注
专栏目录
大数据运维2--MapReduce的配置,简单的词频分析,hadoop节点的管理,搭建NFS挂载HDFS系统
朱海燕的博客日记
06-23 395
目录 MapReduce的配置(主要是给开发用的,程序呢) hadoop统计词频 移除节点 NFS配置 MapReduce的配置(主要是给开发用的,程序呢) 需要修改两个配置文件 mapred-site.xml和yarn-site.xml,在nn01节点安装之后,需要同步到其他的主机上. [root@nn01 hadoop]# cd /usr/local/hadoop/etc/hadoop/ [root@nn01 hadoop]# cp mapred-site.xm...
Hadoop学习笔记[8]-MapReduce样例程序
unlock的博客
02-15 385
Hadoop学习笔记[8]-MapReduce样例程序   写几个MR的小程序吧 1、WordCount   传说中分布式计算领域的Hello Word，就是单词计数，北京和题干就不介绍了 2、分组取Top N 要求如下 有如下的数据集： 2019-06-01 00:00:00#32 2019-05-21 00:00:00#33 2019-06-01 12:00:00#33 2019-06-02 00:00:00#31 2018-03-11 00:00:00#18 2018-04-23 00:00:00#2
hadoop经典wordcount和hdfs增加删除追加
小飞侠的博客
04-27 229
学习hadoop的经典实例，网上找了好多代码，自己做了些修改，这个例子有hadoop的wordcount和操作hdfs的全过程，已跑通。 1.RunJob。java package com.dinfo.hadoop; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.ap...
递归删除某个文件夹下的某些内容
github_35817521的博客
12-02 416
Linux实用命令
大数据系列（三）以日志为例，利用hadoop原生hdfs和MapReduce分别进行统计
璐璐璐大大少的博客
05-07 525
待定
练习HDFS的访问，创建目录，删除目录--超详细
qq_58476985的博客
09-11 1万+
2、进入到sbin目录下输入：start-dfs.sh，重启一下。4、创建的多个目录，在虚拟机上查看：hdfs dfs -ls /之后再输入hdfs dfs -ls /，没有出现拒绝连接即可。hdfs dfs -mkdir /(文件名字）
大数据介绍 Hadoop 伪分布式 完全分布式 HDFS MapReduce yarn zookeeper
嘭嘭啊啊啊的博客
08-10 1000
大数据 数据：字母 数字 声音 影像等都是数据 数据没有任何含义，仅代表一个符号。数据是信息的载体。 信息：数据经过解释加工之后，赋予一定的含义。 信息量：消除人们对不确定因素的大小 大： 1 数据量大 基于非常非常大量的数据，甚至是海量数据才能给我们带来一定的价值。 价值是从这些数据中挖掘出来的。 2.大数据的技术 在海量数据的基础上，必须产生能处理这么大数据量的技术。 大数据： 大数据（big data），是指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的数据集合，是需要新处理模式才能具有更强
华为大数据认证HCIP-Big Data Developer H13-723大数据题库
12-17
3. FusionInsightHD系统中Oozie作业提交：Oozie是一个用于管理和调度Hadoop作业的工作流管理系统，所以在提交作业前，需要上传作业依赖的配置文件和jar包到HDFS。因此，答案为A.正确。 4. DStream对象生成方法：...
[Hadoop案例 wordcount的实际操作]
努力努力再努力博客
03-09 265
** 提交 mr 作业到 yarn 上运行 wc ** 1.先编辑两个文件： [hadoop@hadoop002 hadoop-2.6.0-cdh5.7.0]$ vi a.log（先编辑一个文件保存） ruoze jepson www.ruozedata.com dashu adai fanren 1 a b c a b ...
Hadoop学习之路，YARN的配置与安装（2）
qq_42559628的博客
03-19 2237
Hadoop中YARN的配置 etc/hadoop/mapred-site.xml文件编辑 <configuration> <property> <name>mapreduce.framework.name</name> <value>yarn</value> </property> </configuration> etc/hadoop/yarn-site.xm
Hadoop -- MapReduce
Cool_Pepsi的博客
02-28 281
1. 为什么用MapReduce? 小案例： 统计HDFS的/wordcount/input 目录下所有文件中的每个单词出现的次数——wordcount 这个wordcount程序可以在任何地方运行，访问HDFS上的文件并进行统计运算，并且可以把统计的结果写回HDFS的结果文件中； 但是，进一步思考：如果文件又多又大，用上面那个程序有什么弊端？ 慢！因为只有一台机器在进行运算处理！ 如何变得更快？...
hadoop（四）——MapReduce（上）
weixin_42596778的博客
06-28 155
引入： 之前学习了hdfs，它是Hadoop的分布式存储系统，那么既然有了存储，我们就需要对存储的数据做一些操作，这就需要使用分布式计算系统MapReduce来做。 分布式计算过程： 使用统计字母个数的案例来解释计算过程 map（映射）过程： MapReduce会把HDFS中的文件切片，然后每一片对应有个MapTask线程，每个MapTask线程处理每个分片的逻辑是相同的，默认对数据进行逐行处理，每片的字母和个数以key-value的形式保存起来。 reduce（规约）阶段： 从上面可以看出，每个MapR
Hadoop 之Mapreduce wordcount词频统计案例
Dangerous的博客
08-05 7955
首先我们来看一张描述MapReduce运行过程的图。 首先input就是输入文件。 spliting:把文件按行经行拆分。 Mapping：把每行的word进行计数。 Shuffing:混洗。将相同的word分发到相同的节点。 Reduceing：对每个节点的word进行统计。 以上就是简单的Mapreduce作业过程。下面看下官网的介绍： A MapReduce job ...
Hadoop自带WordCount进行词频统计（mapreduce）
weixin_43322782的博客
12-10 8407
Hadoop自带WordCount进行词频统计 准备： 安装好的Hadoop 需要统计词频txt文件 step1 启动Hadoop cd /usr/local/hadoop ./sbin/start-all.sh 用jps命令查看是否开启成功 准备好需要统计词频的txt文件（也可以用filezilla传入Ubuntu） 链接: 如何用filezilla连接Ubuntu. 找到Hadoop文件所在位置 把需要计算词频的文件放在Hadoop文件下 step2 使用Hadoo
如何在spark中删除hdfs的某个文件夹
Landebug的博客
08-12 1万+
直接上代码 val output = new Path("hdfs://master:9000/output/"); val hdfs = org.apache.hadoop.fs.FileSystem.get( new java.net.URI("hdfs://master:9000"), new org.apache.hadoop.conf.Configuration()
Linux 删除hdfs上的指定文件夹
@羲凡—只为更好的活着
05-22 3030
@羲凡——只为了更好的活着 Linux 删除hdfs上的指定文件夹 知识点1：用 cat … | while read line 循环文件的每一行 知识点2：用 =~ 判断左边字符串是否包含右边字符串 batchid=20190520202202 hdfs dfs -ls /Data/beforeMerge/$batchid/JON* | awk '{print $8}' > file.tx...
删除hdfs上指定的文件
navy专栏
03-23 6573
package com.yc.hadoop.hdfs;import java.net.URI;import java.util.Scanner;import org.apache.hadoop.conf.Configuration;import org.apache.hadoop.fs.FileStatus;import org.apache.hadoop.fs.FileSystem;import...
VHDL 入门 01编程步骤
无数
09-26 1759
VHDL Language Structural Modeling Step1 Generate top-level entity declaration entity my_compare is port( A_IN : in std_logic_vector(2 downto 0) ; B_IN : in std_logic_vector(2 downto 0) ; EQ_OUT : out std_logic); end my_compare; step2 Decla
MapReduce实战：WordCount词频统计与HDFS应用
在本次大数据实验中，主要目标是通过MapReduce编程实践，实现对HDFS系统中多个文本文件的WordCount词频统计功能。实验内容主要包括以下几个步骤： 1. **实验准备**： - 在本地创建一个文件夹，使用`vim`命令编辑器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值