对数据进行输入输出操作(往文件中写入数据)
1，将内存中数据都写入到文件中。
需要使用系统资源，Java中用于操作系统资源的对象是哪个呢？
通过api的索引关键字 Output Input
找到OutputStream InputStream。
2，OutputStream InputStream
字节输出流和字节输入流的超类。
定义了write 和read方法。
3，它们的子类都具备名称定义规律：后缀名是父类名，前缀名是流对象的功能。★★★
4，依据这个规律，找到了可以用于操作文件的流对象。流可以理解系统资源。
5，写入数据到文件的特点。
5.1 必须明确目的地文件，会自动创建，如果文件存在则会覆盖。
5.2 续写只要在构造函数中传递true。换行只要使用系统的行分隔符。
5.2IO异常处理必须使用finally关闭资源，在关闭前做!=null的判断。★★★★
6，读取文件数据的特点：★★★★★
6.1 明确数据源，让读取流和数据源相关联。
6.2 读取有两种方式。
read():一次读取一个字节并返回，没有数据返回-1.
read(byte[])：读取一定数量的数据存储到byte[]中，返回读到字节的个数，没有数据返回-1.
第二种方式高效。字节数组的长度建议为 1024.
7，复制文件：需要中转。建议使用字节数组作为中转，效率高。
字节输出流-数据写入到文件中
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//需求：将数据写入到文件中。
//创建临时目录，
File dir = new File("tempfile");
if(!dir.exists()){
dir.mkdir();
}
//创建存储数据的文件。
File file = new File(dir,"file.txt");
//创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
//输出流目的是文件，会自动创建。如果文件存在，则覆盖。
FileOutputStream fos = new FileOutputStream(file);
//调用父类中的write方法。
byte[] data = "abcde".getBytes();
fos.write(data);
//关闭流资源。
fos.close();
}
}
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class FileOutputStreamDemo2 {
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws Exception {
//需求：将数据续写到已有文件中。
File file = new File("tempfile/file.txt");
//FileOutputStream(File file, boolean append) 续写。
FileOutputStream fos = new FileOutputStream(file, true);
// LINE_SEPARATOR 在下一行写入新的数据
String str = LINE_SEPARATOR+"haha";
fos.write(str.getBytes());
fos.close();
}
}
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo3 {
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) {
File file = new File("k:\\file.txt");
FileOutputStream fos = null;
try {
fos = new FileOutputStream(file);
fos.write("abcde".getBytes());
} catch (IOException e) {
System.out.println(e.toString() + "----");
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
throw new RuntimeException("");
}
}
}
}
}
字节输入流-读取数据
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamDemo {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// 2,需求：读取文件中的数据，显示在屏幕上。
File file = new File("tempfile/file.txt");
//创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
FileInputStream fis = new FileInputStream(file);
//读取数据。使用 read();一次读一个字节。
int ch = 0;
while((ch=fis.read())!=-1){
System.out.println("ch="+(char)ch);
}
// 关闭资源。
fis.close();
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamDemo2 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
/*
* 演示第二个读取方法， read(byte[]);
*/
File file = new File("tempfile/file.txt");
// 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
FileInputStream fis = new FileInputStream(file);
//创建一个字节数组。
byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。
int len = 0;
while((len=fis.read(buf))!=-1){
System.out.println(new String(buf,0,len));
}
/*int len1 = fis.read(buf);
System.out.println(len1+":"+new String(buf,0,len1));
int len2 = fis.read(buf);
System.out.println(len2+":"+new String(buf,0,len2));
int len3 = fis.read(buf);
System.out.println(len3+":"+new String(buf,0,len3));
int len4 = fis.read(buf);
System.out.println(len4);
*/
fis.close();
}
}
练习：复制文件
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFileTest {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
/*
* 练习：复制文件。
* 原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中。
*/
//1,明确源和目的。
File srcFile = new File("tempfile/file.txt");
File destFile = new File("tempfile/copy_file.txt");
//2,明确字节流 输入流和源相关联，输出流和目的关联。
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//3, 使用输入流的读取方法读取字节，并将字节写入到目的中。
int ch = 0;
while((ch=fis.read())!=-1){
fos.write(ch);
}
//4,关闭资源。
fos.close();
fis.close();
}
}
字节流复制文件图解
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFileByBufferTest {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
File srcFile = new File("tempfile/file.txt");
File destFile = new File("tempfile/copy_file.txt");;
// 2,明确字节流 输入流和源相关联，输出流和目的关联。
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
// 3,定义一个缓冲区。
byte[] buf = new byte[1024];
int len = 0;
while ((len = fis.read(buf)) != -1) {
fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
}
// 4,关闭资源。
fos.close();
fis.close();
}
}
字节流缓冲区对象复制图解
available方法
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ByteStreamDemo {
public static void main(String[] args) throws IOException {
/*
* 字节输入流。
* available();
*/
FileInputStream fis = new FileInputStream("tempfile/file.txt");
// System.out.println(fis.available());//输出文件大小
byte[] buf = new byte[fis.available()];//定义了一个刚刚好的数组。 注意：如果文件过大，容易溢出。
//建议缓冲区的长度最好还是1024的整数倍。
fis.read(buf);
String str = new String(buf);
System.out.println(str);
fis.close();
}
}
删除一个带有内容的目录
import java.io.File;
public class Test2 {
public static void main(String[] args) {
// 2，请删除一个带有内容的目录。
/*
* 思路: 1，删除一个带有内容的目录原理；必须从里往外删。 2，到底有多级目录不确定，递归。
*/
File dir = new File("tempfile");
// System.out.println(dir.delete());
removeDir(dir);
}
/**
* 删除一个目录。
*/
public static void removeDir(File dir) {
// 1,列出当前目录下的文件以及文件夹File[]
File[] files = dir.listFiles();//如果目录是系统级文件夹，java没有访问权限，那么会返回null数组。最好加入判断。
if (files != null) {
// if(files.length == 0){
// dir.delete();
// return;
// }
for (File file : files) {
// 2,对遍历到的file对象判断是否是目录。
if (file.isDirectory()) {
removeDir(file);
} else {
System.out.println(file + ":" + file.delete());// 删除文件。用打印语句验证是否删除成功，是否出现了误删操作。
}
}
}
System.out.println(dir + ":" + dir.delete());
}
}
获取指定目录下所有的.java文件(包含子目录中的)，并将这些java文件的绝路路径写入到一个文件中
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class Test5 {
private static final String LINE_SEPARATOR = SeparatorTool.LINE_SEPARATOR;
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// 5，获取指定目录下所有的.java文件(包含子目录中的)，
// 并将这些java文件的绝路路径写入到一个文件中。
// 建立一个java文件清单列表。
/*
* 思路：
* 1，一看到包含子目录，必须递归。
* 2，写数据到文件，输出流。
* 3，继续分析，发现只要.java ，需要过滤器。
* 4，满足过滤的条件的文件有可能非常多，先进行存储。
*/
//被遍历的目录。
File dir = new File("tempfile");
//明确一个过滤器。
FileFilter filter = new FileFilterBySuffix(".java");
//符合过滤器条件的文件有很多，最好先存储起来，然后在进行操作。
List<File> list = new ArrayList<File>();
//获取指定文件清单。
getFileList(dir,filter,list);
// System.out.println(list.size());
File destFile = new File(dir,"javalist.txt");
write2File(list,destFile);
}
/**
* 将集合中的数据的绝对路径写入到文件中。
* @param list
* @param destFile
* @throws IOException
*/
public static void write2File(List<File> list, File destFile) throws IOException {
//FileOutputStream fos = null;
BufferedOutputStream bufos = null;
try{
//fos = new FileOutputStream(destFile);
bufos = new BufferedOutputStream(fos);
for(File file : list){
String info = file.getAbsolutePath()+LINE_SEPARATOR;
bufos.write(info.getBytes());
bufos.flush();//每写一个绝对路径就刷新一次。
}
}finally{
if(bufos!=null){
try {
fos.close();
} catch (IOException e) {
throw new RuntimeException("关闭失败");
}
}
}
}
/**
* 根据指定的过滤器在指定目录下获取所有的符合过滤条件的文件，并存储到list集合中。
* @param dir
* @param filter
* @param list
*/
public static void getFileList(File dir,FileFilter filter,List<File> list) {
File[] files = dir.listFiles();
for(File file : files){
if(file.isDirectory()){
getFileList(file,filter,list);
}else{
//如果是文件，传递到过滤器中去过滤。将满足条件存储起来。
if(filter.accept(file)){
list.add(file);
}
}
}
}
}
网友评论