import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.*;

import org.apache.hadoop.fs.FileSystem;

 

import java.io.*;

 

public class CopyToLocal {

     /**

     * 下载文件到本地 判断本地路径是否已存在，若已存在，则自动进行重命名

     */

    public static void copyToLocal(Configuration conf, String remoteFilePath,

            String localFilePath) {

        Path remotePath = new Path(remoteFilePath);

        try (FileSystem fs = FileSystem.get(conf)) {

            File f = new File(localFilePath);

            /* 如果文件名存在，自动重命名(在文件名后面加上 _0, _1 ...) */

            if (f.exists()) {

                System.out.println(localFilePath + " 已存在.");

                Integer i = Integer.valueOf(0);

                while (true) {

                    f = new File(localFilePath + "_" + i.toString());

                    if (!f.exists()) {

                        localFilePath = localFilePath + "_" + i.toString();

                        break;

                    } else {

                        i++;

                        continue;

                    }

                }

                System.out.println("将重新命名为: " + localFilePath);

            }

            // 下载文件到本地

            Path localPath = new Path(localFilePath);

            fs.copyToLocalFile(remotePath, localPath);

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

 

    /**

     * 主函数

     */

    public static void main(String[] args) {

        Configuration conf = new Configuration();

        conf.set("fs.defaultFS", "hdfs://localhost:9000");

        String localFilePath = "/usr/local/hadoop/test.txt"; // 本地路径

        String remoteFilePath = "/user/hadoop/test.txt"; // HDFS路径

 

        try {

            CopyToLocal.copyToLocal(conf, remoteFilePath, localFilePath);

            System.out.println("下载完成");

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

 

}

实验内容目录
(1)向HDFS上传任意文本文件，如果指定的文件在HDFS中已经存在，由用户指定是追加到原有文件末尾还是覆盖原有的文件；
(2)从HDFS中下载指定文件，如果本地文件与要下载的文件名称相同，则自动对下载的文件重命名；
(3)将HDFS中指定文件的内容输出到终端中；
(4)显示HDFS中指定的文件的读写权限、大小、创建时间、路径等信息；
(5)给定HDFS中某一个目录，输出该目录下的所有文件的读写权限、大小、创建时间、路径等信息，如果该文件是目录，则递归输出该目录下所有文件相关信息；
(6)提供一个HDFS内的文件的路径，对该文件进行创建和删除操作。如果文件所在目录不存在，则自动创建目录；
(7)在HDFS中，将文件从源路径移动到目的路径。

(1)向HDFS上传任意文本文件，如果指定的文件在HDFS中已经存在，由用户指定是追加到原有文件末尾还是覆盖原有的文件；

相关代码如下

	public int FileUpload() throws IOException{
		FileSystem fs=FileSystem.get(conf);	
		if(!fs.exists(new Path(dst_path))){//HDFS判断是否存在
		    System.out.println("file not exist");
			fs.copyFromLocalFile(false, new Path(scr_filename), new Path(dst_path));//不存在
		}else{//存在
			System.out.print("the file"+scr_filename+" exists on HDFS,do you want (a)ppend or (o)verwrite?");
			Scanner input=new Scanner(System.in);
			String s=input.next();		
			if(s.equalsIgnoreCase("o")){
				System.out.println("overwrite");
				fs.copyFromLocalFile(false, true, new Path(scr_filename), new Path(dst_path));
			}else if(s.equalsIgnoreCase("a")){
				System.out.println("append");					
				FileInputStream in=new FileInputStream(scr_filename);		
				FSDataOutputStream app_f=fs.append(new Path(dst_path));	
				byte[] data=new byte[1024];
		    	int read=-1;   	
		    	while((read=in.read(data))>0){
		    		app_f.write(data,0,read);
		    	}		    	
		    	in.close();
			}	
			input.close();
		}
		return 0;
	}

elipse中的代码截图效果



我创建了append.txt和secondwork.txt（secondwork.txt里面的内容是mango,hello!）

这里显示我创建的append.txt的内容



运行结果如下



我选择了“a” append，就是将“/usr/local/hadoop/append.txt”追加到原有文件secondwork.txt中，如图所示


(2)从HDFS中下载指定文件，如果本地文件与要下载的文件名称相同，则自动对下载的文件重命名；

相关代码如下

public int download(String HDFS_scr_path,String Local_dst_path) throws IOException{	
		File dstFile=new File(Local_dst_path+HDFS_scr_path);		
		FileSystem  fs=FileSystem.get(conf);	
		if(!dstFile.exists()){
			fs.copyToLocalFile(new Path(HDFS_scr_path), new Path(Local_dst_path));		
		}
		else{
			fs.rename(new Path(HDFS_scr_path), new Path(HDFS_scr_path+"001"));
			fs.copyToLocalFile(new Path(HDFS_scr_path+"001"), new Path(Local_dst_path));
			fs.rename(new Path(HDFS_scr_path+"001"), new Path(HDFS_scr_path));
		}		
		return 0;
	}

elipse中的代码截图效果



将HDFS中的secondwork.txt下载到usr//local//hadoop路径下的filework.txt中，cat命令查看filework.txt中的内容如图所示


(3)将HDFS中指定文件的内容输出到终端中；

相关代码如下

public int PrintFile(String HDFS_src_path) throws IOException{
        FileSystem fs=FileSystem.get(conf);	
		FSDataInputStream in=fs.open(new Path(HDFS_src_path));
		
		byte[] data=new byte[1024];
    	int read=-1;
    	PrintStream ps=new PrintStream(System.out);
    	while((read=in.read(data))>0){
    		ps.write(data,0,read);		
    	}
    	in.close();
    	ps.close();
		return 0;
	}

elipse中的代码截图效果



执行结果如图，HDFS中指定文件“secondfile.txt”的内容输出到终端中


(4)显示HDFS中指定的文件的读写权限、大小、创建时间、路径等信息；

相关代码如下

public int PrintFileInfo(String HDFS_path) throws IOException{
		 FileSystem fs=FileSystem.get(URI.create(HDFS_path),conf);
		
		 FileStatus[] status=fs.listStatus(new Path(HDFS_path));
		 for(FileStatus sta:status){
		    	System.out.println("path:"+sta.getPath()+" file size:"+sta.getLen()+" privilesge:"+ sta.getPermission()+"create time:"+sta.getModificationTime());
		 }
		return 0;
	}

elipse中的代码截图效果



查看http://localhost:50070里面/user/hadoop/路径下secondfile.txt的相关信息



运行结果如下，显示了HDFS中指定的文件的读写权限、大小、创建时间、路径等信息 （其中的create time:1588584595493指的是从1970年1月1日格林威治天文台零时起到今天所经历的秒数）


(5)给定HDFS中某一个目录，输出该目录下的所有文件的读写权限、大小、创建时间、路径等信息，如果该文件是目录，则递归输出该目录下所有文件相关信息；

相关代码如下

public int ListDir(String path) throws IOException{
		 FileSystem fs=FileSystem.get(URI.create(path),conf);
		 //递归获取目录下的所有文件
			 RemoteIterator<LocatedFileStatus> files = fs.listFiles(new Path(path),true);
			 while(files.hasNext()){
				 LocatedFileStatus file=files.next();
				 String isDir = file.isDirectory() ? "文件夹" : "文件";
				 String permission = file.getPermission().toString();
		            short replication = file.getReplication();
		            long length = file.getLen();
		            String file_path = file.getPath().toString();
		            System.out.println(isDir + "\t" + permission + "\t" + replication + "\t" + length + "\t" + file_path);
			 }		
		return 0;
	}

elipse中的代码截图效果



运行结果如图，显示了给定HDFS中“/user//hadoop//”目录，输出/user//hadoop//目录下的所有文件的读写权限、大小、创建时间、路径等信息



查看http://localhost:50070里面/user/hadoop/路径下的相关信息如图所示


(6)提供一个HDFS内的文件的路径，对该文件进行创建和删除操作。如果文件所在目录不存在，则自动创建目录；

相关代码如下

public int CreateFile(String path) throws IOException{
		 FileSystem fs=FileSystem.get(URI.create(path),conf);
		 if(!fs.exists(new Path(path))){
			 fs.mkdirs(new Path(path));
		 }
		// fs.create(new Path(path));
		 System.out.println("file created");
		 System.out.println("Do you want to delete this file?Y/N");
		 
		 Scanner input=new Scanner(System.in);
		 if(input.next().equalsIgnoreCase("Y")){
			 fs.delete(new Path(path),false);
		 }
		 input.close();
		return 0;
	}	

elipse中的代码截图效果



运行结果如图，自动创建了/user/hadoop/mango目录下的mangowork.txt文本文件



“Do you want to delete this file?Y/N”选择“Y”，会删掉我们刚才在/user//hadoop//mango//路径下创建的mangowork.txt文件


(7)在HDFS中，将文件从源路径移动到目的路径。

相关代码如下

	public int moveFile(String sourceFile,String DstPath) throws IOException{
		FileSystem srcfile=FileSystem.get(URI.create(sourceFile),conf);
		FileSystem dstfile=FileSystem.get(URI.create(DstPath),conf);
		 if(srcfile.exists(new Path(sourceFile))){
			 FileUtil.copy(srcfile, new Path(sourceFile), dstfile, new Path(DstPath), true, conf);
		 }
		return 0;
	}

elipse中的代码截图效果



运行结果如图，可以看见/user//hadoop//目录下的secondwork.txt文件移动到了input1目录下



整体代码如下
类HDFSFileExam中代码
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.URI;
import java.security.acl.Permission;
import java.util.Scanner;
import java.io.File;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.FileUtil;
import org.apache.hadoop.fs.LocatedFileStatus;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.RemoteIterator;

public class HDFSFileExam {
   private Configuration conf;
   private String scr_filename;
   private String dst_path;
   
   HDFSFileExam(String scr_filename,String Dst_path){
   	this.scr_filename=scr_filename;
   	this.dst_path=Dst_path;
   }
   
   void init(){
   	conf=new Configuration();
   	conf.set("fs.defaultFS","hdfs://localhost:9000");
       conf.set("fs.hdfs.impl","org.apache.hadoop.hdfs.DistributedFileSystem");
       conf.set("dfs.client.block.write.replace-datanode-on-failure.policy", "NEVER");   //解决append异常
   }
   
   public int FileUpload() throws IOException{
   	FileSystem fs=FileSystem.get(conf);	
   	if(!fs.exists(new Path(dst_path))){//HDFS判断是否存在
   	    System.out.println("file not exist");
   		fs.copyFromLocalFile(false, new Path(scr_filename), new Path(dst_path));//不存在
   	}else{//存在
   		System.out.print("the file"+scr_filename+" exists on HDFS,do you want (a)ppend or (o)verwrite?");
   		Scanner input=new Scanner(System.in);
   		String s=input.next();		
   		if(s.equalsIgnoreCase("o")){
   			System.out.println("overwrite");
   			fs.copyFromLocalFile(false, true, new Path(scr_filename), new Path(dst_path));
   		}else if(s.equalsIgnoreCase("a")){
   			System.out.println("append");					
   			FileInputStream in=new FileInputStream(scr_filename);		
   			FSDataOutputStream app_f=fs.append(new Path(dst_path));	
   			byte[] data=new byte[1024];
   	    	int read=-1;   	
   	    	while((read=in.read(data))>0){
   	    		app_f.write(data,0,read);
   	    	}		    	
   	    	in.close();
   		}	
   		input.close();
   	}
   	return 0;
   }

   public int download(String HDFS_scr_path,String Local_dst_path) throws IOException{
   	
   	File dstFile=new File(Local_dst_path+HDFS_scr_path);		
   	FileSystem  fs=FileSystem.get(conf);	
   	if(!dstFile.exists()){
   		fs.copyToLocalFile(new Path(HDFS_scr_path), new Path(Local_dst_path));		
   	}
   	else{
   		fs.rename(new Path(HDFS_scr_path), new Path(HDFS_scr_path+"001"));
   		fs.copyToLocalFile(new Path(HDFS_scr_path+"001"), new Path(Local_dst_path));
   		fs.rename(new Path(HDFS_scr_path+"001"), new Path(HDFS_scr_path));
   	}
   	
   	return 0;
   }
   
   public int PrintFile(String HDFS_src_path) throws IOException{
       FileSystem fs=FileSystem.get(conf);	
   	FSDataInputStream in=fs.open(new Path(HDFS_src_path));
   	
   	byte[] data=new byte[1024];
   	int read=-1;
   	PrintStream ps=new PrintStream(System.out);
   	while((read=in.read(data))>0){
   		ps.write(data,0,read);		
   	}
   	in.close();
   	ps.close();
   	return 0;
   }
   
   public int PrintFileInfo(String HDFS_path) throws IOException{
   	 FileSystem fs=FileSystem.get(URI.create(HDFS_path),conf);
   	
   	 FileStatus[] status=fs.listStatus(new Path(HDFS_path));
   	 for(FileStatus sta:status){
   	    	System.out.println("path:"+sta.getPath()+" file size:"+sta.getLen()+" privilesge:"+ sta.getPermission()+"create time:"+sta.getModificationTime());
   	 }
   	return 0;
   }
   
   public int ListDir(String path) throws IOException{
   	 FileSystem fs=FileSystem.get(URI.create(path),conf);
   	 //递归获取目录下的所有文件
   		 RemoteIterator<LocatedFileStatus> files = fs.listFiles(new Path(path),true);
   		 while(files.hasNext()){
   			 LocatedFileStatus file=files.next();
   			 String isDir = file.isDirectory() ? "文件夹" : "文件";
   			 String permission = file.getPermission().toString();
   	            short replication = file.getReplication();
   	            long length = file.getLen();
   	            String file_path = file.getPath().toString();
   	            System.out.println(isDir + "\t" + permission + "\t" + replication + "\t" + length + "\t" + file_path);
   		 }		
   	return 0;
   }

   public int CreateFile(String path) throws IOException{
   	 FileSystem fs=FileSystem.get(URI.create(path),conf);
   	 if(!fs.exists(new Path(path))){
   		 fs.mkdirs(new Path(path));
   	 }
   	// fs.create(new Path(path));
   	 System.out.println("file created");
   	 System.out.println("Do you want to delete this file?Y/N");
   	 
   	 Scanner input=new Scanner(System.in);
   	 if(input.next().equalsIgnoreCase("Y")){
   		 fs.delete(new Path(path),false);
   	 }
   	 input.close();
   	return 0;
   }
   
   public int moveFile(String sourceFile,String DstPath) throws IOException{
   	FileSystem srcfile=FileSystem.get(URI.create(sourceFile),conf);
   	FileSystem dstfile=FileSystem.get(URI.create(DstPath),conf);
   	 if(srcfile.exists(new Path(sourceFile))){
   		 FileUtil.copy(srcfile, new Path(sourceFile), dstfile, new Path(DstPath), true, conf);
   	 }
   	return 0;
   }
}


类HDFSBookWork 中代码

import java.io.IOException;

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

public class HDFSBookWork {

	/**
	 * @param args
	 * @throws IOException 
	 */
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		HDFSFileExam  fo=new HDFSFileExam("/usr/local/hadoop/append.txt","secondwork.txt");
		fo.init();
	   // fo.FileUpload();
	    //fo.download("secondwork.txt", "/usr//local//hadoop//filework.txt/");
	    //fo.PrintFile("secondwork.txt");
	    //fo.PrintFileInfo("secondwork.txt");
		//fo.ListDir("/user//hadoop//");
		//fo.CreateFile("/user//hadoop//mango//mangowork.txt");
		//fo.moveFile("/user//hadoop//secondwork.txt", "/user//hadoop//input1");
	}
}

elipse中的代码截图效果



完成！

操作题目+命令实现

（1）向 HDFS 中上传任意文本文件，如果指定的文件在 HDFS 中已经存在，由用户指定是追加到原有文件末尾还是覆盖原有的文件；





（2）从 HDFS  中下载指定文件，如果本地文件与要下载的文件名称相同，则自动对下载的文件重命名；





（3）将 HDFS 中指定文件的内容输出到终端中；



（4）显示HDFS 中指定的文件的读写权限、大小、创建时间、路径等信息；



（5）给定 HDFS  中某一个目录，输出该目录下的所有文件的读写权限、大小、创建时间、路径等信息，如果该文件是目录，则递归输出该目录下所有文件相关信息；



（6）提供一个 HDFS  内的文件的路径，对该文件进行创建和删除操作。如果文件所在目录不存在，则自动创建目录；



（7）提供一个 HDFS 的目录的路径，对该目录进行创建和删除操作。创建目录时， 如果目录文件所在目录不存在则自动创建相应目录；删除目录时，由用户指定当该目录不为空时是否还删除该目录；



（8）向 HDFS  中指定的文件追加内容，由用户指定内容追加到原有文件的开头或结尾；



若把a放到b的头部，则先将b放到a尾部，再将a复制给b

（9）删除HDFS 中指定的文件；



（10）删除HDFS 中指定的目录，由用户指定目录中如果存在文件时是否删除目录；



（11）在 HDFS 中，将文件从源路径移动到目的路径。



源代码
package cn.itcast.bigdata.hdfs;

import java.net.URI;//获取互联网资料
import java.text.SimpleDateFormat;
import java.util.Scanner;
import java.io.*;

import org.apache.hadoop.conf.Configuration;//配置文件
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileStatus;
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;
public class hadoopAPI {
	**//删除文件**
		public static void rmdir(String filePath) throws IOException {
			//读取配置文件
			Configuration conf = new Configuration();
			//获取文件系统
			FileSystem fs = FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
			Path path = new Path(filePath);
			
			//调用deleteOnExit(）
			boolean flag = fs.deleteOnExit(path);
			//	fs.delete(path);
			if(flag) {
				 System.out.println("delete ok!");
			}else {
				 System.out.println("delete failure");
			}
			
			//关闭文件系统
			fs.close();
		}
		**//添加到文件末尾**
		public static void appendFile(String src,String dst) throws IOException{
			Configuration conf = new Configuration();
			FileSystem fs = FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
			Path dstPath = new Path(dst);
			InputStream in = new BufferedInputStream(new FileInputStream(src));
			FSDataOutputStream out = fs.append(dstPath);
			IOUtils.copyBytes(in,out,4096,true);
			//fs.close();
		}
		**//本地文件上传到hdfs**
		public static void uploadFile(String src,String dst) throws IOException{
			Configuration conf = new Configuration();
			FileSystem fs = FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
			Path srcPath = new Path(src);//原路径
			Path dstPath = new Path(dst);//目标路径
			//判断是否存在相同名称的文件
			if(!fs.exists(dstPath))//不存在，直接复制
			{
				fs.copyFromLocalFile(false,srcPath, dstPath);//（false不删除本地文件；true删除本地文件，原路径，目标路径）
			}
			else//若存在，由用户选择上传方式
			{
			    System.out.println("请选择 1覆盖原文件；2追加到文件末尾");
			    Scanner in=new Scanner(System.in); 
			    int x=in.nextInt();
			    if(x==1)
			    {
					fs.copyFromLocalFile(false,srcPath, dstPath);
			    }
				else if(x==2)
					appendFile(src,dst);
			}
			System.out.println("上传成功！");
		}
		**//文件重命名**
			public static void rename(String oldname,String newname) throws IOException{
			     	Configuration conf = new Configuration();
					FileSystem fs = FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					Path oldPath = new Path(oldname);
					Path newPath = new Path(newname);
				
					boolean flag = fs.rename(oldPath,newPath);
					if(flag){
						System.out.println("rename ok!");
					}else{
						System.out.println("rename fail!");
					}
				}
				**//文件下载**
				public static void download(String oldPath,String newPath) throws IOException{
					Configuration conf = new Configuration();
					FileSystem fs = FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					Path ofile = new Path(oldPath);
					File nfile=new File(newPath);
					FSDataInputStream in = fs.open(ofile);
					if(!nfile.exists())
					{
						FileOutputStream out =  new FileOutputStream(nfile);
						IOUtils.copyBytes(in,out,2048,true);
					}
					else{
						Scanner sc=new Scanner(System.in); 
						System.out.println("文件存在，修改名称:");
					    String new2=sc.next();
					    File newfile = new File(new2);
						FileOutputStream out = new FileOutputStream(newfile);
						IOUtils.copyBytes(in,out,2048,true);
					}
					System.out.println("Dowmload success!");
				}
				 **//文件内容输出到终端**
				public static void readFile(String uri) throws IOException{
					Configuration conf = new Configuration();
					FileSystem fs = FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					InputStream in = null;
					try{
						in = fs.open(new Path(uri));
						IOUtils.copyBytes(in,System.out,4096,false);
						System.out.println("show succeed!");
					}catch(Exception e){
						e.printStackTrace();
					}finally{
						IOUtils.closeStream(in);
					}
				}
				**//显示文件大小、权限、创建时间、权限等**
				public static void answer4(String remote) throws IOException{
					Configuration conf = new Configuration();
					FileSystem fs = FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					FileStatus[] status = fs.listStatus(new Path(remote));
					for(FileStatus s:status){
						System.out.println("文件大小："+s.getBlockSize());
						System.out.println("文件权限："+s.getPermission());
						System.out.println("文件路径："+s.getPath());
						long time = s.getModificationTime();
						SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						String data = format.format(time);
						System.out.println("文件创建时间："+data);
					}
				}
				**//显示所有文件大小、权限、创建时间、权限等**
				public static void allfile(String remote) throws IOException{
					Configuration conf = new Configuration();
					FileSystem fs =FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					RemoteIterator<LocatedFileStatus> iterator = fs.listFiles(new Path(remote),true);
					while(iterator.hasNext())
					{
						FileStatus status = iterator.next();
						System.out.println("文件大小为："+status.getBlockSize());
						System.out.println("文件路径为："+status.getPath());
						System.out.println("文件的权限为："+status.getPermission());
						long time =status.getModificationTime();
						SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						String data = format.format(time);
						System.out.println("文件创建时间："+data);
					}
				}
				**//创建文件**
				public static void mk(String upremote,String remote) throws IOException{
					Configuration conf = new Configuration();
					FileSystem fs =FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					Path a = new Path(upremote);
					Path b = new Path(remote);
					if(!fs.exists(a))
					{
						System.out.println("路径不存在，即将进行创建");
						fs.mkdirs(a);
						FSDataOutputStream out = fs.create(b);
						out.close();
						System.out.println("文件创建成功！");
					}else{
						System.out.println("路径存在，即将创建目标文件");
						FSDataOutputStream out = fs.create(b);
						out.close();
						System.out.println("文件创建成功！");
					}
				}
				**//删除文件，由用户指定删除目录不为空时，是否还进行删除**
				public static void rm(String remote) throws IOException{
					Configuration conf = new Configuration();
					FileSystem fs =FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					Path a = new Path(remote);
					FileStatus[] status = fs.listStatus(a);
					if(status.length>0)
					{
						System.out.println("文件目录不为空，请选择 1继续删除 2不删除");
						Scanner in = new Scanner(System.in);
						int x=in.nextInt();
					    if(x==1)
					    {
							fs.delete(a,true);
							System.out.println("目录已经删除");
					    }
						else if(x==2)
						{
							System.out.println("未做任何操作！");
						}	
					}
				}	
				**//向指定文件指定位置追加指定内容**
				public static void addword(String prefile,String addfile) throws IOException{
					Configuration conf = new Configuration();
					FileSystem fs =FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					Path a = new Path(prefile);
					Path b = new Path(addfile);
						System.out.println("选择添加位置，请选择 1末尾 2头部");
						Scanner in = new Scanner(System.in);
						int x = in.nextInt();
						if(x==1)
						{
							appendFile(addfile,prefile);
							System.out.println("ok!");
						}
						else if(x==2)
						{
							String temp="/usr/local/hadoop/guodu1";
							download(prefile,temp);//先下载到本地
							fs.copyFromLocalFile(true,b,a);
							appendFile(temp,prefile);	
							System.out.println("ok!");
						}
					}		
				**//在hdfs中进行文件的移动**
				public static void removeinhdfs(String prepath,String newpath) throws IOException{
					Configuration conf = new Configuration();
				    FileSystem fs =FileSystem.get(URI.create("hdfs://localhost:9000"),conf);
					Path a = new Path(prepath);
					Path b = new Path(newpath);
					if(fs.rename(a,b))
					{
						System.out.println("移动成功");
					}
				}
		**//主函数**
		public static void main(String[] args) throws IOException{
			//rmdir("lwx/l.text");
			//uploadFile("/usr/local/hadoop/lwx1.txt","lwx/lwx1.txt");
			//download("lwx/lwx.text","/usr/local/hadoop/lwx.text");
			//readFile("lwx/lwx.text");
			//answer4("lwx/lwx.text");
			//allfile("lwx");
			//mk("lwx/lwx1","lwx/lwx1/l.text");
			//rm("lwx/lwx1");
			//addword("lwx/lwx.text","/usr/local/hadoop/lwx2.text");
			removeinhdfs("lwx/lwx.text","input");
		}
		


}

简单的HDFS操作
文章目录
简单的HDFS操作
HDFS常用Shell命令
使用HDFS的Shell命令
输出HDFS某一个目录下所有文件详细信息
向HDFS中上传任意文本文件
将HDFS中指定文件的内容输出到终端
从HDFS中下载指定文件
删除HDFS中指定的文件
HDFS常用JavaAPI
使用HDFS的JavaAPI
创建工程并导入JAR包
向HDFS上传任意文本文件
从HDFS下载指定文件
参考文章

HDFS常用Shell命令
操作 HDFS的 Shell命令有三种：

hadoop fs （适用于任何不同的文件系统，比如本地文件系统和 HDFS文件系统）
hadoop dfs （只适用于 HDFS文件系统）
hdfs dfs （只适用于 HDFS文件系统）

官方并不推荐使用第二种命令 hadoop dfs，有些 Hadoop版本中已将这种命令弃用。
Shell命令语法如下

hadoop fs [genericOptions] [commandOptions]





HDFS常用命令
说明




hadoop fs -ls 
显示指定文件的详细信息


hadoop fs -cat 
将指定文件的内容输出到标准输出


hadoop fs touchz 
创建一个指定的空文件


hadoop fs -mkdir [-p] 
创建指定的一个或多个文件夹，-p选项用于递归创建


hadoop fs -cp 
将文件从源路径复制到目标路径


hadoop fs -mv 
将文件从源路径移动到目标路径


hadoop fs -rm 
删除指定的文件，只删除非空目录和文件


hadoop fs -rm -r 
删除指定的文件夹及其下的所有文件，-r表示递归删除子目录


hadoop fs -chown 
改变指定文件的所有者为，该命令仅适用于超级用户


hadoop fs -chmod 
将指定的文件权限更改为，该命令仅适用于超级用户和文件所有者


hadoop fs -get 
复制指定的文件到本地文件系统指定的文件或文件夹


hadoop fs -put 
从本地文件系统中复制指定的单个或多个源文件到指定的目标文件系统


hadoop fs -moveFromLocal 
与put命令功能相同，但是文件上传结束后会删除源文件


hadoop fs -copyFromLocal 
将本地源文件复制到路径指定的文件或文件夹中


hadoop fs -copyToLocal 
将目标文件复制到本地文件或文件夹中


使用HDFS的Shell命令
输出HDFS某一个目录下所有文件详细信息
我的 Hadoop版本为 Hadoop3.1.3。首先，我们先开启 Hadoop集群
cd $HADOOP_HOME
./sbin/start-dfs.sh

如果没有配置环境变量 HADOOP_HOME，请把上面命令中的 HADOOP_HOME改成你本地 Hadoop的安装位置。


第一次使用HDFS时，需要首先在HDFS中创建用户目录。我们建立用户目录/user/hadoop。

./bin/hdfs dfs –mkdir –p /user/hadoop

用户目录的名字自己可以随意拟定，因为我现在使用的用户名是 hadoop，所以我的用户目录顺便也叫 hadoop。
用户目录建立完成后，所有的操作都会在用户目录上进行。也就是说，现在用户目录就是当前 HDFS默认的操作路径。例如，我们在 HDFS直接上建立文件夹 test，它的绝对路径是 /user/hadoop/test。
//下面两个命令等价
./bin/hdfs dfs –mkdir test
./bin/hdfs dfs –mkdir /user/hadoop/test

我们在用户目录下建立input和output文件夹，并创建一个abc.txt文件。
./bin/hdfs dfs -mkdir input output
./bin/hdfs dfs touchz abc.txt


我们现在可以查看用户目录下所有文件的读写权限、大小、创建时间、路径等信息。

./bin/hdfs dfs -ls .


向HDFS中上传任意文本文件
我们在本地 home目录中创建一个 myFile.txt文件，使用 vim编辑文件。
cd ~
touch myFile.txt
vim myFile.txt

按 “i” 键进入编辑模式，随便往文件里输入一些字母，比如
hadoop
spark
flink

然后按 “esc” 键，输入“:wq”保存并退出。


然后我们使用 put命令，把 myFile.txt文件上传到 HDFS用户目录的 input文件夹中。
cd $HADOOP_HOME
./bin/hdfs dfs -put ~/myLocalFile.txt  input

我们可以使用 ls命令查看一下文件是否成功上传到HDFS中

./bin/hdfs dfs –ls input


可以看到，myFile.txt文件已经在 input文件夹中。
将HDFS中指定文件的内容输出到终端
我们使用 cat命令即可查看 HDFS中 myFile.txt文件的内容

./bin/hdfs dfs -cat input/myFile.txt


从HDFS中下载指定文件
我们使用 get命令将刚才上传的 myFile.txt文件下载到本地 home/Videos目录中

./bin/hdfs dfs -get input/myFile.txt  ~/Videos

同样地，使用 ls命令查看是否下载成功
cd ~/Videos
ls


删除HDFS中指定的文件
我们使用 rm 命令删除 input文件夹，以及该文件夹下的所有文件
cd $HADOOP_HOME
./bin/hdfs dfs -rm -r input

然后用 ls命令查看用户目录，判断是否删除成功

./bin/hdfs dfs -ls .


HDFS常用JavaAPI
Hadoop本身使用 Java语言编写的，Hadoop不同的文件系统之间可以通过调用 JavaAPI来进行交互。Shell命令本质上就是 JavaAPI的应用。




HDFS常用 JavaAPI
说明




org.apache.hadoop.fs.FileSystem
一个通用文件系统的抽象基类，可以被分布式文件系统继承。所有可能使用 Hadoop文件系统的代码都要使用这个类。


org.apache.hadoop.fs.FileStatus
一个接口，用于向客户端展示系统中文件和目录的元数据，具体包括文件大小、块大小、副本信息、所有者、修改时间等。


org.apache.hadoop.fs.FSDataInputStream
文件输入流，用于读取 Hadoop文件


org.apache.hadoop.fs.FSDataOutputStream
文件输入流，用于写 Hadoop文件


org.apache.hadoop.conf.Configuration
访问配置项


org.apache.hadoop.fs.Path
用于表示 Hadoop文件系统中的一个文件或一个目录的路径


使用HDFS的JavaAPI
创建工程并导入JAR包
这里我们使用的是 Ubuntu16.04系统，IDE是 Eclipse。如果没有在 Ubuntu系统上安装 Eclipse的，请参考这篇博客进行安装 Ubuntu16.04系统安装Eclipse
启动 Eclipse，在菜单栏选择 “File”->“New”->“Java Project”，创建新的 Java项目。


根据个人喜好输入工程名称，这里我们输入“HDFS_Practice”。勾选“Use default location”，让工程文件保存在我们设置的 Eclipse的工作区里。JRE部分选择“Use a project specific JRE”，使用我们自己安装的 JDK版本。然后点击“next”，进入下一步。


我们需要为项目导入必要的 JAR包，这些 JAR包中包含了可以访问 HDFS的 Java API。JAR包的位置在“Hadoop安装目录/share/hadoop”目录下。比如我的是在“/usr/local/hadoop/share/hadoop”目录下，下面的操作中请选择到自己配置的 hadoop目录下导入 JAR包。
我们点击标题栏的“Libraries”，点击“Add Externtal JARs”


在新的弹窗中，我们通过选择上面的文件目录，进入“/usr/local/hadoop/share/hadoop”目录，记住是进入自己的Hadoop安装目录。


我们需要向 Java工程中添加以下 JAR包：

“/usr/local/hadoop/share/hadoop/common”目录下的所有 JAR包，即 hadoop-common-3.1.3.jar、hadoop-common-3.1.3-tests.jar、haoop-nfs-3.1.3.jar和、haoop-kms-3.1.3.jar，不包括 jdiff、lib、sources、webapps四个文件夹。
“/usr/local/hadoop/share/hadoop/common/lib”目录下的所有 JAR包
“/usr/local/hadoop/share/hadoop/hdfs”目录下的所有 JAR包。同样地，不包括 jdiff、lib、sources、webapps四个文件夹。
“/usr/local/hadoop/share/hadoop/hdfs/lib”目录下的所有 JAR包

我们分四次操作，把需要的 JAR包全部导入进来（lib目录下的 JAR包太多，我们可以使用 Ctrl+A快捷键进行全选）。所需的 JAR包全部添加完毕以后，我们点击右下角的“Finish”，完成 Java工程的创建。


如果是第一次使用 Eclipse来操作 HDFS，我们还需要去关闭 HDFS的权限检测。因为 HDFS的权限检测机制默认是打开的，未关闭的时候，不能使用 eclipse插件对 HDFS上的文件进行操作，比如上传，删除等。我们先关闭 HDFS服务，然后在 hdfs-site.xml文件中加入一个变量 dfs.permissions，值设置为 false，用来其关闭权限检测。
我们先进入 home folder（也就是文件管理器），点击右上角的更多按钮，选择“Enter Location”


然后弹出的搜索框中输入“hadoop安装目录/etc/hadoop”，回车进入目录，然后找到 hdfs-site.xml，鼠标右键点击文件，选择“Open with”->“vim”进行编辑。


输入以下代码并保存。
<property>
    <name>dfs.permissions</name>
    <value>false</value>
</property>


因为我们是伪分布式模式运行 Hadoop，我们还需要将“hadoop安装目录/etc/hadoop”目录下的 core-site.xml、hdfs-site.xml这两个文件拷贝到 eclipse工作区中该工程的 bin文件夹下。
向HDFS上传任意文本文件
我们开始新建一个 Java程序，在 Eclipse界面左侧找到我们刚才创建的项目，点击鼠标右键，选择“New”->“Class”。


因为我们想要向 HDFS上传任意文本文件，所以我们取名为“uploadFile”，其他设置保持默认，点击“Finish”。


创建程序完成后，界面如下


接下来，我们开始编写往 HDFS中上传文件的 Java程序。
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

public class uploadFile {
    public static void main(String[] args) {
        try {
            /*配置参数*/
            Configuration conf = new Configuration();             //实例化配置对象
            URI uri = new URI("hdfs://localhost:9000");           //指定伪分布式模式
            FileSystem fs = FileSystem.get(uri, conf, "hadoop");  //获取文件系统对象，三个参数分别绑定uri，conf，当前用户账户

            /*指定源文件和上传目录*/
            String srcFile = "/home/hadoop/myFile.txt";     //本地目录
            String dstDir = "/user/hadoop/";                //hdfs用户目录
            Path src = new Path(srcFile);                   //绑定Path路径
            Path dst = new Path(dstDir);

            /*上传文件*/
            fs.copyFromLocalFile(src, dst);     //调用copyFromLocal命令
            fs.close();                         //关闭文件系统对象
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

源文件是我已经提前编写好放在 /home/hadoop/目录下的 myFile.txt，待上传的目录 /user/hadoop也是之前创建好的。
在开始编译运行程序之前，请一定确保 Hadoop已经启动运行，如果还没有启动，请打开一个 Linux终端，输入命令启动 Hadoop
cd $HADOOP_HOME
./sbin/start-dfs.sh

按快捷键“Ctrl+S”保存一下代码，接下来我们开始编译运行 Java程序。我们点击 Eclipse菜单栏上的运行按钮，选择“Run as”->“Java Application”。或者我们也可以使用快捷键“Ctrl+F11”直接运行。


程序运行结束后，底部的“Console”控制台会弹出运行信息，我们可以根据运行信息来判断程序是否成功执行。
如果遇到“log4j：WARN···”之类的警告信息，将 “hadoop安装目录/etc/hadoop”目录下的 log4j.properties文件复制到项目的 bin文件夹下，重新运行即可。


如果在控制台上看到这个提示信息，则证明文件上传成功。

INFO sasl.SaslDataTransferClient: SASL encryption trust check: localHostTrusted = false, remoteHostTrusted = false


我们看到，虽然程序运行没有问题，但是多了一个警告，说是不能加载 native-hadoop库。

Unable to load native-hadoop library for your platform… using builtin-java classes where applicable

这是因为我们修改配置文件的时候少配置了 native路径，系统加载不到这些库文件。具体解决办法请参考这篇博客 Hadoop之Unable to load native-hadoop library问题解决
言归正传，我们现在通过 terminal终端，验证一下文件是否上传成功。
cd $HADOOP_HOME
./bin/hdfs dfs -ls .


可以看到，HDFS的用户目录 /user/hadoop下已经有了 myFile.txt文件。
我们也可以通过 Web界面来查看 HDFS的文件，进行验证。打开 Ubuntu自带的 FireFox浏览器，在地址栏输入“localhost:9870”，回车，进入 HDFS的 WebUI。点击标题栏右侧的“Utilities”，选择“Browse the file system”


在下方目录搜索栏中输入“/user/hadoop”，然后回车。可以看到，此时 HDFS的用户目录下的确存在 myFile.txt文件，通过 Java API向 HDFS 上传文件成功。


从HDFS下载指定文件
同理，我们新建 Java程序 downloadFile.java，使用 Java API编写程序从 HDFS下载文件。我们就将刚才上传的 myFile.txt文件，从 HDFS中下载到本地桌面上。
import java.net.URI;

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

public class downloadFile {
	public static void main(String[] args) {
		try {
			//set configurations
			Configuration conf = new Configuration();
			URI uri = new URI("hdfs://localhost:9000");
			FileSystem fs = FileSystem.get(uri, conf, "hadoop");
			
			//set File and Dir
			String srcFile = "/user/hadoop/myFile.txt";
			String dstDir = "/home/hadoop/Desktop/";
			Path src = new Path(srcFile);
			Path dst = new Path(dstDir);
			
			//download
			fs.copyToLocalFile(src, dst);
			fs.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


保存代码，然后我们开始编译运行 Java程序。同样地，看到提示信息，证明文件下载成功。

INFO sasl.SaslDataTransferClient: SASL encryption trust check: localHostTrusted = false, remoteHostTrusted = false


我们回到桌面上，可以看到，桌面上已经有了 myFile.txt文件，通过 Java API从 HDFS 下载文件成功。


参考文章
HDFS编程实践（Hadoop3.1.3）
通过JAVA API 来操作HDFS
使用Java API操作hdfs
eclipse控制台打印log4j警告