黑马程序员——day19(1)IO流

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

一，IO
/*
字符流和字节流：

字节流两个基类：
InputStream   OutputStream

字符流两个基类：
Reader Writer

先学习一下字符流的特点

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

那么线以操作文件为主来演示。

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

找到一个专门用于操作文件的Writer子类对象。FileWriter.后缀名是父类名。前缀名是该流对象的功能。

*/
import java.io.*;
class FileWriterDemo
{
 public static void main(String[] args) throws IOException
 {
 //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
 //而且该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖。
 //其实该步就是要明确数据要存放的目的地。 
  FileWriter fw = new FileWriter("demo.txt");

 //调用write方法，将字符串写入到流中。
  fw.write("abcde");

 //刷新流对象中的缓冲中的数据。
 //将数据刷到目的地中。 
  //fw.flush();

 //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
 //将数据刷到目的地中。
 //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
  fw.close();

 }

二，
/*
IO异常的处理方式。

*/

import java.io.*;
class FileWriterDemo2
{
 public static void main(String[] args)
 {
       FileWriter  fw = null;

       try
      {
  fw = new FileWriter("demo.txt");

  fw.write("abcdefg"); 
  
      }
      catch(IOException e)
      {
  System.out.println(e.toString());
      }
      finally
      {
  
  try{
          if(fw!=null)
    fw.close();
      }
  catch(IOException e)
      {
  System.out.println(e.toString());
      }
        }   
}

三，
/*
演示对已有文件的数据续写。
*/

import java.io.*;
class FileWriterDemo3
{
 public static void main(String[] args)
       {
 //传递一个true参数，代表不覆盖已有的文件。并在已有文件上的末尾处进行数据续写
 FileWriter fw = new FileWriter("demo.txt",true);
 
 fw.write("nihao\r\xiexie") // \r\换行

 fw.close();
 }

}

四，
/*
读文件   demo.txt  "abcdefg"
*/
import java.io.*;
class FileWriterDemo
{
 public static void main(String[] args) throws IOException
       {
 //创建一个文件读取流对象，和指定名称的文件相关联。
 //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
   FileReader  fr = new FileReader("demo.txt");
 /*
 //调用读取流对象的read方法。
 //read():一次读一个字符。而且会自动往下读。
 int ch = fr.read();
 
 System.out.pritnln("ch"+(char)ch);    // 结果：ch=a
 */
 int ch = 0;
 while((ch=fr.read())!=-1)  //读到尾往后读就会返回-1
 {
  System.out.println((char)ch);
 
 }
    }
}

五，
/*
第二种方式：通过字符数组进行读取。
*/
import java.io.*;
class FileWriterDemo2
{
 public static void main(String[] args) throws IOException
       {

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

  //定义一个字符数组，用于存储读到字符。
  //该read(char[])返回的是读到字符个数。
  char[] buf = new char[1024];

  /*int num = fr.read(buf);

  System.out.println("num="+num+"..."+new String(buf));
  */
  
  int num = 0;
  while((num=fr.read(buf))!=-1)
  {
   System.out.println(new String(buf，0,num))  //num截取有效位
  }

  fr.close();
 ｝   
｝

//将C盘一个文本文件复制到D盘
/*
复制的原理：
其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：
1，在D盘创建一个文件。用于存储C盘文件中的数据。
2，定义读取流和C盘文件关联。
3，通过不断的读写完成数据存储。
4，关闭资源
*/
 
import java.io.*;
class CopyText
{
 public static void main(String[] args)
 {
  
 copy_1();

 }
 public static void copy_1()throws IOException
 {
 //创建目的地。
 FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");

 //与已有文件关系。
 FileReader fr = new FileReader("")
 
}
}

 

/*
缓冲区的出现是为了提高流的操作效率而出现的。

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

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

import java.io.*;
class BufferedWriteDemo
{
 public static void main(String[] args) throws IOException
 {
 //创建一个字符写入流对象。
 FileWriter fw = new FileWriter("buf.txt");
 
 //为了提高字符写入流效率，加入了缓冲技术，
 //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
 BufferedWrite bufw = new BufferedWrite(fw);

 /*bufw.write("abcde");

 bufw.newLine(); //换行*/

 for(int x=1;x<5;x++)
 {
  bufw.write("abcd"+x);
  bufw.newLine();
  bufw.flush();
 }
 //记住，只要用到缓冲区，就要记得刷新。
 bufw.flush();

 //其实关闭缓冲区，就是在关闭缓冲区中的流对象。
 bufw.close();
      //fw.close();
 }
}

/*
字符读取流缓冲区 ：
该缓冲区提供了一个一次读一行的方法 readLine。方便于五年级数据的获取。
当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
*/
import java.io.*;
class BufferedReaderDemo
{
 public static void main(String[] args) throws IOException
 {
 //创建一个读取流对象和文件相关联。
 FileReader fr = new FileReader("buf.txt");

 //为了提高效率，加入缓冲技术。将字符流对象作为参数传递给缓冲对象的构造函数。
 BufferedReader bufr = new BufferedReader(fr);

 String line = null;
 while((line=bufr.readLine())!=null)
 ｛
  System.out.println(line); 
 ｝
 bufr.close();

/*
装饰设计模式：
当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。

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

装饰模式比继承要灵活，避免了继承体系臃肿。
而且降低了类与类之间的关系。

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

*/
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("甜点")；
  System.out.println("来一根")；
 }
 
}

class PersonDemo
{
 public static void main(String[] args)
 {
  person p = new Person();
  
  SuperPerson sp = new SuperPerson(p);
  sp.superChifan();
 }
}

/*
字符流：
FileReader
FileWriter

BufferedReader
BufferedWriter

字节流：
InputStream读   OutputStream写
需求：想要操作图片数据。这时就要用到字节流。

*/
import java.io.*;
class FileStream
{
 public static void main(String[] args) throws IOException
 {
  readFile_1();
 }

