欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

21. IO流(字符流)

程序员文章站 2024-03-07 15:02:33
...

目录

1:字符流(掌握)

           C:字符串中的编码问题

           A:OutputStreamWriter

           B:InputStreamReader

(6) OutputStreamWriter的方法:

(7) InputStreamReader的方法:

      (9)字符流的子类FileWriter与FileReader

      (10)字符缓冲流的特殊方法:

2:IO流小结(掌握)

3:案例(理解练习一遍)


1:字符流(掌握)

       (1)字节流操作中文数据不是特别的方便,所以就出现了转换流。

          转换流的作用就是把字节流转换字符流来使用。

       (2)转换流其实是一个字符流

              字符流= 字节流 + 编码表

       (3)编码表

              A:就是由字符和对应的数值组成的一张表

              B:常见的编码表

                     ASCII

                     ISO-8859-1

                     GB2312

                     GBK

                     GB18030

                     UTF-8

           C:字符串中的编码问题

 String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组

 byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组

 编码:把看得懂的变成看不懂的

 String -- byte[]

 解码:把看不懂的变成看得懂的

 byte[] -- String

 

public class StringDemo {
       publicstatic void main(String[] args) throws UnsupportedEncodingException {
              String s= "你好";
              // String -- byte[]
              byte[] bys = s.getBytes(); //[-60, -29, -70, -61]
              // byte[] bys =s.getBytes("GBK");// [-60, -29, -70, -61]
              // byte[] bys =s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
              System.out.println(Arrays.toString(bys));
              // byte[] -- String
              String ss = new String(bys); // 你好
              // String ss = new String(bys,"GBK"); // 你好
              // String ss = new String(bys,"UTF-8"); // ???
              System.out.println(ss);
       }
}

(4)IO流中的编码问题

           A:OutputStreamWriter

                     OutputStreamWriter(OutputStreamos):                                   默认编码,GBK

                     OutputStreamWriter(OutputStreamos,String charsetName):       指定编码。

 

publicclass OutputStreamWriterDemo {
   public static void main(String[] args) throwsIOException {
          // 创建对象
          // OutputStreamWriter osw = newOutputStreamWriter(new FileOutputStream(
          // "osw.txt")); // 默认GBK
          // OutputStreamWriter osw = newOutputStreamWriter(new FileOutputStream(
          // "osw.txt"),"GBK"); // 指定GBK
          OutputStreamWriter osw = newOutputStreamWriter(new FileOutputStream(
                        "osw.txt"),"UTF-8"); // 指定UTF-8
          //写数据
          osw.write("中国");
          //释放资源
          osw.close();
   }
}

 

           B:InputStreamReader

                     InputStreamReader(InputStreamis):                                        默认编码,GBK

                     InputStreamReader(InputStreamis,String charsetName):           指定编码

 

public class InputStreamReaderDemo{
       publicstatic void main(String[] args) throws IOException {
              //创建对象
              //InputStreamReader isr = new InputStreamReader(new FileInputStream(
              //"osw.txt"));
              //InputStreamReader isr = new InputStreamReader(new FileInputStream(
              //"osw.txt"), "GBK");
              InputStreamReaderisr = new InputStreamReader(new FileInputStream(
                            "osw.txt"),"UTF-8");
              //读取数据
              //一次读取一个字符
              intch = 0;
              while((ch = isr.read()) != -1) {
                     System.out.print((char)ch);
              }
              //释放资源
              isr.close();
       }
}

 

       (5)字符流

              Reader

                     |--InputStreamReader

                            |--FileReader

                     |--BufferedReader

              Writer

                     |--OutputStreamWriter

                            |--FileWriter

                     |--BufferedWriter

(6) OutputStreamWriter的方法:

  public void write(int c):                                    写一个字符

  public void write(char[] cbuf):                           写一个字符数组

  public void write(char[] cbuf,int off,intlen):        写一个字符数组的一部分

  public void write(String str):                             写一个字符串

  public void write(String str,int off,intlen):          写一个字符串的一部分

    * 面试题:close()和flush()的区别?

 * A:close()关闭流对象,但是先刷新一次缓冲区。关闭之后,流对象不可以继续再使用了。

 * B:flush()仅仅刷新缓冲区,刷新之后,流对象还可以继续使用。

 

