初学者对于I/O流的小节-上
我是一个刚刚进入java开发的菜鸟，java 基础比较薄弱，面试的路程也经历坎坷。带着这样的心态，我总结了这个关于java io 的文章，肯定覆盖面不全，但是肯定都是最基础最实用的。
第一章 初步认识 输入输出流 I/O流
第一步 流是什么 ？
流是对于信息的一个抽象！
站在程序的角度上讲 输入流 是读取数据
站在程序的角度上讲 输出流 是写入数据
第二步 流 分两种
（1）字节流 用于译字节为单位的输入输出，主要是用于处理 图形声音文件
InputStream 这是所有字节输入流的 父类
OutputStream 这是所有字节输出流的 父类
（2）字符流 以字符为基本处理的单位 ，主要用于处理文本类型文件
Reader这是所有字节输入流的 父类
Writer这是所有字节输出流的 父类
第三步 操作文件
File 类 它既可以代表一个资源文件 也可以代表一个文件夹！
介绍几个常用的方法 getPath() getName() isFile() exists() createNewFile() mkdir()
对于文件的方法可以对文件进行各种操作，唯独不能对其内容进行操作
public class FileDemo {
public static void main(String[] args) {
//创建一个file 对象 指向 一个文件或者目录 文件或者目录不一定存在
File file = new File("d:"+File.separator+"a.txt");//separator 是分割符的意思 //
if(!file.exists())
{
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("文件绝对路径"+file.getAbsolutePath());
long lastmodifile = file.lastModified();
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
String lastdate = df.format(new Date(lastmodifile));
System.out.println("最后修改的日期 "+lastdate);
File file2 = new File("c://hellword ");
if(!file2.exists())
{
file2.mkdir();//创建一个目录
}
}
}
**
第二章 字节流
**
首先是输入流 读取到文件内容 并且打印
public static void read(){
File file = new File("d://ceshi.txt");// 首先先创建一个文件
try {
//创建一个字节输入流
InputStream input = new FileInputStream(file);
byte[] bytes = new byte[1024*1024];
//因为是字节输入流 所以只能用字节的方式去读取数据
// byte 数组 的大小就是没次读取的长度 这里我设置的比较大
//如果把里面的参数设置为1 的话 代表的意思是每次读取一个字节 这样读取中文会出问题
int len = -1;
StringBuffer buffer = new StringBuffer();//创建一个StringBuffer 来接收读取的数据
while((len =input.read(bytes))!=-1) //当读取的长度不等于-1 代表没有读取完的时候 继续读取
{
buffer.append(new String(bytes,0,len));
}
input.close(); //养成一个用完流就关闭的好习惯
System.out.println(buffer);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}接下来是输出流 想文件写入内容
public static void write(){
File file = new File("d://ceshi.txt");
if(file.exists()==false)
{
try {
file.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
try {
OutputStream out = new FileOutputStream(file);
String xieshu ="输入写入的内容 ";
//写入数据 因为这里面是字节流 所以 要把我写入的字符串转换成字节的形式去写入
out.write(xieshu.getBytes());
out.close();//释放资源
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}第三章 字符流
首先是字符输入流 reader
public static void read(){
File file = new File("d://asdcd.txt");//和字节流一样 首先要构造一个文件
try {
Reader reader = new FileReader(file); //创建一个读取reader
char[] c = new char[10]; //这里面传入的不是字节 是字符了
int len = -1;
StringBuffer buffer = new StringBuffer();
//下面实现思路与字节流的读取一样
while((len =reader.read(c))!=-1)
{
buffer.append(new String(c,0,len));
}
reader.close();
System.out.println(buffer);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}下面是字符输出流
public static void write(){
File file = new File("d://asdcd.txt");
try {
Writer out = new FileWriter(file);
String xieshu ="你好 ， world";
//写入数据
out.write(xieshu); //这里想对于这个字节输入流而言 直接向文件输出字符串即可
out.close();//释放资源
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}**
第四章 缓冲流
**
计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。
为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。
为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。
下面分别是加上缓冲流之后的字符输入输出流 、 字节输入输出流
/** * 字符输出流 */
public static void zifuout()
{
try {
Writer writer = new FileWriter("D:\\ceshi.txt");
BufferedWriter bufferwriter = new BufferedWriter(writer);
bufferwriter.write("测试字符缓冲流");
bufferwriter.close();
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** * 字符输入流 */
public static void zifuin()
{
String result;
try {
Reader reader = new FileReader("D:\\ceshi.txt");
BufferedReader bufferedReader = new BufferedReader(reader);
result = bufferedReader.readLine();
bufferedReader.close();
reader.close();
System.out.println(result);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** * 用字节输出流 */
public static void bufferout()
{
try {
OutputStream out = new FileOutputStream("D:\\a.txt");
BufferedOutputStream bufferout = new BufferedOutputStream(out);
bufferout.write("测试用字节缓冲流写入文件 ".getBytes());
bufferout.close();
out.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** * 用字节输入流 */
public static void bufferin()
{
try {
InputStream in = new FileInputStream("D:\\a.txt");
BufferedInputStream bufferin = new BufferedInputStream(in);
int len= -1;
byte[] bytes =new byte[1024*1024];
StringBuffer result = new StringBuffer();
while((len=bufferin.read(bytes))!=-1)
{
result.append(new String(bytes,0,len));
}
bufferin.close();
in.close();
System.out.println(result);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}通过上面的例子 我们还可以发现，当我们 无论是给字符 还是字节输入输出流套上一层缓冲流的时候，当我们用缓冲流对象进行读写的时候，会多一些方法！ 比如readline() 等一写常见好用的方法！所以 建议以后再写流的时候一定要套上缓冲流
第五章 其他常见的流
- 打印流
推荐一个很好用，很常用的输出流 — 打印流
/** * PrintStream 字节打引流 */
public static void shuchu(){
try {
OutputStream out = new FileOutputStream("D:\\a.txt");
BufferedOutputStream bos = new BufferedOutputStream(out);
//bos.write("写入的内容".getBytes());//原来的方法
PrintStream ps = new PrintStream(bos);
ps.println("写入的内容");//用打印流之后的方法
bos.close();
ps.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** * 字符打印流 Print Writer */
public static void shuchu2(){
try {
Writer writer = new FileWriter("D:\\a.txt");
BufferedWriter bufferedWriter = new BufferedWriter(writer);
PrintWriter printWriter = new PrintWriter(bufferedWriter);
printWriter.print("写入的内容");
printWriter.close();
bufferedWriter.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
- 数据流
public static void DataOut(){
try {
OutputStream out = new FileOutputStream("d:\\a.txt");
DataOutputStream dos = new DataOutputStream(out);
dos.writeInt(10);// 按照数据 类型 去写
dos.writeUTF("测试数据流 ");
dos.close();
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void DataIn(){
try {
InputStream in = new FileInputStream("d:\\a.txt");
DataInputStream dis= new DataInputStream(in);
int a =dis.readInt(); //按照数据类型去读
String asd= dis.readUTF();
dis.close();
in.close();
System.out.println(a+asd);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}- 字符串流
public static void StringStream()
{
String s = "需要解析的文件";
StringReader reader = new StringReader(s);
//这样就 可以 用 流的方式去读取
}当我们从网上截取一段报文 一段文字 一段密文 需要用流的形式去解析的时候 字符串流是一个不二选择，不会抛出任何IO异常
- 字节数组流
/** * 在内存中操作 */
public static void bytearryStream(){
String info = "字节数组流测试";
ByteArrayInputStream bis = new ByteArrayInputStream(info.getBytes());
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int i =-1;
while((i=bis.read())!=-1)
{
bos.write(i);
}
//可以把一个图片的数据写进去 这个 ByteArray里面
System.out.println(bos.toString());
}
这个流的特点是在内容当中操作 与外部文件 无关，且不会产生IO异常
此文章为自己总结 ，欢迎大家改正批评！ 不喜勿喷