黑马程序员_IO流一

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

 

其他对象

1.System：类中的方法和属性都是静态的。

out：标准输出，默认是控制台。

in：标准输入，默认是键盘。

getProperties()获取系统属性信息。

将属性信息存入到文件info.txt文件中。

Properties prop = System.getProperties();

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

2.Runtime

没有提供构造函数，不可以new对象。该类中的方法都是静态的。该类中还有非静态方法。说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。由这个特点可以看出该类使用了单例设计模式完成。

该方式是：staticRuntime getRuntime();

3.Date

创建时间对象Date d = new Date();

       将模式封装到SimpeDateformat对象中。

SimpleDateFormat sdf = newSimpleDateFormat("yyyy年MM月dd日Ehh:mm:ss");

       调用format方法让模式格式化指定Date对象。Stringtime = sdf.format(d);

4. Calendar

Calendar c = Calendar.getInstance();使用默认时区和语言环境获得一个日历。

c.get(Calendar.YEAR)获取年。c.get(Calendar.MONTH)获取月。

c.get(Calendar.DAY_OF_MONTH)获取日。c.get(Calendar.DAY_OF_WEEK)获取星期

5.Math

Math.random()返回带正号的 double值，该值大于等于 0.0 且小于 1.0。

Math.ceil()返回大于指定数据的最小整数。

Math.floor()返回小于指定数据的最大整数。

Math.round()四舍五入

 

IO(Input Output)流

1.IO流用来处理设备之间的数据传输；Java对数据的操作是通过流的方式；Java用于操作流对象都在IO包中；流按操作数据分为两种：字节流与字符流；按流向分为：输入流，输出流。

2.IO流常用的基类：字符流和字节流：

字符流两个基类：Reader  Writer

常用子类：FileReaderFileWriter  BufferedReader BufferedWriter

字节流两个基类：InputStream   OutputStream

常用子类：FileInputStream FileOutputStream  BufferedInputStream BufferedOutputStream

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

3.IO程序书写：导入IO包中的类；进行IO异常处理；在finally中对流进行关闭。

字符流

示例：在硬盘上，创建一个文件并写入一些文字数据。

importjava.io.FileWriter;

importjava.io.IOException;

class  FileWriterDemo

{

       public static void main(String[] args)

       {

FileWriter fw = null；

try{

/*创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。其实该步就是在明确数据要存放的目的地。*/

                    fw =new FileWriter("Demo.txt");

//调用write方法，将字符串写入到流中。

                     fw.write("abcde");

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

                     fw.flush();

                     }

              catch(IOException e){

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

              }

              finally{

                            if(fw!=null)

                            try{

//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。将数据刷到目的地中。

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

                                   fw.close();

                            }catch(IOExceptione){

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

}

       }

}

4.字符流读取文件

       (1)建立一个流对象，将已存在的一个文件加载进流。

              FileReader fr = newFileReader(Demo.txt);

       (2)创建一个临时存放数组的数组，提高效率。

              char[] ch = new char[1024];

       (3)调用流对象的读取方法将流中的数据读入到数组中。

              fr.read(ch);

       (4)刷新流，关闭流。

              fr.flush();  fr.close();

注：定义文件路径时，可以用“/”或者“\\”。

       在创建一个文件时，如果目录下有同名文件将被覆盖。

在读取文件时，必须保证该文件已存在，否则出异常。

字符流的缓冲区

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

2.对应类：BufferdWriter BufferReader

3.所以在创建缓冲区之前，必须要先有流对象。

4.该缓冲区中提供了一个跨平台的换行符。newLine();

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

当返回null时，表示读到文件末尾。readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

示例：复制一个文件，并处理异常。

importjava.io.BufferedReader;

importjava.io.BufferedWriter;

importjava.io.FileReader;

importjava.io.FileWriter;

importjava.io.IOException;

class  CopyTextByBuf

{

       public static void main(String[] args)

