hdfsShell

已于 2024-04-10 16:23:25 修改
阅读量260 收藏 6
点赞数 6
文章标签： java
于 2024-04-10 15:23:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xbdbbss/article/details/137598722
版权 
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import java.io.IOException;

public class HShell implements Tool {

    public static void main(String[] args) {
        // 程序的入口点，使用ToolRunner来运行HShell实例
        int res = ToolRunner.run(new Configuration(), new HShell(), args);
        // 退出程序，并返回运行结果
        System.exit(res);
    }

    @Override
    public int run(String[] args) throws Exception {
        // 检查是否提供了足够的参数
        if (args.length < 2) {
            System.out.println("用法：HShell <命令> [选项] <参数>");
            return -1;
        }

        // 命令行参数中的第一个参数是命令
        String command = args[0];
        // 剩余的参数是选项和参数，创建一个新的数组来存储它们
        String[] options = new String[args.length - 1];
        System.arraycopy(args, 1, options, 0, options.length);

        // 根据命令执行相应的操作
        try {
            switch (command) {
                case "-cp":
                    // 拷贝文件命令
                    if (options.length < 2) {
                        System.out.println("用法：-cp <本地路径> <HDFS路径>");
                        return -1;
                    }
                    // 调用拷贝文件的方法
                    copyFile(options[0], options[1]);
                    break;
                case "-rm":
                    // 删除文件或目录命令
                    if (options.length < 1) {
                        System.out.println("用法：-rm [路径]");
                        return -1;
                    }
                    // 检查是否有递归删除目录的选项
                    if ("-r".equals(options[0])) {
                        deleteDirectory(options[1]);
                    } else {
                        deleteFile(options[0]);
                    }
                    break;
                case "-cp -r":
                    // 递归拷贝目录命令
                    if (options.length < 2) {
                        System.out.println("用法：-cp -r <本地目录路径> <HDFS路径>");
                        return -1;
                    }
                    // 调用递归拷贝目录的方法
                    copyDirectory(options[0], options[1]);
                    break;
                case "-list":
                    // 列出文件或目录信息命令
                    if (options.length < 1) {
                        System.out.println("用法：-list <路径>");
                        return -1;
                    }
                    // 调用列出路径信息的方法
                    listPath(options[0]);
                    break;
                case "-mv":
                    // 移动或重命名文件命令
                    if (options.length < 2) {
                        System.out.println("用法：-mv <源路径> <目标路径>");
                        return -1;
                    }
                    // 调用移动文件的方法
                    moveFile(options[0], options[1]);
                    break;
                case "-find":
                    // 递归查找文件命令
                    if (options.length < 2) {
                        System.out.println("用法：-find <文件名> <目录>");
                        return -1;
                    }
                    // 调用查找文件的方法
                    findFile(options[0], options[1]);
                    break;
                default:
                    // 如果命令未知，则打印错误信息
                    System.out.println("未知命令：" + command);
                    return -1;
            }
        } catch (Exception e) {
            // 打印异常堆栈信息，并返回错误代码
            e.printStackTrace();
            return -1;
        }
        // 如果没有异常发生，返回成功代码
        return 0;
    }
    
    

    // 私有方法，用于实现文件拷贝逻辑
private void copyFile(String localPath, String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    // 创建本地文件系统和HDFS的输入输出流对象
    FSDataInputStream in = null;
    FSDataOutputStream out = null;

    try {
        // 打开本地文件的输入流
        in = fs.open(new Path(localPath));
        // 打开HDFS文件的输出流
        out = fs.create(new Path(hdfsPath));

        // 缓冲区用于存储从输入流读取的数据
        byte[] buffer = new byte[8192];
        int bytesRead;

        // 循环读取本地文件并写入到HDFS
        while ((bytesRead = in.read(buffer)) > 0) {
            out.write(buffer, 0, bytesRead);
        }

        // 文件拷贝完成，刷新输出流
        out.hflush();
    } finally {
        // 关闭流资源
        if (in != null) {
            in.close();
        }
        if (out != null) {
            out.close();
        }
        // 关闭FileSystem对象
        fs.close();
    }
}

    

    
    
