------- android培训、java培训、期待与您交流！ ----------
IO概述
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流 。
流按流向分为：输入流，输出流。
字节流通用；字符流基于字节流。
字节流的抽象基类：
InputStream（读流、输入）；OutputStream（写流、输出）。
字符流的抽象基类：
Reader（读）；Write（写）；
注意：四个类派生来的子类名称都是其父类名作为子类名的后缀。
一般牵涉到读写的都会可能存在异常，所以注意写在try、catch语句中。
FileWriter
字符流特点
FileWriter：专门用于操作文件的Writer子类对象。
说明：后缀名是父类名，前缀名是该流对象功能。
1、 创建一个FileWriter对象。该对象被初始化就必须明确被操作的文件，而且该文件会被创建到指定目录下，如果该目录下已有同名文件，将覆盖。
FileWriter fw=newFileWriter（“demo.txt”）；
2、 调用writer方法，将字符写入到流中。
fw.writer(“abcd”);
3、 刷新流对象中的缓冲中数据到目的地中。
fw.flush();
4、 关闭流资源但是关闭前会刷新一次内部的缓冲中的数据到目的地中。
close（）与flush()的区别：flush刷新后，流可以继续使用，close（）刷新后，会将流关闭
fw.close();
IO流异常处理方式
import java.io.*;
publicclassFileWriterDemo {
publicstaticvoid main(String[] args) throws IOException {
FileWriterfw=null;
try{
fw=new FileWriter("d:\\demoFile.txt");
fw.write("abcdefg");
}catch(IOException e){
thrownew IOException("写文件失败！");
}finally{
try{
if(fw!=null)
fw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
文件的续写
import java.io.*;
publicclassFileWriterDemo {
publicstaticvoid main(String[] args) {
FileWriterfw=null;
try{
fw=new FileWriter("d:\\demoFile.txt",true);//表示路径下若又该文件则接着该文件内容续写；若没有则创建文件写入内容。
fw.write("\r\n换行了");在文本中/r/n为换行。
}catch(IOException e){
System.out.println(e.toSting());
}finally{
try{
if(fw!=null)
fw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
写入其他类型的数据：
package iostream;
import java.io.*;
publicclassFileWriterDemo {
publicstaticvoid main(String[] args) {
char[] ch=newchar[]{'a','r','r','a','y','h','e'};
Stringst="你好字符串数组";
FileWriterfw=null;
try{
fw=new FileWriter("d:\\demoFile.txt",true);
fw.write("\r\n换行了");
fw.write(ch,0,5);
fw.write(st,0, 1);
}catch(IOException e){
System.out.prontln(e.toString);
}finally{
try{
if(fw!=null)
fw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
文本文件读取
方式一:单个字符读取
类Reader为抽象的类。
1、 创建一个文件读取流对象，和指定名称的文件相关联，要保证该文件已存在，如果不存在的话会发生FileNotFoundException异常。
FileReader fr=new FileReader(“demo.txt”);
2、 调用读取流对象的reader方法。
reader（）；一次读一个字符，而且会自动往下读。返回int型，当返回-1是说明文件读完。
int ch=0;
while((ch=fr.reader())!=-1){
System.out.println((char)ch);
}
例子：
import java.io.*;
publicclassReaderDemo {
publicstaticvoid main(String[] args)throws IOException {
readds();
}
publicstaticvoid readds(){
FileReaderfr=null;
try {
fr=new FileReader("d:\\demoFile.txt");
int in=0;
while((in=fr.read())!=-1)
System.out.print((char)in);
}
catch (IOException e) {
e.printStackTrace();
}
finally{
if(fr!=null)
try{
fr.close();
}catch(IOException e){
}
}
}
}
方式二:通过字符数组读取
1、 FileReader fr=new FileReader（d:\\demoFile.txt）;
2、 定义一个字符数组，用于存储读到的字符
char[] buf=new char[1024];//通常定义字符数组的长度为1024的整数倍。
3、 用read(char[]);返回的是读到字符数组的个数。
int len=0;
while((len=fr.read(buf))!=-1){
System.out.println(newString(buf,0,len));
}
fr.close();
read(char[]);的特点为：数组满了，停止读入数据；当再次做read（char[]）;方法时会接着读下面的文件，并覆盖已满的数组元素；当文件读完是停止读，再运行read（char[]）;方法时会返回-1；
import java.io.*;
publicclassReaderDemo2 {
publicstaticvoid main(String[] args) {
read();
}
privatestaticvoid read() {
FileReaderfr=null;
char[] ch=newchar[1024];
try{
fr=new FileReader("d:\\demoFile.txt");
int len=0;
while((len=fr.read(ch))!=-1){
System.out.println(new String(ch));
}
}catch(IOException e){
System.out.println(e.toString());
}finally{
if(fr!=null)
try{
fr.close();
}catch(IOException e){}
}
}
}
拷贝文件
import java.io.*;
publicclassReaderDemo2 {
publicstaticvoid main(String[] args) {
copy1();//运用数组读取，写入
copy2();//一个一个字符写入，读取
}
privatestaticvoid copy2() {
FileReaderfr=null;
FileWriterwr=null;
try{
fr=new FileReader(“d:\\demoFile.txt”);
wr=new FileWriter(“e:\\demoFileCopy.java”);
int len=0;
while((len=fr.read())!=-1){
wr.write(len);
}
}catch(IOException e){
thrownew RuntimeException(“拷贝文件失败！”);
}finally{
if(fr!=null)
try{
fr.close();
}catch(IOException e){
}finally{
if(wr!=null)
try{
wr.close();
}catch(IOException e){
}
}
}
}
privatestaticvoid copy1() {
FileReaderfr=null;
FileWriterwr=null;
char[] ch=newchar[1024];
try{
fr=new FileReader(“d:\\demoFile.txt”);
wr=new FileWriter(“e:\\demoFileCopy.txt”);
int len=0;
while((len=fr.read(ch))!=-1){
wr.write(ch,0,len);
}
}catch(IOException e){
thrownew RuntimeException(“拷贝文件失败！”);
}finally{
if(fr!=null)
try{
fr.close();
}catch(IOException e){
}finally{
if(wr!=null)
try{
wr.close();
}catch(IOException e){
}
}
}
}
}
BufferedWriter
缓冲区地出现是为了提高留的操作效率，所以创建缓冲区之前必须要现有流对象。
1、 创建一个字符写入流对象。
FileWriter fw=new FileWriter(“buf.txt”);
2、 为了提高字符写入流效率，加入缓冲区技术，只要将需要被提高效率的对象作为参数传递给缓冲区的构造函数即可。
BufferWriter bufw=new BufferedWriter(fw);
bufw.write(“afdsad”);
3、 只要用到缓冲区，就要记得刷新。
bufw.flush();
4、其实关闭缓冲区，就是关闭缓冲区中的流对象。
bufw.close();
在BufferedReader方法中有一个newLine（）；他可以换行，相当于windows中的”\r\n”;linux中的“\n”,为了跨平台所以有了bufw.newLine();
import java.io.*;
publicclassBufferWriterDemo {
publicstaticvoid main(String[] args) {
FileWriterfw=null;
BufferedWriterbufw=null;
try{
fw=new FileWriter("d:\\buf.txt");
bufw=new BufferedWriter(fw);
for(int x=0;x<5;x++){
bufw.write("abcd"+x);
bufw.newLine();
bufw.flush();
}
}catch(IOException e){
System.out.println(e.toString());
}finally{
try{
if(fw!=null)
bufw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
BufferedReader
1、 创建一个读取流对象和文件相关联。
FileReader fr=new FileReader(“buf.txt”);
2、 为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。
BufferedReader bufr=new BufferedReader(fr);
3、 读一行操作
String line=null;
while((line=bufr.readLIne())!=null){
System.out.print(line);
}
该缓冲区提供一个一次读一行的方法readLine，方便于对文本数据的获取，当返回null时，表示该文件读到了末尾。
readLIne方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
package iostream;
import java.io.*;
publicclassBufferReaderDemo {
publicstaticvoid main(String[] args) {
FileReaderfr=null;
BufferedReaderbufr=null;
try{
fr=new FileReader(“d:\\buf.txt”);
bufr=new BufferedReader(fr);
Stringline=null;
while((line=bufr.readLine())!=null){
System.out.println(line);
}
}catch(IOException e){
System.out.println(e.toString());
}finally{
try{
if(bufr!=null)
bufr.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
通过缓冲区复制文本文件
package iostream;
import java.io.*;
publicclassCopyTextByBuf {
publicstaticvoid main(String[] args) {
BufferedReaderbufr=null;
BufferedWriterbufw=null;
try{
bufr=new BufferedReader(new FileReader("d:\\buf.txt"));
bufw=new BufferedWriter(new FileWriter("e:\\but_Copy.txt"));
Stringlen=null;
while((len=bufr.readLine())!=null){
bufw.write(len);
bufw.newLine();
bufw.flush();
}
}catch(IOException e){
System.out.print("拷贝文件失败！");
}finally{
try{
if(bufr!=null)
bufr.close();
}catch(IOException e){
System.out.println(e.toString());
}
try{
if(bufw!=null)
bufw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
readLine和缓冲区模拟
package iostream;
import java.io.*;
//自定义缓冲区
class MyBufferedReader {
private FileReader r;
MyBufferedReader(FileReaderr){
this.r=r;
}
public String myReadLine()throws IOException{
//定义一个临时容器。原BufferReader
StringBuildersb=newStringBuilder();
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();
returnnull;
}
publicvoid myClose()throws IOException{
r.close();
}
}
publicclassMyBufferedReaderDemo{
publicstaticvoid main(String[] args)throws IOException {
FileReaderfr=newFileReader("d:\\buf.txt");
MyBufferedReadermyBuf=newMyBufferedReader(fr);
Stringline=null;
while((line=myBuf.myReadLine())!=null){
System.out.println(line);
}
myBuf.myClose();
}
}
装饰设计模式
/*
装饰设计模式：
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。
*/
class Person
{
publicvoid chifan()
{
System.out.println("吃饭");
}
}
class SuperPerson
{
privatePerson p ;
SuperPerson(Personp)
{
this.p= p;
}
publicvoid superChifan()
{
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
System.out.println("来一根");
}
}
class PersonDemo
{
publicstatic void main(String[] args)
{
Personp = new Person();
//p.chifan();
SuperPersonsp = new SuperPerson(p);
sp.superChifan();
}
}
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
class MyBufferReader
{
MyBufferReader(MyTextReadertext)
{}
MyBufferReader(MyMediaReadermedia)
{}
}
上面这个类扩展性很差。
找到其参数的共同类型。通过多态的形式。可以提高扩展性。
class MyBufferReader extends MyReader
{
privateMyReader r;
MyBufferReader(MyReaderr)
{}
}
MyReader//专门用于读取数据的类。
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
以前是通过继承将每一个子类都具备缓冲功能。
那么继承体系会复杂，并不利于扩展。
现在优化思想。单独描述一下缓冲内容。
将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。
这样继承体系就变得很简单。优化了体系结构。
装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。
LineNumberReader
此类定义了方法setLineNumber(int)和getLineNumber()，它们可分别用于设置和获取当前行号。
| int | getLineNumber() |
| void | setLineNumber(int lineNumber) |
package iostream;
import java.io.*;
publicclassBufferReaderDemo {
publicstaticvoid main(String[] args) {
FileReaderfr=null;
// BufferedReaderbufr=null;
LineNumberReaderbufr=null;
try{
fr=new FileReader("d:\\buf.txt");
//bufr=new BufferedReader(fr);
bufr=new LineNumberReader(fr);
bufr.setLineNumber(100);
Stringline=null;
while((line=bufr.readLine())!=null){
System.out.println(bufr.getLineNumber()+",,,,,"+line);
}
}catch(IOException e){
System.out.println(e.toString());
}finally{
try{
if(bufr!=null)
bufr.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
}
字节流Flile读写操作
/*
字符流：
FileReader
FileWriter。
BufferedReader
BufferedWriter
字节流：
InputStream OutputStream
字节流与字符流不同的是，不需要刷新就可以写到目的地；
字节流中的特有方法available（）用于统计文件的字节数，有了此方法就可以建立一个刚好的字节数组，但是文件大了会是内存溢出，谨慎使用。
需求，想要操作图片数据。这时就要用到字节流。
复制一个图片.
*/
import java.io.*;
class FileStream
{
publicstatic void main(String[] args) throws IOException
{
readFile_3();
}
//定义一个刚刚好的数组作为缓冲，不用再循环了（操作文件大了不建议用此方法）
publicstatic void readFile_3()throws IOException
{
FileInputStreamfis = new FileInputStream("fos.txt");
// intnum = fis.available();
byte[]buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用在循环了。
fis.read(buf);
System.out.println(newString(buf));
fis.close();
}
//定义一个字节数组，吧读取的数据先放到数组中。（建议使用）
publicstatic void readFile_2()throws IOException
{
FileInputStreamfis = new FileInputStream("fos.txt");
byte[]buf = new byte[1024];
intlen = 0;
while((len=fis.read(buf))!=-1)
{
System.out.println(newString(buf,0,len));
}
fis.close();
}
//一个一个字节的读
publicstatic void readFile_1()throws IOException
{
FileInputStreamfis = new FileInputStream("fos.txt");
intch = 0;
while((ch=fis.read())!=-1)
{
System.out.println((char)ch);
}
fis.close();
}
//字节流写入。
publicstatic void writeFile()throws IOException
{
FileOutputStreamfos = new FileOutputStream("fos.txt");
fos.write("abcde".getBytes());//不用刷新就可以写到目的地
fos.close();
}
}
拷贝图片：
package iostream;
import java.io.*;
publicclassCopypic {
publicstaticvoid main(String[] args) {
FileOutputStreamfos=null;
FileInputStreamfis=null;
try{
fos=new FileOutputStream("e:\\wo.jpg");
fis=new FileInputStream("D:\\娱乐\\psu.jpg");
byte[] buf=newbyte[1024];
int len=0;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}
}catch(IOException e){
System.out.println("复制文件失败！");
System.out.println(e.toString());
}finally{
if(fis!=null)
try{
fis.close();
}catch(IOException e){
System.out.println("字节流关闭失败！");
}
if(fos!=null)
try{
fos.close();
}catch(IOException e){
System.out.println("字节流关闭失败！");
}
}
}
}
字节流缓冲区：BufferedOutputStream、BufferedInputStream与字符流缓冲区用法一样，参照字符流缓冲区。
自定义字节流缓冲区
import java.io.*;
class MyBufferedInputStream
{
privateInputStream in;
privatebyte[] buf = new byte[1024*4];
privateint pos = 0,count = 0;
MyBufferedInputStream(InputStreamin)
{
this.in= in;
}
//一次读一个字节，从缓冲区(字节数组)获取。
publicint myRead()throws IOException
{
//通过in对象读取硬盘上数据，并存储buf中。
if(count==0)
{
count= in.read(buf);
if(count<0)
return-1;
pos= 0;
byteb = buf[pos];
count--;
pos++;
returnb&255;
}
elseif(count>0)
{
byteb = buf[pos];
count--;
pos++;
returnb&0xff;
}
return-1;
}
publicvoid myClose()throws IOException
{
in.close();
}
}
/*
11111111-111111110000000000101001001010100101010010101001010
byte: -1 ---> int : -1;
00000000 00000000 00000000 11111111 255
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
0000-0001
1111-1110
000000001
1111-1111 -1
结论：
字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。
因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.
那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。
所以，为了避免这种情况将读到的字节进行int类型的提升。
并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。
而在写入数据时，只写该int类型数据的最低8位。
*/
/*
演示mp3的复制。通过缓冲区。
BufferedOutputStream
BufferedInputStream
*/
import java.io.*;
class CopyMp3
{
publicstatic void main(String[] args) throws IOException
{
longstart = System.currentTimeMillis();
copy_2();
longend = System.currentTimeMillis();
System.out.println((end-start)+"毫秒");
}
publicstatic void copy_2()throws IOException
{
MyBufferedInputStreambufis = new MyBufferedInputStream(new FileInputStream("c:\\9.mp3"));
BufferedOutputStreambufos = new BufferedOutputStream(new FileOutputStream("c:\\3.mp3"));
intby = 0;
//System.out.println("第一个字节:"+bufis.myRead());
while((by=bufis.myRead())!=-1)
{
bufos.write(by);
}
bufos.close();
bufis.myClose();
}
//通过字节流的缓冲区完成复制。
publicstatic void copy_1()throws IOException
{
BufferedInputStreambufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));
BufferedOutputStreambufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));
intby = 0;
while((by=bufis.read())!=-1)
{
bufos.write(by);
}
bufos.close();
bufis.close();
}
}
读取键盘录入
import java.io.*;
publicclassSystemIn {
publicstaticvoid main(String[] args)throws IOException {
InputStream in=System.in;
StringBuildersb=newStringBuilder();
while(true){
int len=in.read();
if(len=='\r')
continue;
if(len=='\n'){
Strings= sb.toString();
if("over".equals(s))
break;
System.out.println(s);
sb.delete(0,sb.length());
}
else
sb.append((char)len);
}
in.close();
}
}
读取、写入转换流
在Reader的子类中有一个InputStreamReader是字节流通向字符流的桥梁：
在Writer的子类中有一个OutputStreamWriter是字符流通向字节流的桥梁：
/*
字符流：
FileReader
FileWriter。
BufferedReader
BufferedWriter
字节流：
FileInputStream
FileOutputStream
BufferedInputStream
BufferedOutputStream
通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
也就是readLine方法。
能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
readLine方法是字符流BufferedReader类中的方法。
而键盘录入的read方法是字节流InputStream的方法。
那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢？
*/
import java.io.*;
class TransStreamDemo
{
publicstatic void main(String[] args) throws IOException
{
//获取键盘录入对象。
//InputStreamin = System.in;
//将字节流对象转成字符流对象，使用转换流。InputStreamReader
//InputStreamReaderisr = new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
//BufferedReaderbufr = new BufferedReader(isr);
//键盘的最常见写法。
BufferedReaderbufr =
newBufferedReader(new InputStreamReader(System.in));
// OutputStreamout = System.out;
// OutputStreamWriterosw = new OutputStreamWriter(out);
// BufferedWriterbufw = new BufferedWriter(osw);
BufferedWriterbufw = new BufferedWriter(new OutputStreamWriter(System.out));
Stringline = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}
流操作的基本规律
import java.io.*;
/*
1,
源：键盘录入。
目的：控制台。
2，需求：想把键盘录入的数据存储到一个文件中。
源：键盘。
目的：文件。
3，需求：想要将一个文件的数据打印在控制台上。
源：文件。
目的：控制台。
流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪一个。
通过三个明确来完成。
1，明确源和目的。
源：输入流。InputStream Reader
目的：输出流。OutputStream Writer。
2，操作的数据是否是纯文本。
是：字符流。
不是：字节流。
3，当体系明确后，在明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘。键盘
目的设备：内存，硬盘，控制台。
1，将一个文本文件中数据存储到另一个文件中。复制文件。
源：因为是源，所以使用读取流。InputStream Reader
是不是操作文本文件。
是！这时就可以选择Reader
这样体系就明确了。
接下来明确要使用该体系中的哪个对象。
明确设备：硬盘。上一个文件。
Reader体系中可以操作文件的对象是FileReader
是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.
FileReaderfr = new FileReader("a.txt");
BufferedReaderbufr = new BufferedReader(fr);
目的：OutputStreamWriter
是否是纯文本。
是！Writer。
设备：硬盘，一个文件。
Writer体系中可以操作文件的对象FileWriter。
是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter
FileWriterfw = new FileWriter("b.txt");
BufferedWriterbufw = new BufferedWriter(fw);
---------------------------------------
2，需求：将键盘录入的数据保存到一个文件中。
这个需求中有源和目的都存在。
那么分别分析
源：InputStreamReader
是不是纯文本？是！Reader
设备：键盘。对应的对象是System.in.
不是选择Reader吗？System.in对应的不是字节流吗？
为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，那么就将System.in转换成Reader。
用了Reader体系中转换流,InputStreamReader
InputStreamReaderisr = new InputStreamReader(System.in);
需要提高效率吗？需要！BufferedReader
BufferedReaderbufr = new BufferedReader(isr);
目的：OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用FileWriter。
FileWriterfw = new FileWriter("c.txt");
需要提高效率吗？需要。
BufferedWriterbufw = new BufferedWriter(fw);
**************
扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
目的：OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用FileWriter。
但是FileWriter是使用的默认编码表。GBK.
但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream
OutputStreamWriterosw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
需要高效吗？需要。
BufferedWriterbufw = new BufferedWriter(osw);
所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
需要用到转换流。
*/
class TransStreamDemo2
{
publicstatic void main(String[] args) throws IOException
{
System.setIn(newFileInputStream("PersonDemo.java"));//改变标准输入设备
System.setOut(newPrintStream("zzz.txt"));//改变标准输出设备
//键盘的最常见写法。
BufferedReaderbufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriterbufw = new BufferedWriter(new OutputStreamWriter(System.out));
Stringline = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}
改变标准输入输出设备
class TransStreamDemo2
{
publicstatic void main(String[] args) throws IOException
{
System.setIn(newFileInputStream("PersonDemo.java"));
System.setOut(new PrintStream("zzz.txt"));
//键盘的最常见写法。
BufferedReaderbufr =
newBufferedReader(new InputStreamReader(System.in));
BufferedWriterbufw = new BufferedWriter(new OutputStreamWriter(System.out));
Stringline = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}
异常日志信息
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
publicstatic void main(String[] args)throws IOException
{
try
{
int[]arr = new int[2];
System.out.println(arr[3]);
}
catch(Exception e)
{
try
{
Dated = new Date();
SimpleDateFormatsdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Strings = sdf.format(d);
PrintStreamps = new PrintStream("exeception.log");
ps.println(s);
System.setOut(ps);
}
catch(IOException ex)
{
thrownew RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}
//log4j
------- android培训、java培训、期待与您交流！ ----------详细请查看：http://edu.csdn.net
335
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