       {

              BufferedReader bufr = null;

              BufferedWriter bufw = null;

              try

              {

                     bufr = newBufferedReader(new FileReader("BufferedWriterDemo.java"));

                     bufw = newBufferedWriter(new FileWriter("bufWriter_Copy.txt"));

                     String line = null;

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

                     {

                            bufw.write(line);

                            bufw.newLine();

                            bufw.flush();

                     }

              }catch (IOException e){

                     throw newRuntimeException("读写失败");

              }

              finally

              {

                     try{

                            if(bufr!=null)

                                   bufr.close();

                     }catch (IOException e){

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

                     }

                     try{

                            if(bufw!=null)

                                   bufw.close();

                     }catch (IOException e){

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

                     }

              }

       }

}

装饰设计模式

1.当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入（通常会通过构造方法接收被装饰的对象），基于已有的功能，并提供更强功的能。那么自定义的该类称为装饰类。

2.装饰与继承

(1)继承是每一个子类都具备父类功能。那么继承体系会复杂，并不利于扩展。

(2)装饰是将需要的功能，传递进来。也就是说，谁需要功能，谁就作为参数传递给装饰类。这样继承体系就变得很简单。优化了体系结构。

3.装饰模式比继承要灵活。避免了继承体系臃肿。而且降低了类于类之间的关系。装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

4.LineNumberReader获取行号。

示例：模拟一个LineNumberReader类。

importjava.io.*;

class  LineNumberReaderDemo

{

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

       {

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

              MyLineNumberReader mylnr = newMyLineNumberReader(fr);

              //LineNumberReader mylnr = new LineNumberReader(fr);

              String line = null;

              mylnr.setLineNumber(0);

              while((line=mylnr.myReadLine())!=null)

              {

                     System.out.println(mylnr.getLineNumber()+"::"+line);

              }

              mylnr.myClose();

       }

}

classMyLineNumberReader

{

       private Reader r;//作为参数使用MyLineNumberReader类对其装饰。

       private int lineNumber;

       MyLineNumberReader(Reader r)

       {

              this.r = r;

       }

       public String myReadLine()throwsIOException

       {

              lineNumber++;

              StringBuilder sb = newStringBuilder();//定义一个临时容器

              int ch = 0;

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

              {

                     if(ch=='\r')

                            continue;

                     if(ch=='\n')

                            returnsb.toString();

                     else

                            sb.append((char)ch);

              }

              if(sb.length()!=0)

                     return sb.toString();

              return null;

       }

       public void setLineNumber(int lineNumber)

       {

              this.lineNumber = lineNumber;

       }

       public int getLineNumber()

       {

              return lineNumber;

       }

       public void myClose()throws IOException

       {

              r.close();

       }

}

字节流

1.基本操作与字符流类相同，但它不仅可以操作字符，还可以操作其他媒体文件。

2.字节流缓冲区同样是提高了字节流的读写效率。

示例：复制一个Mp3媒体文件

publicstatic void copy1()throws IOException

{

       BufferedInputStream bs = new BufferedInputStream(newFileInputStream("1.mp3"));

       BufferedOutputStream bo = newBufferedOutputStream(new FileOutputStream("2.mp3"));

       int ch=0;

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

       {

              bo.write(ch);

       }

       bs.close();

       bo.close();

}

示例：自定义一个BufferedInputStream

class  MyBufferedInputStream

{

       private InputStream in;

       private byte[] buf= new byte[1024];

       private int pos=0,count=0;

       MyBufferedInputStream (InputStream in)

       {

              this.in=in;

       }

       //一次读一个字节，从缓冲区（字节数组）获取

       public int myRead()throws IOException

       {

              //通过in对象读取硬盘上的数据，并存储buf中

              if(count==0)

              {

                     count = in.read(buf);

                     if(count<0)

                            return -1;

                     pos=0;

                     byte b = buf[pos];

                     count--;

                     pos++;

                     return b&255;

              }

              else if (count>0)

              {

                     byte b = buf[pos];

                     count--;

                     pos++;

                     return b&0xff;

              }

              return -1;

       }

       public void myClose()throws IOException

       {

              in.close();

       }

}

转换流

1.InputStreamReaderOutputStreamWriter

2.转换流的由来：字符流与字节流之间的桥梁；方便了字符流与字节流之间的操作。

3.转换流的应用：字节流中的数据都是字符时，转成字符流操作更高效。

4.标准输入输出流（System.in System.out）：他们各自代表了系统标准的输入和输出设备。默认输入设备是键盘，输出设备是显示器。

最常见写法

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

       BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(System.out));

流的基本小结

1.流是处理数据的。

2.流是在帮助数据进行传输，并对传输的数据进行处理，比如过滤处理，转换处理等。

3.操作流通过三个明确来完成。

       (1)明确源和目的

       源：输入流，InputStream Reader。

       目的：输出流，OutputStream Writer。

       (2)明确操作的数据是否是纯文本。

       是：字符流。

       不是：字节流。

       (3)明确要使用的那个具体对象。通过设备来进行区分：

       源设备：内存，硬盘，键盘

       目的设备：内存，硬盘，控制台。

操作流使用缓冲区来提高效率。

 

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