    // 私有方法，用于实现文件删除逻辑
private void deleteDirectory(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = private void deleteFile(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查文件是否存在
        if (fs.exists(new Path(hdfsPath))) {
            // 删除文件
            boolean result = fs.delete(new Path(hdfsPath), false);
            if (result) {
                System.out.println("文件 " + hdfsPath + " 已成功删除。");
            } else {
                System.out.println("无法删除文件 " + hdfsPath);
            }
        } else {
            System.out.println("文件 " + hdfsPath + " 不存在。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}FileSystem.get(conf);

    try {
        // 检查目录是否存在
        if (fs.exists(new Path(hdfsPath))) {
            // 递归删除目录及其所有子目录和文件
            boolean result = fs.delete(new Path(hdfsPath), true);
            if (result) {
                System.out.println("目录 " + hdfsPath + " 及其所有内容已成功删除。");
            } else {
                System.out.println("无法删除目录 " + hdfsPath);
            }
        } else {
            System.out.println("目录 " + hdfsPath + " 不存在。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

    
    

    // 私有方法，用于实现目录删除逻辑
private void deleteDirectory(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查目录是否存在
        if (fs.exists(new Path(hdfsPath))) {
            // 递归删除目录及其所有子目录和文件
            boolean result = fs.delete(new Path(hdfsPath), true);
            if (result) {
                System.out.println("目录 " + hdfsPath + " 及其所有内容已成功删除。");
            } else {
                System.out.println("无法删除目录 " + hdfsPath);
            }
        } else {
            System.out.println("目录 " + hdfsPath + " 不存在。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}    private void deleteDirectory(String hdfsPath) throws IOException {
        // 这里应该实现使用FileSystem API的目录删除逻辑
    }

    

    // 私有方法，用于实现目录拷贝逻辑
private void copyDirectory(String localDirPath, String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);
    // 获取本地文件系统
    FileSystem localFs = FileSystem.getLocal(conf);

    try {
        // 检查本地目录是否存在
        if (!localFs.exists(new Path(localDirPath))) {
            System.out.println("本地目录 " + localDirPath + " 不存在。");
            return;
        }

        // 检查HDFS目标路径是否存在，如果存在且为文件则抛出异常
        if (fs.exists(new Path(hdfsPath)) && !fs.isDirectory(new Path(hdfsPath))) {
            throw new IOException("目标路径 " + hdfsPath + " 已存在，且是一个文件。");
        }

        // 递归拷贝目录
        FileStatus[] statuses = localFs.listStatus(new Path(localDirPath));
        for (FileStatus status : statuses) {
            Path localPath = status.getPath();
            Path hdfsTargetPath = new Path(hdfsPath, localPath.toUri().relativize(localPath.toUri().getPath()));

            if (status.isDirectory()) {
                // 创建HDFS目录
                fs.mkdirs(hdfsTargetPath);
            } else {
                // 拷贝文件内容
                InputStream in = null;
                OutputStream out = null;
                try {
                    in = localFs.open(localPath);
                    out = fs.create(hdfsTargetPath);
                    IOUtils.copyBytes(in, out, conf);
                } finally {
                    IOUtils.closeStream(in);
                    IOUtils.closeStream(out);
                }
            }
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
        localFs.close();
    }
}

    
 
    // 私有方法，用于实现列出文件或目录信息的逻辑
private void listPath(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查指定路径是否存在
        if (!fs.exists(new Path(hdfsPath))) {
            System.out.println("指定的路径 " + hdfsPath + " 不存在。");
            return;
        }

        // 获取指定路径下的文件和目录信息
        FileStatus[] fileStatuses = fs.listStatus(new Path(hdfsPath));

        // 遍历FileStatus数组并打印信息
        for (FileStatus fileStatus : fileStatuses) {
            String output = StringUtils.format("- " + fileStatus.getPath() + "  " + fileStatus.getLen() + " bytes");
            System.out.println(output);
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

    // 私有方法，用于实现文件移动或重命名逻辑
private void moveFile(String srcPath, String destPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查源文件是否存在
        if (!fs.exists(new Path(srcPath))) {
            System.out.println("源文件 " + srcPath + " 不存在。");
            return;
        }

        // 尝试移动文件到目标路径
        boolean result = fs.rename(new Path(srcPath), new Path(destPath));
        if (result) {
            System.out.println("文件 " + srcPath + " 已成功移动到 " + destPath + "。");
        } else {
            System.out.println("无法移动文件 " + srcPath + " 到 " + destPath + "。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

private void findFile(String fileName, String directory) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 构建要查找的文件的Path对象
        Path targetPath = new Path(directory, fileName);

        // 获取目录列表
        FileStatus[] listStatus = fs.listStatus(targetPath);

        // 遍历目录列表，查找匹配的文件
        for (FileStatus fileStatus : listStatus) {
            Path currentPath = fileStatus.getPath();
            // 如果找到文件且文件名匹配，则输出文件路径
            if (currentPath.getName().equals(fileName) && !fileStatus.isDirectory()) {
                System.out.println("找到文件: " + currentPath);
            }
            // 如果当前路径是目录，则递归查找该目录下匹配的文件
            else if (fileStatus.isDirectory()) {
                findFile(fileName, currentPath.toString());
            }
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.*;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
import java.io.IOException;

public class HShell implements Tool {

    public static void main(String[] args) {
        // 程序的入口点，使用ToolRunner来运行HShell实例
        int res = ToolRunner.run(new Configuration(), new HShell(), args);
        // 退出程序，并返回运行结果
        System.exit(res);
    }

    @Override
    public int run(String[] args) throws Exception {
        // 检查是否提供了足够的参数
        if (args.length < 2) {
            System.out.println("用法：HShell <命令> [选项] <参数>");
            return -1;
        }

        // 命令行参数中的第一个参数是命令
        String command = args[0];
        // 剩余的参数是选项和参数，创建一个新的数组来存储它们
        String[] options = new String[args.length - 1];
        System.arraycopy(args, 1, options, 0, options.length);

        // 根据命令执行相应的操作
        try {
            switch (command) {
                case "-cp":
                    // 拷贝文件命令
                    if (options.length < 2) {
                        System.out.println("用法：-cp <本地路径> <HDFS路径>");
                        return -1;
                    }
                    // 调用拷贝文件的方法
                    copyFile(options[0], options[1]);
                    break;
                case "-rm":
                    // 删除文件或目录命令
                    if (options.length < 1) {
                        System.out.println("用法：-rm [路径]");
                        return -1;
                    }
                    // 检查是否有递归删除目录的选项
                    if ("-r".equals(options[0])) {
                        deleteDirectory(options[1]);
                    } else {
                        deleteFile(options[0]);
                    }
                    break;
                case "-cp -r":
                    // 递归拷贝目录命令
                    if (options.length < 2) {
                        System.out.println("用法：-cp -r <本地目录路径> <HDFS路径>");
                        return -1;
                    }
                    // 调用递归拷贝目录的方法
                    copyDirectory(options[0], options[1]);
                    break;
                case "-list":
                    // 列出文件或目录信息命令
                    if (options.length < 1) {
                        System.out.println("用法：-list <路径>");
                        return -1;
                    }
                    // 调用列出路径信息的方法
                    listPath(options[0]);
                    break;
                case "-mv":
                    // 移动或重命名文件命令
                    if (options.length < 2) {
                        System.out.println("用法：-mv <源路径> <目标路径>");
                        return -1;
                    }
                    // 调用移动文件的方法
                    moveFile(options[0], options[1]);
                    break;
                case "-find":
                    // 递归查找文件命令
                    if (options.length < 2) {
                        System.out.println("用法：-find <文件名> <目录>");
                        return -1;
                    }
                    // 调用查找文件的方法
                    findFile(options[0], options[1]);
                    break;
                default:
                    // 如果命令未知，则打印错误信息
                    System.out.println("未知命令：" + command);
                    return -1;
            }
        } catch (Exception e) {
            // 打印异常堆栈信息，并返回错误代码
            e.printStackTrace();
            return -1;
        }
        // 如果没有异常发生，返回成功代码
        return 0;
    }
    
    

    // 私有方法，用于实现文件拷贝逻辑
private void copyFile(String localPath, String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    // 创建本地文件系统和HDFS的输入输出流对象
    FSDataInputStream in = null;
    FSDataOutputStream out = null;

    try {
        // 打开本地文件的输入流
        in = fs.open(new Path(localPath));
        // 打开HDFS文件的输出流
        out = fs.create(new Path(hdfsPath));

        // 缓冲区用于存储从输入流读取的数据
        byte[] buffer = new byte[8192];
        int bytesRead;

        // 循环读取本地文件并写入到HDFS
        while ((bytesRead = in.read(buffer)) > 0) {
            out.write(buffer, 0, bytesRead);
        }

        // 文件拷贝完成，刷新输出流
        out.hflush();
    } finally {
        // 关闭流资源
        if (in != null) {
            in.close();
        }
        if (out != null) {
            out.close();
        }
        // 关闭FileSystem对象
        fs.close();
    }
}

    

    
    
    // 私有方法，用于实现文件删除逻辑
private void deleteDirectory(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = private void deleteFile(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查文件是否存在
        if (fs.exists(new Path(hdfsPath))) {
            // 删除文件
            boolean result = fs.delete(new Path(hdfsPath), false);
            if (result) {
                System.out.println("文件 " + hdfsPath + " 已成功删除。");
            } else {
                System.out.println("无法删除文件 " + hdfsPath);
            }
        } else {
            System.out.println("文件 " + hdfsPath + " 不存在。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}FileSystem.get(conf);

    try {
        // 检查目录是否存在
        if (fs.exists(new Path(hdfsPath))) {
            // 递归删除目录及其所有子目录和文件
            boolean result = fs.delete(new Path(hdfsPath), true);
            if (result) {
                System.out.println("目录 " + hdfsPath + " 及其所有内容已成功删除。");
            } else {
                System.out.println("无法删除目录 " + hdfsPath);
            }
        } else {
            System.out.println("目录 " + hdfsPath + " 不存在。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

    
    

    // 私有方法，用于实现目录删除逻辑
private void deleteDirectory(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查目录是否存在
        if (fs.exists(new Path(hdfsPath))) {
            // 递归删除目录及其所有子目录和文件
            boolean result = fs.delete(new Path(hdfsPath), true);
            if (result) {
                System.out.println("目录 " + hdfsPath + " 及其所有内容已成功删除。");
            } else {
                System.out.println("无法删除目录 " + hdfsPath);
            }
        } else {
            System.out.println("目录 " + hdfsPath + " 不存在。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}    private void deleteDirectory(String hdfsPath) throws IOException {
        // 这里应该实现使用FileSystem API的目录删除逻辑
    }

    

    // 私有方法，用于实现目录拷贝逻辑
private void copyDirectory(String localDirPath, String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);
    // 获取本地文件系统
    FileSystem localFs = FileSystem.getLocal(conf);

    try {
        // 检查本地目录是否存在
        if (!localFs.exists(new Path(localDirPath))) {
            System.out.println("本地目录 " + localDirPath + " 不存在。");
            return;
        }

        // 检查HDFS目标路径是否存在，如果存在且为文件则抛出异常
        if (fs.exists(new Path(hdfsPath)) && !fs.isDirectory(new Path(hdfsPath))) {
            throw new IOException("目标路径 " + hdfsPath + " 已存在，且是一个文件。");
        }

        // 递归拷贝目录
        FileStatus[] statuses = localFs.listStatus(new Path(localDirPath));
        for (FileStatus status : statuses) {
            Path localPath = status.getPath();
            Path hdfsTargetPath = new Path(hdfsPath, localPath.toUri().relativize(localPath.toUri().getPath()));

            if (status.isDirectory()) {
                // 创建HDFS目录
                fs.mkdirs(hdfsTargetPath);
            } else {
                // 拷贝文件内容
                InputStream in = null;
                OutputStream out = null;
                try {
                    in = localFs.open(localPath);
                    out = fs.create(hdfsTargetPath);
                    IOUtils.copyBytes(in, out, conf);
                } finally {
                    IOUtils.closeStream(in);
                    IOUtils.closeStream(out);
                }
            }
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
        localFs.close();
    }
}

    
 
    // 私有方法，用于实现列出文件或目录信息的逻辑
private void listPath(String hdfsPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查指定路径是否存在
        if (!fs.exists(new Path(hdfsPath))) {
            System.out.println("指定的路径 " + hdfsPath + " 不存在。");
            return;
        }

        // 获取指定路径下的文件和目录信息
        FileStatus[] fileStatuses = fs.listStatus(new Path(hdfsPath));

        // 遍历FileStatus数组并打印信息
        for (FileStatus fileStatus : fileStatuses) {
            String output = StringUtils.format("- " + fileStatus.getPath() + "  " + fileStatus.getLen() + " bytes");
            System.out.println(output);
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

    // 私有方法，用于实现文件移动或重命名逻辑
private void moveFile(String srcPath, String destPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 检查源文件是否存在
        if (!fs.exists(new Path(srcPath))) {
            System.out.println("源文件 " + srcPath + " 不存在。");
            return;
        }

        // 尝试移动文件到目标路径
        boolean result = fs.rename(new Path(srcPath), new Path(destPath));
        if (result) {
            System.out.println("文件 " + srcPath + " 已成功移动到 " + destPath + "。");
        } else {
            System.out.println("无法移动文件 " + srcPath + " 到 " + destPath + "。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

    // 私有方法，用于实现递归查找文件的逻辑
private void moveFile(String srcPath, String destPath) throws IOException {
    // 创建Hadoop的配置对象
    Configuration conf = new Configuration();
    // 获取FileSystem对象
    FileSystem fs = FileSystem.get(conf);

    try {
        // 构建源文件和目标文件的Path对象
        Path src = new Path(srcPath);
        Path dest = new Path(destPath);

        // 检查源文件是否存在
        if (!fs.exists(src)) {
            System.out.println("源文件 " + srcPath + " 不存在。");
            return;
        }

        // 尝试移动文件到目标路径
        if (fs.rename(src, dest)) {
            System.out.println("文件已成功从 " + srcPath + " 移动到 " + destPath + "。");
        } else {
            System.out.println("移动文件失败，文件可能已被移动或删除。");
            throw new IOException("无法移动文件从 " + srcPath + " 到 " + destPath + "。");
        }
    } finally {
        // 关闭FileSystem对象
        fs.close();
    }
}

xbdbbss
关注
hdfs shell操作
m0_72168501的博客
11-23 5908
hdfs 的shell 操作
HDFS shell
JAX_fire的博客
07-30 391
f覆盖目标文件下（已存在下）
实验二：HDFS shell操作
qq_63525511的博客
10-16 395
（1）向HDFS中上传XXX.txt文件(2)查看HDFS中制定文件的内容（3）显示HDFS中制定文件的读写权限、大小、创建时间、路径等信息。根据提供的文件路径，这是一个名为"杨海军.txt"的文件。该文件的权限为"rw-r--r--"，表示文件所有者具有读写权限，而文件所有者所在的组和其他用户只有读取权限。文件大小为313字节，并且最后修改时间为2023年10月16日19:08。(4)从HDFS中下载第（1）步上传XXX.txt文件，并本地文件系统查看下载文件内容。1、在桌面打开终端。
HDFS Shell
Vincent_Li
02-21 439
HDFS shell
hdfs shell
weixin_63548495的博客
04-28 958
hadoop fs -cat 输出 ;hadoop fs -count 计数;hadoop fs -cp 拷贝;
HDFS Shell命令练习
大头皮鞋的博客
03-21 4285
前提条件 拥有hadoop2环境，可参考：CentOS7安装hadoop2.7.3伪分布式 步骤 hdfs常用的操作命令是dfs命令。 查看hdfs dfs所有命令 [hadoop@node1 ~]$ hdfs dfs Usage: hadoop fs [generic options] [-appendToFile <localsrc> ... <dst>] [-cat [-ignoreCrc] <src> ...] [-che
HDFS shell操作
Z_Data的博客
09-21 281
在HDFS的几种常见访问方式中，命令行操作方式是最常用的，所以一定要熟练掌握这种访问方式。
常用hdfs shell命令操作
糯米君的博客
01-10 1026
hdfs shell常用命令
HDFS SHELL 操作命令
qq_67829861的博客
05-12 331
（5），把Hadoop安装目录下share/doc/hadoop/images目录中的所有文件上传到picture目录中。（2)，读本地myfile文件的数据内容并追加到HDFS中的myinfo.txt文件中。（6），把picture目录中的所有.jpg图片移到子目录myphoto中保存。（4），把Hadoop安装目录中的README.txt文件上传到doc目录中。（8），删除picture目录中的所有后缀名为png的文件。（7），统计picture目录中的所有文件的总个数。
HDFS Shell基本命令
亦萧的博客
07-18 640
转载自：http://hadoop.apache.org/docs/r1.0.4/cn/hdfs_shell.html
HDFSShell命令综合练习.pdf
07-11
在Hadoop分布式文件系统(HDFS)的管理中，Shell命令是操作HDFS的基本工具，用于执行文件和目录的创建、查看、上传、下载、复制、移动、删除等操作。以下是对HDFS Shell命令的详细解释： 1. **创建文件夹**： 使用`...
实验二、HDFS shell操作及HDFS Java API编程
04-10
适合刚接触hadoop的学生或小白，内容包括HDFS shell操作及HDFS Java API编程 有图片有代码
HDFS shell
11-08
为了更好地管理和操作HDFS中的数据，用户可以使用HDFS Shell命令行工具来执行各种文件操作。 HDFS Shell包含了一组丰富的命令，使得用户能够像操作本地文件系统一样操作HDFS中的文件和目录。这组命令包括但不限于：...
HDFS Shell命令应用数管2101李怡然2021012073(1).docx
04-06
HDFS Shell 命令应用 HDFS（Hadoop Distributed File System）是 Hadoop 项目中的一个分布式文件系统，提供了高可靠性、高可扩展性和高性能的存储解决方案。HDFS 使用 Shell 命令来管理和操作文件系统。下面将从 ...
工厂模式的介绍及实现
户伟伟的博客
09-25 73
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 496
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 205
BI商业智能：数据可视化、报表可视化系统。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 693
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
最新发布
y050505的博客
09-25 411
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值