Java输入输出

Java语⾔中File类是唯⼀表⽰⽂件对象和⽬录对象的数据类型。在Java语⾔中⽂件路径分隔符使使⽤’/’或’\\\\’。⽂件可以存储字节或字符;⽬录不能直接存储字节或字符，只能存储⽂件后⼦⽬录。

⽂件可以被读取和写⼊，⽽⽬录不能执⾏读写操作，只能建⽴，删除及获取其中包含的⼦⽬录及⽂件。对于⽂件和⽬录通常要严格区分，File类提供⽅法可以判断此File对象是⽂件还是⽬录。

File(File dir,String child)

根据parent抽象路径名和child路径名字字符串创建⼀个新File实例。File(String pathName)

通过将给定路径名字符串转换为抽象路径名来创建⼀个新File实例。File(String parent,String child)

根据parent路径名字符串和child路径名字符串创建⼀个新File实例。File(URI uri)

通过将给定的file:URI转换为⼀个抽象路径名来创建⼀个新的File实例。

File类常⽤⽅法

public boolean canWrite() //判断⽂件是否可以写⼊public boolean canRead() //判断⽂件是否可以读取

public boolean createNewFile() throws IOException //⽂件不存在时创建该⽂件public boolean delete() //删除该⽂件public boolean exists() //判断⽂件是否存在

public String getAbsolutePath() //获取⽂件的绝对路径public String getName() //获取⽂件名，⽂件的后缀也会获取public String getParent() //获取⽂件的⽗⽬录public String getPath() //和getAbsolutePath()类似

public boolean isDirectory() //判断是否是⽬录，如果是⽂件，返回假public boolean isFile() //判断是否是⽂件

public File[] listFiles() //返回包含的所有⽂件列表，此⽅法通常只对⽬录起作⽤public boolean mkdir() //创建⽬录

public boolean mkdirs() //创建⽬录，如果路径中间⽬录缺失，会⾃动创建

File⽂件流分类⽅向

输⼊(Input)流——读取⽂件输出(Output)流——写⼊⽂件内容

字节(Byte)流——读写⼆进制⽂件字符(Char)流——读写⽂本⽂件

⽅式

节点流——针对⽂件建⽴处理流——针对其它⽂件流建⽴ 输⼊流

1. 输⼊流是指建⽴在⽂件或其他⽂件流上的⽤来对⽬标⽂件进⾏读取的⽂件流。2. 输⼊流只能对⽂件进⾏读取。

3. 读取⼆进制⽂件使⽤字节输⼊流，读取⽂本⽂件使⽤⽂本输⼊流。

字节输⼊流

InputStream——FileInputStream——BufferedInputStreamInputStream——FileInputStream——DataInputStreamInputStream——ObjectInputStreamInputStream——ByteArrayInputStream

字节输⼊流常⽤⽅法

public abstract int read()throws IOException //返回读取到的字节数，基本没啥⽤public int read(byte[] b)throws IOException //返回读取到的内容字节数组，不常⽤

public int read(byte[] b.int off,int len)throws IOException //int off是从哪⾥开始读数组，⼀般是0，int len是试图读取的长度，通常会取⼀个字节数组的长度

public void close() throws IOException //读写完毕以后关闭流，释放资源

字符输⼊流

Reader——InputStreamReader——FileReaderReader——StringReaderReader——CharArrayReaderReader——BufferedReader

字符输⼊流常⽤⽅法

public int read()throws IOException

public int read(char[] cbuf)throws IOException

public abstract int read(char[] cbuf,int off,int len)throws IOExceptionpublic void close()throws IOException 输出流

1. 输出流是指建⽴在⽂件或其他⽂件流上的⽤来对⽬标⽂件进⾏写⼊的⽂件流。2. 输出流只对⽬标⽂件进⾏写⼊操作。

3. 写⼊⼆进制⽂件使⽤字节输出流，写⼊⽂本⽂件使⽤⽂本输出流。

