JAVA IO FileInputStream和FileOutputStream，字节流的打包输出

最新推荐文章于 2024-06-28 21:07:29 发布

原创最新推荐文章于 2024-06-28 21:07:29 发布 · 368 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#JAVA IO操作 #字节流 #java核心思想

JAVA 基础专栏收录该内容

73 篇文章

订阅专栏

本文深入探讨了Java中文件的字节流与字符流操作，包括文件输入输出流的使用方法，如FileInputStream、FileOutputStream的实例应用，以及如何通过缓冲流提升数据传输效率，并详细解析了读取与写入文件的具体实现过程。

在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流

1，字节流是由字节构成的，字符流是由字符构成的字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流

类 FileInputStream 从文件系统中的某个文件中获得输入字节

类 FileOutputStream 文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。

2，数据流：用于传输的管道

3.java.io 输入流 InputStream 输出流 OutputStream

4.对文件系统的输入和输出字节流：数据在管道中是以字节的方式传输的

文件输入流 FileInputStream

文件输出流 FileOutputStream

将字节流包装到缓冲流中，传输的速度回提高几百倍，在下面的代码中我们将做测试

缓冲字节输入流 BufferedInputStream

缓冲字节输出流 BufferedOutputStream

5，使用FileInputStream来一字节一个字节的读取字节：在写代码之前先看api文档中字节输入流中有哪些方法，

在java输入流中，如果程序读取的文件不存在程序是不会自动的创建该文件，输出流则会自己创建

在工程中创建一个FileInputstream01.txt 文本，里面写"中国式"个字符

package FileIO0523;
/**
 * 字节流的操作
 * 使用FileInputStream来一字节一个字节的读取字节
 */

import java.io.File;
import java.io.FileInputStream;

public class FileInputstream01 {

	public static void main(String[] args) {
      //创建文件的对象
		File file = new File("FileInputstream01.txt");
		try{
         //try-catch是因为这个文件可能不存在，程序可能会无法执行抛出异常
			//使用文本创建输入流对象
			FileInputStream fis =new FileInputStream(file);
			
//			for(int i=0;i<file.length();i++){
//				//byte ch = (byte) fis.read();
//				char ch  = (char) fis.read();
//				System.out.println(ch);
//				}
			//根据文件的长度来创建一个byte数组用来保存字节
                     //
			byte[] by= new byte[(int) (file.length())];
			fis.read(by);
			String str = new String(by);
				System.out.println(str);
				
				
			//	fis.read();
			
				fis.close();
				
			//}
			
			
		}catch(Exception e){
			e.printStackTrace();
		}

	}

}

运行结果;
中国式

分析read()；也可以用来判断读的字节，当read为-1的时候表示已经是最后一个字节了

fis.read(by);将by数组中的字符一个一个读出来

String str = new String(by);通过使用平台的默认字符集解码指定的 byte 数组 ，  构造一个
新的 String
System.out.println(str);
将这个String打印出来

fis.close();关闭这个输入流，java程序是运行在java虚拟机上面的，虚拟机的运行空间是由系统内存分配的，如果不关闭输入流空间，会导致大量的内存浪费，及内存空间不足

6，使用FileOutputStream来一字节一个字节的写字节：在写代码之前先看api文档中字节输入流中有哪些方法，

在java输入输出的文件操作中，如果该文件在程序要输出时不存在程序会自动的创建该文件，

package FileIO0523;

import java.io.File;
import java.io.FileOutputStream;

/**
 * 创建一个字节输出流
 * @author Administrator
 *
 */

public class FileoutputStream01 {

	public static void main(String[] args) {

		String str ="湖南长沙";
		//由于是静态方法可直接通过方法名来调用
		put01(str);
	}
	//创建一个静态的方法，方便在主函数中来调用该方法
	public static void put01(String str){
		//创建文件对象，文件输出对象会在输出时候判断
//		该文件是否存在，如果不存在会自动创建该标准文件
		File file = new File("FileoutputStream01.txt");
		try{
			//通过文件创建输出字节流的对象
			//创建输出流
			//参数一：要写入的文件
			//参数二：是否需要将数据追到数据的末尾ture表示追加到末尾，false表示覆盖
			FileOutputStream stream = new FileOutputStream(file,true);
			//将字符串保存到数组中
			byte[] buf=str.getBytes();
			//将数组中的元素写出来
			stream.write(buf);
			//强制的从内存写到硬盘中
			stream.flush();
			//关闭流
			stream.close();
		}catch(Exception e){
			e.printStackTrace();
		}
		
	}

}

运行结果：
湖南长沙

