现在的位置: 首页 > 综合 > 正文

黑马程序员_【java】IO总结

2014年09月05日 ⁄ 综合 ⁄ 共 11337字 ⁄ 字号 评论关闭

----------------------
android培训
java培训、期待与您交流! ----------------------

IO流(数据流)

IO(Input/Output)流用来处理设备之间的数据传输 , java对数据的操作是通过流的方式, java用于操作流的对象都在IO包中

 按操作数据分为两种:字节流字符流。字节流通用,字符流基于字节流

按流向分为:输入流输出流

IO常用基类:

字节流的抽象基类:

InputStream,OutputStream

字符流的抽象基类:

Reader,Writer

:由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀

如:InputStream的子类FileInputStream

Reader的子类FileReader.

字符流的特点:

既然IO流是用于操作数据的,那么数据的最常见体现形式是:文件。

需求:在硬盘上,创建一个文件并写入一些文字数据

代码:

import java.io.*;

class  FileWriterDemo

{

       public static void main(String[] args)throws IOException

       {

              //创建一个FileWriter对象,该对象一被初始化就必须

//要明确被操作的文件。 

              //而且该文件会被创建到指定目录下,如果

//该目录下已有同名文件,将被覆盖。 

              //其实该步就是在明确数据要存放的目的地。(就好比写字得先有纸)

 

              FileWriter fw = newFileWriter("demo.txt");

              

              //调用FileWriter 类的write方法,将字符串写入到流中。

 

              fw.write("hello world");

 

              //刷新流对象中的缓冲中的数据,将数据刷到目的地中。

              //fw.flush();

 

 

              //关闭流资源,但是关闭之前会刷新一次内部的缓冲中的数据

              //将数据刷到目的地中

              //和flush区别:flush刷新后,流可以继续使用,close刷新后,会将流关闭。

              fw.close();

       }

}

 

IO异常的处理方式:

示例代码:

import java.io.*;

classFileWriterDemo2 

{

       public static void main(String[] args) 

       {

              //在外边建立引用,在try内进行初始化,不然

//finally里的fw.close()执行不了,报找不到符号。

 

              FileWriter fw = null;

              try

              {      //创建文件输出流对象

                     fw = newFileWriter("K:\\demo.txt");

                     //向文件中写入数据

                     fw.write("afsdhdfghjj.......hfggd");

              }

              catch (IOException e)

              {

                     System.out.println("catch:"+e.toString());

              }

              finally

              {

                     try

                     {

                            if(fw!=null)//这个一定要判断

                                   fw.close();

                     }

                     catch (IOException e)

                     {

                            System.out.println(e.toString());

                     }

              }

       }

}

注意:window系统中,换行用\r\n表示,在linux中用\n 

文件读取操作:

示例代码:

import java.io.*;

classFileReaderDemo 

{

       public static void main(String[] args)throws Exception

       {

              //创建一个文件读取流对象,和指定名称的文件相关联。

              //要保证该文件是已经存在的,如果

//不存在,会发生异常FileNoFoundException

 

              FileReader fr = newFileReader("demo.txt");

 

              

              //调用读取流对象的read方法

              //read():一次读一个字符,而且会自动往下读。

              int ch = 0;

              while((ch = fr.read())!=-1)

              {

                     System.out.println("ch="+(char)ch);

              }

              fr.close();

       }

}

文件读取操作

示例代码: 通过字符数组进行读取。

import java.io.*;

classFileReaderDemo2 

{

       public static void main(String[] args)throws IOException

       {

              FileReader fr = newFileReader("demo.txt");

 

              //定义一个字符数组,用于存储读到的字符

              //该read(char[])返回的是读到的字符个数。

              

              char[] buf = new char[1024];//2K  因为一个字符是两个字节

              int len = 0;

              while((len=fr.read(buf))!=-1)

              {

                     System.out.println(newString(buf,0,len));

              }

              fr.close();

       }

}

练习:读取一个.java文件,并打印在控制台上。

代码:

import java.io.*;

classFileReaderDemo3 

{

       public static void main(String[] args)throws IOException

       { 

              //创建文件读取流对象

              FileReader fr = newFileReader("DateDemo.java");

              

              char[] buf = new char[1024];

              int len = 0;

              while((len=fr.read(buf))!=-1)

              {

                     System.out.println(newString(buf,0,len));

              }

              //关闭流

              fr.close();

       }

}

 

文件的复制:

需求:C盘下的一个文本文件复制到D盘下。(其实就是将C盘下的文件数据存储到D盘下的一个文件中)

 步骤:

1.D盘中创建一个文件,用于存储C盘文件中的数据。

2.定义读取流和C盘文件关联

3.通过不断的读写完成数据存储。

4.关闭资源。

