使用IDEA工具，通过Java API 操作 HDFS （文件/目录的操作，含源码，详细操作步骤）

最新推荐文章于 2024-04-01 14:33:07 发布
梁辰兴 最新推荐文章于 2024-04-01 14:33:07 发布
阅读量4.1k 收藏 72
点赞数 14
分类专栏： 大数据 文章标签： java hdfs hadoop idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/m0_62617719/article/details/128112255
版权
大数据 专栏收录该内容
23 篇文章 10 订阅
订阅专栏

文章目录

一，了解 HDFS Java API

Hadoop文件系统API文档： https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/index.html
在这里插入图片描述

（一）HDFS常见类与接口

Hadoop整合了众多文件系统，HDFS只是这个文件系统的一个实例，下表整合了一些类或接口：

类或接口功能描述
org.apache.hadoop.fs.FileSystem一个通用文件系统的抽象基类，可被分布式文件系统继承。
org.apache.hadoop.fs.FileStatus文件状态接口，用于向客户端展示系统中文件和目录的元数据。具体包括文件大小、块大小、副本信息、所有者、修改时间等，可通过FileSystem.listStatus()方法获得具体的实例对象。
org.apache.hadoop.fs.FileDataInputStream文件输入流，用于读取Hadoop文件。
org.apache.hadoop.fs.FileDataOutputStream文件输出流，用于写Hadoop文件。
org.apache.hadoop.fs.Configuration访问配置项，所有配置项的值，如果在core-site.xml中有对应的配置，则以core-site.xml为准。
org.apache.hadoop.fs.Path路径，用于表示Hadoop文件系统中的一个文件或一个目录的路径。
org.apache.hadoop.fs.PathFilter路径过滤器接口，通过实现方法PathFilter.accept(Path path)来判断

（二）FileSystem的常用方法

FileSystem类API文档： https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/filesystem/filesystem.html
在这里插入图片描述

FileSystem对象的一些方法可以对文件进行操作，如下表所示：

方法名功能描述
copyFromLocalFile(Path src, Path dst)从本地磁盘复制文件到HDFS
copyToLocalFile(Path src, Path dst)从HDFS复制文件到本地磁盘
mkdirs(Path f)建立子目录
rename(Path src, Path dst)重命名文件或文件夹
delete(Path f)删除指定文件

二，编写Java程序访问HDFS

01 创建Maven项目

创建名称为HDFSDemo的Maven项目
在这里插入图片描述
创建成功
在这里插入图片描述

02 添加相关依赖

在pom.xml文件里添加hadoop和junit依赖

1.在pox.xml文件中添加如下内容：

<dependencies>             
    <!--hadoop客户端-->                       
    <dependency>                                  
        <groupId>org.apache.hadoop</groupId>      
        <artifactId>hadoop-client</artifactId>    
        <version>3.3.4</version>                  
    </dependency>     
    <!--单元测试框架-->                            
    <dependency>                                  
        <groupId>junit</groupId>                  
        <artifactId>junit</artifactId>            
        <version>4.13.2</version>                 
    </dependency>                                 
</dependencies>

在这里插入图片描述

2.下载相关依赖到本地仓库
在这里插入图片描述3.查看下载好的依赖
在这里插入图片描述

03 创建日志属性文件

（1）在resources目录里创建log4j.properties文件

1.右击【resources】，选择【New】，单击【Resource Bundle】
在这里插入图片描述2.在弹出的对话框中输入log4j，按【ok】键，成功创建
在这里插入图片描述
3.向log4j.properties文件中添加如下内容：

log4j.rootLogger=stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/hdfs.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

在这里插入图片描述

04 启动集群HDFS服务

在主节点输入命令：start-dfs.sh
在这里插入图片描述
在Hadoop WebUI界面查看
在这里插入图片描述

05 在HDFS上创建文件

注：在HDFS Shell里利用hdfs dfs -touchz命令可以创建时间戳文件+

（1）创建net.army.hdfs包

1.右击【java】，选择【New】，单击【Package】
在这里插入图片描述2.在弹出的对话框中输入：net.army.hdfs，按下回车键，创建成功
在这里插入图片描述

（2）在net.army.hdfs包里创建CreateFileOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述2.在弹出的对话框中输入：CreateFileOnHDFS，按下回车键，创建成功
在这里插入图片描述

（3）编写create1()方法

create1()源码

@Test                                                    
public void create1() throws Exception {                 
    // 创建配置对象                                            
    Configuration conf = new Configuration();            
    // 定义统一资源标识符（uri: uniform resource identifier）       
    String uri = "hdfs://master:9000";                   
    // 创建文件系统对象（基于HDFS的文件系统）                             
    FileSystem fs = FileSystem.get(new URI(uri), conf);  
    // 创建路径对象（指向文件）                                      
    Path path = new Path(uri + "/ied01/hadoop.txt");     
    // 基于路径对象创建文件                                        
    boolean result = fs.createNewFile(path);             
    // 根据返回值判断文件是否创建成功                                   
    if (result) {                                        
        System.out.println("文件[" + path + "]创建成功！");     
    } else {                                             
        System.out.println("文件[" + path + "]创建失败！");     
    }                                                    
}

注：导包不要导错了，请仔细对照

运行程序，查看结果
在这里插入图片描述在Hadoop WebUI查看
在这里插入图片描述

（4）编写create2()方法，事先判断文件是否存在

create2()源码

@Test                                                                    
public void create2() throws Exception {                                 
    // 创建配置对象                                                            
    Configuration conf = new Configuration();                            
    // 定义统一资源标识符（uri：uniform resource identifier)                        
    String uri = "hdfs://master:9000";                                   
    // 创建文件系统对象（基于HDFS的文件系统）                                             
    FileSystem fs = FileSystem.get(new URI(uri), conf);                  
    // 创建路径对象                                                            
    Path path = new Path(uri + "/ied01/hadoop.txt");                     
    // 判断路径对象指向的文件是否存在                                                   
    if (fs.exists(path)) {                                               
        // 提示用户文件已存在                                                     
        System.out.println("文件[" + path + "]已经存在！");                     
    } else {                                                             
        // 基于路径对象创建文件                                                    
        boolean result = fs.createNewFile(path);                         
        // 根据返回值判断文件是否创建成功                                               
        if (result) {                                                    
            System.out.println("文件[" + path + "]创建成功！");                 
        } else {                                                         
            System.out.println("文件[" + path + "]创建失败！");                 
        }                                                                
    }                                                                    
}

