缓冲区
所以在创建缓冲区之前，必须要先有流对象。
该缓冲区中提供了一个跨平台的换行符。newLine()
//写入缓冲区
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args)
{
//创建一个字符写入流对象
FileWriter fw = new FileWriter("buf.txt");
//为了提高字符写入流效率。加入了缓冲技术。
//只要将需要提高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriter bufw = new BufferedWriter(fw);
for(int x=1;x<5;x++)
{
bufw.writer("abcde"+x);
bufw.newLine();
bufw.flush();
}
//记住，只要用到缓冲区，就要记得刷新。
//bufw.flush();
//其实关闭缓冲区，就是在关闭缓冲区中的流对象。
bufw.close();
}
}<strong>字符读取流缓冲区：</strong>/*
该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾.
readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。
*/
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args)
{
//创建一个读取流对象和文件相关联。
FileReader fr = new FileReader("buf.txt");
//为了提高效率，加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数中。
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine()!=null)
{
System.out.println(line);
}
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("bufWriter_copy.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("写入关闭失败);
}
}
}
}
readLine方法的原理：
无论是读一行，还是读取多个字符。其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。
/*
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟下BufferedReader。
*/
import java.io.*;
class MyBufferedReader extends Reader//继承Read就要覆盖其所有抽象方法。
{
private FileReader r ;
MyBufferedReader(FileReader r)
{
this.r = r;
}
//可以一次读取一行的方法。
public String myReadLine()throws IOException
{
//定义一个临时容器，原BufferReader封装的是字符串。
//为了掩饰方便，定义一个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 int read(char[] cbuf,int off,int len)throws IOException
{
return r.read(cbuf,off,len);
}
public void close()throws IOException
{
r.close();
}
public void myClose()throw 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 lin = null;
}
}
对已有对象进行功能增强，就是装饰设计模式
/*
装饰设计模式：
当想要对已有的对象进行功能增强时，
可以定义一个类，将已有对象传入，基于已有对象的功能，并提供加强功能。
那么自定义的该类就称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰对象的功能，提供更强的功能。
*/
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("甜点");
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
|--MyDateReader
|--MyBufferDateReader
class MyBufferReader
{
MyBufferReader(MyTextReader text)
{}
MyBufferReader(MyMediaReader text)
{}
}
上面这个类扩张性很差。
找到其参数的共同类型。通过多态的形式，可以提高扩展性。
class MyBufferReader extends MyReader
{
private MyReader r;
MyBufferReader(MyReader r)
{}
}
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyMediaReader
|--MyDateReader
|--MyBufferReader
装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类与类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。
<strong>LineNumberReader</strong>import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args)
{
FileReader fr = null;
try
{
<span style="white-space:pre"> </span>FileReader fr = new FileReader("PersonDemo.java");
<span style="white-space:pre"> </span>LineNumberReader lnr = new LineNumberReader(fr);
<span style="white-space:pre"> </span>String line = null;
lnr.setLineNumber(100);
<span style="white-space:pre"> </span>while((line=lnr.readLine())!=null)
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>System.out.println(lnr.getLineNumber()+":"+line);
<span style="white-space:pre"> </span>}
}
catch(IOException e)
{
System.out.println("读取失败")；
}
finally
{
try
{
if(lnr!=null)
<span style="white-space:pre"> </span>lnr.close();
}
catch(IOException)
{
System.out.println("关闭失败");
}
<span style="white-space:pre"> </span>}
}
}import java.io.*;
class MyLinNumberReader extends MyBufferReader//通过继承，可以简化代码
{
private int linNumber;
MyLineNumberReader(Reader r)
{
super(r);
}
public String myReadLine()throws IOException
{
lineNumber++;
return super.myReadLine();
}
public void setLineNumber(int lineNumber)
{
this.lineNumber = lineNumber;
}
public int getLineNumber()
{
return lineNumber;
}
}
/*
class MyLinNumberReader
{
private Reader r;
private int linNumber;
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()
{
r.close();
}
}
*/
class MyLineNumberReaderDemo
{
public static void main(String[] args)
{
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();
}
}
<strong>字节流：</strong>/*
字符流：
FileReader
FileWriter
BufferedReader
BufferedWriter
字节流：
InputStream OutputStream
需求：想要操作图片数据。这时就要用到字节流。
*/
import java.io.*;
class FileStream
{
public static void main(String[] args)
{
writeFile_3();
}
public static void writeFile_3()throws IOException
{
FileOutputStream fos = new FileOutputStream("fos.txt");
//int num = fis.available();
byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区，不用再循环了。
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
public static void writeFile_2()throws IOException
{
FileInputStream fis = new FileOutputStream("fos.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read())!=-1)
{
System.out.println(new String(buf,0,len));
}
fis.close();
}
public static void writeFile_1()throws IOException
{
FileOutputStream fis = new FileOutputStream("fos.txt");
int ch = 0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
fis.close();
}
public static void writeFile()throws IOException
{
FileOutputStream fos = FileOutputStream("fos.txt");
fos.write("abcde".getBytes());
fos.close();
}
}
<strong>练习：复制一个图片</strong>/*
复制一个图片
思路：
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("d:\\2.bmp");
fis = new FileInputStream("d:\\1.bmp");
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(fos!=null)
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
}
}
}
<strong>演示：mp3的复制。通过缓冲区</strong>/*
BufferedOutStream
BufferedInStream
*/
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("d:\\0.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream("d:\\1.mp3"));
int by = 0;
while((by=bufis)!=-1)
{
<span style="white-space:pre"> </span>bufos.write(by);
}
bufis.close();
bufos.close();
}
}
<strong>MyBufferedInputStream</strong>import java.io.*;
class MyBufferedInputStream
{
private InputStream in;
private byte[] buf = new byte[1024];
private int pos = 0,count = 0;
MyBufferedInputStream(InputStream in)
{
this.in = in;
}
//一次读一个字节，从缓冲区(字节数组)获取。
public int myRead()throws IOException
{
//通过in对象读取硬盘上的数据，并存储在buf中。
if(count==0)
{
count = in.read(buf);
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b&255;//返回值是int类型，不是byte类型，提升成int型，避免出现-1.
}
else if(count>0)
{
byte b = buf[pos];
count--;
pos++;
return b&0xff;
}
return -1;
}
public void myClose() throws IOException
{
in.close();
}
}
/*
byte:-1 ----> int:-1;
11111111
11111111 11111111 11111111 11111111
11111111 ---》提升了一个int类型，那不还是-1吗？是-1的原因是因为在8个1前面补的是1导致的。
那么我只要在前面补0，既可以保留原字节数据不变，又可以避免-1的出现。
怎么补0呢？
11111111 11111111 11111111 11111111
& 00000000 00000000 00000000 11111111
-----------------------------------------
00000000 00000000 00000000 11111111
*/<strong>读取键盘录入。</strong>
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.delate(0,sb.length());
}
else
sb.append(char(ch));
}
}
}
<strong>转换流</strong>
通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
也就是readLine方法。
能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
readLine方法是BufferedReader类中的方法。
而键盘录入的read方法是字节流InputStream的方法。
那么能不能将字节流转成字符流再使用字符流缓冲区readLine的方法呢？/*
字符流：
FileReader
FileWriter
BufferedReader
BufferedWriter
字节流：
FileInputStream
FileOutputStream
BufferedInputStream
BufferedOutoutStream
*/
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)
{
//获取键盘录入对象。
//InputStream in = System.in;
//将字节流对象转成字符流对象，使用转换流。InputStreamReader
//InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术搞笑操作，使用BufferedReader
//BufferedReader bufr = new BufferedReader(isr);
//键盘录入的最常见方法。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//OutputStream out = System.out;
//OutputStreamWriter osw = new OutputStreamWriter(out);
//BufferedWriter bufw = new BufferedWriter(osw);
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while((line=bufr.readLine())!=null;)
{
if("over".equals(line))
break;
bufw.write(line.tuUpperCase());
bufw.newlin();
bufw.flush();
}
burf.close();
}
}总结一下
1，
源：键盘录入。
目的：控制台。
2，需求：想把键盘录入的数据存储到一个文件中。
源：键盘
目的：文件。
3，需求：想要将一个文件的数据打印在控制台上。
源：文件
目的：控制台。
流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪个。
通过三个明确来完成。
1，明确源和目的。
源：输入流。InputStreamReader
目的：输出流。OutputStreamWriter
2，操作的数据是否是纯文本。
是：字符流。
不是：字节流、
3，当体系明确后，再明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘，键盘。
目的设备：内存，硬盘，控制台。
1，将一个文本文件中的数据存储到另一个文件中，复制文件。
源：因为是源，所以使用读取流。InputStream Reader
是不是操作文本文件。
是！这时就可以选择Reader
这样体系就明确了。
接下来明确要使用该体系中的哪个对象。
明确设备：硬盘。上的一个文件
Reader体系中可以操作文件的对象是FileReader
是否需要提高效率：是!加入Reader体系中缓冲区BufferedReader
FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);
目的：OutputStreamWriter
是否是纯文本。
是！Writer
设备：硬盘，一个文件。
Writer体系中可以操作文件的对象FileWriter.
是否需要提高效率：是！加入Writer体系中缓冲区BufferedWriter
FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);
练习：将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确
-------------------------------
2，需求：将键盘录入的数据保存到一个文件中。
这个需求中有源和目的的都存在。
那么分别分析
源：InputStream Reader
是不是纯文本？是！Reader
设备：键盘。对应的对象是System.in
不是选择Reader妈？System.in对应的不是字节流么？
为了操作键盘的文本数据方便，转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，那么就将System.in转换成Reader。
用了Reader体系中转换流，InputStreamReader
InputStreamReader isr = new InputStreamReader(System.in);
需要提高效率么？需要！BufferedReader
BufferedReader bufr = new BufferedReader(isr);
目的：OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用FileWriter。
FileWriter fw = new FileWriter();
需要提高效率吗？需要！
BufferedWriter bufw = new BufferedWriter(fw);
******************************
扩展一下。想要把录入的数据按照指定的编码表（utf-8）,将数据存到文件中。
目的：OutputStreamWriter
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用FileWriter。
但是FileWriter是使用的默认编码表GBK
但是存储时，需要加入指定编码表utf-8，而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream
OutputStreamWriter osw = new OutputStreamWriter()
需要高效么？需要。
BufferedWriter bufw = new BufferedWriter(osw);
所以，记住，转换流什么时候用，字符和字节直接的桥梁，通常涉及到字符编码转换时，
需要用到转换流。
练习：讲一个文本数据打印在控制台上，按照以上格式完成三个明确。
import java.io.*;
class TransStreamDemo2
{
public static void main(String[] args) throws IOException
{
System.setIn(new FileInputStream("PersonDemo.java"));//改变源
System.setOut(new PrintStream("zzz.txt"));//改变目的
//键盘录入的最常见方法。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw =
<span style="white-space:pre"> </span> new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d2.txt","UTF-8"));
String line = null;
while((line=bufr.readLine())!=null;)
{
if("over".equals(line))
break;
bufw.write(line.tuUpperCase());
bufw.newlin();
bufw.flush();
}
burf.close();
}
}
其他小问题
//将异常信息保存到文档中。
import java.text.*;
import java.util.*;
import java.io.*;
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("exception.log");
ps.println(s);
System.setOut(ps);
}
catch (IOException ex)
{
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();
//System.out.println(prop);
prop.list(new PrintStream("sysinfo.txt"));
}
}
386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