字节输出流

OutputStream——FileOutputStream——BufferedOutputStream

OutputStream——FileOutputStream——DataOutputStreamOutputStream——ObjectOutputStreamOutputStream——ByteArrayOutputStream

字节输出流常⽤⽅法

public void write(int b)throws IOException //这个⽅法没什么意义public void write(byte[] b)throws IOException //写⼊byte[]这个字节数组

public void write(byte[]b,int off,int len)throws IOException //⽤的最多的⽅法，第⼆个参数是从哪⾥开始写⼊，第三个参数是写⼊的长度public void close() throws IOException //关闭输出流

字符输出流

Writer——OutputStreamWriter——FileWriterWriter——StringWriterWriter——CharArrayWriterWriter——BufferedWriter

字符输出流主要⽅法

public void write(int b)throws IOExceptionpublic void write(char[] b)throws IOException

public abstract void write(chars[] b,int off,int len)throws IOExceptionpublic void write(String str)throws IOExceptionpublic void close()throws IOException ⽂件复制

将给定的⽂件复制到⽬标新⽂件

序列化读写

Java不仅提供了以字节和字符形式读写⽂件的功能，⽽且也提供了对任何Java数据类型进⾏读写的能⼒。

将⼀个数据以Java对象的形式存储到⽂件中或从⽬标⽂件中获取⼀个Java对象的操作被称为序列化操作，能够被序列化的对象称之为序列化的对象。

序列化对象

Java规定任何实现Serializable接⼝的类，被看做是序列化类，此类的实例即是⼀个序列化对象。

序列化对象可以通过序列化输⼊和输出流进⾏读写操作，通常序列化类必须提供⼀个公共⽆参的构造器，在反序列化（读取序列化对象）中JVM使⽤公共⽆参构造器创建Java的对象。

序列化⽂件流

ObjectOutputStream //序列化流，将⼀个Java对象保存到⽬标⽂件中ObjectInputStream //反序列化流，从⽬标⽂件中读取序列化Java对象到内存

package until;

import Interfaces.FileBasicSupport;import java.io.*;

