Java笔记5 IO<2>缓冲流、转换流
2013-05-22 23:00
525 查看
------- android培训、java培训、期待与您交流! ----------
19天-03-IO流(通过缓冲区复制文本文件)
l 字符读取流缓冲区:
该缓冲区提供了一个一次读取一行的方法readLine,方便与对文本数据的获取。当返回null时,表示独到文件末尾。
l readLine方法返回时,只返回回车符之前的数据内容,并不返回回车符。在写入数据时,需要换行。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public
class BufferedCopy {
public
static void main(String[] args) {
BufferedReader bufr = null;
BufferedWriter bufw = null;
try {
bufr = new BufferedReader(new FileReader("buf.txt"));//创建//字符缓冲读取流
bufw = new BufferedWriter(new FileWriter("des.txt"));//创建//字符缓冲写入流。
String line = null;
while((line=bufr.readLine())!=null){//readLine方法不会读取行//终止符
bufw.write(line);//写一行,须换行。
bufw.newLine();//换行
bufw.flush();
}
} catch (IOException e) {
throw
new RuntimeException("读写失败!");
}finally{
if(bufr!=null){
try {
bufr.close();
} catch (IOException e) {
thrownew RuntimeException("文件读取失败!");
}
}
if(bufw!=null){
try {
bufw.close();
} catch (IOException e) {
thrownew RuntimeException("文件写入失败!");
}
}
}
}
}
19天-05-IO流(MyBufferedReader)
l 模拟自定义缓冲区
import java.io.FileReader;
import java.io.IOException;
public
class MyBufferedReader {
private FileReaderr;
public MyBufferedReader(FileReader r){
this.r = r;
}
//可以一次读一行数据的方法
public String MyReaderLine()throws IOException{
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);
}
}
return
null;
}
public
void myClose() throws IOException{
r.close();
}
}
19天-06-IO流(装饰设计模式)
l 装饰设计模式:
当想要对已有的对象进行功能增强时,可以定义类,将已有对象传入(通过构造函数),基于已有的功能,并提供加强功能。那么自定义的该类成为装饰类。
l 装饰类通常会通过构造方法接受被装饰的对象。并基于被装饰的对象的功能,提供更强的功能。
示例:
class Person{
public
void chifan(){
System.out.println("吃饭");
}
}
public
class SuperPerson {
private Personp;
public SuperPerson(Person p) {
this.p = p;
}
public
void superChiFan(){//通过提供已有对象的方法(不对该方法重写),再对//该功能进行了加强。
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
}//功能加强:除了吃放,还能喝酒、吃甜点。
}class Person{
public
void chifan(){
System.out.println("吃饭");
}
}
public
class SuperPerson {
private Personp;
public SuperPerson(Person p) {
this.p = p;
}
public
void superChiFan(){//通过提供已有对象的方法(不对该方法重写),再对该功能进行了加强。
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
}//功能加强:除了吃放,还能喝酒、吃甜点。
}
Ÿ 19-05的举例也是装饰设计模式的例子。
² 装饰模式与继承比较,要比继承灵活的多,避免了继承体系的臃肿(继承必须继承父类成员,而装饰类通过构造方法传入对象后,可以对该对象的一个或多个方法的功能进行增强,这样必然会很灵活),而且降低了类与类之间的关系。
² 装饰类因为增强了已有对象,具备的功能和已有的是相同的,只不过提供了更抢的功能。所以装饰类和被装饰类通常都是属于一个体系中的。
19天-10-IO流(MyLineNumberReader)
此例的父类为19-05:MyBufferedReader。
import java.io.FileReader;
import java.io.IOException;
public
class MyLineNumberDemo1 extends MyBufferedReader {
private
int lineNumber = 1;
public MyLineNumberDemo1(FileReader r){
super(r);
}
//可以一次读一行数据的方法
public String MyReaderLine()throws IOException{
lineNumber++;//每读一行加一次
return
super.MyReaderLine();//引用父类的MyReaderLine()方法
}
public
void setMyLineNumber(int lineNumber){
this.lineNumber = lineNumber;
}
public
int getMyLineNumber(){
return
this.lineNumber;
}
}
19天-12-IO流(拷贝图片)
l 复制一个文件。
思路:
1) 用字节流读取流对象和文件关联。
2) 用字节流写入流对象创建一个图片文件,用于存储获取到的图片数据。
3) 通过循环读写,完成数据的存储。
4) 关闭资源。
注:为了省事,代码直观,就不用try/catch语句了,但是开发中不能这样写。
public
class CopyFile12Demo {
public
static void main(String[]args)throws IOException {
FileInputStream fis = new FileInputStream("C:\\baidu player\\归宿.mp3");
FileOutputStream fos = new FileOutputStream("C:\\baidu player\\3.mp3");
//copyStreamFile2(fis,fos);
copyStreamFile2(fis, fos);//运行结果表明:方法2的拷贝效率比方式一高。
}
public
static voidcopyStreamFile1(FileInputStream fis,FileOutputStream fos)throws IOException{
long start =System.currentTimeMillis();
int ch = 0;
while((ch=fis.read())!=-1){
fos.write(ch);
//fos.write((char)ch);javaAPI中没有接收字符参数的write方法,这里
//只不过先强制将int类型强制转换为char类型,再由jvm自动向上转型成int类型。
//这种方式多此一举。
}
fis.close();
fos.close();
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start));
}
public
static void
copyStreamFile2(FileInputStreamfis,FileOutputStream fos) throws IOException{
long start =System.currentTimeMillis();
byte[] buf =newbyte[1024];
int len = 0;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
fos.flush();//刷新为了防止缓冲区数据溢出,造成数据丢失。
}
fis.close();
fos.close();
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start));
}
}
19天-13-IO流(字节流的缓冲区)
l 练习,利用字节缓冲流拷贝Mp3
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class CopyFile12Demo1 {
publicstatic void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入要拷贝的文件路径名:");
String src = s.nextLine();
System.out.println("请输入目的文件路径名:");
String des = s.nextLine();
try {
copy1(src,des);
} catch (IOException e) {
e.printStackTrace();
}
}
publicstatic void copy1(String fisStr,String fosStr) throws IOException{
BufferedInputStream bufIn= null;
BufferedOutputStream bufOut= null;
try {
bufIn= new BufferedInputStream(new FileInputStream(fisStr));
bufOut= new BufferedOutputStream(new FileOutputStream(fosStr));
byte[]buf = new byte[1024];
intlen = 0;
while((len=bufIn.read(buf))!=-1){
bufOut.write(buf,0,len);
bufOut.flush();
}
} catch (FileNotFoundException e) {
thrownew RuntimeException("读写失败!");
}finally{
if(bufIn!=null){
try {
bufIn.close();
} catch (IOException e2) {
thrownew RuntimeException("读取失败!");
}
}
if(bufOut!=null){
try {
bufOut.close();
} catch (Exception e2) {
thrownew RuntimeException("写入失败");
}
}
}
}
}
19天-14-IO流(自定义字节流的缓冲区-read和write的特点)
自定义myRead()方法。(通过视频讲解,做了详尽注释,能看懂了)
import java.io.IOException;
import java.io.InputStream;
public
class MyBufferedInputStream {
private InputStreamin;
private
byte[] buf = newbyte[1024];
private
int pos = 0,count = 0;
public MyBufferedInputStream(InputStream in){
this.in = in;
}
//<1>首次执行myRead方法(此时,count=0,pos=0)。
//<5>判断(myRead()!=-1),true,接着循环
//此时,(count=buf.length-1)>0,pos=1;
//<9>…
public
int myRead() throws IOException{
if(count==0){
count =
in.read(buf);//<2>count是返回的字节数。
if(count<0){
return -1;
}
pos = 0;
byte b =buf[pos];//<3>读取第一个字节
count--;//<4>字节数-1。
pos++;//<4>//索引+1,pos=1;
return b&255;//<4>返回第一个字节(字节的8位数据保持不变,存于int型//数据低8位)
}else
if(count>0){//<6>(count=buf.length-1)>0,执行此语句块。
byte b =buf[pos];//<7>读取缓冲区索引为1的字节数据,并赋值给b。
count--;//<8>count = buf.length-2;
pos++;//<8>pos = 2
return b&255;//<8>返回字节&255转换后的整数值
/*b&255的原因。防止当b=1111-1111时,直接返回b,向上转型成
* 1111-1111 1111-11111111-1111 1111-1111后,在判断是否*myRead()!=-1
* 时,false,而使循环终止。b&255好处,1111-1111&255,可以得到:
* 0000-0000 0000-00000000-0000 1111-1111,不会使*while(myRead()!=-1)
* 终止,能继续数据的读写。
* */
}
return -1;
}
public
void myClose() throws IOException{
in.close();
}
}
19天-16-IO流(读取转换流)
l 字节流转换成字符流的举例
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public
class InputStreamReaderDemo {
public
static void main(String[] args)throws IOException {
//获取键盘录入对象
InputStream in = System.in;
//将字节流对象转成字符流对象,使用转换流。InputStreamReader
InputStreamReader isr = newInputStreamReader(in);
//为了提高效率,将字符串进行缓冲技术高效操作。使用bufferedReader。
BufferedReader bufr = new BufferedReader(isr);
String line = null;
while((line=bufr.readLine())!=null){
if(line.equals("over")){
break;
}
System.out.println(line.toUpperCase());
}
bufr.close();
}
}
19天-17-IO流(写入转换流)
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public
class OutputStreamReaderDemo {
//为简化代码,没写try/catch语句。
public
static void main(String[] args)throws IOException {
BufferedReader bufr = new BufferedReader(newInputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(newOutputStreamWriter(System.out));
String line = null;
while((line=bufr.readLine())!=null){
if(line.equals("over")){
break;
}
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
19天-18-IO流(流操作规律-1)
l 流操作规律
1. 源:键盘录入。
目的:控制台。
2. 需求:把键盘录入的数据存储到一个文本中。
源:键盘。
目的:文件。
3. 需求:将一个文本的数据打印在控制台。
源:文件。
目的:控制台。
流操作的基本规律:
最痛苦的就是流对象高很多,不知道该用哪一个。
通过两个明确来完成。
1. 明确源和目的。
源:输入流。InputStream Reader
目的:输出流。OutputStream Writer
2. 操作的数据是否是纯文本。
是:字符流。
不是:字节流。
3. 当体系明确后,在明确要使用哪一个具体的对象。
通过设备来进行区分:
原设备:内存,硬盘,键盘。
目的设备:内存,硬盘,控制台。
19天-20-IO流(改变标准输入输出设备)
示例:
System.setIn(new FileInputStream(“PersonDemo.java”));
System.setOut(new FileOutputStream(“zzz.txt”));
改变标准输入输出设备后,就会从指定的文件读取数据,和向执行文件写入数据了。
19天-21-IO流(异常的日志信息)
import java.io.IOException;
import java.io.PrintStream;
importjava.text.SimpleDateFormat;
import java.util.Date;
public
class ExceptionInfo {
public
static void main(String[] args)throws IOException {
try {
int[] arr =newint[2];
System.out.println(arr[3]);
} catch (Exception e) {
try {
//System.setOut(newPrintStream("exception.log"));//<1>
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");
System.setOut(ps);
ps.println(d.toString());
} catch (IOException e1) {
thrownew RuntimeException("日志文件创建失败");
}
//e.printStackTrace(System.out);//<1>
}
}
}
//打印的异常信息会保存到当前目录的exception.log文件中。
------- android培训、java培训、期待与您交流! ----------
19天-03-IO流(通过缓冲区复制文本文件)
l 字符读取流缓冲区:
该缓冲区提供了一个一次读取一行的方法readLine,方便与对文本数据的获取。当返回null时,表示独到文件末尾。
l readLine方法返回时,只返回回车符之前的数据内容,并不返回回车符。在写入数据时,需要换行。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public
class BufferedCopy {
public
static void main(String[] args) {
BufferedReader bufr = null;
BufferedWriter bufw = null;
try {
bufr = new BufferedReader(new FileReader("buf.txt"));//创建//字符缓冲读取流
bufw = new BufferedWriter(new FileWriter("des.txt"));//创建//字符缓冲写入流。
String line = null;
while((line=bufr.readLine())!=null){//readLine方法不会读取行//终止符
bufw.write(line);//写一行,须换行。
bufw.newLine();//换行
bufw.flush();
}
} catch (IOException e) {
throw
new RuntimeException("读写失败!");
}finally{
if(bufr!=null){
try {
bufr.close();
} catch (IOException e) {
thrownew RuntimeException("文件读取失败!");
}
}
if(bufw!=null){
try {
bufw.close();
} catch (IOException e) {
thrownew RuntimeException("文件写入失败!");
}
}
}
}
}
19天-05-IO流(MyBufferedReader)
l 模拟自定义缓冲区
import java.io.FileReader;
import java.io.IOException;
public
class MyBufferedReader {
private FileReaderr;
public MyBufferedReader(FileReader r){
this.r = r;
}
//可以一次读一行数据的方法
public String MyReaderLine()throws IOException{
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);
}
}
return
null;
}
public
void myClose() throws IOException{
r.close();
}
}
19天-06-IO流(装饰设计模式)
l 装饰设计模式:
当想要对已有的对象进行功能增强时,可以定义类,将已有对象传入(通过构造函数),基于已有的功能,并提供加强功能。那么自定义的该类成为装饰类。
l 装饰类通常会通过构造方法接受被装饰的对象。并基于被装饰的对象的功能,提供更强的功能。
示例:
class Person{
public
void chifan(){
System.out.println("吃饭");
}
}
public
class SuperPerson {
private Personp;
public SuperPerson(Person p) {
this.p = p;
}
public
void superChiFan(){//通过提供已有对象的方法(不对该方法重写),再对//该功能进行了加强。
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
}//功能加强:除了吃放,还能喝酒、吃甜点。
}class Person{
public
void chifan(){
System.out.println("吃饭");
}
}
public
class SuperPerson {
private Personp;
public SuperPerson(Person p) {
this.p = p;
}
public
void superChiFan(){//通过提供已有对象的方法(不对该方法重写),再对该功能进行了加强。
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
}//功能加强:除了吃放,还能喝酒、吃甜点。
}
Ÿ 19-05的举例也是装饰设计模式的例子。
² 装饰模式与继承比较,要比继承灵活的多,避免了继承体系的臃肿(继承必须继承父类成员,而装饰类通过构造方法传入对象后,可以对该对象的一个或多个方法的功能进行增强,这样必然会很灵活),而且降低了类与类之间的关系。
² 装饰类因为增强了已有对象,具备的功能和已有的是相同的,只不过提供了更抢的功能。所以装饰类和被装饰类通常都是属于一个体系中的。
19天-10-IO流(MyLineNumberReader)
此例的父类为19-05:MyBufferedReader。
import java.io.FileReader;
import java.io.IOException;
public
class MyLineNumberDemo1 extends MyBufferedReader {
private
int lineNumber = 1;
public MyLineNumberDemo1(FileReader r){
super(r);
}
//可以一次读一行数据的方法
public String MyReaderLine()throws IOException{
lineNumber++;//每读一行加一次
return
super.MyReaderLine();//引用父类的MyReaderLine()方法
}
public
void setMyLineNumber(int lineNumber){
this.lineNumber = lineNumber;
}
public
int getMyLineNumber(){
return
this.lineNumber;
}
}
19天-12-IO流(拷贝图片)
l 复制一个文件。
思路:
1) 用字节流读取流对象和文件关联。
2) 用字节流写入流对象创建一个图片文件,用于存储获取到的图片数据。
3) 通过循环读写,完成数据的存储。
4) 关闭资源。
注:为了省事,代码直观,就不用try/catch语句了,但是开发中不能这样写。
public
class CopyFile12Demo {
public
static void main(String[]args)throws IOException {
FileInputStream fis = new FileInputStream("C:\\baidu player\\归宿.mp3");
FileOutputStream fos = new FileOutputStream("C:\\baidu player\\3.mp3");
//copyStreamFile2(fis,fos);
copyStreamFile2(fis, fos);//运行结果表明:方法2的拷贝效率比方式一高。
}
public
static voidcopyStreamFile1(FileInputStream fis,FileOutputStream fos)throws IOException{
long start =System.currentTimeMillis();
int ch = 0;
while((ch=fis.read())!=-1){
fos.write(ch);
//fos.write((char)ch);javaAPI中没有接收字符参数的write方法,这里
//只不过先强制将int类型强制转换为char类型,再由jvm自动向上转型成int类型。
//这种方式多此一举。
}
fis.close();
fos.close();
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start));
}
public
static void
copyStreamFile2(FileInputStreamfis,FileOutputStream fos) throws IOException{
long start =System.currentTimeMillis();
byte[] buf =newbyte[1024];
int len = 0;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
fos.flush();//刷新为了防止缓冲区数据溢出,造成数据丢失。
}
fis.close();
fos.close();
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start));
}
}
19天-13-IO流(字节流的缓冲区)
l 练习,利用字节缓冲流拷贝Mp3
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
public class CopyFile12Demo1 {
publicstatic void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入要拷贝的文件路径名:");
String src = s.nextLine();
System.out.println("请输入目的文件路径名:");
String des = s.nextLine();
try {
copy1(src,des);
} catch (IOException e) {
e.printStackTrace();
}
}
publicstatic void copy1(String fisStr,String fosStr) throws IOException{
BufferedInputStream bufIn= null;
BufferedOutputStream bufOut= null;
try {
bufIn= new BufferedInputStream(new FileInputStream(fisStr));
bufOut= new BufferedOutputStream(new FileOutputStream(fosStr));
byte[]buf = new byte[1024];
intlen = 0;
while((len=bufIn.read(buf))!=-1){
bufOut.write(buf,0,len);
bufOut.flush();
}
} catch (FileNotFoundException e) {
thrownew RuntimeException("读写失败!");
}finally{
if(bufIn!=null){
try {
bufIn.close();
} catch (IOException e2) {
thrownew RuntimeException("读取失败!");
}
}
if(bufOut!=null){
try {
bufOut.close();
} catch (Exception e2) {
thrownew RuntimeException("写入失败");
}
}
}
}
}
19天-14-IO流(自定义字节流的缓冲区-read和write的特点)
自定义myRead()方法。(通过视频讲解,做了详尽注释,能看懂了)
import java.io.IOException;
import java.io.InputStream;
public
class MyBufferedInputStream {
private InputStreamin;
private
byte[] buf = newbyte[1024];
private
int pos = 0,count = 0;
public MyBufferedInputStream(InputStream in){
this.in = in;
}
//<1>首次执行myRead方法(此时,count=0,pos=0)。
//<5>判断(myRead()!=-1),true,接着循环
//此时,(count=buf.length-1)>0,pos=1;
//<9>…
public
int myRead() throws IOException{
if(count==0){
count =
in.read(buf);//<2>count是返回的字节数。
if(count<0){
return -1;
}
pos = 0;
byte b =buf[pos];//<3>读取第一个字节
count--;//<4>字节数-1。
pos++;//<4>//索引+1,pos=1;
return b&255;//<4>返回第一个字节(字节的8位数据保持不变,存于int型//数据低8位)
}else
if(count>0){//<6>(count=buf.length-1)>0,执行此语句块。
byte b =buf[pos];//<7>读取缓冲区索引为1的字节数据,并赋值给b。
count--;//<8>count = buf.length-2;
pos++;//<8>pos = 2
return b&255;//<8>返回字节&255转换后的整数值
/*b&255的原因。防止当b=1111-1111时,直接返回b,向上转型成
* 1111-1111 1111-11111111-1111 1111-1111后,在判断是否*myRead()!=-1
* 时,false,而使循环终止。b&255好处,1111-1111&255,可以得到:
* 0000-0000 0000-00000000-0000 1111-1111,不会使*while(myRead()!=-1)
* 终止,能继续数据的读写。
* */
}
return -1;
}
public
void myClose() throws IOException{
in.close();
}
}
19天-16-IO流(读取转换流)
l 字节流转换成字符流的举例
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public
class InputStreamReaderDemo {
public
static void main(String[] args)throws IOException {
//获取键盘录入对象
InputStream in = System.in;
//将字节流对象转成字符流对象,使用转换流。InputStreamReader
InputStreamReader isr = newInputStreamReader(in);
//为了提高效率,将字符串进行缓冲技术高效操作。使用bufferedReader。
BufferedReader bufr = new BufferedReader(isr);
String line = null;
while((line=bufr.readLine())!=null){
if(line.equals("over")){
break;
}
System.out.println(line.toUpperCase());
}
bufr.close();
}
}
19天-17-IO流(写入转换流)
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public
class OutputStreamReaderDemo {
//为简化代码,没写try/catch语句。
public
static void main(String[] args)throws IOException {
BufferedReader bufr = new BufferedReader(newInputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(newOutputStreamWriter(System.out));
String line = null;
while((line=bufr.readLine())!=null){
if(line.equals("over")){
break;
}
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
19天-18-IO流(流操作规律-1)
l 流操作规律
1. 源:键盘录入。
目的:控制台。
2. 需求:把键盘录入的数据存储到一个文本中。
源:键盘。
目的:文件。
3. 需求:将一个文本的数据打印在控制台。
源:文件。
目的:控制台。
流操作的基本规律:
最痛苦的就是流对象高很多,不知道该用哪一个。
通过两个明确来完成。
1. 明确源和目的。
源:输入流。InputStream Reader
目的:输出流。OutputStream Writer
2. 操作的数据是否是纯文本。
是:字符流。
不是:字节流。
3. 当体系明确后,在明确要使用哪一个具体的对象。
通过设备来进行区分:
原设备:内存,硬盘,键盘。
目的设备:内存,硬盘,控制台。
19天-20-IO流(改变标准输入输出设备)
示例:
System.setIn(new FileInputStream(“PersonDemo.java”));
System.setOut(new FileOutputStream(“zzz.txt”));
改变标准输入输出设备后,就会从指定的文件读取数据,和向执行文件写入数据了。
19天-21-IO流(异常的日志信息)
import java.io.IOException;
import java.io.PrintStream;
importjava.text.SimpleDateFormat;
import java.util.Date;
public
class ExceptionInfo {
public
static void main(String[] args)throws IOException {
try {
int[] arr =newint[2];
System.out.println(arr[3]);
} catch (Exception e) {
try {
//System.setOut(newPrintStream("exception.log"));//<1>
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");
System.setOut(ps);
ps.println(d.toString());
} catch (IOException e1) {
thrownew RuntimeException("日志文件创建失败");
}
//e.printStackTrace(System.out);//<1>
}
}
}
//打印的异常信息会保存到当前目录的exception.log文件中。
------- android培训、java培训、期待与您交流! ----------
相关文章推荐
- JavaIO 总结笔记<四> 缓冲流和转换流
- 【Java.IO】I/O 字节 <-> 字符转换流 —— InputStreamReader,OutputStreamWriter(FileReader,FileWriter)
- Java笔记7 Java基础加强<2>内省
- Java笔记3 多线程<2>线程间通信-代码分析以及多线程常见方法的运用
- Java笔记4 JavaAPI<2>TreeSet、Comparator、泛型
- Java笔记8 面试技巧<2>银行调度系统
- Java笔记5 IO<1>其他对象以及IO流
- Java笔记1 Java编程基础<2>循环语句、函数(重载)、变量和数组的内存结构
- Java笔记5 IO<3>File、Properties、PrintWriter、合并流
- Java笔记5 IO<4>对象的序列化、管道流
- Java笔记2 面向对象<2>static关键字、main函数、静态运用、单例设计模式
- Java笔记6 网络编程<2>TCP、自定义图形界面浏览器、URL
- [原]java专业程序代写(qq:928900200),学习笔记之基础入门<Struts2_实战演练(上)>(三十八)
- 程序员_Java基础之<十一>-IO流<2>File流
- 【Java】多线程<2>-线程池
- [模式识别].(希腊)西奥多里蒂斯<第四版>笔记6之__feature generation (1):数据转换和降维
- Java笔记2 面向对象<5>内部类、静态内部类、内部类定义原则、匿名内部类、异常概述、RuntimeException
- Java笔记7 Java基础加强<1>反射
- LDAP学习笔记<四>jldap实现Java对LDAP的基本操作
- [原]java专业程序代写(qq:928900200),学习笔记之基础入门<SQL_Server>(二十一)