IO流是用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按照操作数据分两种：字节流和字符流
流按照流向分为：输入流和输出流。
IO流常用基类
字节流的抽象基类：
InputStream ，OutputStream。
字符流的抽象基类：
Reader，Writer。
注：由这四个派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
Reader的子类FileReader。
先学习一下字符流特点。
既然IO流失用于操作数据的，
那么数据的最常见体现形式：文件。
那么先以操作文件为主来演示。
需求：在硬盘上创建一个文件，并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象：FileWriter。后缀名是父类名，前缀名是该流对象的功能。
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。
//而且该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖。
//其实该步骤就是在明确数据要存放的目的地。
FileWriter fw = new FileWriter("demo.txt");
//调用write方法，将字符串写入流中。
fw.write("abcde");
//刷新流对象缓冲中的数据。将数据刷到目的地中。
fw.flush();
//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据，将数据刷到目的地中。
fw.close();
}
}
IO异常的处理方式。
/*
IO异常的处理方式。
*/
import java.io.*;
class FileWriterDemo2
{
public static void main(String[] args)
{
FileWriter fw = null;
try
{
fw = new FileWriter("demo.txt");
fw.write("abcdefg");
}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(fw!=null) //一定要注意判断fw是否建立成功
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
演示对已有文件的数据续写。
/*
演示对已有文件的数据续写。
*/
import java.io.*;
class FileWriterDemo3
{
public static void main(String[] args)
{
FileWriter fw = null;
try
{
//传递一个true参数，代表不覆盖已有的文件，并在已有文件的末尾处进行数据续写。
fw = new FileWriter("demo.txt",true);
fw.write("haha\r\nhehe"); //windows换行用\r\n
}
catch (IOException e)
{
System.out.println(e.toString());
}
finally
{
try
{
if(fw!=null) //一定要注意判断fw是否建立成功
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
文本文件读取方式
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
FileReader fr = new FileReader("demo.txt");
//弟阿勇读取流对象的read方法。
//read():一次读一个字符，而且会自动往下读。
/*
while(true)
{
int ch = fr.read();
if(ch==-1)
break;
System.out.println("ch="+(char)ch);
}
*/
int ch = 0;
while((ch=fr.read())!=-1)
{
System.out.println((char)ch);
}
fr.close();
}
}/*
第二种方式：通过字符数组进行读取。
*/
import java.io.*;
class FlieReaderDemo2
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("demo.txt");
//定义一个字符数组，用于存储读到字符。
//该read(char[])返回的是读到的个数。
char[] buf = new char[1024];
int num = 0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}
练习：
/*
练习：读取一个.java文件，并打印在控制台上。
*/
import java.io.*;
class FlieReaderTest
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("DateDemo.java");
char[] buf = new char[1024];
int num = 0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}
拷贝文本文件练习：
/*
练习：将c盘中一个文件复制到d盘。
复制原理：
其实就是将c盘的文件数据存储到d盘的一个文件中。
步骤：
1.在d盘创建一个文件，用于存储c盘文件中的数据。
2.定义读取流和c盘文件关联。
3.通过不断的读写完成数据存储。
4.关闭资源。
*/
import java.io.*;
class CopyTest
{
public static void main(String[] args) throws IOException
{
copy_1();
copy_2();
}
//从c盘读一个字符就往d盘写一个字符。
public static void copy_1() throws IOException
{
//创建目的地。
FileWriter fw = new FileWriter("RuntimeDemo_copy.text");
//与已有文件关联。
FileReader fr =new FileReader("RuntimeDemo.java");
int ch = 0;
while((ch=fr.read())!=-1)
{
fw.write(ch);
}
fw.close();
fr.close();
}
public static void copy_2()
{
FileWriter fw = null;
FileReader fr = null;
try
{
fw = new FileWriter("SystemDemo_copy.txt");
fr = new FileReader("SystemDemo.java");
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
if(fr!=null)
try
{
fr.close();
}
catch (IOException e)
{
}
if(fw!=null)
try
{
fw.close();
}
catch (IOException e)
{
}
}
}
}
字符流的缓冲区
缓冲区的出现提高了对数据的读写效率
对应类：
BufferedWriter
BufferedReader
缓冲区要结合流才可以使用
在流的基础上对流的功能进行增强
BufferedWriter
字符输入流缓冲区：
缓冲区的出现是为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。
该缓冲区中提供了一个跨平台的换行符：newLine().
/*
缓冲区的出现是为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。
该缓冲区中提供了一个跨平台的换行符：newLine().
*/
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建一个字符写入流对象。
FileWriter fw = new FileWriter("buf.txt");
//为了提高字符写入流效率，加入了缓冲技术。
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriter bufw = new BufferedWriter(fw);
for(int x=1;x<5;x++)
{
bufw.write("abcde"+x);
bufw.newLine();
bufw.flush();
}
//记住，只要用到缓冲区，就要记得刷新。
bufw.flush();
//其实关闭缓冲区，就是在关闭缓冲区中的流对象。
bufw.close();
}
}
BufferedReader
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法：readLine(),方便于对文本数据的获取。
当返回null时，表示读到文件末尾。
readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个读取流对象和文件相关联。
FileReader fr = new FileReader("buf.txt");
//为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine())!=null)
{
System.out.println(line);
}
//String s1 = bufr.readLine();
bufr.close();
}
}
通过缓冲区复制一个文本文件。
/*
通过缓冲区复制一个.java文件。
*/
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args)
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
bufw = new BufferedWriter(new FileWriter("bufferedWriterDemo.txt"));
String line = null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
MyBufferedReader的设计
/*
自定义一个类包含一个功能和readLine一致的方法来模拟一下BufferedReader。
*/
import java.io.*;
class MyBufferedReader extends Reader
{
private FileReader r;
MyBufferedReader(FileReader r)
{
this.r = r;
}
//可以一次读一行数据的方法。
public String myReadLine()throws IOException
{
//定义一个临时容器，原BufferedReader封装的是字符数组。
//为了演示方便，定义一个StringBuilder容器，因为最终还是要将数据变成字符串。
StringBuilder sb = new StringBuilder();
int ch =0;
while((ch=r.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
//覆盖Reader类中的抽象方法。
public void close()throws IOException
{
r.close();
}
public int read(char[] cbuf,int off,int len)throws IOException
{
return r.read(cbuf,off,len);
}
public void myClose()throws IOException
{
r.close();
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("buf.txt");
MyBufferedReader myBuf = new MyBufferedReader(fr);
String line = null;
while((line=myBuf.myReadLine())!=null)
{
System.out.println(line);
}
myBuf.myClose();
}
}
装饰设计模式
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的类称为装饰类。
装饰类通常会通过构造方法接收被装饰对象，并基于被装饰的对象的功能，提供更强的功能。
class Person
{
public void chifan()
{
System.out.println("吃饭");
}
}
class SuperPerson
{
private Person p;
SuperPerson(Person p)
{
this.p=p;
}
public void superChifan()
{
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();
p.chifan();
SuperPerson sp = new SuperPerson(p);
sp.superChifan();
}
}
装饰和继承的区别
MyReader//专门用于读取数据的对象。
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
class MyBufferReader
{
MyBufferedReader(MyTextReader text){}
MyBufferedReader(MyMediaReader Media){}
MyBufferedReader(MyDataReader Data){}
}
上面这个类扩展性很差。
找到其参数的共同类型，通过多态的形式，可以提高扩展性。
class MyBufferReader extends MyReader
{
private MyReader r;
MyBufferedReader(MyReader r){}
}
MyReader//专门用于读取数据的对象。
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
装饰模式比继承要灵活，避免了继承体系的臃肿。
而且降低了类与类之间的关系。
装饰类因为增强已有对象，具备的功能和已有对象是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常都属于一个体系中。
LineNumberReaderDemo
import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("PersonDemo.java");
LineNumberReader lnr = new LineNumberReader(fr);
String line = null;
lnr.setLineNumber(100);
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
}
lnr.close();
}
}
//练习：模拟一个带行号的缓冲区对象。
import java.io.*;
class MyLineNumberReader
{
private Reader r;
private int lineNumber;
MyLineNumberReader(Reader r)
{
this.r = r;
}
public String myReadLine()throws IOException
{
lineNumber++;
StringBuilder sb = new StringBuilder();
int ch =0;
while((ch=r.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
public void setLineNumber(int lineNumber)
{
this.lineNumber = lineNumber;
}
public int getLineNumber()
{
return lineNumber;
}
public void myClose()throws IOException
{
r.close();
}
}
class MyLineNumberReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("copyTextByBuf.java");
MyLineNumberReader mylnr = new MyLineNumberReader(fr);
String line = null;
mylnr.setLineNumber(100);
while((line=mylnr.myReadLine())!=null)
{
System.out.println(mylnr.getLineNumber()+"::"+line);
}
mylnr.myClose();
}
}
字节流File读写操作
/*
字节流：
InputStream
OutputStream
需求:想要操作图片，这时就要用到字节流。
*/
import java.io.*;
class FileStreamDemo
{
public static void main(String[] args) throws IOException
{
readFile();
readFile_2();
readFile_3();
writeFile();
}
public static void readFile()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}
fis.close();
}
public static void readFile_2()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
int ch = 0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
fis.close();
}
public static void readFile_3()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");
byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不需要循环。
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
public static void writeFile()throws IOException
{
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("abcde".getBytes());
fos.close();
}
}
练习：复制一张图片。
/*
复制一个图片：
思路：
1.用字节读取流对象和图片关联。
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。
3.通过循环读写，完成数据的存储。
4.关闭资源。
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos = null;
FileInputStream fis = null;
try
{
fos = new FileOutputStream("c:\\2.png");
fis = new FileInputStream("c:\\1.png");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("文件复制失败");
}
finally
{
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("文件读取失败");
}
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("文件写入失败");
}
}
}
}
字节流的缓冲区
/*
演示MP3的复制，通过缓冲区：
BufferedOutputStream
BUfferedInputStream
*/
import java.io.*;
class CopyMp3
{
public static void main(String[] args) throws IOException
{
long start = System.currentTimeMillis();
copy_1();
long end = System.currentTimeMillis();
System.out.println((end-start)+"毫秒");
}
public static void copy_1()throws IOException
{
BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("f:\\KuGou\\M-Girls - 心愿.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\2.mp3"));
int by = 0;
while((by=bufis.read())!=-1)
{
bufos.write(by);
}
bufos.close();
bufis.close();
}
}
读取键盘录入
/*
读取键盘录入。
System.out:对应的是标准的输出设备，控制台。
System.in:对应的是标准的输入设备，键盘。
需求：通过键盘录入数据，当录入一行数据后，就将该行数据进行打印，
如果录入的数据是over时，那么停止录入。
*/
import java.io.*;
class ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in =System.in;
StringBuilder sb = new StringBuilder();
while(true)
{
int ch = in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s = sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
读取转换流和写入转换流。
通过刚才的键盘录入一行数据并且打印其大写，发现其实就是读一行数据的原理。
也就是readLine方法。
能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
readLine方法时BufferedReader类中的方法。
而键盘录入的read方法时InputStream的方法。
那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢？
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
InputStream in = System.in;
//将字节流对象转换成字符流对象。
InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符流进行缓冲区技术高效操作。
BufferedReader bufr = new BufferedReader(isr);
//也可以用一句代码表示上述3句(键盘录入最常用写法)：
//BufferedReader bufr = new BufferedReader(new InputStreamReader( System.in));
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bufw = new BufferedWriter(osw);
//也可以用一句代码表示上述3句：
//BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
String line= null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}
流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪一个。
通过三个明确来完成。
1.明确源和目的。
源：输入流。InputStream Reader
目的：输出流。OutputStream Writer
2.明确操作的数据是否是纯文本。
是：字符流。
不是：字节流。
3.当体系明确后，再明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘，键盘。
目的设备：内存，硬盘，控制台。
举例：1.将一个文本文件中数据存储到另一个文件中。复制文件。
源：InputStream Reader。
是不是操作文本文件：是。选择Reader。
这样体系就明确了。
接下来明确要使用该体系中的哪个对象。
明确设备：硬盘上一个文件。
Reader体系中可以操作文件的对象是FileReader
是否需要提高效率：是！加入Reader体系中的缓冲区 BufferedReader
FileReader fr = new FileReader(“a.txt”)
BufferedReader bufr = new BufferedReader(fr)
目的：OutPutStream Writer
是否是纯文本：是：Writer。
设备：硬盘上一个文件。
可以操作Writer体系中文件的对象是FileWriter。
是否需要提高效率：是！加入Writer体系中的缓冲区 BufferedWriter
FileWriter fw = new FileWriter(“b.txt”)
BufferedWriter bufw = new Buffered(fw)
2.将键盘录入的数据保存到一个文件中。
这个需求中源和目的都存在。
源：InputStream Reader
是不是纯文本？是。Reader
设备：键盘。对应的对象是System.in。
不是选择Reader么？System.in对应的不是InputStream么？
为了操作键盘的文本数据方便，转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，就将System.in转成字符流。
用到了Reader体系中的转换流，InputStreamReader。
InputStreamReader isr = new InputStreamReader(System.out)；
需要提高效率么？要。
BufferedReader bufr = new BufferedReader(isr)
目的：OutputStream Writer
是否是纯文本？是：Writer
设备：硬盘上一个文件。使用FileWriter。
FileWriter fw = new FileWriter(“c.txt”)
需要提高效率么？要。
BufferedWriter bufw= new BufferedWriter(fw)
扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
目的：OutputStream Writer
是否是纯文本？是：Writer
设备：硬盘上一个文件。使用FileWriter。
但是FIleWriter使用的是默认编码表。
因此存储时，需要加入指定编码表，而指定的编码表，只有转换流才能使用。
所以要使用的对象是OutPutStreamWriter。
而该转换流对象要接收一个字节输出流，而且还可以操作文件的字节输出流：
FileOutPutStream
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“d.txt”,UTF-8))
需要提高效率么？要。
BufferedWriter bufw= new BufferedWriter(osw)
所以记住，转换流什么时候使用呢？
字符和字节之间的桥梁，通常涉及到字符编码转化时，需要用到转换流。
异常的日志信息
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
public static void main(String[] args)
{
try
{
int[] arr = new int[2];
System.out.println(arr[3]);
}
catch (Exception e)
{
try
{
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
PrintStream ps = new PrintStream("exeception.log");
ps.println(d.toString());
System.setOut(ps);
}
catch (Exception e1)
{
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}
//网上可以下载工具包log4j直接使用。
系统信息
import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args) throws IOException
{
Properties prop = System.getProperties();
prop.list(new PrintStream("sysinfo.txt"));
}
}
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
