JAVA学习日记-IO流-FileInputStream

FileInputStreamTest01:

/*
java.io.InputStream;
	java.io.FileInputStream; 文件字节输入流

	按照字节方式读取文件.
*/
import java.io.*;
public class FileInputStreamTest01 {
	public static void main(String[] args){
		 
		FileInputStream fis = null;
		
		try{
			//1.要读取某文件，先与这个文件创建一个“输入流”

			//文件路径
			//String filePath = "temp01.txt"; //相对路径，相对当前而言，在当前路径下找。
			//String filePath = "C:\\Users\\z\\workspace\\Practice\\src\\IO\\temp01.txt";
			String filePath = "C:/Users/z/workspace/Practice/src/IO/temp01.txt";
			fis = new FileInputStream(filePath);
			
			//开始读
			int i1 = fis.read();//以字节的方式读取
			int i2 = fis.read();
			int i3 = fis.read();
			int i4 = fis.read();
			int i5 = fis.read();
			int i6 = fis.read();

			int i7 = fis.read();
			
			System.out.println(i1);
			System.out.println(i2);
			System.out.println(i3);
			System.out.println(i4);
			System.out.println(i5);
			System.out.println(i6);
			System.out.println(i7);
		}catch(FileNotFoundException e){
			e.printStackTrace();
		}catch(IOException e){
			e.printStackTrace();
		}finally{
			
			//为了保证流一定会被释放，所以finally语句块中执行
			if(fis!=null){
				try{
					fis.close();
				}catch(IOException e){
					e.printStackTrace();
				}
			}
		}

}
}

FileInputStreamTest02:

import java.io.*;
public class FileInputStreamTest02 {
	public static void main(String[] args)throws Exception{
		
		//创建流
		
		String filePath = "C:/Users/z/workspace/Practice/src/IO/temp01.txt";

		FileInputStream fis = new FileInputStream(filePath);
		
		//2.开始读
				/*
				while(true){
					int temp = fis.read();
					if(temp==-1) break;
					System.out.println(temp);
				}
				*/
		//以上程序存在缺点：频繁访问磁盘，伤害磁盘，并且效率低。
		
		
		//升级循环
		int temp = 0;
		while((temp=fis.read())!=-1){
			System.out.println(temp);
			
		}
		
		//关闭
		fis.close();
	}

}

FileInputStreamTest03:

/*
int read(byte[] bytes);
读取之前在内存中准备一个byte数组，每次读取多个字节存储到byte数组中。
一次读取多个字节，不是单字节读取了。

效率高。
*/
import java.io.*;
public class FileInputStreamTest03 {
	public static void main(String[] args)throws IOException{
		
		//创建输入流
		String filePath = "C:/Users/z/workspace/Practice/src/IO/temp01.txt";

		FileInputStream fis = new FileInputStream(filePath);
		
		//开始读
		//准备一个byte数组
		byte[] bytes = new byte[3];//每一次最多读取3个字节
		
		//int read(byte[] bytes);该方法返回的int类型的值代表的是，这次读取了多少个字节
		int i1 = fis.read(bytes);//3
		
		//将byte数组转化为字符串
		System.out.println(new String(bytes));//abc
		
		int i2 = fis.read(bytes);//3
		
		System.out.println(new String(bytes));//def
		
		int i3 = fis.read(bytes);//1
		
		System.out.println(new String(bytes));//gef
		
		System.out.println(new String(bytes,0,i3));//g
		
		int i4 = fis.read(bytes);//-1 已到达文件的末尾， 返回-1
		
		System.out.println(i1);//3
		System.out.println(i2);//3
		System.out.println(i3);//1
		System.out.println(i4);//-1
		
		
		//关闭
		fis.close()
		
	}

}

FileInputStreamTest04:

//循环读取
import java.io.*;
public class FileInputStreamTest04 {
	public static void main(String[] args)throws IOException{
		
		//创建输入流
				String filePath = "C:/Users/z/workspace/Practice/src/IO/temp01.txt";

				FileInputStream fis = new FileInputStream(filePath);
				
				//循环读取
				byte[] bytes = new byte[1024];//每次读取1KB
				
				/*
				while(true){
					
					int temp = fis.read(bytes);
					if(temp==-1) break;

					//将byte数组中有效的数据转换成字符串.
					System.out.print(new String(bytes,0,temp));
				}
				*/
				
				//升级循环
				int temp = 0;
				while((temp=fis.read(bytes))!=-1){
					System.out.println(new String(bytes,0,temp));
				}
				
				fis.close();		
	}

}

FileInputStreamTest05:

import java.io.*;
public class FileInputStreamTest05 {
	public static void main(String[] args)throws IOException{
		
		//创建流
				String filePath = "C:/Users/z/workspace/Practice/src/IO/temp01.txt";

				FileInputStream fis = new FileInputStream(filePath);
				
				System.out.println(fis.available());//7
				
				System.out.println(fis.read());//97
				
				//int available();返回流中剩余的估计字节数
				System.out.println(fis.available());//6
				
				fis.skip(2);//跳过两个字节
				
				System.out.println(fis.read());//100
				
				//关闭
				fis.close();
				
				
	}

}

注：需要掌握的十六个流
java.io.*;

FileInputStream
FileOutputStream
FileReader
FileWriter

BufferedReader
BufferedWriter
BufferedInputStream
BufferedOutputStream

DataInputStream
DataOutputStream

ObjectInputStream
ObjectOutputStream

转换流(字节流转换成字符流)
InputStreamReader
OutputStreamWriter

PrintWriter
PrintStream //标准的输出流(默认输出到控制台)

java语言中的流分为：四大家族,(InputStream,OutputStream,Reader,Writer)