public classOutputStreamWriterDemo {
       publicstatic void main(String[] args) throws IOException {
              //创建对象
              OutputStreamWriterosw = new OutputStreamWriter(new FileOutputStream("osw2.txt"));
              //写数据
              //public void write(int c):写一个字符
              //osw.write('a');
              //osw.write(97);
              //为什么数据没有进去呢?
              //原因是:字符 = 2字节
              //文件中数据存储的基本单位是字节。
              //void flush()
              //public void write(char[] cbuf):写一个字符数组
              //char[] chs = {'a','b','c','d','e'};
              //osw.write(chs);
              //public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
              //osw.write(chs,1,3);
              //public void write(String str):写一个字符串
              //osw.write("我爱林青霞");
 
              //public void write(String str,int off,int len):写一个字符串的一部分
              osw.write("我爱林青霞", 2, 3);
              //刷新缓冲区
              osw.flush();
              //osw.write("我爱林青霞", 2, 3);
              //释放资源
              osw.close();
              //java.io.IOException: Stream closed
              //osw.write("我爱林青霞", 2, 3);
       }
}

 

(7) InputStreamReader的方法:

  intread():                  一次读取一个字符

  int read(char[] chs):    一次读取一个字符数组

 

public class InputStreamReaderDemo{
   publicstatic void main(String[] args) throws IOException {
          //创建对象
          InputStreamReaderisr = new InputStreamReader(new FileInputStream("StringDemo.java"));
          //一次读取一个字符
          //int ch = 0;
          //while ((ch = isr.read()) != -1) {
          //System.out.print((char) ch);
          //}
          //一次读取一个字符数组
          char[]chs = new char[1024];
          intlen = 0;
          while((len = isr.read(chs)) != -1) {
                 System.out.print(newString(chs, 0, len));
          }
          //释放资源
          isr.close();
   }
}

       (8)复制文本文件

  需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

  数据源:

             a.txt-- 读取数据 -- 字符转换流-- InputStreamReader

  目的地:

             b.txt-- 写出数据 -- 字符转换流 -- OutputStreamWriter

 

public class CopyFileDemo {
       publicstatic void main(String[] args) throws IOException {
              //封装数据源
              InputStreamReaderisr = new InputStreamReader(new FileInputStream("a.txt"));
              //封装目的地
              OutputStreamWriterosw = new OutputStreamWriter(new FileOutputStream("b.txt"));
              //读写数据
              //方式1
              //int ch = 0;
              //while ((ch = isr.read()) != -1) {
              //osw.write(ch);
              //}
              //方式2
              char[]chs = new char[1024];
              intlen = 0;
              while((len = isr.read(chs)) != -1) {
                     osw.write(chs,0, len);
                     //osw.flush();
              }
              //释放资源
              osw.close();
              isr.close();
       }
}

 

 

 

      (9)字符流的子类FileWriterFileReader

  由于我们常见的操作都是使用本地默认编码,所以,不用指定编码。

  而转换流的名称有点长,所以,Java就提供了其子类供我们使用。

  OutputStreamWriter = FileOutputStream + 编码表(GBK)

  FileWriter = FileOutputStream + 编码表(GBK)

  InputStreamReader = FileInputStream + 编码表(GBK)

  FileReader = FileInputStream + 编码表(GBK)

 * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

 * 数据源:

 *          a.txt -- 读取数据 -- 字符转换流 --InputStreamReader -- FileReader

 * 目的地:

 *          b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter-- FileWriter

 

publicclass CopyFileDemo2 {
       public static void main(String[] args)throws IOException {
              // 封装数据源
              FileReader fr = newFileReader("a.txt");
              // 封装目的地
              FileWriter fw = newFileWriter("b.txt");
              // 一次一个字符
              // int ch = 0;
              // while ((ch = fr.read()) != -1){
              // fw.write(ch);
              // }
              // 一次一个字符数组
              char[] chs = new char[1024];
              int len = 0;
              while ((len = fr.read(chs)) != -1){
                     fw.write(chs, 0, len);
                     fw.flush();
              }
              // 释放资源
              fw.close();
              fr.close();
       }
}

 

      (10)字符缓冲流的特殊方法:

 BufferedWriter:

             publicvoid newLine():          根据系统来决定换行符

 BufferedReader:

             publicString readLine()     一次读取一行数据

             包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null

 

public class BufferedDemo {
       public static voidmain(String[] args) throws IOException {
              // write();
              read();
       }
       private static voidread() throws IOException {
              // 创建字符缓冲输入流对象
              BufferedReader br= new BufferedReader(new FileReader("bw2.txt"));
              // public StringreadLine():一次读取一行数据
              // String line =br.readLine();
              // System.out.println(line);
              // line =br.readLine();
              //System.out.println(line);
              // 最终版代码
              String line =null;
              while ((line =br.readLine()) != null) {
                     System.out.println(line);
              }
              //释放资源
              br.close();
       }
       private static voidwrite() throws IOException {
              // 创建字符缓冲输出流对象
              BufferedWriter bw= new BufferedWriter(new FileWriter("bw2.txt"));
              for (int x = 0; x < 10; x++) {
                     bw.write("hello"+ x);
                     // bw.write("\r\n");
                     bw.newLine();
                     bw.flush();
              }
              bw.close();
       }
}

 * BufferedReader

 * 从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。

 * 可以指定缓冲区的大小,或者可使用默认的大小。大多数情况下,默认值就足够大了。

 * BufferedReader(Reader in)

 