示例代码:

import java.io.*;

class CopyText 

{

       public static void main(String[] args)throws IOException

       {

                     copy();

       }

       public static void copy ()

       {

              FileReader fr = null;

              FileWriter fw = null;

              try

              {      //创建文件输入输出流对象

                     fr = newFileReader("c:\\demo.txt");

                     fw = newFileWriter("d:\\demoD.txt",true);

                     //定义一个临时数组

                     char[] buf = newchar[1024];

                     int len = 0;

                     while((len=fr.read(buf))!=-1)

                     {

                            fw.write(buf,0,len);

                     }

              }

              catch (IOException e)

              {

                     throw newRuntimeException("读写失败");

              }

              finally

              {

                     if(fr!=null)

                     try

                     {

                            //关闭流

                            fr.close();

                     }

                     catch (IOException e)

                     {

                            System.out.println(e.toString());

                     }

 

                     if(fw!=null)

                     try

                     {

                            //关闭流

                            fw.close();

                     }

                     catch (IOException e)

                     {

                            System.out.println(e.toString());

                     }

              }

       }

}

文件复制过程示例图:

 

字符的缓冲区

缓冲区的出现提高了对数据的读写效率

对应类:

BufferedWriter,BufferedReader

注:缓冲区要结合流才可以使用,在流的基础上对流的功能进行了增强

字符写入流缓冲区示例:

import java.io.*;

classBufferedWriterDemo

{

       public static void main(String[]args)throws IOException

       {

              //创建一个字符写入流对象。

              FileWriter fw = newFileWriter("buf.txt");

              

              //为了提高字符写入流效率,加入了缓冲技术,

              //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

              BufferedWriter bufw = newBufferedWriter(fw);

 

              for(int x = 0 ; x < 10;x ++)

              {

                     bufw.write("abcde"+x);

                     bufw.newLine();//跨平台的换行符。

                     bufw.flush();//只要用到缓冲区,就要记得刷新。

 

              }      

              //其实关闭缓冲区,就是在关闭缓冲区中的流对象。

              bufw.close();

       }

}

 

字符读取流缓冲区示例:

该缓冲区提供了一个一次读一行的方法 readLine ,方便于对文本数据的获取

当返回null时,表示读到了文件末尾。

readLine 方法返回的时候只返回回车符之前的数据内容,并不返回回车符

import java.io.*;

classBufferedReaderDemo 

{

       public static void main(String[] args)throws IOException

       {

              //创建一个读取流对象和文件相关联

              FileReader fr = new FileReader("buf.txt");

 

              //为了提高效率,加入缓冲技术,将字符读取流对象作为参数传递给缓冲对象的构造函数。

              BufferedReader bufr = newBufferedReader(fr);

 

              String line = null;

              while((line=bufr.readLine())!=null)

              {

 

                     System.out.println(line);

              }

              //关闭缓冲流对象。

              bufr.close();

       }

}

 

通过缓冲区复制一个.java文件。

import java.io.*;

classCopyTextByBuf

{

       public static void main(String[] args)

       {

              BufferedWriter bufw = null;

              BufferedReader bufr = null;

              try

              {

                     bufw = newBufferedWriter(new FileWriter("e:\\bufD.txt",true));

                     bufr = newBufferedReader(new FileReader("c:\\buf.txt"));

                    

                     String line = null;//相当于中转站。

                     while((line=bufr.readLine())!=null)

                     {

                            bufw.write(line);

                            bufw.newLine();

                            bufw.flush();

                     }

              }

              catch (IOException e)

              {

                     throw new RuntimeException("读写失败");

              }

              finally

              {

                     if(bufw!=null)

                     try

                     {

                            bufw.close();

                     }

                     catch (IOException e)

                     {

                            throw newRuntimeException("写入关闭失败");

                     }

                     if(bufr!=null)

                     try

                     {

                            bufr.close();

                     }

                     catch (IOException e)

                     {

                            throw newRuntimeException("读取关闭失败");

                     }

              }

       }

}

readLine方法的原理图:

 

 

装饰设计模式:

当想要对已有的对象进行功能增强时,可以定义类,将已有对象传入,基于已有的功能,并提供加强功能,那么自定义的该类称为装饰类

 

装饰类通常会通过构造方法接收被装饰的对象,并基于被装饰的对象的功能,提供更强的功能。

例:定义了一个类SuperPerson来加强Person类的chifan方法,将Person对象作为参数传递给SuperPerson
构造函数。

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("开胃酒");

              p.chifan();

              System.out.println("甜点");

              System.out.println("来一根");

       }

}

 

class PersonDemo

{

       public static void main(String[] args)

       {

              Person p = new Person();

              SuperPerson sp = newSuperPerson(p);

              sp.superChifan();

       }

}

 