分析:该程序在写出字符时会先判断要写出的文件是否存在，如果不存会自动的创建

7，如何在一个程序中将读取到的方法写到文件中去：下面是一个复制程序:

package FileIO0523;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 文件流的操作
 * 
 *
 * 
 */
public class FIleIO2 {

	public static void main(String args[]) {

		String path = "C:\\Users\\Administrator\\Desktop\\import";
		String path1 = "F:\\file1\\import";
		// 创建文件对象
		File f = new File(path);
		File f1 = new File(path1);

		long t1 = System.currentTimeMillis();
		byte[] str = readFile(f);
		writeFile(f1, str);
		long t2 = System.currentTimeMillis();
		System.out.println("复制完成！耗时：" + (t2 - t1) + "ms");

	}

	public static void writeFile(File f, byte[] bs) {
		try {
			// 根据文件对象建立文件输出流
			// 参数1：要写入数据的文件路径
			// 参数2：是否将数据追加到文件末尾
			FileOutputStream fos = new FileOutputStream(f, false);
			// 将输出流包装成缓冲输出流
			BufferedOutputStream bos = new BufferedOutputStream(fos);

			// 使用缓冲流将数组写入输出流
			bos.write(bs);

			// 强制将管道中的数据输出到目标，保证数据写完整
			bos.flush();
			// 关闭输出流
			fos.close();

		} catch (Exception ef) {
			ef.printStackTrace();
		}
	}

	/**
	 * 读取文件数据的方法
	 * 
	 * @param f
	 *            要读读取的文件路径
	 */
	public static byte[] readFile(File f) {
		try {
			// 根据文件建立建立文件输入流
			FileInputStream fis = new FileInputStream(f);
			// 将文件输入流打包成缓冲输入流
			BufferedInputStream bis = new BufferedInputStream(fis);

			int len = bis.available();// 得到流中的字节数
			// 方式一：通过流的长度决定读的次数
			// while(len>0){
			// //读取流中的一个字节
			// int b = fis.read();
			// System.out.println("字节:"+b);
			// len = fis.available();
			// }

			byte[] bs = new byte[len];

			// 方式二，通过读取的字节判断读取的次数〉若为-1，就结束
			// int i=0;
			// int b = fis.read();
			// while(b!=-1){
			// System.out.println("字节:"+b);
			// //将字节保存到字节数组
			// bs[i]=(byte)b;
			// i++;
			//
			// b = fis.read();
			// }

			// 方式三：直接将数据读取到字节数组，数组有多大，就读取多少次
			bis.read(bs);
			fis.close();

			return bs;

		} catch (Exception ef) {
			ef.printStackTrace();

		}

		return null;

	}

}

分析：在这个复制程序中创建两个方法分别是读和写，在程序的执行中会先调用读的方法，将读取到的内容保存到数组中在读的方法中不直接打印出来通过return返回主函数中以数组的形式来接受；并且该数组要作为参数传递到写的方法中；

7，作业：在一个方法中完成文件的复制

分析：方法中要包读和写的操作

package FileIO0523;
/**
 * 不可以拷贝文件夹，图片
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 *  作业：在一个方法中完成文件的复制
 
 * @author Administrator
 *
 */
public class copyinputoutput02 {

	public static void main(String[] args) {
		
		//源文件的地址
		String path1 ="C:\\Users\\Administrator\\Desktop\\文件操作.rar";
		//copy的地址
		String path2 = "F:\\file1\\文件操作.rar";
		
		File file1 = new File(path1);
		File file2 = new File(path2);
		copy02(file1,file2);
		System.out.println("拷贝完成");
	}
	
	
	public static void copy02(File file1,File file2){
		
		try{
			//读
			FileInputStream fis= new FileInputStream(file1);
			//创建输入缓冲流
			BufferedInputStream bis = new BufferedInputStream(fis);
			//根据读到文件的大小来创建数组
			byte[] by = new byte[(int) (file1.length())];
			//读取
			bis.read(by);
			//关闭流
			fis.close();
			
			//写
			FileOutputStream fos = new FileOutputStream(file2);
			//创建输出缓冲流
			BufferedOutputStream bos = new BufferedOutputStream(fos);
			//直接写保存在数组中的数据
			bos.write(by);
			//强制写出来
			bos.flush();
			//关闭流空间
			fos.close();
			
		}catch(Exception e){
			e.printStackTrace();
		}
		

	
	}
	

	
}

分析：该程序的可读性高，在一个方法中不做任何的返回，将读取到的数据保存到根据读取的文件大小创建的数组中，写的方法可以调用；