public class BufferedReaderDemo {
       public static voidmain(String[] args) throws IOException {
              // 创建字符缓冲输入流对象
              BufferedReader br= new BufferedReader(new FileReader("bw.txt"));
              // 方式1
              // int ch = 0;
              // while ((ch =br.read()) != -1) {
              //System.out.print((char) ch);
              // }
              // 方式2
              char[] chs = newchar[1024];
              int len = 0;
              while ((len =br.read(chs)) != -1) {
                     System.out.print(newString(chs, 0, len));
              }
              // 释放资源
              br.close();
       }
}

------------------------------------------------------------------------------------------------------------------------------------------

 * 字符流为了高效读写,也提供了对应的字符缓冲流。

 * BufferedWriter:字符缓冲输出流

 * BufferedReader:字符缓冲输入流

 * BufferedWriter:字符缓冲输出流

 * 将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。

 * 可以指定缓冲区的大小,或者接受默认的大小。在大多数情况下,默认值就足够大了。

 

public class BufferedWriterDemo {
       public static voidmain(String[] args) throws IOException {
              //BufferedWriter(Writer out)
              // BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(
              // newFileOutputStream("bw.txt")));
              BufferedWriter bw= new BufferedWriter(new FileWriter("bw.txt"));
              bw.write("hello");
              bw.write("world");
              bw.write("java");
              bw.flush();
              bw.close();
       }
}

------------------------------------------------------------------------------------------------------------------------------------------

 * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

 * 数据源:

 *          a.txt -- 读取数据 -- 字符转换流 --InputStreamReader -- FileReader -- BufferedReader

 * 目的地:

 *          b.txt -- 写出数据 -- 字符转换流 --OutputStreamWriter -- FileWriter -- BufferedWriter

 

public class CopyFileDemo {
       public static voidmain(String[] args) throws IOException {
              // 封装数据源
              BufferedReader br= new BufferedReader(new FileReader("a.txt"));
              // 封装目的地
              BufferedWriter bw= new BufferedWriter(new FileWriter("b.txt"));
              // 两种方式其中的一种一次读写一个字符数组
              char[] chs = newchar[1024];
              int len = 0;
              while ((len =br.read(chs)) != -1) {
                     bw.write(chs,0, len);
                     bw.flush();
              }
              // 释放资源
              bw.close();
              br.close();
       }
}

------------------------------------------------------------------------------------------------------------------------------------------

 * 需求:把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

 * 数据源:

 *          a.txt -- 读取数据 -- 字符转换流 --InputStreamReader -- FileReader -- BufferedReader

 * 目的地:

 *          b.txt -- 写出数据 -- 字符转换流 --OutputStreamWriter -- FileWriter -- BufferedWriter

 

public class CopyFileDemo2 {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		// 封装目的地
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
		// 读写数据
		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		// 释放资源
		bw.close();
		br.close();
	}
}

 

 

 

2:IO流小结(掌握)

       IO

              |--字节流

                     |--字节输入流

                            InputStream

                                   int read():一次读取一个字节

                                   intread(byte[] bys):一次读取一个字节数组

                                   |--FileInputStream

                                   |--BufferedInputStream

                     |--字节输出流

                            OutputStream

                                   voidwrite(int by):一次写一个字节

                                   voidwrite(byte[] bys,int index,int len):一次写一个字节数组的一部分

                                   |--FileOutputStream

                                   |--BufferedOutputStream

              |--字符流

                     |--字符输入流

                            Reader

                                   int read():一次读取一个字符

                                   intread(char[] chs):一次读取一个字符数组

                                   |--InputStreamReader

                                          |--FileReader

                                   |--BufferedReader

                                          StringreadLine():一次读取一个字符串

                     |--字符输出流

                            Writer

                                   voidwrite(int ch):一次写一个字符

                                   voidwrite(char[] chs,int index,int len):一次写一个字符数组的一部分

                                   |--OutputStreamWriter

                                          |--FileWriter

                                   |--BufferedWriter

                                          voidnewLine():写一个换行符

                                          voidwrite(String line):一次写一个字符串

3:案例(理解练习一遍)

       A:复制文本文件5种方式(掌握)

 * 分析:

 *          复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。

 *          通过该原理,我们知道我们应该采用字符流更方便一些。

 *          而字符流有5种方式,所以做这个题目我们有5种方式。推荐掌握第5种。

 * 数据源:

 *          c:\\a.txt-- FileReader -- BufferdReader

 * 目的地:

 *          d:\\b.txt-- FileWriter -- BufferedWriter

 