装饰与继承的比较:

1.装饰模式比继承要灵活,避免了继承体系的臃肿。

2.降低了类与类之间的关系。

装饰类因为增强已有对象,具备的功能和已有的是相同的,只不过提供了更强功能,所以装饰类和被装饰类通常都是属于同一个体系中的。

 

 

 

复制一个图片:

思路:

1.字节读取流对象和图片关联

2.字节写入流对象创建一个图片文件,用于存储获取到的图片数据

3.通过循环读写,完成数据的存储

4.关闭资源。

示例代码:

import java.io.*;

class  CopyPic

{

       public static void main(String[] args)

       {

              FileOutputStream fos = null;

              FileInputStream fis = null;

              try

              {

                     fos = newFileOutputStream("CopyofSrc.png");

                     fis = newFileInputStream("src.jpg");

 

                     byte[] buf = newbyte[fis.available()];

                     int len = 0;

                     while((len =fis.read(buf))!=-1)

                     {

                            fos.write(buf);

                     }

              }

              catch (IOException e)

              {

                     throw newRuntimeException("读写失败");

              }

              finally

              {

                     try

                     {

                            if(fos!=null)

                                   fos.close();

                     }

                     catch (IOException e)

                     {

                            throw newRuntimeException("写入失败");

                     }

                     try

                     {

                            if(fis!=null)

                                   fis.close();

                     }

                     catch (IOException e)

                     {

                            throw newRuntimeException("读取失败");

                     }

              }     

       }

}

注意:不要拿字符流处理媒体文件,字符流只处理文字数据

 

 

mp3的复制,通过缓冲区

示例代码:

import java.io.*;

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_1() throwsIOException

       {

              BufferedInputStream bufis = newBufferedInputStream(new FileInputStream("1.mp3"));

              BufferedOutputStream bufos = newBufferedOutputStream(new FileOutputStream("copy.mp3"));

 

              int by = 0;

              while((by = bufis.read())!=-1)

              {

                     bufos.write(by);

              }

 

              bufos.close();

              bufis.close();

 

       }

}

 

 

读取键盘录入

System.out:对应的是标准输出设备:控制台

System.in:对应的是标准输入设备:键盘。

 

需求:

通过键盘录入数据,当录入一行数据后,就将该行数据进行打印,如果录入的数据是over,那么就停止录入

示例代码:

import java.io.*;

class ReadIn

{

       public static void main(String[] args)throws IOException

       {

              //获取输入流对象

              InputStream in = System.in;

      

              StringBuilder sb = newStringBuilder();

              while(true)

              {

                     int ch = in.read();

                     if(ch=='\r') //判断回车符

                            continue;

                     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);

              }

       }

}

 

改变标准输入输出设备:

 

import java.io.*;

class  TransStreamDemo2

{

       public static void main(String[] args)throws IOException

       {

              //改变标准输入输出设备

              System.setIn(new FileInputStream("ReadIn.java"));

 

              System.setOut(newPrintStream("123.txt"));

 

              //键盘的最常见写法。

              BufferedReader bufr =

                     new BufferedReader(newInputStreamReader(System.in));//只需改变源就可以实现源的不同来源

 

              BufferedWriter bufw =

                     new BufferedWriter(newOutputStreamWriter(System.out));//只需改变目的,就可以实现目的不同展现

              String line = null;

              while((line =bufr.readLine())!=null)

              {

                     if("over".equals(line))

                            break;

                     bufw.write(line.toUpperCase());

                     bufw.newLine();

                     bufw.flush();

              }

              bufr.close();

       }

}

 

将异常信息保存到硬盘文件中:

import java.io.*;

importjava.util.*;

importjava.text.*;

classExceptionInfo

{

       public static void main(String[] args)throws IOException

       {

              try

              {

                     int[] arr = new int[2];

                     System.out.println(arr[3]);

              }

              catch (Exception e)

              {

                     try

                     {

                            Date d = new Date();

 

                            SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                            String s =sdf.format(d);

 

                            PrintStream ps = newPrintStream("exception.log");

                            ps.println(s);

                            System.setOut(ps);

                     }

                     catch (IOException ex)

                     {

                            throw newRuntimeException("日志文件创建失败");

                     }

                    

                     e.printStackTrace(System.out);

              }

       }

}

 

将系统属性信息保存到硬盘文件中:

importjava.util.*;

import java.io.*;

class SystemInfo

{

       public static void main(String[] args)throws IOException

       {

              Properties prop =System.getProperties();

              prop.list(newPrintStream("systeminfo.txt"));

       }

}

 

 

 

 

 

----------------------
android培训
java培训、期待与您交流! ----------------------

抱歉!评论已关闭.