java-IO流-创新互联

流操作的是文件的内容，这个内容始终需要存储在文件中，否则等待程序关闭后就会烟消云散。数据存储最终是以文件的形式保存在在操作系统中的磁盘上。Java中对应的类是File。

//在磁盘中创建一个文件
File file = new File("d:\\test.txt");
//创建文件：
file.createNewFile();
//创建文件夹：
file.mkdir();
//检测文件是否存在：
file.exists()

例子

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class FileCreateDemo {public static void main(String[] args) {String path = FileReader.class.getResource("/").getFile();
        String fileName = path + "/test.txt";
        File file = new File(fileName);
        // 创建文件
        try {file.createNewFile();
            System.out.println(file.exists());
            String dirName = path + "/myFolder";
            File dir = new File(dirName);
            //创建文件夹
            dir.mkdir();
            System.out.println(dir.exists());
        } catch (IOException e) {e.printStackTrace();
        }
    }
}

看下file对象的一些常用方法吧：

作用	函数签名
获取文件名	String getName()
磁盘文件是否存在	boolean exists()
获取文件的磁盘绝对地址	String getAbsolutePath()
列取文件夹下的文件列表有过滤器有文件名过滤器file必须是文件夹才能使用	File[] listFiles() File[] listFiles(FileFilter filter)File[] listFiles(FilenameFilter filter)
创建文件夹	boolean mkdir()
创建文件指定目录中创建指定前缀和后缀的文件	boolean createNewFile()createTempFile(String prefix, String suffix, File directory)
获取父目录	String getParent()//上层文件路径 File getParentFile()//上层文件
是否隐藏	boolean isHidden()
删除文件	boolean delete()

例子

import java.io.File;
import java.io.FileReader;
public class FileInfoDemo {public static void main(String[] args) {//获取当前项目运行时所在根目录
        String path = FileReader.class.getResource("/").getFile();
        String fileName = path;
        showFileInfo(fileName);
    }
    public static void showFileInfo(String fileName) {File file = new File(fileName);
        for (File f : file.listFiles()) {String str = "";
            if (f.isDirectory()){str = "文件夹";
                //getAbsolutePath()获取文件的磁盘绝对地址
                showFileInfo(f.getAbsolutePath());
            } else {str = "文件";
            }

对象状态在内存中或者在网络间传输的状态是瞬时状态，对象状态被保存到磁盘的文件中（磁盘文件或数据库文件中），是持久化状态。而这个由瞬时到持久的过程称为“持久化”。

以数据的流向分类，能够读取字节的序列的API对象成为输入流（InputStream），能够写入字节序列的成为输出流（OutputStream）。字节是计算机数据的存储的形式，任何数据都可以使用字节流进行读写。JAVA中有专门提供了对于字符流的两个抽象类Reader和Writer

分类： IO流按照操作对象：字节流和字符流 ; 按照流的方向分：输入流和输出流

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test {public static void main(String[] args)throws Exception { FileInputStream fis = new FileInputStream("D:\\工作文档\\Test.java");
         FileOutputStream fos = new FileOutputStream("D:\\工作文档\\COPY\\Test2.java");
        
        int n;
        ----------------------------方法一------------------------------------
        while((n=fis.read()) != -1){//System.out.print((char)n);
            fos.write(n);
        }
        ----------------------------方法二------------------------------------
         byte[] bytes = new byte[1024];
         while((n=(fis.read(bytes))) != -1){//System.out.print((char)n);
            fos.write(bytes,0,n);
        }
        fis.close();
        fos.close();
    }
   }

多次运行写入文件的内容始终是最后的一次输入，之前的写入都被覆盖掉了。
构造函数构造出来的FileOutputStream(fileName) 是不支持追加内容的
在输出流从创建到关闭的过程中可以多次使用write写入数据，
但是再次打开流时，文件会重头写，所以会覆盖掉以前的内容。

FileOutputStream fos = new FileOutputStream(fileName);

构造追加内容的输出流：

FileOutputStream fos = new FileOutputStream(fileName,true);

更改后的代码是能够追加内容到文件中。

fos.write(content.getBytes());//按照字节写
fis.read(bytes);//按照字节读
fis.read(bytes,off,len)// byte 要存放读取的字节数组，off起点，len读取长度
fis.skip(len);//跳过多少字节
System.getProperty("file.encoding") //查看系统中文件的编码。
    
//文件输入输出字节流的详细API如下：
//FileInputStream字节流常用的API:
fis.skip(len);//跳过一定字节
fis.read();//按照字节逐个读取
fis.read(byte[]);//从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
fis.read(byte[],off,len);//将输入流中最多len个数据字节读入byte数组的偏移位置off处
fis.close();//关闭输入流

//FileOutputStream字节流常用的API
write(byte[] b);//将 b.length 个字节写入此输出流
write(byte[] b, int off, int len);//将指定byte数组中从偏移量off开始的len个字节写入此输出流
write(int b);//将指定byte写入此输出流
void flush();//刷新此输出流，并强制将所有已缓冲的输出字节写入该流中
close()//关闭流

字节流缺点：在读取文本的时候非常不方便，需要按照字节进行操作，这也是字符流出现的原因。

字节流优点：字节流不仅可以操作文本，还可以操作读取其他媒体：如mp3，图片，还有视频，这些都可以使用字节流进行操作

例子：内容读取，追加两位同学的信息,每行一条Lucy,女,15；Lilei,男,16

import java.io.*;

public class StudentFile {public static void main(String[] args) {String path = FileReader.class.getResource("/").getFile();
		String fileName = path + "/student.data";
		String info=StudentFile.readStudentInfo(fileName);
		System.out.println(info);
		String[] infos={"Lucy,女,15","Lilei,男,16"};
		StudentFile.writeStr2File(fileName,infos);
		info=StudentFile.readStudentInfo(fileName);
		System.out.println(info);
	}

	public static void writeStr2File(String fileName, String[] infos) {try{	FileOutputStream fos = new FileOutputStream(fileName, true);
			for (String line : infos) {		line = "\r\n" + line;
				fos.write(line.getBytes());
			}
			fos.close();
		}catch(Exception e){	e.printStackTrace();
		}
	}

	public static String readStudentInfo(String fileName) {try {	FileInputStream fis = new FileInputStream(fileName);
            //available()可以读取的剩余字节数
			byte[] bytes = new byte[fis.available()];
			fis.close();
			return new String(bytes);
		} catch (Exception e) {	e.printStackTrace();
		}
		return null;
	}
}

序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。可序列化的对象，这个类必须是实现了Serializable接口的类，而且其成员变量也必须是可序列化的。

序列化： 父类如果是可序列化的，子类也是可序列化的；类的成员变量全部是可序列化的，类才能被正常可序列化。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KLXRzqVn-1672105540832)(C:\Users\maker\AppData\Roaming\Typora\typora-user-images\image-20220727084250746.png)]

import java.io.FileReader;
import java.io.FileWriter;


public class Test2 {public static void main(String[] args)throws Exception { FileReader fr = new FileReader("D:\\工作文档\\Test.java");
         FileWriter fw = new FileWriter("D:\\工作文档\\COPY\\Test2.java");
        