public class CopyFileDemo {
       publicstatic void main(String[] args) throws IOException {
              StringsrcString = "c:\\a.txt";
              StringdestString = "d:\\b.txt";
              //method1(srcString, destString);
              //method2(srcString, destString);
              //method3(srcString, destString);
              //method4(srcString, destString);
              method5(srcString,destString);
       }
       //字符缓冲流一次读写一个字符串
       privatestatic void method5(String srcString, String destString)
                     throwsIOException {
              BufferedReaderbr = new BufferedReader(new FileReader(srcString));
              BufferedWriterbw = new BufferedWriter(new FileWriter(destString));
              Stringline = null;
              while((line = br.readLine()) != null) {
                     bw.write(line);
                     bw.newLine();
                     bw.flush();
              }
              bw.close();
              br.close();
       }
       //字符缓冲流一次读写一个字符数组
       privatestatic void method4(String srcString, String destString)
                     throwsIOException {
              BufferedReaderbr = new BufferedReader(new FileReader(srcString));
              BufferedWriterbw = new BufferedWriter(new FileWriter(destString));
 
              char[]chs = new char[1024];
              intlen = 0;
              while((len = br.read(chs)) != -1) {
                     bw.write(chs,0, len);
              }
              bw.close();
              br.close();
       }
       //字符缓冲流一次读写一个字符
       privatestatic void method3(String srcString, String destString)
                     throwsIOException {
              BufferedReaderbr = new BufferedReader(new FileReader(srcString));
              BufferedWriterbw = new BufferedWriter(new FileWriter(destString));
              intch = 0;
              while((ch = br.read()) != -1) {
                     bw.write(ch);
              }
              bw.close();
              br.close();
       }
       //基本字符流一次读写一个字符数组
       privatestatic void method2(String srcString, String destString)
                     throwsIOException {
              FileReaderfr = new FileReader(srcString);
              FileWriterfw = new FileWriter(destString);
              char[]chs = new char[1024];
              intlen = 0;
              while((len = fr.read(chs)) != -1) {
                     fw.write(chs,0, len);
              }
              fw.close();
              fr.close();
       }
       //基本字符流一次读写一个字符
       privatestatic void method1(String srcString, String destString)
                     throwsIOException {
              FileReaderfr = new FileReader(srcString);
              FileWriterfw = new FileWriter(destString);
              intch = 0;
              while((ch = fr.read()) != -1) {
                     fw.write(ch);
              }
              fw.close();
              fr.close();
       }
}

       B:复制图片(二进制流数据)4种方式(掌握)

 * 分析:

 *             复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流。

 *             通过该原理,我们知道我们应该采用字节流。

 *             而字节流有4种方式,所以做这个题目我们有4种方式。推荐掌握第4种。

 * 数据源:

 *             c:\\a.jpg-- FileInputStream -- BufferedInputStream

 * 目的地:

 *             d:\\b.jpg-- FileOutputStream -- BufferedOutputStream

 

public class CopyImageDemo {
   publicstatic void main(String[] args) throws IOException {
          //使用字符串作为路径
          //String srcString = "c:\\a.jpg";
          //String destString = "d:\\b.jpg";
          //使用File对象做为参数
          FilesrcFile = new File("c:\\a.jpg");
          FiledestFile = new File("d:\\b.jpg");
          //method1(srcFile, destFile);
          //method2(srcFile, destFile);
          //method3(srcFile, destFile);
          method4(srcFile,destFile);
   }
   //字节缓冲流一次读写一个字节数组
   privatestatic void method4(File srcFile, File destFile) throws IOException {
          BufferedInputStreambis = new BufferedInputStream(new FileInputStream(srcFile));
          BufferedOutputStreambos = new BufferedOutputStream(new FileOutputStream(destFile));
          byte[]bys = new byte[1024];
          intlen = 0;
          while((len = bis.read(bys)) != -1) {
                 bos.write(bys,0, len);
          }
          bos.close();
          bis.close();
   }
 
   //字节缓冲流一次读写一个字节
   privatestatic void method3(File srcFile, File destFile) throws IOException {
          BufferedInputStreambis = new BufferedInputStream(new FileInputStream(srcFile));
          BufferedOutputStreambos = new BufferedOutputStream(new FileOutputStream(destFile));
          intby = 0;
          while((by = bis.read()) != -1) {
                 bos.write(by);
          }
          bos.close();
          bis.close();
   }
   //基本字节流一次读写一个字节数组
   privatestatic void method2(File srcFile, File destFile) throws IOException {
          FileInputStreamfis = new FileInputStream(srcFile);
          FileOutputStreamfos = new FileOutputStream(destFile);
          byte[]bys = new byte[1024];
          intlen = 0;
          while((len = fis.read(bys)) != -1) {
                 fos.write(bys,0, len);
          }
          fos.close();
          fis.close();
   }
   //基本字节流一次读写一个字节
   privatestatic void method1(File srcFile, File destFile) throws IOException {
          FileInputStreamfis = new FileInputStream(srcFile);
          FileOutputStreamfos = new FileOutputStream(destFile);
          intby = 0;
          while((by = fis.read()) != -1) {
                 fos.write(by);
          }
          fos.close();
          fis.close();
   }
}

 

       C:把集合中的数据存储到文本文件

