java输入输出流

最新推荐文章于 2024-06-13 13:32:01 发布

LifePassion

最新推荐文章于 2024-06-13 13:32:01 发布

阅读量168

点赞数 2

分类专栏： java 笔记

本文链接：https://blog.csdn.net/weixin_43184936/article/details/105559817

版权

笔记同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

java

5 篇文章 0 订阅

订阅专栏

java输入输出流

File类常用方法：

package fileDemo;

import java.io.File;
import java.io.IOException;

public class FileTest {
	public static void main(String[] args) {
		// 创建file对象
		// File file1=new File("D:\\life\\life.txt"); //通过路径直接创建
		// File file1=new File("D:\\life","life.txt"); //通过分开的两段路径创建
		File file0 = new File("D:\\life"); // 通过已有的file对象创建
		File file1 = new File(file0, "life.txt");

		// 判断是否是目录或者文件
		System.out.println("是否是文件：" + file1.isFile());
		System.out.println("是否是目录：" + file1.isDirectory());

		File file2 = new File("D:\\life", "life2");
		if (!file2.exists()) {
			file2.mkdir();
			// file2.mkdirs(); //多级文件
		}

		if (!file1.exists()) {

			try {
				file1.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}
}

字节流：

⭐️使用完成后必须关闭输入输出流：

当我们new一个java流对象之后，不仅在计算机内存中创建了一个相应类的实例对象。而且，还占用了相应的系统资源，比如：文件句柄、端口、数据库连接等。在内存中的实例对象，当没有引用指向的时候，java垃圾收集器会按照相应的策略自动回收，但是却无法对系统资源进行释放。

FileInputStream:

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputDemo1 {

	public static void main(String[] args) {
		try {
			FileInputStream fis = new FileInputStream("life.txt");
			int n=0;
			while((n=fis.read())!=-1) {
				System.out.print((char)n);		     //.read()返回值是下一个字节数据
			}
			fis.close();
			
		} catch (FileNotFoundException e) {			//将异常按从小范围到大范围抛出，有利于排错										
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputDemo2 {

	public static void main(String[] args) {

		try {
			FileInputStream fis = new FileInputStream("life.txt");
			byte[] b = new byte[100];
			fis.read(b, 0, 5); // 将文件读取到数组，后面代表偏移量，返回值是读取到的字节数据长度
			System.out.println(new String(b)); // 调用String类型的构造方法，输出数组元素

			fis.close();
		} catch (FileNotFoundException e) { // 将异常按从小范围到大范围抛出，有利于排错
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

}

FileOutputStream:

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileoutputDemo1 {

	public static void main(String[] args) {
		FileOutputStream fos;
		try {
//			fos=new FileOutputStream("life.txt");       //写入文件，会覆盖源文件内容
//			fos.write(20);
//			fos.write('a');

			fos = new FileOutputStream("life.txt", true); // true属性说明是在文件里面添加，不是覆盖
			fos.write(20);
			fos.write('a');

			fos.close();

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

	}

}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputDemo2 {

	public static void main(String[] args) {
		try {
			FileInputStream fis = new FileInputStream("pictrue.jpg");
			FileOutputStream fos = new FileOutputStream("pictrue2.jpg");
			int n = 0;
			byte[] b = new byte[1024];        	// 1024字节数组存放1k的数据
			while ((n = fis.read(b)) != -1) { 	// 循环将读到的数据放入pictrue2,返回值n是读取											     // 字节数据长度
				fos.write(b, 0, n); 			// write(b,0,n)的意思是将b中0-n个数据写到文件												// 中，最后一次的字节数组可能没有存满,n则代表了读到 											  // 数据在b中的偏移量
                   								// 最后一次的字节数组可能 
												// 没有存满,n代表了读到的数据在b中的偏移量
			}
			fis.close();
			fos.close();

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

	}

}

字节缓冲流：

BufferedInputStream:

缓冲输入当创建 BufferedInputStream 时，将创建一个内部缓冲区数组。

BufferedOutputStream:

该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

⭐️提高读写速度，和输入输出流结合使用

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedDemo {

	public static void main(String[] args) {
		try {
			FileOutputStream fos = new FileOutputStream("buffer.txt");
			BufferedOutputStream bos = new BufferedOutputStream(fos);

			FileInputStream fis = new FileInputStream("buffer.txt");
			BufferedInputStream bis = new BufferedInputStream(fis);

			bos.write(50);                              //写入和读出的都是一个字节8位int
			bos.write('Y');
			bos.flush();
			System.out.println(bis.read());            //通过缓冲区读取文件内容
			System.out.println((char) bis.read());	   //读取下一个

			bos.close();
			bis.close();
			fos.close();
			fis.close();

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

	}

}

字节字符转换流：

InputStreamReader:

InputStreamReader是从字节流到字符流的桥：它读取字节，并使用指定的编码将其解码为字符。它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。

OutputStreamWriter:

OutputStreamWriter是从字符流到字节流的桥：它接收字符，由指定的编码解码成字节流。它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集。

模拟从网络读取到字节流的文件：

package fileDemo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

	public static void main(String[] args) {
		try {
			FileInputStream fis=new FileInputStream("life.txt");
            InputStreamReader isr=new InputStreamReader(fis);
            
			FileOutputStream fos=new FileOutputStream("life.txt2");
			OutputStreamWriter osw=new OutputStreamWriter(fos); 
			
			int n=0;	
//			while((n=isr.read())!=-1) {
//				System.out.print((char)n);
//			}
			
//			char[] cbuf=new char[10];			
//			while((n=isr.read(cbuf))!=-1) {
//				System.out.print(new String(cbuf,0,n));
//			}
			
			
//			while((n=isr.read())!=-1) {
//				osw.write(n);
//			}
//			osr.flush();
			
			char[] cbuf=new char[10];			     //读入和写出的都是一个字符，返回字符的int值
			while((n=isr.read(cbuf))!=-1) {            
			osw.write(cbuf,0,n);
			}
		    osw.flush();
		    
		    fis.close();
		    fos.close();
		    isr.close();
		    osw.close();
					
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

}

字符缓冲流：

BufferedReader:

从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。

BufferedWriter:

将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。

使用缓冲流读入和写出：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

	public static void main(String[] args) {
		try {
			FileInputStream fis=new FileInputStream("life.txt");
			InputStreamReader isr=new InputStreamReader(fis);
			BufferedReader br=new BufferedReader(isr);				//使用缓冲区读
		
			FileOutputStream fos=new FileOutputStream("life.txt2");
			OutputStreamWriter osw=new OutputStreamWriter(fos); 
			BufferedWriter bw=new BufferedWriter(osw);             //使用缓冲区写
			
			int n=0;	
//			while((n=isr.read())!=-1) {
//				System.out.print((char)n);
//			}
			
//			char[] cbuf=new char[10];			
//			while((n=isr.read(cbuf))!=-1) {
//				System.out.print(new String(cbuf,0,n));
//			}
			
			
//			while((n=isr.read())!=-1) {
//				osw.write(n);
//			}
//			osr.flush();							 //刷新流
			
			char[] cbuf=new char[10];			     //读入和写出的都是一个字符，返回字符的int值
			while((n=br.read(cbuf))!=-1) {            
			bw.write(cbuf,0,n);
			}
		    bw.flush();
		    
		    fis.close();
		    fos.close();
		    isr.close();
		    osw.close();
		    br.close();
		    bw.close();
					
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	
	}

}

字符流：

FileReader:

FileReader是用于读取字符流。要读取原始字节流，请考虑使用FileInputStream 。

FileWriter:

FileWriter是用于写入字符流。要编写原始字节流，请考虑使用FileOutputStream。

对象的序列化与反序列化

ObjectOutputStream：

oos.write(对象)
序列化：把java对象转化为字节序列的过程

ObjectInputStream:

ois.readObject() 返回对象的所有父类
反序列化：把字节序列恢复成java对象

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class GoodsTest {

	public static void main(String[] args) {

		Goods goods = new Goods("001", "手机", 2999);
		try {

			FileOutputStream fos = new FileOutputStream("life.txt");
			ObjectOutputStream oos = new ObjectOutputStream(fos);

			FileInputStream fis = new FileInputStream("life.txt");
			ObjectInputStream ois = new ObjectInputStream(fis);

			// 将Goods对象写入到文件life.txt
			oos.writeObject(goods);
			// 从life.txt文件中读出对象
			System.out.println(ois.readObject());
			// 关闭输入输出流
			oos.close();
			fos.close();
			fis.close();
			ois.close();

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

	}

}

LifePassion

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java输入输出流

java输入输出流[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wVlfbSBC-1587023533769)(C:\Users\life\AppData\Roaming\Typora\typora-user-images\image-20200413131912574.png)]File类常用方法：package fileDemo;import java...
复制链接

扫一扫

专栏目录