标签：javascrip ted 复制 缓冲流 get com 继承 增强 input
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流
按流向分为：输入流和输出流
字节流的抽象基类：
InputStream,OutputStream字符流的抽象基类：
Reader，Writer
字符流和字节流
读字符流
FileReader fd = null;
try {
fd=new FileReader("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/nihao.txt");
try {
while(true){
int a=fd.read();
if(a==-1){
break;
}
System.out.print((char)a);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
fd.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//写字符流
FileWriter fw = null;
try {
fw=new FileWriter("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/nihao.txt");
fw.write("putaopier");//写入字符串
fw.flush();//写入后必须刷新
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally{
try {
fw.close();必须关闭流
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
复制文件
定义 FileReader fd=new FileReader("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/nihao.txt");
定义BufferedReader br=new BufferedReader(fd);
FileWriter fw=new FileWriter("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/ni.txt");
定义接收数组：char[] ch=new char[1024];
定义变量读取个数：int b;
while((b=br.read(ch))!=null){
fw.write(new String(ch,0,b));
fw.flash();
}
缓冲区读文件
FileReader fd=new FileReader("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/nihao.txt");
BufferedReader br=new BufferedReader(fd);
String str;
while((str=br.readlin())!=null){
System.out.println(str);
}
/////////////通过获取字节流的数量 读出
int sum=fis.available();//获取字节流的数量
System.out.println(sum);
byte[] by=new byte[sum];
int c=fis.read(by);
System.out.print(new String(by,0,c));
字节流
///////写入 字符流先进缓冲区，字节流输入一个字节就输出一个，所以字节流不需要刷新；
FileOutputStream fos=new FileOutputStream("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/t.txt");
// fos.write("sdsfa".getBytes());
// fos.write("\n".getBytes());
// fos.write("fgds".getBytes());
/////////////循环读出
FileInputStream fis=new FileInputStream("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/t.txt");
//// byte[] by=new byte[20];
//// int ch;
//// while((ch=fis.read(by))!=-1){//回车换行符可以读出来
//// System.out.print(new String(by,0,ch));
//// }
//
//// int ch;
//// while((ch=fis.read())!=-1){
//// System.out.print((char)ch);
//// }
readLin()方法：
public class Bufferedmethod {
FileReader fr;
public Bufferedmethod(FileReader fr){
this.fr=fr;
}
public String MyReadLine()throws IOException{
int ch;
StringBuilder sb=new StringBuilder();
while((ch=fr.read())!=-1){
if(ch==‘\r‘){
continue;
}
if(ch==‘\n‘){
return sb.toString();
}
sb.append((char)ch);
}
if(sb.length()!=0){
return sb.toString();
}
return null;
}
public void close() throws IOException{//close方法
fr.close();
}
IO流注意：我们在关闭流的时候一定要在finally里面，在关闭的时候要加判断，判断我们的文件是否存在，如果前面代码抛出异常是不会运行后面的代码，所以在关闭的时候要加上if判断其是否为空，不为空则关闭。
装饰设计模式
功能增强，通过构造方法接收被装饰对象
与继承的区别：更优化，更灵活，避免继承系统体系臃肿，降低类与类之间的关系
public class Person {
public void Drink(){
System.out.println("喝开水");
}
public class SuperPerson {
private Person p;
public SuperPerson(Person p){//摆明修饰的对象的有参构造；
this.p=p;
}
public void Ddrink(){
System.out.println("吃水果");
p.Drink();
System.out.println("吃糕点");
}
public static void main(String[] args) {
Person p=new Person();
SuperPerson sp=new SuperPerson(p);
sp.Ddrink();
｝
流转换：
InputStream in=System.in;
// System.setIn(new FileInputStream("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/nihao.txt"));
// PrintStream ps=System.out;//输出流，默认控制台；
// System.setOut(new PrintStream("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/text2.txt"));
////对象必须申明在循环外部，申明在循环内部，会导致每次循环new一个新对象，每一次只添加一个字节
// StringBuilder sb=new StringBuilder();
// int ch;//=in.read();//read方法是阻塞式方法
// while((ch=in.read())!=-1){
// ps.write(ch);
// }
//
// while(true){
// ch=in.read();
// if(ch==‘\r‘){
// continue;
// }
// if(ch==‘\n‘){
// String str=sb.toString();
// if("end".equals(str)){
// break;
// //return;
// }
// //sb=new StringBuilder//每次进来重新new一个StringBuilder对象，不建议使用，因为循环new很多对象，占内存
// sb.delete(0,sb.length());//清除原有StringBuilder里面所添加的元素
// System.out.print((char)ch);
// }else{
// sb.append((char)ch);
// }
//
// }
/////////////////输出转换流,字节转换字符
// OutputStream os=System.out;//得到控制台的输出流
// OutputStreamWriter osw=new OutputStreamWriter(os);//将字节流对象转换成字符流对象，使用转换流OutputStreamWriter
// BufferedWriter bw=new BufferedWriter(osw);为提高效率，使用字符缓冲流BufferedWriter；
// InputStream is=System.in;//获取键盘输入的字节流对象
// InputStreamReader isr=new InputStreamReader(is);//将字节流对象转成字符流对象,使用转换流InputStreamReader
// BufferedReader br=new BufferedReader(isr);//为了提高效率,使用字符缓冲流BufferedReader
// String str;
// try {
// while((str=br.readLine())!=null){
// bw.write(str);//写入str
// bw.newLine();//换行
// bw.flush(); //清空缓冲区,否则下一次输出时会重复输出
// }
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }finally{
// try {
// bw.close();
// br.close();
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//
// }
日志记录异常处理
public static void main(String[] args) {
try {
int[] arr=new int[2];
System.out.println(arr[2]);
} catch (Exception e) {
// TODO: handle exception
PrintWriter fw=null; //FileWriter fw=null;//
try {
Date date=new Date();
SimpleDateFormat sdm=new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
String time=sdm.format(date);
//fw=new FileWriter("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/Exception.txt");
fw=new PrintWriter("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/IoException.txt");
fw.write(time+"\n");
//fw.write(e.toString());
//fw.write(Arrays.toString(e.getStackTrace()));
e.printStackTrace(fw);
fw.flush();
} catch (IOException e1) {//要处理的io异常的操作
// TODO Auto-generated catch block
System.out.println("这是需要处理io异常的操作");
e1.printStackTrace();
}finally{
if(fw==null){
fw.close();}
}
System.out.println("你的网页已走丢");
//e.printStackTrace();//什么异常
}
}
将/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo该目录下的abc.txt封装成file对象，可以将已有的和未出现的文件或文件夹封装成对象
File file=new File("/Users/admin/Documents/workspace/Io/src/com/rf/th/iodemo/abc.txt");//封装路径
System.out.println(file);//输出file的封装路径
System.out.println(file3.createNewFile());//file3.createNewFile() 创建新文件
// System.out.println(file3.mkdir());//创建目录
// System.out.println(file3.exists());//判断文件是否存在
// System.out.println(file3.isDirectory());//判断是否是一个目录；
// System.out.println(file3.isFile());//判断是否是一个文件
//
// //file3.delete();//删除文件
// //file3.deleteOnExit();//程序一结束就删除文件；
////////////递归创建文件夹
File file4=new File("/Users/admin/Desktop/a/d/f/a/111");
System.out.println(file4.mkdirs());
/////////////////递归删除文件夹
String path="/Users/admin/Desktop/a";
remove(path);
public static void remove(String path){
File file=new File(path);
if(file.isDirectory()){//判断是否目录
String[] ss=file.list();
if(ss!=null){
for(String str:ss){
String newpath= path+"/"+str;
System.out.println(newpath);
remove(newpath);
}
}
}
if(file.delete()){
System.out.println("目录"+file.getPath()+"删除成功");
}
}
标签：javascrip ted 复制 缓冲流 get com 继承 增强 input
原文地址：http://www.cnblogs.com/tanghao666/p/7246444.html