* 分析:

 *          通过题目的意思我们可以知道如下的一些内容,

 *                 ArrayList集合里存储的是字符串。

 *                 遍历ArrayList集合,把数据获取到。

 *                 然后存储到文本文件中。

 *                 文本文件说明使用字符流。

 * 数据源:

 *          ArrayList<String>-- 遍历得到每一个字符串数据

 * 目的地:

 *          a.txt-- FileWriter -- BufferedWriter

 

public class ArrayListToFileDemo {
       publicstatic void main(String[] args) throws IOException {
              //封装数据与(创建集合对象)
              ArrayList<String>array = new ArrayList<String>();
              array.add("hello");
              array.add("world");
              array.add("java");
              //封装目的地
              BufferedWriterbw = new BufferedWriter(new FileWriter("a.txt"));
              //遍历集合
              for(String s : array) {
                     //写数据
                     bw.write(s);
                     bw.newLine();
                     bw.flush();
              }
              //释放资源
              bw.close();
       }
}

       D:把文本文件中的数据读取到集合并遍历集合

* 分析:

 *          通过题目的意思我们可以知道如下的一些内容,

 *                 数据源是一个文本文件。

 *                 目的地是一个集合。

 *                 而且元素是字符串。

 * 数据源:

 *          b.txt-- FileReader -- BufferedReader

 * 目的地:

 *          ArrayList<String>

 

public class FileToArrayListDemo {
       publicstatic void main(String[] args) throws IOException {
              //封装数据源
              BufferedReaderbr = new BufferedReader(new FileReader("b.txt"));
              //封装目的地(创建集合对象)
              ArrayList<String>array = new ArrayList<String>();
              //读取数据存储到集合中
              Stringline = null;
              while((line = br.readLine()) != null) {
                     array.add(line);
              }
              //释放资源
              br.close();
 
              //遍历集合
              for(String s : array) {
                     System.out.println(s);
              }
       }
}

E:我有一个文本文件中存储了几个名称,请大家写一个程序实现随机获取一个人的名字。

* 分析:

 *          A:把文本文件中的数据存储到集合中

 *          B:随机产生一个索引

 *          C:根据该索引获取一个值

 

public class GetName {
       publicstatic void main(String[] args) throws IOException {
              //把文本文件中的数据存储到集合中
              BufferedReaderbr = new BufferedReader(new FileReader("b.txt"));
              ArrayList<String>array = new ArrayList<String>();
              String line = null;
              while((line = br.readLine()) != null) {
                     array.add(line);
              }
              br.close();
              //随机产生一个索引
              Randomr = new Random();
              intindex = r.nextInt(array.size());
              //根据该索引获取一个值
              Stringname = array.get(index);
              System.out.println("该幸运者是:" + name);
       }
}

       F:复制单级文件夹

* 数据源:e:\\demo

 * 目的地:e:\\test

 * 分析:

 *             A:封装目录

 *             B:获取该目录下的所有文本的File数组

 *             C:遍历该File数组,得到每一个File对象

 *             D:把该File进行复制

 

public class CopyFolderDemo {
   public static void main(String[] args) throws IOException {
          //封装目录
          File srcFolder = newFile("e:\\demo");
          //封装目的地
          FiledestFolder = new File("e:\\test");
          //如果目的地文件夹不存在,就创建
          if(!destFolder.exists()) {
                 destFolder.mkdir();
          }
          //获取该目录下的所有文本的File数组
          File[]fileArray = srcFolder.listFiles();
          //遍历该File数组,得到每一个File对象
          for(File file : fileArray) {
                 //System.out.println(file);
                 //数据源:e:\\demo\\e.mp3
                 //目的地:e:\\test\\e.mp3
                 Stringname = file.getName(); // e.mp3
                 FilenewFile = new File(destFolder, name); // e:\\test\\e.mp3
                 copyFile(file,newFile);
          }
   }
   private static void copyFile(File file, File newFile) throws IOException {
          BufferedInputStreambis = new BufferedInputStream(new FileInputStream(
                        file));
          BufferedOutputStreambos = new BufferedOutputStream(
                        newFileOutputStream(newFile));
          byte[]bys = new byte[1024];
          intlen = 0;
          while((len = bis.read(bys)) != -1) {
                 bos.write(bys,0, len);
          }
          bos.close();
          bis.close();
   }
}

       G:复制单级文件夹中指定的文件并修改后缀名

 * 指定的文件是:.java文件。

 * 指定的后缀名是:.jad

 * 指定的目录是:jad

 * 数据源:e:\\java\\A.java

 * 目的地:e:\\jad\\A.jad

 * 分析:

 *          A:封装目录

 *          B:获取该目录下的java文件的File数组

 *          C:遍历该File数组,得到每一个File对象

 *          D:把该File进行复制

 *          E:在目的地目录下改名

 