public class FileManager implements FileBasicSupport {

/* 按照给定的⽬录名称,在硬盘上创建此⽬录 */ @Override

public void createFolder(String folderPath) { //new⼀个⽂件路径对象

File dirFile = new File(folderPath);

if (!dirFile.exists()){ //如果⽬录不存在则创建⽬录 boolean bool = dirFile.mkdirs();

System.out.println(dirFile+\" ⽬录不存在，尝试创建该⽬录，创建是否成功：\"+bool); }else{

System.out.println(\"⽬录 \"+dirFile+\" 已存在\"); } }

/* 按照给定的⽗⽬录名称及⽂件名称,创建⽬标⽂件并返回此⽂件对象*/ @Override

public File createTargetFile(String parent, String fileName) { //new⼀个⽂件路径对象

File dirFile = new File(parent);

if (!dirFile.exists()){//如果⽬录不存在则创建⽬录 boolean bool = dirFile.mkdirs();

System.out.println(dirFile+\" ⽬录不存在，尝试创建该⽬录，创建是否成功：\"+bool); if (bool){//如果⽂件⽬录创建成功，则在此⽬录下创建⽂件

File f = new File(dirFile,fileName); //创建⽂件对象，dirFile是路径，连接上第⼆个参数fileName⽂件名 try {

f.createNewFile();//在硬盘上创建⽂件 } catch (IOException e) { e.printStackTrace(); }

return f; } }

else {

System.out.println(\"⽬录\"+parent+\"已存在\");

File f = new File(dirFile,fileName); //创建⽂件对象，dirFile是路径，连接上第⼆个参数fileName⽂件名 try {

f.createNewFile();//在硬盘上创建⽂件 } catch (IOException e) { e.printStackTrace(); }

return f; }

return null; }

/* 将给定的字符串内容写⼊到⽬录⽂件中,返回写⼊的字节数 */ @Override

public long writeFile(File file, String content) {

OutputStream out = null; //建⽴⼀个字节输出流 BufferedOutputStream bs = null; //建⽴⼀个缓冲输出流

byte[]bys = content.getBytes(); //建⽴⼀个字节数组，存⼊要输⼊的内容 if (file.exists()){ try {

System.out.println(\"⽂件的路径是\"+file.getAbsolutePath());

out = new FileOutputStream(file.getAbsolutePath()+\"/七绝.txt\");

bs = new BufferedOutputStream(out);//基于OutputStream建⽴⼀个缓冲输出流 bs.write(bys,0,bys.length);//写⼊⽬标⽂件 } catch (IOException e) { e.printStackTrace(); }finally { try {

bs.close(); //关闭缓冲输出流 out.close(); //关闭字节输出流 } catch (IOException e) { e.printStackTrace(); } } }

return bys.length; }

/* 按照给定的硬盘⽬录⽂件路径及名称,读取⽬标⽂件并返回*/ @Override

public File readFile(String path) { /*1.建⽴⽬标要读取的⽂件对象*/

File file = new File(path);

/* 2.建⽴⼀个⽂本输⼊流 上半部分*/ FileReader read = null;

/* 3.建⽴⼀个⽂本缓冲流 上半部分*/ BufferedReader br = null;

if (file.exists()){ //如果⽂件存在 try {

read = new FileReader(file); //基于⽂件建⽴普通⽂本输⼊流 下半部分 br = new BufferedReader(read); //基于Reader建⽴⽂本缓冲流 下半部分 char chs[] = new char[50]; //建⽴⼀个char数组接收输⼊的⽂本内容 int count = 0; //定义⼀个变量计算⽂本读取的字节数 while ((count = br.read(chs,0,chs.length))!=-1){ String s = new String(chs,0,count); System.out.println(s); }

} catch (IOException e) { e.printStackTrace(); }finally { try {

br.close(); //关闭⽂本缓冲流 read.close(); //关闭字节输⼊流

System.out.println(\"关闭字符输⼊流对象\"); } catch (IOException e) { e.printStackTrace(); } } } else{

System.out.println(\"⽂件不存在！\"); }

return file; }}

/**

* 2 在任务1的基础上,定义编写⼀个新接⼝FileAdvancedSupport 继承FileBasicSupport,并新添加以下抽象⽅法: *

* 对给定的⽬录进⾏迭代,并返回此⽬录下的所有包含⼦⽂件⽬录下的所有⽂件 * * 并返回List *

* public abstract List folderIteration(File directory); *

* 将给定的源⽂件拷贝到⽬标⽬录⽂件 *

* public abstract void copyFile(File sourceFile,String savePath,String fileName); *

* 编写⼀个类实现上述FileAdvancedSupport接⼝并对接⼝中的抽象⽅法进⾏功能实现. *

* 编写测试类包含main⽅法实现功能测试. */

package until;

import Adaptor.FileAdvancedSupportAdaptor;import Interfaces.FileAdvancedSupport;import java.io.*;import java.util.*;

public class FileManager2 extends FileAdvancedSupportAdaptor {

/* 对给定的⽬录进⾏迭代,并返回此⽬录下的所有包含⼦⽂件⽬录下的所有⽂件 * 并返回List */

@Override

public List folderIteration(File directory,List list) { //获取⽬录下所有⽂件和⽬录的绝对路径，存⼊数组fs中 File[] fs = directory.listFiles(); //迭代这个路径 for (File f:fs){

if (f.isDirectory()){ //如果是⽬录，就递归调⽤⾃⼰ folderIteration(f,list); //调⽤⾃⼰ }else{

list.add(f); //判断如果是⽂件，就加⼊集合 } }

return list; }

/* 将给定的源⽂件拷贝到⽬标⽬录⽂件*/ @Override

public void copyFile(File sourceFile, String savePath, String fileName) { InputStream in = null; //⽂件输⼊流

OutputStream out = null; //⽂件输出流

File copyFile = null; //⽬标写⼊的⽂件对象

File path = new File(savePath); //新建⼀个⽂件路径对象 if (sourceFile.exists()){ //判断⽬标⽂件是否存在 if (!path.exists()){ //判断要拷贝的⽬录是否存在 path.mkdirs(); //如果不存在就新建这个⽬录 } try {

in = new FileInputStream(sourceFile); //基于⽬标⽂件建⽴⽂件输⼊流 /**

* 避免⽂件重名被覆盖，可以使⽤系统时间的毫秒作为⽂件的前缀 */

//建⽴⽬标写⼊的⽂件对象

copyFile = new File(path+\"/\"+fileName);

out = new FileOutputStream(copyFile); //建⽴基于⽬标⽂件的输出流 byte bys[] = new byte[1024]; //临时存储字节数据的缓冲区 int count = 0; //记录读取内容的临时变量 while((count = in.read(bys,0,bys.length))!=-1){

out.write(bys,0,count); //将临时缓冲区的内容写⼊到⽬标⽂件中 }

System.out.println(\"⽂件复制完成\"); } catch (IOException e) { e.printStackTrace(); }finally { try {

out.close(); in.close();

} catch (IOException e) { e.printStackTrace(); } } } }}

/**

* 1 使⽤Eclipse IDE 编写⼀个控制台应⽤程序, 此应⽤主要提供⼀个⾃定义⽂件管理接⼝FileBasicSupport(接⼝名⾃定义), 定义以下抽象⽅法: *

* 按照给定的⽬录名称,在硬盘上创建此⽬录

*public abstract void createFolder(String folderPath); *

* 按照给定的⽗⽬录名称及⽂件名称,创建⽬标⽂件并返回此⽂件对象 *public abstract File createTargetFile(String parent,String fileName); *

* 将给定的字符串内容写⼊到⽬录⽂件中,返回写⼊的字节数 *public abstract long writeFile(File file,String content); *

* 按照给定的硬盘⽬录⽂件路径及名称,读取⽬标⽂件并返回 *Public abstract File readFile(String path); *

*编写⼀个类实现上述FileBasicSupport接⼝并对接⼝中的抽象⽅法进⾏功能实现. *

*编写测试类包含main⽅法实现功能测试. * */

package main;

import until.FileManager;import java.io.File;

public class TestIO {

public static void main(String[] args) { FileManager fil = new FileManager();

/* 按照给定的⽬录名称,在硬盘上创建此⽬录 */ String dir = \"e:/files3/\"; //调⽤创建⽬录的⽅法 fil.createFolder(dir);

System.out.println(\"-----------分割线--------------\");

/* 按照给定的⽗⽬录名称及⽂件名称,创建⽬标⽂件并返回此⽂件对象*/ String dir1 =\"e:/files3/testFile/\";

String fileName = \"这是⼀个测试⽂件.txt\";

//建⽴⼀个⽂件对象f接收调⽤创建⽬标⽂件的⽅法的返回值 File f = fil.createTargetFile(dir1,fileName); System.out.println(\"⽂件对象：\"+f);

System.out.println(\"-----------分割线--------------\");

/* 将给定的字符串内容写⼊到⽬录⽂件中,返回写⼊的字节数 */ File file = new File(\"e:/files3/\");

String str = \"孩⼉⽴志出乡关，\\n学不成名誓不还，\\n埋⾻何须桑梓地。\\n⼈⽣⽆处不青⼭\";

//建⽴⼀个long1变量接收调⽤写⼊⽅法返回的写⼊的字节数 long long1 = fil.writeFile(file,str);

System.out.println(\"写⼊的字节数是：\"+long1); System.out.println(\"-----------分割线--------------\");

/* 按照给定的硬盘⽬录⽂件路径及名称,读取⽬标⽂件并返回*/ String path = \"e:/files3/七绝.txt\";

//建⽴⼀个⽂件对象file2接收调⽤创建⽬标⽂件的⽅法的返回值 File file2 = fil.readFile(path);

System.out.println(\"⽬标⽂件 \"+file2);

System.out.println(\"-----------分割线--------------\"); }}

/**

* 2 在任务1的基础上,定义编写⼀个新接⼝FileAdvancedSupport 继承FileBasicSupport,并新添加以下抽象⽅法: *

* 对给定的⽬录进⾏迭代,并返回此⽬录下的所有包含⼦⽂件⽬录下的所有⽂件 * * 并返回List *

* public abstract List folderIteration(File directory); *

* 将给定的源⽂件拷贝到⽬标⽬录⽂件 *

* public abstract void copyFile(File sourceFile,String savePath,String fileName); *

* 编写⼀个类实现上述FileAdvancedSupport接⼝并对接⼝中的抽象⽅法进⾏功能实现. *

* 编写测试类包含main⽅法实现功能测试. */

package main;

import until.FileManager2;import java.io.File;

import java.util.ArrayList;import java.util.List;

public class TestCopy {

public static void main(String[] args) { FileManager2 fil = new FileManager2();

/* 对给定的⽬录进⾏迭代,并返回此⽬录下的所有包含⼦⽂件⽬录下的所有⽂件 * 并返回List */

//建⽴⼀个⽂件路径对象

File directory = new File(\"e:/files3/\"); //创建⼀个数组，⽤来作为递归的参数 List list = new ArrayList<>();

//调⽤迭代的⽅法，定义⼀个File类型的List接收返回值 List list2 = fil.folderIteration(directory,list); //输出⽬标路径下所有⽂件的路径和⽂件名称 for (File f:list){

System.out.println(f.getAbsolutePath()); }

System.out.println(\"------------分割线--------------\");

/* 将给定的源⽂件拷贝到⽬标⽬录⽂件*/

File sourceFile = new File(\"e:/files3/七绝.txt\"); //给定的源⽂件 String savePath = \"e:/files3/copyFile/\"; //⽬标的⽬录

String fileName = \"复制的⽂件.txt\"; //⽬标的⽂件名称 //调⽤复制⽂件的⽅法

fil.copyFile(sourceFile,savePath,fileName); }}

package Interfaces;import java.io.File;

public interface FileBasicSupport {

/* 按照给定的⽬录名称,在硬盘上创建此⽬录 */

public abstract void createFolder(String folderPath);

/* 按照给定的⽗⽬录名称及⽂件名称,创建⽬标⽂件并返回此⽂件对象*/ public abstract File createTargetFile(String parent , String fileName); /* 将给定的字符串内容写⼊到⽬录⽂件中,返回写⼊的字节数 */ public abstract long writeFile(File file,String content); /* 按照给定的硬盘⽬录⽂件路径及名称,读取⽬标⽂件并返回*/ public abstract File readFile(String path);

}

package Interfaces;import java.io.File;import java.util.List;

public interface FileAdvancedSupport extends FileBasicSupport{

/* 对给定的⽬录进⾏迭代,并返回此⽬录下的所有包含⼦⽂件⽬录下的所有⽂件 * 并返回List */

public abstract List folderIteration(File directory,List list); /* 将给定的源⽂件拷贝到⽬标⽬录⽂件*/

public abstract void copyFile(File sourceFile,String savePath,String fileName);}

package Adaptor;

import Interfaces.FileAdvancedSupport;import java.io.File;import java.util.List;

public class FileAdvancedSupportAdaptor implements FileAdvancedSupport { @Override

public List folderIteration(File directory,List list) { return null; }

@Override

public void copyFile(File sourceFile, String savePath, String fileName) { }

@Override

public void createFolder(String folderPath) { }

@Override

public File createTargetFile(String parent, String fileName) { return null; }

@Override

public long writeFile(File file, String content) { return 0; }

@Override

public File readFile(String path) { return null; }}