/**
* IO流，什么是IO？
* I：input
* O：output
* 通过IO可以完成硬盘文件的读和写
*
* IO流的分类：
* 1、按照流的方向进行分类
* 以内存为参照物：
* 往内存中去，叫做输入，或者读（Read）
* 从内存中出来，叫输出，或者写（Write）
*
* 2、另一种方式是按照读取数据方法不同进行分类：
* 1、有些流按照字节的方式及读取数据，一次读取1个字节byte，等同于一次读取8个二进制位
* 这种流是万能的，什么类型的文件都可以读取，（文本文件，图片，声音文件，视频文件等）
* 文件file.txt,采用字节流的话：
* a中国saf张大发dee
* 第一次读：一个字节，’a'字符（‘a’字符在Windows系统中占用一个字节）
* 第二次读：一个字节，‘中’字符的一半（‘中’字符在Windows系统中占用两个字节）
* 第三次读：一个字节，‘中’字符的另一半
*
*
* 2、有的流是按照字符的方式读取数据，一次读取一个字符，这种流是为了方便读取普通文本文件
* 而存在的，这种流不能读取：图片，声音，视频等文件，只能读取纯文本文件，Word文件都无法读取
* 文件file.txt,采用字符流的话：
* a中国saf张大发dee
* 第一次读：’a'字符（‘a’字符在Windows系统中占用一个字节）
* 第二次读：‘中’字符（‘中’字符在Windows系统中占用两个字节）
*
* 总结：
* 输入流，输出流
* 字节流，字符流
*
* 2、java中的IO流已经写好了，我们不需要关心，只要掌握java中提供了哪些流，每个流的特点，每个流对象上的常用方法有哪些？
* java中的流都在java.io.*包下
*
* 3、java IO中的四大家族：
* java.IO.InputStream; 字节输入流
* java.IO.OutputStream; 字节输出流
*
* java.IO.Reader; 字符输入流
* java.IO.Writer; 字符输出流
*
* 四大家族的首领都是接口（abstract class)
* public abstract class InputStream
* extends Object
* implements Closeable
*
* 所有的流都实现了：
* java.io.Closeable接口，都是可关闭的，都有close（）方法
* 流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭
* 不然会耗费（占用）很多资源，养成习惯，用完流要关闭。
*
* 所有的输出流都实现了：
* java.io.Flushable接口，都是可刷新的，都有flush()方法
* 养成习惯，输出流在最终输出之后，一定要记得flush（），刷新一下，这个
* 刷新表示将管道/通道当中剩余未输出的数据，强行输出完（清空管道）
*
* 注意：在java中只要以“stream”结尾的都是字节流，以“Reader/Writer”结尾的都是字符流
*
*
* 4、java.io包下的需要掌握的流有16个：
*
* //文件专属
* java.io.FileInputStream
* java.io.FileOutputStream
* java.io.FileReader
* java.io.FileWriter
*
* 转换流（将字节流转换为字符流）
* java.io.InputStreamReader
* java.io.OutputStreamWriter
*
* 缓冲流专属：
* java.io.BufferedInputStream
* java.io.BufferedOutputStream
* java.io.BufferReader
* java.io.BufferWriter
*
* 数据流专属：
* java.io.DataInputStream
* java.io.DataOutputStream
*
* 对象专属流：
* java.io.ObjectInputStream
* java.io.ObjectOutputStream
*
* 标准输出流：
* java.io.PrintWriter
* java.io.PrintStream
*
*/
public class Note01 {
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest01 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("H:\\temp.txt");
int readData = 0;
while( (readData = fis.read())!= -1){
System.out.println("读取文件的字符，字节流的方式，输出的应该是字节：" + readData);
}
System.out.println("读取到最后，再读取的话，返回值为 ：" + readData);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest02 {
public FileInputStreamTest02() {
}
public static void main(String[] args) {
FileInputStream ss = null;
try {
ss = new FileInputStream("temp.txt");
byte[] bytes = new byte[4];
int shu = ss.read(bytes);
System.out.println(shu);
System.out.println(new String(bytes));
shu = ss.read(bytes);
System.out.println(shu);
System.out.println(new String(bytes));
System.out.println(new String(bytes,0,shu));
shu = ss.read(bytes);
System.out.println(shu);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ss != null) {
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest03 {
public static void main(String[] args) {
FileInputStream aaa = null;
try {
aaa = new FileInputStream("temp.txt");
byte[] i = new byte[4];
int b;
while( (b = aaa.read(i)) != -1){
System.out.print( new String(i,0,b));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (aaa != null) {
try {
aaa.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest04 {
public static void main(String[] args) {
FileInputStream it = null;
try {
it = new FileInputStream("temp.txt");
System.out.println("没有读取的字节个数：" + it.available());
byte[] bytes = new byte[it.available()];
System.out.println(" byte[] bytes = new byte[it.available()];");
System.out.println("这种方式不太适合太大的文件，因为byte[]数组不能太大，大概六千多万吧，60M左右");
int i ;
it.skip(2);
while((i = it.read() )!= -1){
System.out.print(i + " ");
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (it != null) {
try {
it.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}