 public static void readFile_1() throws IOException
 {
  FileInputStream fis = new FileInputStream("fos.txt");  
  byte[] buf = new bytep[1024];
  int len = 0;
  while((len=fis.read(buf))!=-1)
  {
   System.out.println(new String(buf,0,len));
  }

 
 }

 public static void writeFile() throws IOException
 {
  FileOutputStream fos = new FileOutputStream("fos.txt");
  fos.write("abcde".getByte()); 
  fos.close();
 }

}

/*
复制一个图片
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储。
4，关闭资源。

*/

import java.io.*;
class CopyPic
{
 public static void main(String[] args)
 {
  FileOutputStream fos = null;
  FileInputStream fis = null;

    try{
  fos = new FileOutputStream("c:\\2.bmp");
  fis = new FileInputStream("c:\\1.bmp");

  byte[] buf = new byte[1024];

  int len = 0;

  while((len = fis.read())!=-1)
  { 
   fos.write(buf,0,len); 
  }
       }catch(IOException e)
  {
   throw new RuntimeException("复制文件失败")；
  }
  finally
  {
   try{
    if(fis！=null)
    fis.close()
       }catch(IOExcetption e)
    { ...}
   try{
    if(fos！=null)
    fos.close()
       }catch(IOExcetption e)
    { ...}
  }
 }
}

/*
字符流：
FileReader
FileWriter

BufferedReader
BufferedWriter

字节流：
FileInputStream
FileOutputStream

BufferedInputStream
BufferedOutputStream

通过键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
也就是readLine方法。

readLine方法是字符流BufferedReader类中的方法。

而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流在使用字符流缓冲区的readLine的方法呢？

*/

/*
读取键盘录入
最常见写法：：BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));

System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备，键盘。

// ASCLL中\r 13 \n 10

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

*/
import java.io.*;
class ReadIn
{
 public static void main(String[] args)
 {
  InputStream in = System.in;
  StringBuilder sb = new StringBuilder();
  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 TransStreamDemo
{
 public static void main(String[] args)  throws IOExcetpion
 {
 //获取键盘录入对象。 
 InputStream in = System.in;
 
 //将字节流对象转成字符流对象，使用转换流。InputStreamReader
 InputStreamReader isr = new InputStreamReader(in);

 //为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
 BufferedReader bufr = new BufferedReader(isr);

 String line = null;

 while((line=bufr.readLine())!=null)
 {
  if("over".equals(line))
   break;
  System.out.println(line.toUpperCase());
 }
 bufr.close();

 

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

                         详细请查看      http://edu.csdn.net/heima