/*
字符流的缓冲区。自己MyBufferReader的readLine方法。装饰设计模式。字节流。自定义一个缓冲区模拟BufferedInputStream。读取键盘
录入。转换流。流操作的基本规律
*/
/*
字符流的缓冲区
缓冲区的出现提高了对流数据的操作效率
对应类
BufferedWriter
BufferedReader
缓冲区要结合流才可以使用
在流的基础上对流的功能进行了增强
很多软件都有自己的缓冲区。比如迅雷。
二个构造方法必须有参数，必须有流才能使用。
BufferedWriter缓冲区中提供了一个跨平台的换行符。newLine();
/r/n不跨平台。
*/
import java.io.*;
class BufferWriter
{
public static void main(String[] args) throws IOException
{
bufWriter();
/*
//创建一个字符写入流对象
FileWriter fw = new FileWriter("buf.txt");
//为了提高字符写入流的效率，加入了缓冲技术。
//缓冲原理：对象里面封装了数组
//只要将需要被提高效率的流对象作为参数传递给
//缓冲区的构造方法就可。
BufferedWriter bufw =new BufferedWriter(fw);
bufw.write("abcde");
//记住，只要用到BufferedWriter缓冲区，就要记得刷新
bufw.flush();
//其实关闭缓冲区，就是在关闭缓冲区中的流对象
bufw.close();
*/
}
public static void bufWriter() throws IOException
{
FileWriter fw = new FileWriter("demo.txt");
BufferedWriter bufw = new BufferedWriter(fw);
for (int x= 0;x<5 ;x++)
{
bufw.write("abcd"+x);
bufw.newLine();//跨平台的换行。
bufw.flush();
}
bufw.close();
}
}
/*
字符读取流缓冲区：BufferReader
该缓冲区提供了一个一次读一行的方法：readLine(),
方便于对文本数据的获取，当读到null时，表示读到文件的末尾。
readLine()方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
所以我们自己写的时候要加newLine();
原理：无论是读一行，获取读取多个字符，其实最终都是在硬盘上一个一个
读取，所以最终还是使用read()一次读一个方法。
*/
import java.io.*;
class BufferReader
{
public static void main(String[] args) throws IOException
{
//创建一个读取流对象和文件相关联
FileReader fr = new FileReader("demo.txt");
//为了提高效率。加入缓冲技术，将字符读取流对象
//作为参数传递给缓冲对象的构造函数
BufferedReader bufr = new BufferedReader(fr);
String s1 = null;
while((s1=bufr.readLine())!=null)
{
System.out.println("s1="+s1);
}
bufr.close();
}
}
/*练习
通过缓冲区复制一个.java文件
*/
import java.io.*;
class BufferCopyJava
{
public static void main(String[] args)
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader("BufferWriter.java"));
bufw = new BufferedWriter(new FileWriter("CopyBufferJava.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("写入关闭失败");
}
}
}
}
/*
定义一个自己MyBufferReader的readLine方法
原理：无论是读一行，获取读取多个字符，其实最终都是在硬盘上一个一个
读取，所以最终还是使用read()一次读一个方法。
*/
import java.io.*;
class MyBufferReader
{
private FileReader r;
MyBufferReader(FileReader r)
{
this.r = r;
}
public String myReadLine() throws IOException
{
//定义一个临时容器，源程序中封装的是字符数组。
//这里为了演示方便，定义一个StringBuilder容器，因为最终还要是将数据变成字符串
StringBuilder sb = new StringBuilder();
int buf = 0;
while((buf=r.read())!= -1)
{
if (buf=='\r')
{
continue;
}
if (buf=='\n')
{
return sb.toString();
//sb.delete(0,sb.length());？？？
//是因为return后,sb会自己清空。生命周期。
//还是每次都新一个new StringBuilder？？
}
else
sb.append((char)buf);
}
if (sb.length()!=0)
{
return sb.toString();
}
return null;
}
public void myClose()throws IOException
{
r.close();
}
}
class MyBuffer
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("demo.txt");
MyBufferReader mbr = new MyBufferReader(fr);
String s = null;
while ((s = mbr.myReadLine())!=null)
{
//return s;
System.out.println(s);
}
mbr.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("开胃酒");
//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();
SupperPerson sp = new SupperPerson(p);
sp.superChifan();
}
}
/*
MyReader//专门用于读取数据的类
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDateReader
|--MyBufferDateReader
class MyBufferReader
{
MyBufferReader(MyTextReader text){}
MyBufferReader(MyMediaReader media){}
}//这个类扩展类很差，可以找其参数的共同类型，
//通过多态的形式，可以提高扩展性
class MyBufferReader extends MyReader
{
private MyReader r;
MyBufferReader(MyReader r){}
//从继承变结合结构
}
后来的体系
MYReader//专门用于读取数据的类
|--MyTextReader
|--MyMediaReader
|--MyDateReader
|--MyBufferReader
装饰模式比继承更灵活，避免了继承体系的臃肿
而且降低了类之间的关系。
装饰类因为增强已有对象，具备的功能和已有对象是相同的，
只不过提供了更强的功能，
所以装饰类和被装饰类都属于一个体系中。
建设继承要写，但不要以继承为主，继承太多了会臃肿。
*/
/*
自己定义一个模拟BufferedReader的方法readLine()
通过read()方法
*/
import java.io.*;
class MyBufferedReader extends Reader//继承
{
private Reader r;//修改了FileReader，更具扩展性
MyBufferedReader( Reader r)
{
this.r = r;
}
public String myReadLine()throws IOException
{
int buf = 0;
StringBuilder sb = new StringBuilder();
while ((buf = r.read())!=-1)
{
if(buf == '\r')
{
continue;
}
if(buf=='\n')
{
return sb.toString();
}
else
sb.append((char)buf);
}
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()throws IOException
{
r.close();
}
}
class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("demo.txt");
MyBufferedReader mybuf = new MyBufferedReader(fr);
String line = null;
while ((line=mybuf.myReadLine())!=null)
{
System.out.println(line);
}
mybuf.myClose();
}
}
//练习。自定义一个带行号的readLine();LineNumberReader
import java.io.*;
class MyLineNumberReader
{
private Reader r ;
private int lineNumber ;
MyLineNumberReader(Reader r)
{
this.r = r;
}
public void setLineNumber(int lineNumber)
{
this.lineNumber = lineNumber;
}
public int getLineNumber()
{
return lineNumber;
}
public String myReaderLine()throws IOException
{
lineNumber++;
StringBuilder sb = new StringBuilder();
int buf =0;
while ((buf = r.read())!=-1)
{
if(buf=='\r')
{
continue;
}
if (buf=='\n')
{
return sb.toString();
}
else
sb.append(buf);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
public void myColse()throws IOException
{
r.close();
}
}
class MyLineNumberReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("MyBuffer.java");
MyLineNumberReader mylnr = new MyLineNumberReader(fr);
String line = null;
while ((line = mylnr.myReaderLine())!=null)
{
System.out.println(mylnr.getlineNumber()+":::"+line);
}
mylnr.close();
}
}
/*
class LineNumberReaderDemo
{
public static void main(String[] args) throws IOException
{//第一次，这是java提供的。
FileReader fr = new FileReader("MyBuffer.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();
}
}
*///以上可以简化程序，因为父类已经提供了相关方法。这里我就不写了
/*
字符流
FileReader
FileWriter
BufferedReader
BufferedWriter
字节流
InputStream OutputStream
需求：想要操作图片数据。这时就要用到字节流。
字节流不需要缓冲。不需要刷新。
但需要关闭资源。
*/
import java.io.*;
class FileStream
{
public static void main(String[] args) throws IOException
{
stream_3();
}
public static void stream_1()throws IOException
{
FileOutputStream fo = new FileOutputStream("fos.txt");
fo.write("abcdef".getBytes());
FileInputStream fi = new FileInputStream("fos.txt");
int num = 0;
while ((num = fi.read())!=-1)
{
System.out.println((char)num);
}
fi.close();
fo.close();
}
public static void stream_2()throws IOException
{
FileInputStream fi = new FileInputStream("fos.txt");
byte[] buf = new byte[1024];
int len = 0;
while ((len = fi.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}
fi.close();
}
public static void stream_3()throws IOException
{
FileInputStream fi = new FileInputStream("fos.txt");
byte buf[] = new byte[fi.available()];
//字节流特有的，返回字符个数。换行符(\r\n)等于二个字节。
//定义一个刚刚好的缓冲区，不用循环了。
fi.read(buf);
System.out.println(new String(buf));
fi.close();
}
}
/*
复制一个图片
思路：
1，用字节读取流对象和图片关联
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储
4，关闭资源。
最后问：用字符流可以复制吗？可以，但是有可能打不开。因为要去表里面查
字符，有可能这个字符没有，就用相似的表示了。所以不要用字符流拷贝媒体文件。
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileInputStream fi = null;
FileOutputStream fo = null;
try
{
fi = new FileInputStream("c:\\1.jpg");
fo = new FileOutputStream("c:\\2.jpg");
byte[] buf = new byte[1024];
int len = 0;
while ((len = fi.read(buf))!=-1)
{
fo.write(buf,0,len);
}
}
catch (IOException e)
{
new RuntimeException("复制失败");
}
finally
{
try
{
if (fi != null)
{
fi.close();
}
}
catch (IOException e)
{
new RuntimeException("1111复制失败");
}
try
{
if (fo != null)
{
fo.close();
}
}
catch (IOException e)
{
new RuntimeException("222复制失败");
}
}
}
}
/*
演示MP3的复制,通过缓冲区
*/
import java.io.*;
class CopyMp3
{
public static void main(String[] args) throws IOException
{
long start = System.currentTimeMillis();
copy1();
long end = System.currentTimeMillis();
System.out.println("end-start:"+ (end-start)+"毫秒");
}
public static void copy1()throws IOException
{
BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));
int len = 0;
while ((len = bufis.read())!=-1)//缓冲区里取。
{
bufos.write(len);//字节流可以不用刷新。
}
bufis.close();
bufos.close();
}
}
import java.io.*;
/*
自定义一个缓冲区模拟BufferedInputStream
myRead方法原理和具体实现。
myRead函数主要是把数据抓到缓冲区里，并从缓冲区里一次读一个字节
那么原理是定义一个数组，把流里面的数据抓到数据里面，但是数组长度固定，定义的数组可能装不下；
此时就要用循环读取，但是最后一次读的数组可能就不是数组的长度，此时要把数组里面元素的有效位数找到，通过read(byte[] b)方法。
用一个count变量记住一次读的字节的数量,每读myRead一次时，就把缓冲区里的字节赋值给一个变量，怎么赋值？这根把数组元素的值赋给变量一样，
并且每次赋值时，数组指针会随myRead读取次数向后移1位，故会有pos++，并且把count--(为了后面的count==0),并把变量处理后返回出去;当count为0时候，
此时又会调用一次read(byte[] b) 方法，如此循环，直到count小于(或等于(最后一次))自己定义的数组长度，当读到最后一次字节再往下读的时，此时count为0，
又会执行read(byte[] b) 方法，但此时的count返回-1，就不要在继续读取下去了。
需要注意的是：每读取一次myRead方法，就爱需要读取下一个字节，就需要pos++;
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
*/
class MyBufferedInputStream
{
private FileInputStream r;
private int pos = 0,count = 0;
byte[] buf = new byte[1024];
MyBufferedInputStream (FileInputStream r)
{
this.r = r;
}
public int myRead()throw IOException//返回int是为了避免出现byte为-1情况。
{
//一次性全部读到缓冲区，不要再到硬盘里读，所以速度比较快。
if (count ==0)
{
count = r.read(buf);
if (count < 0)
{
return -1;
}
pos = 0;
byte b = buf[pos];
pos++;
count--;
return b&255;
}
if (count > 0)
{
byte b = buf[pos];
pos++;
count--;
return b&255;
/*1111-1111———>提升了一个int类型，那不还是-1吗？是-1的原因是因为在前面补1的原因造成的。
那么我只要在前面补0,可以保留原字节数据不变，又可以避免-1出现。怎么补0呢？就是与上255.
b&255;也可以写成b&0xff。
*/
}
return -1;
}
public void myClose()throw IOException
{
r.close();
}
}
class MyBufferedInputStreamDemo
{
public static void main(String[] args)throw IOException
{
long start = System.currentTimeMillis();
copy2();//这是一个比较快的复制文件的方法。自定义的读取流缓冲。
long end = System.currentTimeMillis();
System.out.println((end-start)+"毫秒");
}
public static int copy2()throw IOException
{
FileInputStream fis = new FileInputStream("c:\\0.mp3");
MyBufferedInputStream mybuf = new MyBufferedInputStream(fis);
BufferedOutputStream bufout = new BufferedOutputStream(new FileOutputStream("c:\\3.mp3"));
int num = 0;
while ((num = mybuf.myRead())!=-1)
{
bufout.write(num);//上面提升了4倍大小，byte->int...其实write在自动做一个强转动作。
} //把最低的八位写出去，其他的全部砍掉。
mybuf.myClose();
bufout.close();
}
private static void copy3() throws IOException{//15最快啊。这是最快的复制文件的方法
BufferedInputStream bufin = new BufferedInputStream(
new FileInputStream("1.mp3"));
BufferedOutputStream bufout = new BufferedOutputStream(
new FileOutputStream("2copy.mp3"));
int i = 0;
byte[] buf = new byte[1024];
while((i=bufin.read(buf))!=-1){//读一片，写一片。
bufout.write(buf,0,i);
}
bufout.close();
bufin.close();
}
}
/*
读取键盘录入
System.out:对应的是标准输出设备，控制台
System.in:对应的标准输入设备：键盘
需求：
通过键盘录入数据
当录入一行数据后，就将该行数据进行打印
如果录入的数据是over,那么停止录入
*/
import java.io.*;
class SystemOut
{
public static void main(String[] args) throws IOException
{
InputStream in = System.in;//键盘录入
StringBuilder sb = new StringBuilder();
while (true)
{
int num = in.read();
if (num == '\r')
{
continue;
}
if (num == '\n')
{
String s = sb.toString();
if (s.equals("over"))
{
break;
}
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());//这里不是返回，所以要删除。
}
else//为什么要写上这个over才会停止？break跳出当前循环
sb.append((char)num);
}
//int by = in.read();//阻塞式方法
//int by1 = in.read();//阻塞式方法
//System.out.println(by);
//System.out.println(by1);
//System.out.println('\r'+0);//验证'\r'的int
/*
int num = 0;
while ((num = in.read())!=-1)
{
System.out.println(num);//这也是可以的，一个一个字节，还不能判断-1；
}
*/
}
}
/*转换流
本来就有字节流，字符流可以更方便的操作字符数据，所以把转换流放到字符流里。
*/
import java.io.*;
class InputStreamReaderDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入。
//InputStream in = System.in;
//将字节流转换成字符流对象。
//InputStreamReader isr = new InputStreamReader(in);
//缓冲
//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);
String line = null;
while ((line = bufr.readLine())!=null)
{
if ("over".equals(line))
{
break;
}
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();//字符输出流要刷新
}
}
}
/*
流操作的基本规律
最痛苦的就是流对象有很多，不知道该用哪一个
通过三个明确来完成
1.明确源和目的
源：输入流。InputStream Reader
目的：输出流。OutputStream Writer.
2.操作的数据是否是纯文本。
是；字符流
不是：字节流。
3.当体系明确后，再明确要使用哪个具体的对象
通过设备来进行区分
源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台
需求：
1.将一个文本文件中的数据存储到另一个文件中。复制文件。
源：输入流InputStream Reader，是一个文本文件，用Reader.
设备是硬盘，FileReader fr = new FileReader("a.txt");
需要高效：BufferedReader bufr = new BufferedReader(fr);
目的：输出流。OutputStream Writer. 是一个文本，Writer
设备是硬盘，FileWriter fw = new FileWriter("b.txt");
需要高效：BufferedWriter bufw = new BufferedWriter();
2:将键盘录入的数据保存到一个文件中。
源：输入流InputStream Reader，是否纯文本？是！Reader.
设备是键盘，InputStream fis = System.in;
不是选择Reader吗？System.in对应的不是字节流吗？
为了操作键盘的文本数据方便，转成字符流操作字符串最方便。
所以明确了Reader，那就将System.in转成字符流
用到Reader体系中的转换流。InputStreamReader
InputStreamReader isr = new InputStreamReader(System.in);
提高效率：BufferedReader bufr = new BufferedReader(isr);
目的：输出流。OutputStream Writer.是一个文本，Writer.
设备：硬盘。FileWriter fw = new FileWriter("c.txt");
高效：BufferedWriter bufw = new BufferedWriter(fw);
---------------------------
扩展一下，想要把录入的数据按照指定的编码表（UTF-8），
将数据存入到文件中。
目的：输出流。OutputStream Writer.是一个文本，Writer.
设备：硬盘。FileWriter 。
但是！！！FileWriter 是使用的默认编码表。GBK
在存储时，要加入指定的编码表UTF- 8，指定编码表只有转换流可以。
所以指定的对象是OutputStreamWriter!!!
而转换流要接收一个字节输出流，而且是可以操作文件的字节输出流
FileOutputStream!!!
FileOutputStream fos = new FileOutputStream("d.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
高效：
BufferWriter bufw = new BufferedWriter(osw);
所以记住，转换流什么时候使用。
1.字符和字节之间的桥梁，通常涉及到编码表时，就要使用。
2.当源和目的是字节流时，而操作的是字符。！
*/
/*
System.setIn();改变输入
System.setOut();改变输出。如:System.setOut(new PrintStream("zz.txt"))
*/
import java.io.*;
import java.text.*;
import java.util.Date;
//建立java异常信息。。。其实网络上有专门的工具。log4j
class ExceptionInfo
{
public static void main(String[] args) throws IOException
{
int[] arr = new int[2];
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(date);
try
{
System.out.println(arr[3]);//这里会出错。
}
catch (Exception e)
{
//e.printStackTrace();
try
{
PrintStream ps = new PrintStream("b.txt");
//ps.write(date.toString().getBytes());
//ps.println(date.toString());
ps.println(s);
System.setOut(ps);
//System.out.println(s.toString());
}
catch (IOException ex)
{
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
//e.printStackTrace(new PrintStream("exceptioninfo.txt"));
}
}
}
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Properties;
public class SystemInfo {
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
// TODO Auto-generated method stub
Properties prop = System.getProperties();
//System.out.println(prop);//打印在控制台上
//prop.list(System.out);//自己的方法打印在控制台上
prop.list(new PrintStream("systemInfo.txt"));//改变输出的目的。
}
}
扫一扫
09-09
1255
1255
09-23
459
459
09-20
326
326
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
