14：IO之字符字节流

方法1：/* * 思路： * 1，需要读取源， * 2，将读到的源数据写入到目的地。 * 3，既然是操作文本数据，使用字符流。 * */public class CopyTextTest {    public static void main(String[] args) throws IOException {      //1,读取一个已有的文本文件，使用字符读取流和文件相关联。      FileReader fr = new FileReader("IO流_2.txt");      //2,创建一个目的，用于存储读到数据。      FileWriter fw = new FileWriter("copytext_1.txt");      //3,频繁的读写操作。      int ch = 0;      while((ch=fr.read())!=-1){      fw.write(ch);  }     //4,关闭流资源。先关写再关读     fw.close();     fr.close();  }} 

方法2：public class CopyTextTest_2 {    private static final int BUFFER_SIZE = 1024;    public static void main(String[] args) {        FileReader fr = null;        FileWriter fw = null;        try {            fr = new FileReader("IO流_2.txt");            fw = new FileWriter("copytest_2.txt");               //创建一个临时容器，用于缓存读取到的字符。            char[] buf = new char[BUFFER_SIZE];//这就是缓冲区。              //定义一个变量记录读取到的字符数，(其实就是往数组里装的字符个数 )            int len = 0;              while((len=fr.read(buf))!=-1){          fw.write(buf, 0, len);         }        } catch (Exception e) {     // System.out.println("读写失败");      throw new RuntimeException("读写失败");     }finally{         if(fw!=null)    try {        fw.close();    } catch (IOException e) {          e.printStackTrace();    }   if(fr!=null)        try {        fr.close();    } catch (IOException e) {          e.printStackTrace();    }  } }}

/ * 缓冲区的出现就是为了提高操作流的效率   * 所以在创建缓冲区之前必须要先有流对象   *    * 缓冲区提供了一个跨平台的换行符 new Line();   */  public class BufferedWriterDemo {      public static void main(String[] args) {          method();      }        public static void method() {          // 创建一个字符写入流对象          FileWriter fw = null;          BufferedWriter bfw = null;          try {              fw = new FileWriter("buf.txt");              // 为了提高字符写入流效率。加入了缓冲技术。其实缓冲区就是封装了数组，不用自己定义数组，用起来更方便              // 只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。              bfw = new BufferedWriter(fw);                for (int x = 0; x < 10; x++) {                  bfw.write("abcds" + x);                  bfw.newLine();// 换行在windows中相当于\r\n,在linux中相当于\n              }              // 记住，只要用到缓冲区，就要记得刷新。              // bufw.flush();          } catch (IOException e) {              e.printStackTrace();          } finally {              try {                  bfw.close();// 关闭缓冲区就是在关闭缓冲区中的流对象，关闭前刷新              } catch (IOException e) {                  e.printStackTrace();              }          }      }  }

 private static final String LINE_SEPARATOR = System.getProperty("line.separator");      //使用缓冲区的写入方法将数据先写入到缓冲区中。    // bufw.write("abcdefq"+LINE_SEPARATOR+"hahahha");    // bufw.write("xixiixii");   // bufw.newLine(); 行分隔，就不需要LINE_SEPARATOR，不过只在这里有效   // bufw.write("heheheheh");

public class BufferedReaderDemo {      public static void main(String[] args) {          method();      }            public static void method(){          //创建一个读取流对象          FileReader fr = null;          BufferedReader bfr = null;          try {              fr = new FileReader("buf.txt");              //为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。              bfr = new BufferedReader(fr);                //          char[] buf = new char[1024];  //          bfr.read(buf);  //          int len = 0;  //          while((len = bfr.read(buf)) != -1){  //              System.out.println(new String(buf,0,len));  //          }                            String line = null;              while((line = bfr.readLine()) != null){                  System.out.println(line);              }          } catch (IOException e) {              e.printStackTrace();          }finally{              try {                  bfr.close();              } catch (IOException e) {                  e.printStackTrace();              }          }      }  }

public class CopyTextByBufTest {	//不处理异常，抛出去	public static void main(String[] args) throws IOException {		FileReader fr = new FileReader("buf.txt");		BufferedReader bufr = new BufferedReader(fr);		FileWriter fw = new FileWriter("buf_copy.txt");		BufferedWriter bufw = new BufferedWriter(fw);		String line = null;		while ((line = bufr.readLine()) != null) {			bufw.write(line);			bufw.newLine();			bufw.flush();		}		/*		 * int ch = 0;		 * 		 * while((ch=bufr.read())!=-1){		 * 		 * bufw.write(ch); }		 */		bufw.close();		bufr.close();	}}

public class CopyByBuffer {      public static void main(String[] args) {          copyByBuf();      }        public static void copyByBuf() {          FileWriter fw = null;          FileReader fr = null;          BufferedWriter bfw = null;          BufferedReader bfr = null;            try {              fw = new FileWriter("C:\\buffertest.txt");//创建写文件对象              fr = new FileReader("buffertest.txt");//创建读文件对象              bfw = new BufferedWriter(fw);//使用缓冲区关联读写对象              bfr = new BufferedReader(fr);                String line = null;              while ((line = bfr.readLine()) != null) {//通过读一行的方式提高效率                  bfw.write(line);                  bfw.newLine();//换行，夸平台              }          } catch (IOException e) {              e.printStackTrace();          } finally {              if (bfw != null) {                  try {                      bfw.close();                  } catch (IOException e) {                      e.printStackTrace();                  }              }                if (bfr != null) {                  try {                      bfr.close();                  } catch (IOException e) {                      e.printStackTrace();                  }              }          }      }  }  

public class MyBufferedReader extends Reader {	 private Reader r;	 	 //定义一个数组作为缓冲区。	 private char[] buf = new char[1024];	 	 //定义一个指针用于操作这个数组中的元素。当操作到最后一个元素后，指针应该归零。	 private int pos = 0;	 	 	 //定义一个计数器用于记录缓冲区中的数据个数。 当该数据减到0，就从源中继续获取数据到缓冲区中。	 private int count = 0;	 MyBufferedReader(Reader r){	  this.r = r;	 }	/**	  * 该方法从缓冲区中一次取一个字符。	  * @return	  * @throws IOException	  */	/*	public int myRead() throws IOException{ 	  //从源中获取一批数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据。	  if(count==0){	   count = r.read(buf); //这是在底层	   	   if(count<0)//没有了	    return -1;	   	   //每次获取数据到缓冲区后，角标归零（第一个read，底层）创建了一个数组。	   pos = 0;	   char ch = buf[pos];	  // 然后调用一次（第二个）read，返回一个a,再调用返回b,角标取一个，count减一个	   pos++;	   count--;	   	   return ch;	   	  }	else if(count>0){//第二次调用的时候count就不为0了， 不需要count = r.read(buf)这一步了	   	   char ch = buf[pos];	   	   pos++;	   count--;	   	   return ch;	   	  }*/

优化后 public int myRead() throws IOException{   if(count==0){   count = r.read(buf);   pos = 0;  }  if(count<0)   return -1;   char ch = buf[pos++];   count--;   return ch;   }  

public String myReadLine() throws IOException{	 	  // 定义一个临时容器，原BufferedReader封装的是字符数组，这里定义StringBuilder演示原理  	  StringBuilder sb = new StringBuilder();	 	  int ch = 0;	  while((ch = myRead())!=-1){	   	   if(ch=='\r') //如是'\r'继续往下读  	    continue;	   if(ch=='\n') //读到'\n'就停止读，然后将这些数据返回  	    return sb.toString();	   //将从缓冲区中读到的字符，存储到缓存行数据的缓冲区中。	   sb.append((char)ch);	     }   	 	  if(sb.length()!=0) //最后没有空格，说明有东西，返回，	//这里是防止最后一行没有回车符的情况  	   return sb.toString();	  return null;	 }	 public void myClose() throws IOException {	 	  r.close();	 }	 @Override	 public int read(char[] cbuf, int off, int len) throws IOException {	 	  return 0;	 }	 @Override	 public void close() throws IOException {	 }	}	运行 ReadLine	public class MyBufferedReaderDemo {	 public static void main(String[] args) throws IOException {	  FileReader fr = new FileReader("buf.txt");	 	  MyBufferedReader bufr = new MyBufferedReader(fr);	 	  String line = null;	 	  while((line=bufr.myReadLine())!=null){	   System.out.println(line);	  }	 	  bufr.myClose();	     	 	  Collections.reverseOrder();	  HashMap map = null;	  map.values();	   } 	}

public class LineNumberReaderDemo {	public static void main(String[] args) throws IOException {		FileReader fr = new FileReader("IO流_2.txt");		LineNumberReader lnr = new LineNumberReader(fr);		String line = null;		lnr.setLineNumber(100);// 默认是0		while ((line = lnr.readLine()) != null) {			System.out.println(lnr.getLineNumber() + ":" + line);		}		lnr.close();	}}

class Buffer {	Buffer(TextWriter w) // 要缓冲谁就加入进来	{	}	Buffer(MediaWirter w) // 要缓冲谁就加入进来	{	}} // 但是这样做，来新对象还得加入，比较麻烦// 都能写入，为了名字有意义，写成BufferWriterclass BufferWriter extends Writer {	BufferWriter(Writer w) {	}}

 / * 字节流操作   * InputStream OutputStream   *    */  public class FileStreamDemo {      public static void main(String[] args) {          // writeFile();          // readFile_1();          // readFile_2();          readFile_3();      }        /*       * 对字节流读操作的第一种方式 通过read()方法读取一个字节       */      public static void readFile_1() {          FileInputStream fis = null;// 定义字节输入流          try {              fis = new FileInputStream("fos.txt");// 指定输入流和文件关联              int ch = 0;              while ((ch = fis.read()) != -1) {// 读取操作                  System.out.println((char) ch);              }          } catch (FileNotFoundException e) {              e.printStackTrace();          } catch (IOException e) {              e.printStackTrace();          } finally {              try {                  if (fis != null)// 判空，提高程序的健壮性                      fis.close();              } catch (IOException e) {                  e.printStackTrace();              }          }      }        /*       * 对字节流读操作的第二种方式 通过read(byte[])方法读取字节数组       */      public static void readFile_2() {          FileInputStream fis = null;          try {              fis = new FileInputStream("fos.txt");              byte[] byf = new byte[1024];              int len = 0;              while ((len = fis.read(byf)) != -1) {                  System.out.println(new String(byf, 0, len));              }          } catch (FileNotFoundException e) {              e.printStackTrace();          } catch (IOException e) {              e.printStackTrace();          } finally {              try {                  if (fis != null)                      fis.close();              } catch (IOException e) {                  e.printStackTrace();              }          }      }        /*       * 对字节流读操作的第三种方式 通过字节流的available()方法获取到文件大小，定义一个大小刚刚好的数组，无需循环  但是，这种方式操作较大数据时容易内存溢出，所以要慎用 首选的还是定义1024的整数倍数组       */      public static void readFile_3() {          FileInputStream fis = null;          try {              fis = new FileInputStream("fos.txt");              // 通过这样的方式定义一个刚刚好的数组              // 这种方法慎用，如果文件不大，可以用这个方法              byte[] byf = new byte[fis.available()];// fis.available()获取文件大小              fis.read(byf);              System.out.println(new String(byf));          } catch (FileNotFoundException e) {              e.printStackTrace();          } catch (IOException e) {              e.printStackTrace();          } finally {              try {                  fis.close();              } catch (IOException e) {                  e.printStackTrace();              }          }      }        /*       * 对字节流进行写操作       */      public static void writeFile() {          FileOutputStream fos = null;          try {              fos = new FileOutputStream("fos.txt");//定义字节写出流和文件关联              fos.write("abcds".getBytes());// str.getBytes()将String转化成字节数组          } catch (FileNotFoundException e) {              e.printStackTrace();          } catch (IOException e) {              e.printStackTrace();          } finally {              if (fos != null)                  try {                      fos.close();// 因为字节流没有用到缓冲区，所以不需要刷新，但必须关闭资源                  } catch (IOException e) {                      e.printStackTrace();                  }          }      }  }

 * 通过字节流拷贝图片   */  public class CopyPicture {      public static void main(String[] args) {          copyPic();      }        public static void copyPic() {          FileInputStream fis = null;          FileOutputStream fos = null;          try {              fis = new FileInputStream("1.jpg");              fos = new FileOutputStream("C:\\1.jpg");                byte[] byf = new byte[1024];              int len = 0;              while ((len = fis.read(byf)) != -1) {// 将数据读取到数组中                  fos.write(byf, 0, len);// 写入数组中的有效数据              }          } catch (FileNotFoundException e) {              e.printStackTrace();          } catch (IOException e) {              e.printStackTrace();          } finally {              // 有多个流不能一起关闭，要分别关闭              if (fis != null) {                  try {                      fis.close();                  } catch (IOException e) {                      e.printStackTrace();                  }              }              if (fos != null) {                  try {                      fos.close();                  } catch (IOException e) {                      e.printStackTrace();                  }              }          }      }  }  //	千万不要用，效率没有！ public static void copy_4() throws IOException {  FileInputStream fis = new FileInputStream("c:\\0.mp3");  FileOutputStream fos = new FileOutputStream("c:\\4.mp3");   int ch = 0;    while((ch =fis.read())!=-1){   fos.write(ch);  }   fos.close();  fis.close(); } //不建议。 public static void copy_3() throws IOException {  FileInputStream fis = new FileInputStream("c:\\0.mp3");  FileOutputStream fos = new FileOutputStream("c:\\3.mp3");   byte[] buf = new byte[fis.available()];  fis.read(buf);  fos.write(buf);  fos.close();  fis.close(); }//提高效率public static void copy_2() throws IOException {   FileInputStream fis = new FileInputStream("c:\\0.mp3");  BufferedInputStream bufis = new BufferedInputStream(fis);   FileOutputStream fos = new FileOutputStream("c:\\2.mp3");  BufferedOutputStream bufos = new BufferedOutputStream(fos);    int ch = 0;    while((ch=bufis.read())!=-1){   bufos.write(ch);  }   bufos.close();  bufis.close(); }

 * 自定义字节流缓冲区   */  public class MyBufferedInputStream {      private InputStream in;      private byte[] buf = new byte[1024];      private int pos;// 定义数组的指针      private int count;// 定义计数器        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;// &255是因为存放的是二进制，也就是可能前八位是11111111，提升为int还是-1，就直接return了，              // &255就是让前面补0              /*               *  11111111 11111111 11111111 11111111                * &00000000 00000000 00000000 11111111                * ------------------------------------                *  00000000 00000000  00000000 11111111               */          }else if(count>0){              byte b = buf[pos];                            count--;              pos++;              return b&255;//&0xff          }          return -1;      }            public void myClose() throws IOException{          in.close();      }  }

      //获取键盘录入对象  
         InputStream in = System.in;                     //将字节流对象转换成字符流对象           InputStreamReader isr = new InputStreamReader(in);                     //将字符流对象用缓冲技术高效处理           BufferedReader bufr = new BufferedReader(isr);         // 键盘录入最常见的写法           BufferedReader bufr = new BufferedReader(new  InputStreamReader(System.in));  

 * 获取键盘录入  public class ReadIn {      public static void main(String[] args) {          // method_1();          // method_2();          InputStreamReaderDemo();      }        /*       * 获取键盘录入       */      public static void method_1() {          InputStream in = System.in;// 定义输入流与键盘输入流相关联          int ch = 0;          try {              while ((ch = in.read()) != -1) {                  System.out.println(ch);              }          } catch (IOException e) {              e.printStackTrace();          }      }        /*       * 需求：通过键盘录入数据。 当录入一行数据后，就将该行数据进行打印。 如果录入的数据是over，那么停止录入。       * 1，因为键盘录入只读取一个字节，要判断是否是over，需要将读取到的字节拼成字符串。     * 2，那就需要一个容器。StringBuilder.     * 3，在用户回车之前将录入的数据变成字符串判断即可。      */      public static void method_2() {          InputStream in = System.in;          StringBuilder sb = new StringBuilder();// 定义一个临时容器            while (true) {              int ch = 0;              try {                  ch = in.read();                  if (ch == '\r')// windows中换行符为\r\n                      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);    //将读取到的字节存储到StringBuilder中。                }              } catch (IOException e) {                  e.printStackTrace();              }          }      }        // **************************************************************************        /*       * 通过上面录入一行数据，发现其方法类似于readLine方法 但是readLine方法是字符流缓冲区的方法，所以需要把字节流转换成字符流进行操作       * 需要用到InputStreamReader方法进行转换,InputStreamReader字节通向字符的桥梁       *        * 转换流       */      public static void InputStreamReaderDemo() {             BufferedReader bufr = null;          try {              // 源为文件              bufr = new BufferedReader(new InputStreamReader(                      new FileInputStream("buf.txt")));          } catch (FileNotFoundException e2) {              e2.printStackTrace();          }            // 操作输出          // 目的地是控制台          BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(                  System.out));            // 目的地是文件          // BufferedWriter bfw = null;          // try {          // bfw = new BufferedWriter(new OutputStreamWriter(new          // FileOutputStream("out.txt")));          // } catch (FileNotFoundException e1) {          // e1.printStackTrace();          // }            String line = null;            try {              while ((line = bufr.readLine()) != null) {                  if ("over".equals(line)) {                      break;                  }                  bfw.write(line.toUpperCase());                  bfw.newLine();// 换行                  bfw.flush();// 数据存放在缓冲区，所以需要刷新              }          } catch (IOException e) {              e.printStackTrace();          } finally {              try {                  bufr.close();              } catch (IOException e) {                  e.printStackTrace();              }          }      }  }不处理异常public class TransStreamDemo2 {   public static void main(String[] args) throws IOException {   /*   * 1,需求：将键盘录入的数据写入到一个文件中。   *   * 2,需求：将一个文本文件内容显示在控制台上。   *   * 3,需求：将一个文件文件中的内容复制到的另一个文件中。   */     BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));     BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new       FileOutputStream("b.txt")));      String line = null;       while((line=bufr.readLine())!=null){     if("over".equals(line))     break;          bufw.write(line.toUpperCase()); //变成大写     bufw.newLine();     bufw.flush();    }  } }

	public static void writeText_2() throws IOException {		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(				"gbk_3.txt"), "GBK");		// OutputStreamWriter osw = new OutputStreamWriter(new		// FileOutputStream("gbk_3.txt"),"GBK");		// FileWriter fw = new FileWriter("gbk_1.txt");		/*		 * 这两句代码的功能是等同的。 FileWriter：其实就是转换流指定了本机默认码表的体现。而且这个转换流的子类对象，可以方便操作文本文件。		 * 简单说：操作文件的字节流+本机默认的编码表。 这是按照默认码表来操作文件的便捷类。		 * 		 * 如果操作文本文件需要明确具体的编码。FileWriter就不行了。必须用转换流		 */		osw.write("你好");		osw.close();	}	public static void writeText_3() throws IOException {		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(				"u8_1.txt"), "UTF-8");		osw.write("你好");		osw.close();	}

public static void readText_1() throws IOException {	 	  FileReader fr = new FileReader("gbk_1.txt");	 	  char[] buf = new char[10];	  int len = fr.read(buf);	  String str = new String(buf,0,len);	  System.out.println(str);	   fr.close();	   } 	//用utf-8读默认的编码文件	 public static void readText_2() throws IOException, FileNotFoundException {	 	  InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk_1.txt"),"utf-8"); 	  char[] buf = new char[10];	  int len = isr.read(buf);	  String str = new String(buf,0,len);	  System.out.println(str);	  isr.close();	 }	  }	}