运行程序，查看结果
在这里插入图片描述

06 写入HDFS文件

注：类似于HDFS Shell里的hdfs dfs -put命令

（1）在net.hw.hdfs包里创建WriteFileOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：WriteFileOnHDFS，按下回车键，创建成功
在这里插入图片描述

（2）将数据直接写入HDFS文件

创建write1()方法

write1()源码

@Test                                                  
public void write1() throws Exception {                
    // 创建配置对象                                          
    Configuration conf = new Configuration();          
    // 定义统一资源标识符（uri: uniform resource identifier）     
    String uri = "hdfs://master:9000";                 
    // 创建文件系统对象（基于HDFS的文件系统）                           
    FileSystem fs = FileSystem.get(new URI(uri), conf);
    // 创建路径对象（指向文件）                                    
    Path path = new Path(uri + "/ied01/hello.txt");    
    // 创建文件系统数据字节输出流（出水管：数据从程序到文件）                     
    FSDataOutputStream out = fs.create(path);          
    // 通过字节输出流向文件写数据                                   
    out.write("Hello Hadoop World".getBytes());        
    // 关闭文件系统数据字节输出流                                   
    out.close();                                       
    // 关闭文件系统对象                                        
    fs.close();                                        
    // 提示用户写文件成功                                       
    System.out.println("文件[" + path + "]写入成功！");       
}

运行write1()测试方法，查看结果，抛出RemoteException异常，三个数据节点都在运行，但是无法写入数据
在这里插入图片描述修改代码，设置数据节点主机名属性，如下图所示
在这里插入图片描述运行程序，查看结果
在这里插入图片描述在Hadoop WebUI查看hello.txt文件
在这里插入图片描述

（3）将本地文件写入HDFS文件

在项目根目录创建一个文本文件test.txt

1.右击【HDFSDemo】，选择【New】，单击【File】
在这里插入图片描述2.在弹出的对话框中输入test.txt，按下回车键，创建成功
在这里插入图片描述
3.向test.txt文件添加如下内容：

hello linux world
hello hadoop world
hello zookeeper world
hello hive world
hell hbase world

在这里插入图片描述

创建write2()方法

write2()源码

@Test                                                                          
public void write2() throws Exception {                                        
    // 创建配置对象                                                                  
    Configuration conf = new Configuration();                                  
    // 设置数据节点主机名属性                                                             
    conf.set("dfs.client.use.datanode.hostname", "true");                      
    // 定义统一资源标识符（uri: uniform resource identifier）                             
    String uri = "hdfs://master:9000";                                         
    // 创建文件系统对象（基于HDFS的文件系统）                                                   
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                
    // 创建路径对象（指向文件）                                                            
    Path path = new Path(uri + "/ied01/exam.txt");                             
    // 创建文件系统数据字节输出流（出水管：数据从程序到文件）                                             
    FSDataOutputStream out = fs.create(path);                                  
    // 创建文件字符输入流对象（进水管：数据从文件到程序）                                               
    FileReader fr = new FileReader("test.txt");                                
    // 创建缓冲字符输入流对象                                                             
    BufferedReader br = new BufferedReader(fr);                                
    // 定义行字符串变量                                                                
    String nextLine = "";                                                      
    // 通过循环遍历缓冲字符输入流                                                           
    while ((nextLine = br.readLine()) != null) {                               
        // 在控制台输出读取的行                                                          
        System.out.println(nextLine);                                          
        // 通过文件系统数据字节输出流对象写入指定文件                                               
        out.write((nextLine + "\n").getBytes());                                        
    }                                                                          
    // 关闭缓冲字符输入流                                                               
    br.close();                                                                
    // 关闭文件字符输入流                                                               
    fr.close();                                                                
    // 关闭文件系统数据字节输出流                                                           
    out.close();                                                               
    // 提示用户写入文件成功                                                              
    System.out.println("本地文件[test.txt]成功写入[" + path + "]！");                   
}

运行write2()测试方法，查看结果
在这里插入图片描述
查看/ied01/exam.txt内容，输入命令：hdfs dfs -cat /ied01/exam.txt
在这里插入图片描述

注：其实这个方法的功能就是将本地文件复制（上传）到HDFS，有没有更简单的处理方法呢？有的，通过使用一个工具类IOUtils来完成文件的相关操作。

创建write3()方法

write3()源码

@Test                                                                  
public void write3() throws Exception {                               
    // 创建配置对象                                                          
    Configuration conf = new Configuration();                          
    // 设置数据节点主机名属性                                                     
    conf.set("dfs.client.use.datanode.hostname", "true");              
    // 定义统一资源标识符（uri: uniform resource identifier）                     
    String uri = "hdfs://master:9000";                                 
    // 创建文件系统对象（基于HDFS的文件系统）                                           
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");        
    // 创建路径对象（指向文件）                                                    
    Path path = new Path(uri + "/ied01/test.txt");                     
    // 创建文件系统数据字节输出流（出水管：数据从程序到文件）                                     
    FSDataOutputStream out = fs.create(path);                          
    // 创建文件字节输入流（进水管：数据从文件到程序）                                         
    FileInputStream in = new FileInputStream("test.txt");              
    // 利用IOUtils类提供的字节拷贝方法在控制台显示文件内容                                   
    IOUtils.copyBytes(in, System.out, 1024, false);                    
    // 利用IOUtils类提供的字节拷贝方法来复制文件                                        
    IOUtils.copyBytes(in, out, conf);                                  
    // 关闭文件字节输入流                                                       
    in.close();                                                        
    // 关闭文件系统数据字节输出流                                                   
    out.close();                                                       
    // 提示用户写入文件成功                                                      
    System.out.println("本地文件[test.txt]成功写入[" + path + "]！");           
}

运行write3()测试方法，查看结果
在这里插入图片描述

在webui界面查看创建的文件，大小为0B，说明没有成功写入，是怎么肥事呢？
在这里插入图片描述原来是因为字节输入流的数据已经输出到到控制台，此时字节输入流里已经没有数据，此时执行IOUtils.copyBytes(in, out, conf);，因此输出流肯定也没有数据可以写入文件，那该怎么办呢？