public class CopyFolderDemo {
       publicstatic void main(String[] args) throws IOException {
              //封装目录
              FilesrcFolder = new File("e:\\java");
              //封装目的地
              FiledestFolder = new File("e:\\jad");
              //如果目的地目录不存在,就创建
              if(!destFolder.exists()) {
                     destFolder.mkdir();
              }
              //获取该目录下的java文件的File数组
              File[]fileArray = srcFolder.listFiles(new FilenameFilter() {
                     @Override
                     publicboolean accept(File dir, String name) {
                            returnnew File(dir, name).isFile() && name.endsWith(".java");
                     }
              });
              //遍历该File数组,得到每一个File对象
              for(File file : fileArray) {
                     //System.out.println(file);
                     //数据源:e:\java\DataTypeDemo.java
                     //目的地:e:\\jad\DataTypeDemo.java
                     Stringname = file.getName();
                     FilenewFile = new File(destFolder, name);
                     copyFile(file,newFile);
              }
              //在目的地目录下改名
              File[]destFileArray = destFolder.listFiles();
              for(File destFile : destFileArray) {
                     //System.out.println(destFile);
                     //e:\jad\DataTypeDemo.java
                     //e:\\jad\\DataTypeDemo.jad
                     String name =destFile.getName();//DataTypeDemo.java
                     StringnewName = name.replace(".java", ".jad");//DataTypeDemo.jad
                    
                     FilenewFile = new File(destFolder,newName);
                     destFile.renameTo(newFile);
              }
       }
       privatestatic void copyFile(File file, File newFile) throws IOException {
              BufferedInputStreambis = new BufferedInputStream(new FileInputStream(
                            file));
              BufferedOutputStreambos = new BufferedOutputStream(
                            newFileOutputStream(newFile));
              byte[]bys = new byte[1024];
              intlen = 0;
              while((len = bis.read(bys)) != -1) {
                     bos.write(bys,0, len);
              }
              bos.close();
              bis.close();
       }
}

       H:复制多级文件夹

* 数据源:E:\JavaSE\day21\code\demos

 * 目的地:E:\\

 * 分析:

 *          A:封装数据源File

 *          B:封装目的地File

 *          C:判断该File是文件夹还是文件

 *                 a:是文件夹

 *                        就在目的地目录下创建该文件夹

 *                        获取该File对象下的所有文件或者文件夹File对象

 *                        遍历得到每一个File对象

 *                        回到C

 *                 b:是文件

 *                        就复制(字节流)

 

public class CopyFoldersDemo {
       publicstatic void main(String[] args) throws IOException {
              //封装数据源File
              FilesrcFile = new File("E:\\JavaSE\\day21\\code\\demos");
              //封装目的地File
              FiledestFile = new File("E:\\");
 
              //复制文件夹的功能
              copyFolder(srcFile,destFile);
       }
       privatestatic void copyFolder(File srcFile, File destFile)
                     throwsIOException {
              //判断该File是文件夹还是文件
              if(srcFile.isDirectory()) {
                     //文件夹
                     FilenewFolder = new File(destFile, srcFile.getName());
                     newFolder.mkdir();
                     //获取该File对象下的所有文件或者文件夹File对象
                     File[]fileArray = srcFile.listFiles();
                     for(File file : fileArray) {
                            copyFolder(file,newFolder);
                     }
              }else {
                     //文件
                     FilenewFile = new File(destFile, srcFile.getName());
                     copyFile(srcFile,newFile);
              }
       }
       privatestatic void copyFile(File srcFile, File newFile) throws IOException {
              BufferedInputStreambis = new BufferedInputStream(new FileInputStream(
                            srcFile));
              BufferedOutputStreambos = new BufferedOutputStream(
                            newFileOutputStream(newFile));
              byte[]bys = new byte[1024];
              intlen = 0;
              while((len = bis.read(bys)) != -1) {
                     bos.write(bys,0, len);
              }
              bos.close();
              bis.close();
       }
}

       I:键盘录入学生信息按照总分从高到低存储到文本文件

* 分析:

 *             A:创建学生类

 *             B:创建集合对象

 *                    TreeSet<Student>

 *             C:键盘录入学生信息存储到集合

 *             D:遍历集合,把数据写到文本文件

 

