提要
08 自定义装饰类
09 LineNumberReader
10 MyLineNumberReader
11 字节流File读写操作
12 拷贝图片
13 字节流的缓冲区
14 自定义字节流的缓冲区-read和write的特点
15 读取键盘录入
08 自定义装饰类
/*自定义装饰设计类*/
import java.io.*;
class MyBufferedReader2 extends Reader
{
private Reader r;
public MyBufferedReader2(Reader r)
{
this.r=r;
}
public String MyReadLine()throws IOException
{
int ch;
StringBuilder sb=new StringBuilder();
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 MyClose()throws IOException
{
r.close();
}
//重写父类的抽象方法
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 class MyBufferedReaderDemo2
{
public static void main(String[] args)throws IOException
{
FileReader fw=new FileReader("buf.txt");
MyBufferedReader2 mr=new MyBufferedReader2(fw);
String line;
while((line=mr.MyReadLine())!=null)
{
System.out.println(line);
}
mr.MyClose();
}
}
09 LineNumberReader
/*带行号的缓冲区，lineNumberReader
是BufferedReader的直接子类，此类定义了setLineNumber(int)和getLineNumber)(),
分别用来设置和获取当前行号。
*/
import java.io.*;
public class LineNumberReaderDemo
{
public static void main(String[] args)
{
try
{
FileReader fw=new FileReader("PersonDemo.java");
LineNumberReader lr=new LineNumberReader(fw);
String line;
lr.setLineNumber(100);
while((line=lr.readLine())!=null)
{
System.out.println(lr.getLineNumber()+":"+line);
}
lr.close(); }
catch (IOException ie)
{
ie.printStackTrace();
} }
}
10 MyLineNumberReader
/*
练习，自定义一个类，实现LineNumberReader的功能 */
import java.io.*;
class MyLineNumberReader extends MyBufferedReader2
{
private int lineNumber;
public MyLineNumberReader(Reader r)
{
super(r);
}
public String readLine()throws IOException
{
lineNumber++;
return super.MyReadLine();
}
//自定义设置行号的方法
public void setLineNumber(int lineNumber)
{
this.lineNumber=lineNumber;
}
//自定义获取行号的方法
public int getLineNumber()
{
return lineNumber;
} }
public class MyLineNumberReaderDemo
{
public static void main(String[] args)
{
try
{
FileReader fr=new FileReader("BufferedReaderDemo.java");
MyLineNumberReader mlnr=new MyLineNumberReader(fr);
String line=null;
mlnr.setLineNumber(99); while((line=mlnr.readLine())!=null)
{
System.out.println(mlnr.getLineNumber()+" "+line);
}
mlnr.close(); }
catch (IOException ie)
{
ie.printStackTrace();
} } }
11 字节流File读写操作
/*
字符流：
FileReader
FileWriter BufferedReader
BufferedWriter 字节流：
InputStream 读
OutPutStream 写 需求：想要操作图片数据，这就需要用到字节流。 */
import java.io.*;
public class FileStream
{
public static void main(String[] args)throws IOException
{
writeFile();
readFile_1();
readFile_2();
readFile_3(); }
//把读到的存放到一个字节数组中，然后一起输出
public static void readFile_3()throws IOException
{
FileInputStream fis=new FileInputStream("fos.txt");
//int num=fis.available();
//使用avaliable方法，定义一个刚刚好的缓冲区，不用再循环了
//如果文件太大，不建议使用，会出现内存溢出
byte[] buf=new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf)); fis.close();
}
//把读到的存放到一个字节数组中，然后一起输出
public static void readFile_2()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_1()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 writeFile()throws IOException
{
FileOutputStream fos=new FileOutputStream("fos.txt");
fos.write("abcde".getBytes());
//对最小单位字节操作，不需要刷新
fos.close();
}
}
12 拷贝图片
void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
int read(byte[] b) 从此输入流中，将最多b.length个字节的数据读入byte数组中。返回读入缓冲区的字节总数，如果达到文件末尾没有更多数据，则返回-1.
/*
复制一个图片
思路：
1.用字节读取流对象和图片相关联
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
3.通过循环读写，完成数据的存储
4.关闭资源
*/
import java.io.*;
public class CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos=null;
FileInputStream fis=null;
try
{
fis=new FileInputStream("d:\\十字路口.bmp");
fos=new FileOutputStream("d:\\路口.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(fis!=null)
fis.close(); }
catch (IOException e)
{
throw new RuntimeException("读取关闭失败！");
}
try
{
if(fos!=null)
fos.close(); }
catch (IOException e)
{
throw new RuntimeException("写入关闭失败！");
}
}
}
}
13 字节流的缓冲区
/*
演示mp3的复制，通过缓冲区
BufferedOutputStream
BufferedInputStream
*/
import java.io.*;
public class CopyMp3
{
public static void main(String[] args)throws IOException
{
long start=System.currentTimeMillis();
copy();
long end=System.currentTimeMillis(); System.out.println((end-start)+"毫秒"); }
//通过字节流的缓冲区完成复制
public static void copy()throws IOException
{
BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("D:\\安又琪-那你呢.mp3"));
BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("d:\\那你呢.mp3")); int by=0;
while((by=bufis.read())!=-1)
{
bufos.write(by);
}
bufis.close();
bufos.close(); }
}
14 自定义字节流的缓冲区-read和write的特点
/*
通过自定义的缓冲区，拷贝Mp3 注意，把myRead方法的返回值设为int型，而不是byte型
因为当连续读取8个1时，可能错误结束main函数中的读取循环，
提升了一个int型(byte型1个字节，int型32位，4个字节)，还是-1的原因是因为在8个1前面补1造成的。
那么如果能在前面补0，既可以保留原字节数据不变，又可以避免-1的出现。 补0的方法：
和255相与 最后文件大小并没有变成原来的4倍的原因是，write方法只写入后8位，对int型又做了强制转换 运行发现，自定义的缓冲区的拷贝时间比原来的提高了大约200毫秒 */
import java.io.*;
class MyBufferedInputStream
{
private InputStream in;
private byte[] buf=new byte[1024];
private int pos=0,count=0;
public 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;
}
else if(count>0)
{
byte b=buf[pos];
count--;
pos++;
return b&255;
}
return -1; }
public void myClose()throws IOException
{
in.close();
}
}
public class CopyMp3_2
{
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
{
MyBufferedInputStream bufis=new MyBufferedInputStream(new FileInputStream("D:\\安又琪-那你呢.mp3"));
BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("d:\\那你呢.mp3")); int by=0;
while((by=bufis.myRead())!=-1)
{ bufos.write(by);
}
bufis.myClose();
bufos.close(); }
}
15 读取键盘录入
需求：
通过键盘录入数据
当录入一行数据后，就将该行数据转变为大写形式再进行打印
如果录入的数据是over,则停止录入。
/*
字符流：
FileReader
FileWriter BufferedReader
BufferedWriter 字节流：
FileInputStream
FileOutputStream BufferedInputStream
BufferedOutputStream 读取键盘录入：
System.out :对应的是标准输出设备，控制台
System.in :对应的标准输入设备：键盘 */
import java.io.*;
public class ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in=System.in;
//建立一个读入数据的缓冲区
StringBuilder sb=new StringBuilder(); while(true)
{
//read方法是阻塞式方法，没有录入，就会一直等待
int ch=in.read();
if(ch=='\r')
continue;
else 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); } }
}