那当然是再次读取文件，让字节输入流有数据。
在这里插入图片描述运行write3()方法，查看结果
在这里插入图片描述
再到webui界面，查看/ied01/test.txt文件，数据成功写入了
在这里插入图片描述

07 读取HDFS文件

注：相当于Shell里的两个命令：hdfs dfs -cat和hdfs dfs -get

（1）在net.hw.hdfs包里创建ReadFileOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：ReadFileOnHDFS，按下回车键，创建成功
在这里插入图片描述

（2）读取HDFS文件直接在控制台显示

准备读取hdfs://master:9000/ied01/test.txt文件
在这里插入图片描述创建read1()方法

read1()源码

@Test                                                                 
public void read1() throws Exception {                                
    // 创建配置对象                                                         
    Configuration conf = new Configuration();                         
    // 设置数据节点主机名属性                                                    
    conf.set("dfs.client.use.datanode.hostname", "true");             
    // 定义统一资源标识符（uri: uniform resource identifier）                    
    String uri = "hdfs://master:9000";                                
    // 创建文件系统对象（基于HDFS的文件系统）                                          
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");       
    // 创建路径对象（指向文件）                                                   
    Path path = new Path(uri + "/ied01/test.txt");                    
    // 创建文件系统数据字节输入流（进水管：数据从文件到程序）                                    
    FSDataInputStream in = fs.open(path);                             
    // 创建缓冲字符输入流，提高读取效率（字节流-->字符流-->缓冲流）                              
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    // 定义行字符串变量                                                       
    String nextLine = "";                                             
    // 通过循环遍历缓冲字符输入流                                                  
    while ((nextLine = br.readLine()) != null) {                      
        // 在控制台输出读取的行                                                 
        System.out.println(nextLine);                                 
    }                                                                 
    // 关闭缓冲字符输入流                                                      
    br.close();                                                       
    // 关闭文件系统数据字节输入流                                                  
    in.close();                                                       
    // 关闭文件系统                                                         
    fs.close();                                                       
}

运行read1()测试方法，查看结果
在这里插入图片描述其实，我们可以使用IOUtils类来简化代码，创建read2()测试方法

read2()源码

@Test                                                          
public void read2() throws Exception {                         
    // 创建配置对象                                                  
    Configuration conf = new Configuration();                  
    // 设置数据节点主机名属性                                             
    conf.set("dfs.client.use.datanode.hostname", "true");      
    // 定义统一资源标识符（uri: uniform resource identifier）             
    String uri = "hdfs://master:9000";                         
    // 创建文件系统对象（基于HDFS的文件系统）                                   
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
    // 创建路径对象（指向文件）                                            
    Path path = new Path(uri + "/ied01/test.txt");             
    // 创建文件系统数据字节输入流（进水管：数据从文件到程序）                             
    FSDataInputStream in = fs.open(path);                      
    // 读取文件在控制台显示，显示完后关闭流                                      
    IOUtils.copyBytes(in, System.out, 1024, true);             
}

运行read2()测试方法，查看结果
在这里插入图片描述

（3）读取HDFS文件，保存为本地文件

任务：将/ied01/test.txt下载到项目的download目录里

创建download目录
右击【HDFSDemo】，选择【New】，单击【Directory】，在弹出的对话框中输入：download，按下回车键，创建成功
在这里插入图片描述在这里插入图片描述
在这里插入图片描述创建read3()方法

read()3源码

@Test                                                                           
public void read3() throws Exception {                                          
    // 创建配置对象                                                                   
    Configuration conf = new Configuration();                                   
    // 设置数据节点主机名属性                                                              
    conf.set("dfs.client.use.datanode.hostname", "true");                       
    // 定义统一资源标识符（uri: uniform resource identifier）                              
    String uri = "hdfs://master:9000";                                          
    // 创建文件系统对象（基于HDFS的文件系统）                                                    
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                 
    // 创建路径对象（指向文件）                                                             
    Path path = new Path(uri + "/ied01/test.txt");                              
    // 创建文件系统数据字节输入流（进水管：数据从文件到程序）                                              
    FSDataInputStream in = fs.open(path);                                       
    // 创建文件字节输出流（出水管：数据从程序到文件）                                                  
    FileOutputStream out = new FileOutputStream("download/exam.txt");           
    // 利用IOUtils工具类读取HDFS文件（靠输入流），写入本地文件（靠输出流）                                  
    IOUtils.copyBytes(in, out, conf);                                           
    // 关闭文件字节输出流                                                                
    out.close();                                                                
    // 关闭文件系统数据字节流输入流                                                           
    in.close();                                                                 
    // 关闭文件系统                                                                   
    fs.close();                                                                 
    // 提示用户文件下载成功                                                               
    System.out.println("文件[" + path + "]下载到本地文件[download/exam.txt]！");          
}

运行read3()测试方法，查看结果
在这里插入图片描述

08 重命名目录或文件

注：相当于Shell里的hdfs dfs -mv命令

（1）在net.hw.hdfs包里创建RenameDirOrFile类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述2.在弹出的对话框中输入：RenameDirOrFile，按下回车键，创建成功
在这里插入图片描述

（2）重命名目录

任务：将/ied01目录更名为/lzy01

编写renameDir()方法

renameDir()源码

@Test                                                                                               
public void renameDir() throws Exception {                                                          
    // 创建配置对象                                                                                       
    Configuration conf = new Configuration();                                                       
    // 设置数据节点主机名属性                                                                                  
    conf.set("dfs.client.use.datanode.hostname", "true");                                           
    // 定义统一资源标识符（uri: uniform resource identifier）                                                  
    String uri = "hdfs://master:9000";                                                              
    // 创建文件系统对象（基于HDFS的文件系统）                                                                        
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                                     
    // 创建源路径对象（指向目录）                                                                                
    Path sourcePath = new Path(uri + "/ied01");                                                     
    // 创建目标路径对象（指向目录）                                                                               
    Path destinationPath = new Path(uri + "/lzy01");                                                
    // 利用文件系统对象重命名目录                                                                                
    fs.rename(sourcePath, destinationPath);                                                         
    // 关闭文件系统                                                                                       
    fs.close();                                                                                     
    // 提示用户目录更名成功                                                                                   
    System.out.println("目录[" + sourcePath.getName() + "]更名为目录[" + destinationPath.getName() + "]！");
}