public class Student {
   //姓名
   privateString name;
   //语文成绩
   privateint chinese;
   //数学成绩
   privateint math;
   //英语成绩
   privateint english;
 
   publicStudent() {
          super();
   }
   publicStudent(String name, int chinese, int math, int english) {
          super();
          this.name= name;
          this.chinese= chinese;
          this.math= math;
          this.english= english;
   }
   publicString getName() {
          returnname;
   }
   publicvoid setName(String name) {
          this.name= name;
   }
   publicint getChinese() {
          returnchinese;
   }
   publicvoid setChinese(int chinese) {
          this.chinese= chinese;
   }
   publicint getMath() {
          returnmath;
   }
   publicvoid setMath(int math) {
          this.math= math;
   }
   publicint getEnglish() {
          returnenglish;
   }
   publicvoid setEnglish(int english) {
          this.english= english;
   }
   publicint getSum() {
          returnthis.chinese + this.math + this.english;
   }
}

 

 

public class StudentDemo {
   publicstatic void main(String[] args) throws IOException {
          //创建集合对象
          TreeSet<Student>ts = new TreeSet<Student>(new Comparator<Student>() {
                 @Override
                 publicint compare(Student s1, Student s2) {
                        intnum = s2.getSum() - s1.getSum();
                        intnum2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                        intnum3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
                        intnum4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
                        intnum5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
                                      :num4;
                        returnnum5;
                 }
          });
          //键盘录入学生信息存储到集合
          for(int x = 1; x <= 5; x++) {
                 Scannersc = new Scanner(System.in);
                 System.out.println("请录入第" + x + "个的学习信息");
                 System.out.println("姓名:");
                 Stringname = sc.nextLine();
                 System.out.println("语文成绩:");
                 intchinese = sc.nextInt();
                 System.out.println("数学成绩:");
                 intmath = sc.nextInt();
                 System.out.println("英语成绩:");
                 intenglish = sc.nextInt();
                 //创建学生对象
                 Students = new Student();
                 s.setName(name);
                 s.setChinese(chinese);
                 s.setMath(math);
                 s.setEnglish(english);
                 //把学生信息添加到集合
                 ts.add(s);
          }
          //遍历集合,把数据写到文本文件
          BufferedWriterbw = new BufferedWriter(new FileWriter("students.txt"));
          bw.write("学生信息如下:");
          bw.newLine();
          bw.flush();
          bw.write("姓名,语文成绩,数学成绩,英语成绩");
          bw.newLine();
          bw.flush();
          for(Student s : ts) {
                 StringBuildersb = new StringBuilder();
                 sb.append(s.getName()).append(",").append(s.getChinese())
                               .append(",").append(s.getMath()).append(",")
                               .append(s.getEnglish());
                 bw.write(sb.toString());
                 bw.newLine();
                 bw.flush();
          }
          //释放资源
          bw.close();
          System.out.println("学习信息存储完毕");
   }
}

       J:把某个文件中的字符串排序后输出到另一个文本文件中

已知s.txt文件中有这样的一个字符串:“hcexfgijkamdnoqrzstuvwybpl”

 * 请编写程序读取数据内容,把数据排序后写入ss.txt中。

 * 分析:

 *          A:把s.txt这个文件给做出来

 *          B:读取该文件的内容,存储到一个字符串中

 *          C:把字符串转换为字符数组

 *          D:对字符数组进行排序

 *          E:把排序后的字符数组转换为字符串

 *          F:把字符串再次写入ss.txt中

 

public class StringDemo {
       publicstatic void main(String[] args) throws IOException {
              //读取该文件的内容,存储到一个字符串中
              BufferedReaderbr = new BufferedReader(new FileReader("s.txt"));
              Stringline = br.readLine();
              br.close();
              //把字符串转换为字符数组
              char[]chs = line.toCharArray();
              //对字符数组进行排序
              Arrays.sort(chs);
              //把排序后的字符数组转换为字符串
              Strings = new String(chs);
              //把字符串再次写入ss.txt中
              BufferedWriterbw = new BufferedWriter(new FileWriter("ss.txt"));
              bw.write(s);
              bw.newLine();
              bw.flush();
              bw.close();
       }
}

       K:用Reader模拟BufferedReader的特有功能

* readLine():一次读取一行,根据换行符判断是否结束,只返回内容,不返回换行符

 

public class MyBufferedReader {
   private Reader r;
   public MyBufferedReader(Reader r) {
          this.r= r;
   }

    * 思考:写一个方法,返回值是一个字符串。