        int n;
        char[] chars = new char[1024];
        while((n=fr.read(chars)) != -1){//System.out.print(n);
            fw.write(chars,0,n);
        }
        fr.close();
        fw.close();
    }
   }

字符输出流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-buiSfHPI-1672105540832)(C:\Users\maker\AppData\Roaming\Typora\typora-user-images\image-20220727085141225.png)]

import java.io.*;



public class Test3 {public static void main(String[] args)throws Exception { FileReader fr = new FileReader("D:\\工作文档\\Test.java");
         FileWriter fw = new FileWriter("D:\\工作文档\\COPY\\Test2.java");
         BufferedReader br = new BufferedReader(fr);
         BufferedWriter bw = new BufferedWriter(fw);
        
         int count = 0;
         String line = null;
         while((line=br.readLine()) != null){count++
            bw.write(line);
            bw.newLine();
        }
        fr.close();
        br.close();
        bw.close();
        fw.close();
    }
   }

总结

1） 流按照流向可以分为：输入流/输出流；按照操作的对象可以分为字符流/字节流
2）字节流的操作的基类是InputStream，OutputStream这是基本的抽象类。字符流的操作的基类是Reader，Writer这些是字符流的基本抽象类，它们不能直接被实例化，所以我们还需要进行具体常见子类的学习
3） 磁盘文件的字节流FileInputStream FileOutputStream可以很方便的对磁盘上的文件进行读写和复制
4）对象流可以将对象的状态进行序列化和反序列化到磁盘上进行存储和恢复，但是要求我们的对象包括其成员都要实现Serializable接口
入流/输出流；按照操作的对象可以分为字符流/字节流
2）字节流的操作的基类是InputStream，OutputStream这是基本的抽象类。字符流的操作的基类是Reader，Writer这些是字符流的基本抽象类，它们不能直接被实例化，所以我们还需要进行具体常见子类的学习
3） 磁盘文件的字节流FileInputStream FileOutputStream可以很方便的对磁盘上的文件进行读写和复制
4）对象流可以将对象的状态进行序列化和反序列化到磁盘上进行存储和恢复，但是要求我们的对象包括其成员都要实现Serializable接口
5）使用字符流的子类读取写入数据如FileReader FileWriter 以及带缓存的字符流进行按行读取写入文件;File类是对磁盘上的文件和目录的抽象，使用File类的方法：createNewFile()、mkdir()、mkdirs()、delete()、renameTo(File dest)、isDirectory()、isFile()、exists()、canRead()、isHidden()等方法，能进行磁盘文件的管理

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