运行renameDir()方法，查看结果
在这里插入图片描述在Hadoop WebUI界面查看
在这里插入图片描述

（3）重命名文件

任务：将lzy01目录下的hello.txt重命名为hi.txt

创建renameFile()方法

renameFile()源码

@Test                                                                                                      
public void renameFile() throws Exception {                                                                
    // 创建配置对象                                                                                              
    Configuration conf = new Configuration();                                                              
    // 设置数据节点主机名属性                                                                                         
    conf.set("dfs.client.use.datanode.hostname", "true");                                                  
    // 定义统一资源标识符（uri: uniform resource identifier）                                                         
    String uri = "hdfs://master:9000";                                                                     
    // 创建文件系统对象（基于HDFS的文件系统）                                                                               
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                                            
    // 创建源路径对象（指向文件）                                                                                       
    Path sourcePath = new Path(uri + "/lzy01/hello.txt");                                                  
    // 创建目标路径对象（指向文件）                                                                                      
    Path destinationPath = new Path(uri + "/lzy01/hi.txt");                                                
    // 利用文件系统对象重命名文件                                                                                       
    fs.rename(sourcePath, destinationPath);                                                                
    // 关闭文件系统                                                                                              
    fs.close();                                                                                            
    // 提示用户文件更名成功                                                                                          
    System.out.println("文件[" + sourcePath.getName() + "]更名为文件[" + destinationPath.getName() + "]！");       
}

运行renameFile()测试方法，查看结果
在这里插入图片描述在Hadoop WebUI界面查看
在这里插入图片描述

09 显示文件列表

（1）在net.hw.hdfs包里创建ListHDFSFiles类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：ListHDFSFiles，按下回车键，创建成功
在这里插入图片描述

（2）显示指定目录下文件全部信息

任务：显示/lzy01目录下的文件列表

在这里插入图片描述创建list1()方法
在这里插入图片描述文件系统对象的listFiles()方法第二个参数设置true，这样可以将/lzy01目录的一切文件，包括子目录里的文件，都一网打尽

list1()源码

@Test                                                                             
public void list1() throws Exception {                                            
    // 创建配置对象                                                                     
    Configuration conf = new Configuration();                                     
    // 设置数据节点主机名属性                                                                
    conf.set("dfs.client.use.datanode.hostname", "true");                         
    // 定义uri字符串                                                                   
    String uri = "hdfs://master:9000";                                            
    // 创建文件系统对象                                                                   
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                   
    // 创建远程迭代器对象，泛型是位置文件状态类（相当于`hdfs dfs -ls -R /lzy01`）                          
    RemoteIterator<LocatedFileStatus> ri = fs.listFiles(new Path("/lzy01"), true);
    // 遍历远程迭代器                                                                    
    while (ri.hasNext()) {                                                        
        System.out.println(ri.next());                                            
    }                                                                             
}

运行list1()测试方法，查看结果
在这里插入图片描述
上述文件状态对象封装的有关信息，可以通过相应的方法来获取，比如getPath()方法就可以获取路径信息，getLen()方法就可以获取文件长度信息……

（3）显示指定目录下文件路径和长度信息

编写list2()方法
在这里插入图片描述

list2()源码

@Test                                                                                                 
public void list2() throws Exception {                                                                
    // 创建配置对象                                                                                         
    Configuration conf = new Configuration();                                                         
    // 设置数据节点主机名属性                                                                                    
    conf.set("dfs.client.use.datanode.hostname", "true");                                             
    // 定义uri字符串                                                                                       
    String uri = "hdfs://master:9000";                                                                
    // 创建文件系统对象                                                                                       
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");                                       
    // 创建远程迭代器对象，泛型是位置文件状态类（相当于`hdfs dfs -ls -R /lzy01`）                                              
    RemoteIterator<LocatedFileStatus> ri = fs.listFiles(new Path("/lzy01"), true);                    
    // 遍历远程迭代器                                                                                        
    while (ri.hasNext()) {                                                                            
        LocatedFileStatus lfs = ri.next();                                                            
        System.out.println(lfs.getPath() + " " + lfs.getLen() + "字节");                                
    }                                                                                                 
}

运行list2()测试方法，查看结果
在这里插入图片描述对照Hadoop WebUI上给出的文件长度信息
在这里插入图片描述

10 获取文件块信息

任务：获取/lzy01/apache-hive-3.1.3-bin.tar.gz文件块信息

在这里插入图片描述
hive压缩包会分割成3个文件块
在这里插入图片描述

（1）在net.hw.hdfs包里创建GetBlockLocations类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：GetBlockLocations，按下回车键，创建成功
在这里插入图片描述

（2）用getFileBlockLocations()方法来获取物理切块信息

在这里插入图片描述

注：参数说明

  • Path p：文件路径
  • long start：起点
  • long len：长度

（3）编写代码，获取文件块信息

在这里插入图片描述

源码：

package net.army.hdfs;

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

import java.net.URI;
import java.util.Arrays;
/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：获取文件块信息
 */

public class GetBlockLocations {
    public static void main(String[] args) throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建路径对象，指向文件
        Path path = new Path("/lzy01/apache-hive-3.1.3-bin.tar.gz");
        // 获取文件块信息
        BlockLocation[] blks = fs.getFileBlockLocations(path, 0, Integer.MAX_VALUE);
        // 利用Lambda表达式遍历块信息
        Arrays.asList(blks).forEach(blk -> System.out.println(blk));
    }
}

尝试用传统for循环、增强for循环或迭代器来遍历块信息

// 利用增强for循环遍历块信息                                                   
for (BlockLocation blk : blks) {                                  
    System.out.println(blk);                                      
}    
                                                             
// 利用传统for循环遍历块信息                                                   
for (int i = 0; i < blks.length; i++) {                           
    System.out.println(blks[i]);                                  
}    
                                                             
// 利用迭代器遍历块信息                                                       
Iterator<BlockLocation> iterator = Arrays.asList(blks).iterator();  
while (iterator.hasNext()) {                                        
     System.out.println(iterator.next());                            
}