  publicString readLine() throws IOException {
              // 我要返回一个字符串,我该怎么办呢? 我们必须去看看r对象能够读取什么东西呢? 两个读取方法,一次读取一个字符或者一次读取一个字符数组
               // 那么,我们要返回一个字符串,用哪个方法比较好呢? 我们很容易想到字符数组比较好,但是问题来了,就是这个数组的长度是多长呢?
               // 根本就没有办法定义数组的长度,你定义多长都不合适。 所以,只能选择一次读取一个字符。
               // 但是呢,这种方式的时候,我们再读取下一个字符的时候,上一个字符就丢失了 所以,我们又应该定义一个临时存储空间把读取过的字符给存储起来。
               // 这个用谁比较和是呢?数组,集合,字符串缓冲区三个可供选择。
               // 经过简单的分析,最终选择使用字符串缓冲区对象。并且使用的是StringBuilder
          StringBuildersb = new StringBuilder();
          //做这个读取最麻烦的是判断结束,但是在结束之前应该是一直读取,直到-1
          /*
          hello
          world
          java
          104101108108111
          119111114108100
          1069711897
           */
          int ch = 0;
          while((ch = r.read()) != -1) { //104,101,108,108,111
                 if(ch == '\r') {
                        continue;
                 }
                 if(ch == '\n') {
                        returnsb.toString(); //hello
                 }else {
                        sb.append((char)ch);//hello
                 }
          }
          //为了防止数据丢失,判断sb的长度不能大于0
          if(sb.length() > 0) {
                 returnsb.toString();
          }
          returnnull;
   }
    // 先写一个关闭方法
   public void close() throws IOException {
          this.r.close();
   }
}

 

 

 

 //测试MyBufferedReader的时候,你就把它当作BufferedReader一样的使用
public class MyBufferedReaderDemo{
   publicstatic void main(String[] args) throws IOException {
          MyBufferedReadermbr = new MyBufferedReader(new FileReader("my.txt"));
          Stringline = null;
          while((line = mbr.readLine()) != null) {
                 System.out.println(line);
          }
          mbr.close();
          //System.out.println('\r' + 0); // 13
          // System.out.println('\n' + 0);// 10
   }
}

       L:模拟LineNumberReader的特有功能

BufferedReader

 *          |--LineNumberReader

 *                 publicint getLineNumber()获得当前行号。

 *                 publicvoid setLineNumber(int lineNumber)

 

public class LineNumberReaderDemo{
       publicstatic void main(String[] args) throws IOException {
              LineNumberReaderlnr = new LineNumberReader(new FileReader("my.txt"));
              //从10开始才比较好
              //lnr.setLineNumber(10);
              //System.out.println(lnr.getLineNumber());
              //System.out.println(lnr.getLineNumber());
              //System.out.println(lnr.getLineNumber());
              Stringline = null;
              while((line = lnr.readLine()) != null) {
                     System.out.println(lnr.getLineNumber()+ ":" + line);
              }
              lnr.close();
       }
}

 

 

 

public class MyLineNumberReader {
       privateReader r;
       privateint lineNumber = 0;
       publicMyLineNumberReader(Reader r) {
              this.r= r;
       }
       publicint getLineNumber() {
              //lineNumber++;
              returnlineNumber;
       }
       publicvoid setLineNumber(int lineNumber) {
              this.lineNumber= lineNumber;
       }
       publicString readLine() throws IOException {
              lineNumber++;
 
              StringBuildersb = new StringBuilder();
              intch = 0;
              while((ch = r.read()) != -1) {
                     if(ch == '\r') {
                            continue;
                     }
                     if(ch == '\n') {
                            returnsb.toString();
                     }else {
                            sb.append((char)ch);
                     }
              }
              if(sb.length() > 0) {
                     returnsb.toString();
              }
              return null;
       }
       publicvoid close() throws IOException {
              this.r.close();
       }
}

 

 

 

public class MyLineNumberReader2extends MyBufferedReader {
       privateReader r;
       privateint lineNumber = 0;
       publicMyLineNumberReader2(Reader r) {
              super(r);
       }
       publicint getLineNumber() {
              returnlineNumber;
       }
       publicvoid setLineNumber(int lineNumber) {
              this.lineNumber= lineNumber;
       }
       @Override
       publicString readLine() throws IOException {
              lineNumber++;
              return super.readLine();
       }
}

 

 

 

public classMyLineNumberReaderTest {
       publicstatic void main(String[] args) throws IOException {
              //MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader(
              //"my.txt"));
              MyLineNumberReader2mlnr = new MyLineNumberReader2(new FileReader("my.txt"));
              //mlnr.setLineNumber(10);
              //System.out.println(mlnr.getLineNumber());
              //System.out.println(mlnr.getLineNumber());
              //System.out.println(mlnr.getLineNumber());
              Stringline = null;
              while((line = mlnr.readLine()) != null) {
                     System.out.println(mlnr.getLineNumber()+ ":" + line);
              }
              mlnr.close();
       }
}

21. IO流(字符流)