运行程序，查看结果（切点位置，块大小，块存在位置）
在这里插入图片描述
由此可见，apache-hive-3.1.3-bin.tar.gz被hive物理切分成3块，前2块长度均为134217728字节（128MB），第3块长度为58505211字节（55.80MB）。

11 创建目录

任务：在HDFS上创建/ied01目录

（1）在net.hw.hdfs包里创建MakeDirOnHDFS类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：MakeDirOnHDFS，按下回车键，创建成功
在这里插入图片描述

（2）编写代码，创建目录

源代码

package net.army.hdfs;

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

import java.net.URI;
/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：在HDFS上创建目录
 */

public class MakeDirOnHDFS {
    public static void main(String[] args) throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
        // 创建路径对象，指向目录
        Path path = new Path("/ied01");
        // 利用文件系统创建指定目录
        boolean result = fs.mkdirs(path);
        // 判断目录是否创建成功
        if (result) {
            System.out.println("目录[" + path + "]创建成功！" );
        } else {
            System.out.println("目录[" + path + "]创建失败！" );
        }
    }
}

运行程序，查看结果
在这里插入图片描述
在Hadoop WebUI界面查看
在这里插入图片描述

12 判断目录或文件是否存在

任务：判断HDFS上/ied01目录是否存在，判断/ied01/hadoop.txt文件是否存在

（1）在net.hw.hdfs包里创建DirFileExistsOrNot类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：DirFileExistsOrNot，按下回车键，创建成功
在这里插入图片描述

（2）创建dirExists()方法

在这里插入图片描述dirExists()源码

@Test                                                          
public void dirExists() throws Exception {                     
    // 创建配置对象                                                  
    Configuration conf = new Configuration();                  
    // 设置数据节点主机名属性                                             
    conf.set("dfs.client.use.datanode.hostname", "true");      
    // 定义uri字符串                                                
    String uri = "hdfs://master:9000";                         
    // 创建文件系统对象                                                
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
    // 创建路径对象，指向目录                                             
    Path path = new Path("/ied01");                            
    // 判断目录是否存在                                                
    if (fs.exists(path)) {                                     
        System.out.println("目录[" + path + "]存在！");             
    } else {                                                   
        System.out.println("目录[" + path + "]不存在！");            
    }                                                          
}

运行dirExists()方法，查看结果
在这里插入图片描述
修改代码，再测试
在这里插入图片描述在这里插入图片描述

（3）创建fileExists()方法

在这里插入图片描述fileExists()源码

@Test                                                                  
public void fileExists() throws Exception {                            
    // 创建配置对象                                                          
    Configuration conf = new Configuration();                          
    // 设置数据节点主机名属性                                                     
    conf.set("dfs.client.use.datanode.hostname", "true");              
    // 定义uri字符串                                                        
    String uri = "hdfs://master:9000";                                 
    // 创建文件系统对象                                                        
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");        
    // 创建路径对象，指向文件                                                     
    Path path = new Path("/ied01/music.txt");                          
    // 判断文件是否存在                                                        
    if (fs.exists(path)) {                                             
        System.out.println("文件[" + path + "]存在！");                     
    } else {                                                           
        System.out.println("文件[" + path + "]不存在！");                    
    }                                                                  
}

运行fileExists()方法，查看结果
在这里插入图片描述

13 判断Path指向目录还是文件

（1）在net.hw.hdfs包里创建PathToFileOrDir类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：PathToFileOrDir，按下回车键，创建成功
在这里插入图片描述

（2）编写代码，进行判断

PathToFileOrDir源码

package net.army.hdfs;

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

import java.net.URI;

/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：判断路径指向目录还是文件
 */

public class PathToFileOrDir {
    public static void main(String[] args) throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");

        // 创建路径对象，指向目录
        Path path1 = new Path("/ied08");
        if (fs.isDirectory(path1)) {
            System.out.println("[" + path1 + "]指向的是目录！");
        } else {
            System.out.println("[" + path1 + "]指向的是文件！");
        }

        // 创建路径对象，指向文件
        Path path2 = new Path("/lzy01/howard.txt");
        if (fs.isFile(path2)) {
            System.out.println("[" + path2 + "]指向的是文件！");
        } else {
            System.out.println("[" + path2 + "]指向的是目录！");
        }
    }
}

运行程序，查看结果
在这里插入图片描述结果明显不对，说明程序逻辑上有问题，原因在于/ied08目录不存在，/lzy01/howard.txt文件不存在，修改代码，加上目录或文件存在与否的判断
在这里插入图片描述运行程序，查看结果
在这里插入图片描述
修改代码，改成存在的目录和文件
在这里插入图片描述运行程序，查看结果
在这里插入图片描述

最终源码

package net.army.hdfs;

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

import java.net.URI;

/**
 * 作者：Army
 * 日期：2022/12/12
 * 功能：判断路径指向目录还是文件
 */

public class PathToFileOrDir {
    public static void main(String[] args) throws Exception {
        // 创建配置对象
        Configuration conf = new Configuration();
        // 设置数据节点主机名属性
        conf.set("dfs.client.use.datanode.hostname", "true");
        // 定义uri字符串
        String uri = "hdfs://master:9000";
        // 创建文件系统对象
        FileSystem fs = FileSystem.get(new URI(uri), conf, "root");

        // 创建路径对象，指向目录
        Path path1 = new Path("/ied01");
        if (fs.exists(path1)) {
            if (fs.isDirectory(path1)) {
                System.out.println("[" + path1 + "]指向的是目录！");
            } else {
                System.out.println("[" + path1 + "]指向的是文件！");
            }
        } else {
            System.out.println("路径[" + path1 + "]不存在！");
        }


        // 创建路径对象，指向文件
        Path path2 = new Path("/lzy01/test.txt");
        if (fs.exists(path2)) {
            if (fs.isFile(path2)) {
                System.out.println("[" + path2 + "]指向的是文件！");
            } else {
                System.out.println("[" + path2 + "]指向的是目录！");
            }
        } else {
            System.out.println("路径[" + path2 + "]不存在！");
        }
    }
}

14 删除目录或文件

注：类似于HDFS Shell里的hdfs dfs -rmdir和hdfs dfs -rm -r命令

（1）在net.hw.hdfs包里创建DeleteFileOrDir类

1.右击【net.army.hdfs】包，选择【New】，单击【Java Class】
在这里插入图片描述
2.在弹出的对话框中输入：DeleteFileOrDir，按下回车键，创建成功
在这里插入图片描述

（2）删除文件

任务：删除/lzy01/hi.txt文件

在这里插入图片描述创建deleteFile()方法
在这里插入图片描述deleteFile()源码

@Test                                                          
public void deleteFile() throws Exception {                    
    // 创建配置对象                                                  
    Configuration conf = new Configuration();                  
    // 设置数据节点主机名属性                                             
    conf.set("dfs.client.use.datanode.hostname", "true");      
    // 定义uri字符串                                                
    String uri = "hdfs://master:9000";                         
    // 创建文件系统对象                                                
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
    // 创建路径对象（指向文件）                                            
    Path path = new Path(uri + "/lzy01/hi.txt");               
    // 删除路径对象指向的文件（第二个参数表明是否递归，删除文件，不用递归）                      
    boolean result = fs.delete(path, false);                   
    // 根据返回结果提示用户                                              
    if (result) {                                              
        System.out.println("文件[" + path + "]删除成功！");           
    } else {                                                   
        System.out.println("文件[" + path + "]删除失败！");           
    }                                                          
}

运行deleteFile()测试方法，查看结果
在这里插入图片描述在Hadoop WebUI界面查看，已经没有hi.txt文件了
在这里插入图片描述再运行deleteFile()测试方法，查看结果
在这里插入图片描述
我们可以设计在删除文件之前，判断文件是否存在，需要修改代码
在这里插入图片描述
源码

@Test                                                          
public void deleteFile() throws Exception {                    
    // 创建配置对象                                                  
    Configuration conf = new Configuration();                  
    // 设置数据节点主机名属性                                             
    conf.set("dfs.client.use.datanode.hostname", "true");      
    // 定义uri字符串                                                
    String uri = "hdfs://master:9000";                         
    // 创建文件系统对象                                                
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");
    // 创建路径对象（指向文件）                                            
    Path path = new Path(uri + "/lzy01/hi.txt");               
    // 判断路径对象指向的文件是否存在                                         
    if (fs.exists(path)) {                                     
        // 删除路径对象指向的文件（第二个参数表明是否递归，删除文件，不用递归）                  
        boolean result = fs.delete(path, false);               
        // 根据返回结果提示用户                                          
        if (result) {                                          
            System.out.println("文件[" + path + "]删除成功！");       
        } else {                                               
            System.out.println("文件[" + path + "]删除失败！");       
        }                                                      
    } else {                                                   
        System.out.println("文件[" + path + "]不存在！");            
    }                                                          
}

再运行deleteFile()测试方法，查看结果
在这里插入图片描述

（3）删除目录

任务：删除/lzy01目录

编写deleteDir()方法
在这里插入图片描述deleteDir()源码

@Test                                                             
public void deleteDir() throws Exception {                        
    // 创建配置对象                                                     
    Configuration conf = new Configuration();                     
    // 设置数据节点主机名属性                                                
    conf.set("dfs.client.use.datanode.hostname", "true");         
    // 定义uri字符串                                                   
    String uri = "hdfs://master:9000";                            
    // 创建文件系统对象                                                   
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root");   
    // 创建路径对象（指向目录）                                               
    Path path = new Path(uri + "/lzy01");                         
    // 判断路径对象指向的目录否存在                                             
    if (fs.exists(path)) {                                        
        // 删除路径对象指向的目录（第二个参数表明是否递归，删除文件，要递归）                      
        boolean result = fs.delete(path, true);                   
        // 根据返回结果提示用户                                             
        if (result) {                                             
            System.out.println("目录[" + path + "]删除成功！");          
        } else {                                                  
            System.out.println("目录[" + path + "]删除失败！");          
        }                                                         
    } else {                                                      
        System.out.println("目录[" + path + "]不存在！");               
    }                                                             
}

运行deleteDir()方法，查看结果
在这里插入图片描述再运行deleteDir()方法，查看结果
在这里插入图片描述

（4）删除目录或文件

注：进行三个层面的判断：判断是否存在、判断类型（目录或文件）、判断删除是否成功

任务：删除/ied02/read.txt文件和/lzy01目录

在这里插入图片描述编写delete()方法
在这里插入图片描述
运行程序，查看结果
在这里插入图片描述
再次运行程序，查看结果
在这里插入图片描述

源码

@Test                                                           
public void delete() throws Exception {                         
    // 创建配置对象                                                   
    Configuration conf = new Configuration();                   
    // 设置数据节点主机名属性                                              
    conf.set("dfs.client.use.datanode.hostname", "true");       
    // 定义uri字符串                                                 
    String uri = "hdfs://master:9000";                          
    // 创建文件系统对象                                                 
    FileSystem fs = FileSystem.get(new URI(uri), conf, "root"); 
    // 定义随机对象                                                   
    Random random = new Random();                               
    // 产生随机整数 - [0, 1]                                          
    int choice = random.nextInt(100) % 2;                       
    // 定义路径字符串                                                  
    String[] strPath = {"/ied02/read.txt", "/lzy01"};           
    // 创建路径对象（指向目录或文件）                                          
    Path path = new Path(uri + strPath[choice]);                
    // 判断存在性                                                    
    if (fs.exists(path)) {                                      
        // 判断类型：目录或文件                                           
        String type = "";                                       
        if (fs.isDirectory(path)) {                             
            type = "目录";                                        
        } else {                                                
            type = "文件";                                        
        }                                                       
        // 删除路径对象指向的目录或文件                                       
        boolean result = fs.delete(path, true);                 
        // 判断删除是否成功                                             
        if (result) {                                           
            System.out.println(type + "[" + path + "]删除成功！");   
        } else {                                                
            System.out.println(type + "[" + path + "]删除失败！");   
        }                                                       
    } else {                                                    
        System.out.println("路径[" + path + "]不存在！");             
    }                                                           
}
【hadoop】在ieda编写创建文件夹的MapRuce程序
qq_65367204的博客
06-28 235
本次的分享就到这里，根据自己编写的过程来分享经验，希望能对你有所帮助。
IDEA连接Linux上的Hadoop并对HDFS进行操作
ahahayaa的博客
03-26 6323
完成这些步骤后，就能够从Windows机器上的IDE中成功连接到Linux服务器上的Hadoop并对HDFS进行操作。属性的值为Linux服务器的IP地址，例如hdfs://192.168.1.100:9000，然后。如果你没有该冲突问题, 并且该语句让你的程序运行出了问题, 你可以将其去掉。PS:我在上述文件中加入了以下关于slf4j冲突所以去除依赖的语句。相关问题, 如果按照预先安装中的四个步骤应该没有这个问题。: 将放在Linux上面的Hadoop压缩包(, 不需要担心软件的系统适配问题。
如何在IDEA编译器中连接HDFS，运行MapReduce程序
2401_84046545的博客
04-01 689
首先是感觉自己的基础还是不够吧，大厂好像都喜欢问这些底层原理。之前的准备只涉及了Java、Android、计网、数据结构与算法这些方面，面对面试官对其他基础课程的考察显得捉襟见肘。下一步还是要查漏补缺，进行针对性复习。最后的最后，那套资料这次一定要全部看完，是真的太全面了，各个知识点都涵盖了，几乎我面试遇到的所有问题的知识点这里面都有！希望大家不要犯和我一样的错误呀！！！一定要看完！《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！2)]
Java API实现HDFS有关目录与文件的相关功能
行秋的博客
10-24 1万+
HDFS常用操作 JavaAPI实现HDFS以下功能。 1.在HDFS中创建一个新目录； 2.从本地拷贝文件到新创建的目录中； 3.将HDFS中指定文件的内容输出到终端中； 4.显示一个指定目录下所有文件； 5.完成指定目录下指定类型文件的合并 6.在HDFS中，将文件从源路径移动到目的路径。 7.删除HDFS中指定的文件； 实验环境：IDEA 项目如下： 代码如下： 1.在HDFS中创建一个新目录； import org....
idea Java API 操作 HDFS
qq_35911309的博客
03-21 738
下载windows下连接hadoop需要的文件hadoop.dll和winutils.exe(https://github.com/D:\hadoop-3.3.4\etc\hadoop\hadoop-env.cmd文件修改。下载apache-hadoop-3.1.1-winutils-master)(因program file 有空格。用PROGRA~1代替)hadoop tar包解压。
Hadoop——HDFS文件系统的Java API操作（上传、下载、查看、删除、创建文件）详细教学
热门推荐
小袁同学的博客
11-21 2万+
如果还没有配置好Hadoop的可以点击链接查看如何配置 各大技术基础教学、实战开发教学（正在持续更新中······） 首先，启动Hadoop集群服务 然后在浏览器访问Hadoop，点击Browse the file system 查看HDFS文件系统的目录 可以看到目前HDFS文件系统的目录是空的，没有任何的文件和文件夹，下面开始今天的API操作 一、创建Maven项目 首先，打开IDEA，点击新建项目，在左侧中选择Maven，然后直接点击next 设置项目名称，点...
使用Java Api操作HDFS过程详解
08-25
主要介绍了使用Java Api操作HDFS过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
使用Java API操作HDFS分布式文件系统
04-11
分布式文件系统hdfs 使用Java API操作HDFS分布式文件系统
java操作Hadoop源码之HDFS Java API操作-创建目录
01-17
java操作Hadoop源码之HDFS Java API操作-创建目录，附带所需全部jar包，欢迎下载学习。
HDFS两种操作方式：命令行和Java API
01-07
本节将介绍 Linux 操作系统中关于 HDFS 文件操作的常用命令行，并将介绍利用 Hadoop 提供的 Java API 进行基本的文件操作，以及利用 Web 界面查看和管理 HDFS 的方法。 HDFS 常用命令 在 Linux 命令行终端，可以...
基于Java的Hadoop分布式文件系统API操作设计源码
最新发布
06-07
本项目为“基于Java的Hadoop分布式文件系统API操作设计源码”，包含51个文件，其中包括37个Java源文件、10个XML配置文件、2个Properties配置文件、1个Gitignore忽略配置文件、1个Markdown文档。该系统利用Java语言...
intellij idea hdfs plugin
06-12
intellij idea hdfs plugin。 基于intellij idea 2018.1和 Hadoop2.6编译。亲测可用。 使用方法：直接安装本地插件。
【简单易懂版】使用IDEA操作Hadoop（增删改查）
GSCY
07-17 1651
在IDEA中使用JAVA代码操作Hadoop完成增删改查，上传、下载基础功能
IDEA使用HDFS的JavaApi
向之 所欣
12-29 782
注释@Before的作用是在后续每次测试方法之前先执行此方法，进行资源初始化。@Before// 用于初始化HDFS配置，执行打开资源的操作System.out.println("打开资源初始化完成！");// 如果是无参构造函数，那么将加载默认的配置文件//获取FileSystem实例//对于文件的操作都会在 hdfs://user/root/ 文件夹下进行1）关于Configuration。
使用java API 操作
m0_63560941的博客
11-28 1137
了解HDFS Java API掌握使用Java API操作HDFS
HBase Java API使用IDEA开发
04-15 1834
双击打开pom.xml文件 这里把springboot 版本更换为2.3.5.RELEASE。三、编写Hbase操作工具类（创建表空间，表，添加数据，查询数据，修改数据，删除数据）加入hbase client 的支持包，这里版本需要跟服务器上安装的版本号一致。1.从windows本地读取文件写入Hbase。二、使用maven管理jar包。一、使用IDEA创建项目。
java使用idea操作HDFS
m0_48830183的博客
10-10 2486
java和hdfs
IDEA连接hadoop hdfs
jiey0407的博客
08-30 3653
进入一下界面， 搜索重启IDEA。
使用javaAPI对HDFS进行文件上传，下载，新建文件及文件夹删除，遍历所有文件
weixin_72949830的博客
10-20 3031
使用javaAPI对HDFS进行文件上传，下载，新建文件及文件夹删除，遍历所有文件
使用 Java API 操作 HDFS,并创建一个 /user/hadoop/test 目录。
04-04
以下是使用 Java API 操作 HDFS 并创建 /user/hadoop/test 目录的示例代码： ```java import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; public class HdfsExample { public static void main(String[] args) throws Exception { Configuration conf = new Configuration(); conf.set("fs.defaultFS", "hdfs://localhost:9000"); // 设置 HDFS 地址 FileSystem fs = FileSystem.get(conf); // 获取 HDFS 文件系统对象 Path path = new Path("/user/hadoop/test"); if (!fs.exists(path)) { // 判断目录是否存在 fs.mkdirs(path); // 创建目录 System.out.println("创建目录成功：" + path); } else { System.out.println("目录已存在：" + path); } fs.close(); // 关闭文件系统对象 } } ``` 注意：需要添加 Hadoop 依赖包到项目中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
写文章

热门文章

  • JavaScript 教程 （详细 全面） 72390
  • MySQL 视图（详解） 50216
  • Notepad++ 下载与安装教程 48330
  • Redis和Redis可视化管理工具的下载和安装 33845
  • ECharts 下载与安装教程 30271

分类专栏

  • 信息咨询（信息系统工程） 付费 8篇
  • Redis 14篇
  • CSS 31篇
  • Echarts 11篇
  • 数据结构 学习笔记 9篇
  • Java 复习笔记 18篇
  • HTML 前端基础 36篇
  • git 学习笔记 2篇
  • Linux 学习笔记 2篇
  • 大数据处理 26篇
  • 企业级开发 22篇
  • JavaScript 编程基础 75篇
  • 1+X 大数据应用开发（Java）理论题库 5篇
  • React 学习笔记 5篇
  • Ajax 入门基础 9篇
  • Vue 简要学习 11篇
  • Bootstrap 45篇
  • Shell 初步了解 14篇
  • Docker 入门基础 7篇
  • Django 编程基础 20篇
  • JSON 编程基础 16篇
  • Python 编程基础 100篇
  • 计算机 基础知识 15篇
  • 大数据 23篇
  • Java 课程任务 27篇
  • Java 练习题 4篇
  • MySQL 34篇
  • 网络攻防 学习笔记 22篇
  • 移动应用开发 12篇
  • eNSP 4篇
  • Python 编程练习 119篇
  • 软件安装 29篇
  • HTML 实例 3篇

最新评论

  • JavaScript 教程 （详细 全面）

    廖老师小课堂开课了: 干货满满，实用性强，博主的写作风格简洁明了，让人一目了然。文章涵盖了很多实用的知识点。【我也写了一些相关领域的文章，希望能够得到博主的指导，共同进步！】

  • Rational rose 2007 下载和安装教程

    A19_8710_: 太有用啦

  • JavaScript 教程 （详细 全面）

    只有安静心灵才会丰富（敲代码不要听音乐）: 我觉得还是叫livescript更好

  • JavaScript 教程 （详细 全面）

    保尔-科查筋: "typeof(null)==object说明null是object的一个特殊值"这里不恰当，真实原因：https://blog.csdn.net/qq_38290251/article/details/133221598

  • JavaScript 教程 （详细 全面）

    保尔-科查筋: 文中有点不恰当，JavaScript不是面向对象而是基于对象，因为不能像静态语言那样实现纯粹的继承和多态，只能通过原型链模拟出继承关系。

您愿意向朋友推荐“博客详情页”吗？

  • 强烈不推荐
  • 不推荐
  • 一般般
  • 推荐
  • 强烈推荐
提交

最新文章

  • 第八章 信息系统集成
  • 第七章 信息系统维护与管理
  • 2024年 四川省专升本 成绩排名、招生院校和可报专业查询方法
2024年11篇
2023年389篇
2022年552篇
2021年197篇

目录

目录

评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

梁辰兴

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

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

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

打赏作者

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

抵扣说明：

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

余额充值

聚圣源排名第一壮阳药延时效果好起名字大全女孩起名周易在线起名大全永田晴康温泉酒店起名三才五格起名法什么是通假字中华周易研究会免费起名网站外媒为袁隆平集体刷屏男孩新生宝宝起名赵氏起的男孩名字大全五金机电店铺起名大全红婶给学校起姓名酒起名字大全翻来覆去的意思厨房十大品牌庶难从命西安新生儿起名哪里有李胎儿起名大全免费起名13画的字的注册果蔬企业起名圆周长的计算公式起名禁用字笔仙惊魂2姓卢的男孩起什么名字法师起什么名字殊途同归的意思彩色空间留言360注册表瘦身淀粉肠小王子日销售额涨超10倍罗斯否认插足凯特王妃婚姻让美丽中国“从细节出发”清明节放假3天调休1天男孩疑遭霸凌 家长讨说法被踢出群国产伟哥去年销售近13亿网友建议重庆地铁不准乘客携带菜筐雅江山火三名扑火人员牺牲系谣言代拍被何赛飞拿着魔杖追着打月嫂回应掌掴婴儿是在赶虫子山西高速一大巴发生事故 已致13死高中生被打伤下体休学 邯郸通报李梦为奥运任务婉拒WNBA邀请19岁小伙救下5人后溺亡 多方发声王树国3次鞠躬告别西交大师生单亲妈妈陷入热恋 14岁儿子报警315晚会后胖东来又人满为患了倪萍分享减重40斤方法王楚钦登顶三项第一今日春分两大学生合买彩票中奖一人不认账张家界的山上“长”满了韩国人？周杰伦一审败诉网易房客欠租失踪 房东直发愁男子持台球杆殴打2名女店员被抓男子被猫抓伤后确诊“猫抓病”“重生之我在北大当嫡校长”槽头肉企业被曝光前生意红火男孩8年未见母亲被告知被遗忘恒大被罚41.75亿到底怎么缴网友洛杉矶偶遇贾玲杨倩无缘巴黎奥运张立群任西安交通大学校长黑马情侣提车了西双版纳热带植物园回应蜉蝣大爆发妈妈回应孩子在校撞护栏坠楼考生莫言也上北大硕士复试名单了韩国首次吊销离岗医生执照奥巴马现身唐宁街 黑色着装引猜测沈阳一轿车冲入人行道致3死2伤阿根廷将发行1万与2万面值的纸币外国人感慨凌晨的中国很安全男子被流浪猫绊倒 投喂者赔24万手机成瘾是影响睡眠质量重要因素春分“立蛋”成功率更高？胖东来员工每周单休无小长假“开封王婆”爆火：促成四五十对专家建议不必谈骨泥色变浙江一高校内汽车冲撞行人 多人受伤许家印被限制高消费

聚圣源 XML地图 TXT地图 虚拟主机 SEO 网站制作 网站优化