java基础学习_IO流03_字符流、IO流小结、案例_day21总结

 1 package cn.itcast_01;  2  3 import java.io.UnsupportedEncodingException;  4 import java.util.Arrays;  5  6 /*  7  * String类的构造方法：  8  * public String(byte[] bytes, String charsetName) 通过指定的字符集解码字节数组  9  * String类的成员方法： 10  * public byte[] getBytes(String charsetName) 使用指定的字符集合把字符串编码为字节数组 11  * 12  * 编码:把看得懂的变成看不懂的 13  * String --> byte[] 14  * 15  * 解码:把看不懂的变成看得懂的 16  * byte[] --> String 17  * 18  * 举例：谍战片(发电报，接电报) 19  * 20  * 码表：密码本 21  * 字符 <--> 数值 22  * 23  * 要发送一段文字： 24  * 今天晚上在老地方见 25  * 26  * 发送端：今 --> 字符 --> 数值 --> 十进制 --> 二进制 --> 发送 27  * 接收端：接收 --> 二进制 --> 十进制 --> 数值 --> 字符 --> 今 28  * 29  * 今天晚上在老地方见 30  * 31  * 编码问题简单，只要编码解码的格式是一致的就没有问题。 32 */ 33 public class StringDemo { 34 public static void main(String[] args) throws UnsupportedEncodingException { 35 // 本windows电脑默认的编码是GBK 36 // 本Eclipse软件默认的编码是UTF-8 37 38 String s = "你好"; 39 40 // 使用指定的字符集合把字符串编码为字节数组 41 // String --> byte[] 42 byte[] bys = s.getBytes(); // [-28, -67, -96, -27, -91, -67] 43 // byte[] bys = s.getBytes("GBK"); // [-60, -29, -70, -61] 44 // byte[] bys = s.getBytes("UTF-8"); // [-28, -67, -96, -27, -91, -67] 45 System.out.println(Arrays.toString(bys)); // [-28, -67, -96, -27, -91, -67] 46 47 // 通过指定的字符集解码字节数组 48 // byte[] --> String 49 String ss = new String(bys); // 你好 50 // String ss = new String(bys, "GBK"); // 浣犲ソ 51 // String ss = new String(bys, "UTF-8"); // 你好 52 System.out.println(ss); // 你好 53  } 54 }

 1 package cn.itcast_05;  2  3 import java.io.BufferedWriter;  4 import java.io.FileWriter;  5 import java.io.IOException;  6  7 /*  8  * 字符流为了高效读写，也提供了对应的字符缓冲区流。  9  * BufferedWriter:字符缓冲区输出流 10  * BufferedReader:字符缓冲区输入流 11  * 12  * BufferedWriter:字符缓冲区输出流 13  * 将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 14  * 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。 15  * 16  * BufferedWriter类的构造方法 17  * public BufferedWriter(Writer out) 18 */ 19 public class BufferedWriterDemo { 20 public static void main(String[] args) throws IOException { 21 // 创建字符缓冲区输出流对象 22 // public BufferedWriter(Writer out) 23 // BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("bw.txt"))); 24 BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")); 25 26 bw.write("hello"); 27 bw.write("world"); 28 bw.write("java"); 29  bw.flush(); 30 31  bw.close(); 32  } 33 }

 1 package cn.itcast_05;  2  3 import java.io.BufferedReader;  4 import java.io.FileReader;  5 import java.io.IOException;  6  7 /*  8  * BufferedReader:字符缓冲区输入流  9  * 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 10  * 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 11  * 12  * BufferedReader类的构造方法 13  * public BufferedReader(Reader in) 14 */ 15 public class BufferedReaderDemo { 16 public static void main(String[] args) throws IOException { 17 // 创建字符缓冲区输入流对象 18 // public BufferedReader(Reader in) 19 // BufferedReader bw = new BufferedReader(new InputStreamReader(new FileInputStream("bw.txt"))); 20 BufferedReader br = new BufferedReader(new FileReader("bw.txt")); 21 22 // 方式1 23 // int ch = 0; 24 // while ((ch = br.read()) != -1) { 25 // System.out.print((char) ch); 26 // } 27 28 // 方式2 29 char[] chs = new char[1024]; 30 int len = 0; 31 while ((len = br.read(chs)) != -1) { 32 System.out.print(new String(chs, 0, len)); 33  } 34 35 // 释放资源 36  br.close(); 37  } 38 }

 1 package cn.itcast_05;  2  3 import java.io.BufferedReader;  4 import java.io.BufferedWriter;  5 import java.io.FileReader;  6 import java.io.FileWriter;  7 import java.io.IOException;  8  9 /* 10  * 字符缓冲区流的特殊方法： 11  * BufferedWriter类的方法: 12  * public void newLine() 根据系统属性来决定换行符 13  * BufferedReader类的方法: 14  * public String readLine() 一次读取一行数据(字符串) 15  * 返回值是：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。 16 */ 17 public class BufferedDemo { 18 public static void main(String[] args) throws IOException { 19  write(); 20  read(); 21  } 22 23 private static void read() throws IOException { 24 // 创建字符缓冲输入流对象(读取数据) 25 BufferedReader br = new BufferedReader(new FileReader("bw2.txt")); 26 27 // public String readLine() 一次读取一行数据(字符串) 28 // String line = br.readLine(); 29 // System.out.println(line); // hello1 30 // line = br.readLine(); 31 // System.out.println(line); // hello2 32 33 // 最终版代码，循环改进 34 String line = null; 35 while ((line = br.readLine()) != null) { 36  System.out.println(line); 37  } 38 39 //释放资源 40  br.close(); 41  } 42 43 private static void write() throws IOException { 44 // 创建字符缓冲输出流对象(写数据) 45 BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt")); 46 for (int x = 0; x < 100; x++) { 47 bw.write("hello" + x); // bw.write("\r\n"); // 在windows系统下的换行 48 bw.newLine(); // 根据系统属性来决定换行符 49 bw.flush(); // 习惯性写法 50  } 51  bw.close(); 52  } 53 54 }

 1 package cn.itcast_01;  2  3 import java.io.BufferedReader;  4 import java.io.BufferedWriter;  5 import java.io.File;  6 import java.io.FileReader;  7 import java.io.FileWriter;  8 import java.io.IOException;  9  10 /*  11  * 复制文本文件  12  *  13  * 分析：  14  * 复制数据，如果我们知道用windows自带的记事本打开并能够读懂的文件，就用字符流，否则用字节流。  15  * 通过该原理，我们知道我们应该采用字符流更方便一些。  16  * 而字符流有5种方式，所以做这个题目我们有5种方式。推荐掌握第5种。  17  * 数据源：  18  * c:\\a.txt --> FileReader --> BufferdReader  19  * 目的地：  20  * d:\\b.txt --> FileWriter --> BufferedWriter  21 */  22 public class CopyFileDemo {  23 public static void main(String[] args) throws IOException {  24 // 使用字符串作为路径(简洁写法)  25 String srcString = "c:\\a.jpg";  26 String destString = "d:\\b.jpg";  27  28 // 使用File对象作为参数(装逼/专业写法)  29 // File srcFile = new File("c:\\a.jpg");  30 // File destFile = new File("d:\\b.jpg");  31 // 是文件和目录(文件夹)路径名的抽象表示形式。仅仅是一个路径的表示，不代表具体的事物一定是存在的。  32  33 // method1(srcString, destString);  34 // method2(srcString, destString);  35 // method3(srcString, destString);  36 // method4(srcString, destString);  37  method5(srcString, destString);  38  }  39  40 // 字符缓冲区流：一次读写一行数据(字符串)  41 private static void method5(String srcString, String destString) throws IOException {  42 BufferedReader br = new BufferedReader(new FileReader(srcString));  43 BufferedWriter bw = new BufferedWriter(new FileWriter(destString));  44  45 String line = null;  46 while ((line = br.readLine()) != null) {  47 bw.write(line); // 一次写一行数据(字符串)(要与newLine()方法配合使用)  48  bw.newLine();  49  bw.flush();  50  }  51  52  bw.close();  53  br.close();  54  }  55  56 // 字符缓冲区流：一次读写一个字符数组  57 private static void method4(String srcString, String destString) throws IOException {  58 BufferedReader br = new BufferedReader(new FileReader(srcString));  59 BufferedWriter bw = new BufferedWriter(new FileWriter(destString));  60  61 char[] chs = new char[1024];  62 int len = 0;  63 while ((len = br.read(chs)) != -1) {  64 bw.write(chs, 0, len);  65  }  66  67  bw.close();  68  br.close();  69  }  70  71 // 字符缓冲区流：一次读写一个字符  72 private static void method3(String srcString, String destString) throws IOException {  73 BufferedReader br = new BufferedReader(new FileReader(srcString));  74 BufferedWriter bw = new BufferedWriter(new FileWriter(destString));  75  76 int ch = 0;  77 while ((ch = br.read()) != -1) {  78  bw.write(ch);  79  }  80  81  bw.close();  82  br.close();  83  }  84  85 // 基本字符流：一次读写一个字符数组  86 private static void method2(String srcString, String destString) throws IOException {  87 FileReader fr = new FileReader(srcString);  88 FileWriter fw = new FileWriter(destString);  89  90 char[] chs = new char[1024];  91 int len = 0;  92 while ((len = fr.read(chs)) != -1) {  93 fw.write(chs, 0, len);  94  }  95  96  fw.close();  97  fr.close();  98  }  99 100 // 基本字符流：一次读写一个字符 101 private static void method1(String srcString, String destString) throws IOException { 102 FileReader fr = new FileReader(srcString); 103 FileWriter fw = new FileWriter(destString); 104 105 int ch = 0; 106 while ((ch = fr.read()) != -1) { 107  fw.write(ch); 108  } 109 110  fw.close(); 111  fr.close(); 112  } 113 }

 1 package cn.itcast_01;  2  3 import java.io.BufferedInputStream;  4 import java.io.BufferedOutputStream;  5 import java.io.File;  6 import java.io.FileInputStream;  7 import java.io.FileOutputStream;  8 import java.io.IOException;  9 10 /* 11  * 复制图片 12  * 13  * 分析： 14  * 复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。 15  * 通过该原理，我们知道我们应该采用字节流。 16  * 而字节流有4种方式，所以做这个题目我们有4种方式。推荐掌握第4种。 17  * 18  * 数据源： 19  * c:\\a.jpg --> FileInputStream --> BufferedInputStream 20  * 目的地： 21  * d:\\b.jpg --> FileOutputStream --> BufferedOutputStream 22 */ 23 public class CopyImageDemo { 24 public static void main(String[] args) throws IOException { 25 // 使用字符串作为路径(简洁写法) 26 // String srcString = "c:\\a.jpg"; 27 // String destString = "d:\\b.jpg"; 28 29 // 使用File对象作为参数(装逼/专业写法) 30 File srcFile = new File("c:\\a.jpg"); 31 File destFile = new File("d:\\b.jpg"); 32 // 是文件和目录(文件夹)路径名的抽象表示形式。仅仅是一个路径的表示，不代表具体的事物一定是存在的。 33 34 // method1(srcFile, destFile); 35 // method2(srcFile, destFile); 36 // method3(srcFile, destFile); 37  method4(srcFile, destFile); 38  } 39 40 // 字节缓冲区流：一次读写一个字节数组 41 private static void method4(File srcFile, File destFile) throws IOException { 42 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 43 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)); 44 45 byte[] bys = new byte[1024]; 46 int len = 0; 47 while ((len = bis.read(bys)) != -1) { 48 bos.write(bys, 0, len); 49  } 50 51  bos.close(); 52  bis.close(); 53  } 54 55 // 字节缓冲强区流：一次读写一个字节 56 private static void method3(File srcFile, File destFile) throws IOException { 57 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 58 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)); 59 60 int by = 0; 61 while ((by = bis.read()) != -1) { 62  bos.write(by); 63  } 64 65  bos.close(); 66  bis.close(); 67  } 68 69 // 基本字节流：一次读写一个字节数组 70 private static void method2(File srcFile, File destFile) throws IOException { 71 FileInputStream fis = new FileInputStream(srcFile); 72 FileOutputStream fos = new FileOutputStream(destFile); 73 74 byte[] bys = new byte[1024]; 75 int len = 0; 76 while ((len = fis.read(bys)) != -1) { 77 fos.write(bys, 0, len); 78  } 79 80  fos.close(); 81  fis.close(); 82  } 83 84 // 基本字节流：一次读写一个字节 85 private static void method1(File srcFile, File destFile) throws IOException { 86 FileInputStream fis = new FileInputStream(srcFile); 87 FileOutputStream fos = new FileOutputStream(destFile); 88 89 int by = 0; 90 while ((by = fis.read()) != -1) { 91  fos.write(by); 92  } 93 94  fos.close(); 95  fis.close(); 96  } 97 }

 1 package cn.itcast_02;  2  3 import java.io.BufferedWriter;  4 import java.io.FileWriter;  5 import java.io.IOException;  6 import java.util.ArrayList;  7  8 /*  9  * 需求：把ArrayList集合中的字符串数据存储到文本文件 10  * 11  * 分析： 12  * 通过题目的意思我们可以知道如下的一些内容： 13  * 14  * 只有写出数据，没有读取数据。 15  * 16  * ArrayList集合里存储的是字符串。 17  * 遍历ArrayList集合，把数据获取到。 18  * 然后存储到文本文件中。 19  * 20  * 文本文件说明使用字符流。 21  * 22  * 数据源： 23  * ArrayList<String> --> 遍历得到每一个字符串数据 24  * 目的地： 25  * a.txt --> FileWriter --> BufferedWriter 26 */ 27 public class ArrayListToFileDemo { 28 public static void main(String[] args) throws IOException { 29 // 封装数据源(创建集合对象) 30 ArrayList<String> array = new ArrayList<String>(); 31 array.add("hello"); 32 array.add("world"); 33 array.add("java"); 34 35 // 封装目的地 36 BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt")); 37 38 // 遍历集合(增强for) 39 for (String s : array) { 40 // 写数据 41  bw.write(s); 42  bw.newLine(); 43  bw.flush(); 44  } 45 46 // 释放资源 47  bw.close(); 48  } 49 }

 1 package cn.itcast_02;  2  3 import java.io.BufferedReader;  4 import java.io.FileReader;  5 import java.io.IOException;  6 import java.util.ArrayList;  7  8 /*  9  * 需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合 10  * 11  * 分析： 12  * 通过题目的意思我们可以知道如下的一些内容： 13  * 14  * 只有读取数据，没有写出数据。 15  * 16  * 数据源是一个文本文件。 17  * 目的地是一个集合。 18  * 而且元素是字符串。 19  * 20  * 数据源： 21  * b.txt --> FileReader --> BufferedReader 22  * 目的地： 23  * ArrayList<String> 24 */ 25 public class FileToArrayListDemo { 26 public static void main(String[] args) throws IOException { 27 // 封装数据源 28 BufferedReader br = new BufferedReader(new FileReader("b.txt")); 29 // 封装目的地(创建集合对象) 30 ArrayList<String> array = new ArrayList<String>(); 31 32 // 读取数据存储到集合中 33 String line = null; 34 while ((line = br.readLine()) != null) { 35  array.add(line); 36  } 37 38 // 释放资源 39  br.close(); 40 41 // 遍历集合(增强for) 42 for (String s : array) { 43  System.out.println(s); 44  } 45 46  } 47 }

 1 package cn.itcast_02;  2  3 import java.io.BufferedReader;  4 import java.io.FileReader;  5 import java.io.IOException;  6 import java.util.ArrayList;  7 import java.util.Random;  8  9 /* 10  * 需求：我有一个文本文件中存储了几个名字，请大家写一个程序实现随机获取一个人的名字。 11  * 12  * 分析： 13  * A:把文本文件中的数据存储到集合中 14  * B:随机产生一个索引，并设定索引的范围 15  * C:根据该索引获取一个值 16 */ 17 public class GetName { 18 public static void main(String[] args) throws IOException { 19 // 把文本文件中的数据存储到集合中 20 BufferedReader br = new BufferedReader(new FileReader("name.txt")); 21 ArrayList<String> array = new ArrayList<String>(); 22 23 String line = null; 24 while ((line = br.readLine()) != null) { 25  array.add(line); 26  } 27  br.close(); 28 29 // 随机产生一个索引，并设定索引的范围 30 Random r = new Random(); 31 int index = r.nextInt(array.size()); // [0, array.size()) 32 33 // 根据该索引获取一个值 34 String name = array.get(index); 35 System.out.println("该幸运者是：" + name); 36  } 37 }

 1 package cn.itcast_03;  2  3 import java.io.BufferedInputStream;  4 import java.io.BufferedOutputStream;  5 import java.io.File;  6 import java.io.FileInputStream;  7 import java.io.FileOutputStream;  8 import java.io.IOException;  9 10 /* 11  * 需求：复制指定单极文件夹中的所有文件(里面只有文件，且文件各种各样) 12  * 13  * 用字节流 14  * 15  * 数据源：e:\\demo 16  * 目的地：e:\\test 17  * 18  * 分析： 19  * A:封装数据源File对象+封装目的地File对象 20  * B:获取数据源目录下的所有文件的File数组 21  * C:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示 22  * D:把该File进行复制 23 */ 24 public class CopyFolderDemo { 25 public static void main(String[] args) throws IOException { 26 // 封装数据源File对象 27 File srcFolder = new File("e:\\demo"); 28 // 封装目的地File对象 29 File destFolder = new File("e:\\test"); 30 // 如果目的地文件夹不存在，就创建 31 if (!destFolder.exists()) { 32  destFolder.mkdir(); 33  } 34 35 // 获取数据源目录下的所有文件的File数组 36 // 遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示 37 // 把该File进行复制 38 File[] fileArray = srcFolder.listFiles(); 39 for (File srcFile : fileArray) { 40 // System.out.println(file); // e:\demo\e.mp3 41 // 数据源：e:\\demo\\e.mp3 注意：数据源是变化的 42 // 目的地：e:\\test\\e.mp3 注意：目的地也是变化的(使用拼接) 43 String name = srcFile.getName(); // e.mp3 44 File destFile = new File(destFolder, name); // e:\\test\\e.mp3 45 46  copyFile(srcFile, destFile); 47  } 48  } 49 50 private static void copyFile(File srcFile, File destFile) throws IOException { 51 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 52 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)); 53 54 byte[] bys = new byte[1024]; 55 int len = 0; 56 while ((len = bis.read(bys)) != -1) { 57 bos.write(bys, 0, len); 58  } 59 60  bos.close(); 61  bis.close(); 62  } 63 }

 1 package cn.itcast_04;  2  3 import java.io.BufferedInputStream;  4 import java.io.BufferedOutputStream;  5 import java.io.File;  6 import java.io.FileInputStream;  7 import java.io.FileOutputStream;  8 import java.io.FilenameFilter;  9 import java.io.IOException; 10 11 /* 12  * 需求：复制指定单级文件夹中的指定文件，并修改文件后缀名(里面只有文件，且文件各种各样，但是本例题为了增加一点难度，使该单级文件夹中增加一个文件夹名为hello.java的文件夹) 13  * 14  * 指定的文件是：.java文件 15  * 指定的后缀名是：.jad 16  * 指定的目录是：jad 17  * 18  * 数据源：e:\\java\\A.java 19  * 目的地：e:\\jad\\A.jad 20  * 21  * 分析： 22  * A:封装数据源File对象+封装目的地File对象 23  * B:获取数据源目录下的所有.java文件的File数组(加入了判断条件) 24  * C:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示 25  * D:把符合条件的File进行复制 26  * E:获取目的地目录下的所有文件的File数组 27  * F:遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示 28  * E:把该File重命名为新名字 29 */ 30 public class CopyFolderDemo { 31 public static void main(String[] args) throws IOException { 32 // 封装数据源File对象 33 File srcFolder = new File("e:\\java"); 34 // 封装目的地File对象 35 File destFolder = new File("e:\\jad"); 36 // 如果目的地目录不存在，就创建 37 if (!destFolder.exists()) { 38  destFolder.mkdir(); 39  } 40 41 // 获取数据源目录下的所有.java文件的File数组(加入了判断条件) 42 File[] fileArray = srcFolder.listFiles(new FilenameFilter() { 43  @Override 44 public boolean accept(File dir, String name) { 45 return new File(dir, name).isFile() && name.endsWith(".java"); 46  } 47  }); 48 49 // 遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示 50 // 把符合条件的File进行复制 51 for (File srcFile : fileArray) { 52 // System.out.println(file); // e:\java\DataTypeDemo.java 53 // 数据源：e:\\java\\DataTypeDemo.java 注意：数据源是变化的 54 // 目的地：e:\\jad\\DataTypeDemo.java 注意：目的地也是变化的(使用拼接) 55 String name = srcFile.getName(); // DataTypeDemo.java 56 File destFile = new File(destFolder, name); // e:\\jad\\DataTypeDemo.java 57 58  copyFile(srcFile, destFile); 59  } 60 61 // 获取目的地目录下的所有文件的File数组 62 // 遍历该File数组，得到每一个File对象，通过该对象得到一个新的文件路径名的抽象表示 63 // 把该File重命名为新名字 64 File[] destFileArray = destFolder.listFiles(); 65 for (File destFile : destFileArray) { 66 // System.out.println(destFile); // e:\jad\DataTypeDemo.java 67 // 数据源：e:\\jad\\DataTypeDemo.java 68 // 目的地：e:\\jad\\DataTypeDemo.jad 69 String oldName = destFile.getName(); // DataTypeDemo.java 70 String newName = oldName.replace(".java", ".jad"); // DataTypeDemo.jad 71 File newFile = new File(destFolder, newName); // e:\\jad\\DataTypeDemo.jad 72 73  destFile.renameTo(newFile); 74  } 75  } 76 77 private static void copyFile(File srcFile, File destFile) throws IOException { 78 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 79 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile)); 80 81 byte[] bys = new byte[1024]; 82 int len = 0; 83 while ((len = bis.read(bys)) != -1) { 84 bos.write(bys, 0, len); 85  } 86 87  bos.close(); 88  bis.close(); 89  } 90 }

 1 package cn.itcast_09;  2  3 import java.io.File;  4  5 /*  6  * 需求：把E:\评书\三国演义下面的视频名称修改为  7  * 00?_介绍.avi  8  *  9  * 思路： 10  * A:把 E:\\评书\\三国演义 封装成一个File对象 11  * B:获取该目录下所有的文件的File数组 12  * C:遍历该File数组，得到每一个File对象，该对象名打印输出为：E:\\评书\\三国演义\\三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi 13  * D:获取符合要求的各个名称 14  * E:拼接一个新的名称，再new一个新对象，新对象名打印输出为： E:\\评书\\三国演义\\001_桃园三结义.avi 15  * F:然后重命名即可。 16 */ 17 public class FileDemo { 18 public static void main(String[] args) { 19 // 把 E:\\评书\\三国演义 封装成一个File对象 20 File srcFolder = new File("E:\\评书\\三国演义"); 21 22 // 获取该目录下所有的文件的File数组 23 File[] fileArray = srcFolder.listFiles(); 24 25 // 遍历该File数组，得到每一个File对象 26 for (File file : fileArray) { 27 // System.out.println(file); 28 29 // 改前：E:\评书\三国演义\三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi 30 // 改后：E:\评书\三国演义\001_桃园三结义.avi 31 32 String name = file.getName(); // 三国演义_001_[评书网-今天很高兴,明天就IO了]_桃园三结义.avi 33 34 int index = name.indexOf("_"); // 找到第一个_ 35 String numberString = name.substring(index + 1, index + 4); // 001 包左不包右 36 // System.out.println(numberString); // 001 37 38 int endIndex = name.lastIndexOf('_'); // 找到最后一个_ 39 String nameString = name.substring(endIndex); // 桃园三结义.avi 40 // System.out.println(nameString); // 桃园三结义.avi 41 42 // 拼接一个新的名称 43 String newName = numberString.concat(nameString); // 001_桃园三结义.avi 44 // System.out.println(newName); // 001_桃园三结义.avi 45 46 // 把 E:\\评书\\三国演义\\001_桃园三结义.avi 封装成一个File对象 47 File newFile = new File(srcFolder, newName); // E:\\评书\\三国演义\\001_桃园三结义.avi 48 // System.out.println(newFile); 49 50 // 重命名即可 51  file.renameTo(newFile); 52  } 53  } 54 }

 1 package cn.itcast_05;  2  3 import java.io.BufferedInputStream;  4 import java.io.BufferedOutputStream;  5 import java.io.File;  6 import java.io.FileInputStream;  7 import java.io.FileOutputStream;  8 import java.io.IOException;  9 10 /* 11  * 需求：复制多级文件夹 12  * 13  * 数据源：E:\JavaSE\day21\code\demos 14  * 目的地：E:\\ 15  * 16  * 分析： 17  * A:封装数据源File对象+封装目的地File对象 18  * B:判断该数据源File对象是文件夹还是文件 19  * a:是文件夹 20  * 就在目的地目录下创建该文件夹(创建前先拼接一个新的文件夹路径名的抽象表示) 21  * 获取该数据源File对象下的所有文件或者文件夹的File数组 22  * 遍历该File数组，得到每一个File对象 23  * 回到B(递归) 24  * b:是文件(文件各种各样，用字节流复制) 25  * 就在目的地目录下复制该文件(复制前先拼接一个新的文件路径名的抽象表示) 26 */ 27 public class CopyFoldersDemo { 28 public static void main(String[] args) throws IOException { 29 // 封装数据源File对象 30 File srcFile = new File("E:\\JavaSE\\day21\\code\\demos"); 31 // 封装目的地File对象 32 File destFile = new File("E:\\"); 33 34 // 复制文件夹的功能 35  copyFolder(srcFile, destFile); 36  } 37 38 private static void copyFolder(File srcFile, File destFile) throws IOException { 39 // 判断该数据源File对象是文件夹还是文件 40 if (srcFile.isDirectory()) { 41 // 是文件夹 42 // 就在目的地目录下创建该文件夹(创建前先拼接一个新的文件夹路径名的抽象表示) 43 File newFolder = new File(destFile, srcFile.getName()); 44 newFolder.mkdir(); // 因为文件夹不会帮你自动创建，需要你手动创建 45 46 // 获取该数据源File对象下的所有文件或者文件夹的File数组 47 // 遍历该File数组，得到每一个File对象 48 File[] fileArray = srcFile.listFiles(); 49 for (File file : fileArray) { 50  copyFolder(file, newFolder); 51  } 52 } else { 53 // 是文件(文件各种各样，用字节流复制) 54 // 就在目的地目录下复制该文件(复制前先拼接一个新的文件路径名的抽象表示) 55 File newFile = new File(destFile, srcFile.getName()); 56  copyFile(srcFile, newFile); 57  } 58  } 59 60 // 复制文件的功能 61 private static void copyFile(File srcFile, File newFile) throws IOException { 62 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile)); 63 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile)); 64 65 byte[] bys = new byte[1024]; 66 int len = 0; 67 while ((len = bis.read(bys)) != -1) { 68 bos.write(bys, 0, len); 69  } 70 71  bos.close(); 72  bis.close(); 73  } 74 }

 1 package cn.itcast_06;  2  3 public class Student {  4 // 姓名  5 private String name;  6 // 语文成绩  7 private int chinese;  8 // 数学成绩  9 private int math; 10 // 英语成绩 11 private int english; 12 13 public Student() { 14 super(); 15  } 16 17 public Student(String name, int chinese, int math, int english) { 18 super(); 19 this.name = name; 20 this.chinese = chinese; 21 this.math = math; 22 this.english = english; 23  } 24 25 public String getName() { 26 return name; 27  } 28 29 public void setName(String name) { 30 this.name = name; 31  } 32 33 public int getChinese() { 34 return chinese; 35  } 36 37 public void setChinese(int chinese) { 38 this.chinese = chinese; 39  } 40 41 public int getMath() { 42 return math; 43  } 44 45 public void setMath(int math) { 46 this.math = math; 47  } 48 49 public int getEnglish() { 50 return english; 51  } 52 53 public void setEnglish(int english) { 54 this.english = english; 55  } 56 57 public int getSum() { 58 return this.chinese + this.math + this.english; 59  } 60 }

 1 package cn.itcast_06;  2  3 import java.io.BufferedWriter;  4 import java.io.FileWriter;  5 import java.io.IOException;  6 import java.util.Comparator;  7 import java.util.Scanner;  8 import java.util.TreeSet;  9 10 /* 11  * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低存入文本文件。 12  * 13  * 分析： 14  * A:创建学生类 15  * B:创建集合对象(比较器排序:匿名内部类实现) 16  * TreeSet<Student> 17  * C:键盘录入学生信息并存储到集合 18  * D:遍历集合，把数据写到文本文件 19 */ 20 public class StudentDemo { 21 public static void main(String[] args) throws IOException { 22 // 创建集合对象(比较器排序:匿名内部类实现) 23 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { 24  @Override 25 public int compare(Student s1, Student s2) { 26 int num = s2.getSum() - s1.getSum(); // 主要条件 27 int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num; // 次要条件 28 int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2; // 次要条件 29 int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3; // 次要条件 30 int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4; // 次要条件 31 return num5; 32  } 33  }); 34 35 // 键盘录入学生信息并存储到集合 36 Scanner sc = null; 37 for (int x = 1; x <= 5; x++) { 38 sc = new Scanner(System.in); 39 System.out.println("请录入第" + x + "个的学习信息"); 40 System.out.println("姓名："); 41 String name = sc.nextLine(); 42 System.out.println("语文成绩："); 43 int chinese = sc.nextInt(); 44 System.out.println("数学成绩："); 45 int math = sc.nextInt(); 46 System.out.println("英语成绩："); 47 int english = sc.nextInt(); 48 49 // 创建学生对象 50 Student s = new Student(); 51  s.setName(name); 52  s.setChinese(chinese); 53  s.setMath(math); 54  s.setEnglish(english); 55 56 // 把学生对象添加到集合 57  ts.add(s); 58  } 59  sc.close(); 60 61 // 遍历集合，把数据写到文本文件 62 BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt")); 63 bw.write("学生信息如下："); 64  bw.newLine(); 65  bw.flush(); 66 bw.write("姓名,语文成绩,数学成绩,英语成绩"); 67  bw.newLine(); 68  bw.flush(); 69 for (Student s : ts) { 70 StringBuilder sb = new StringBuilder(); 71 sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()); 72  bw.write(sb.toString()); 73  bw.newLine(); 74  bw.flush(); 75  } 76 // 释放资源 77  bw.close(); 78 System.out.println("学习信息存储完毕"); 79  } 80 }

 1 package cn.itcast_09;  2  3 public class Student {  4 // 姓名  5 private String name;  6 // 语文成绩  7 private int chinese;  8 // 数学成绩  9 private int math; 10 // 英语成绩 11 private int english; 12 13 public Student() { 14 super(); 15  } 16 17 public Student(String name, int chinese, int math, int english) { 18 super(); 19 this.name = name; 20 this.chinese = chinese; 21 this.math = math; 22 this.english = english; 23  } 24 25 public String getName() { 26 return name; 27  } 28 29 public void setName(String name) { 30 this.name = name; 31  } 32 33 public int getChinese() { 34 return chinese; 35  } 36 37 public void setChinese(int chinese) { 38 this.chinese = chinese; 39  } 40 41 public int getMath() { 42 return math; 43  } 44 45 public void setMath(int math) { 46 this.math = math; 47  } 48 49 public int getEnglish() { 50 return english; 51  } 52 53 public void setEnglish(int english) { 54 this.english = english; 55  } 56 57 public int getSum() { 58 return this.chinese + this.math + this.english; 59  } 60 }

 1 package cn.itcast_09;  2  3 import java.util.Comparator;  4 import java.util.Scanner;  5 import java.util.TreeSet;  6  7 /*  8  * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)，按照总分从高到低输出到控制台。  9  * 10  * 分析： 11  * A:定义学生类 12  * B:创建一个TreeSet集合(比较器排序:匿名内部类实现) 13  * TreeSet<Student> 14  * C:总分从高到底如何实现呢? 15  * D:键盘录入5个学生信息 16  * E:遍历TreeSet集合 17 */ 18 public class TreeSetDemo { 19 public static void main(String[] args) { 20 // 创建一个TreeSet集合(比较器排序:匿名内部类实现) 21 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { 22  @Override 23 public int compare(Student s1, Student s2) { 24 // 总分从高到低 25 int num = s2.getSum() - s1.getSum(); 26 // 总分相同的不一定语文相同 27 int num2 = (num == 0 ? s1.getChinese() - s2.getChinese() : num); 28 // 总分和语文相同的不一定数序相同 29 int num3 = (num2 == 0 ? s1.getMath() - s2.getMath() : num2); 30 // 总分、语文和数学相同的不一定英语相同 31 int num4 = (num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3); 32 // 总分、语文、数学和英语相同的姓名还不一定相同 33 int num5 = (num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4); 34 return num5; 35  } 36  }); 37 38 System.out.println("学生信息录入开始"); 39 // 键盘录入5个学生信息 40 Scanner sc = null; 41 for (int x = 1; x <= 5; x++) { 42 sc = new Scanner(System.in); 43 44 System.out.println("请输入第" + x + "个学生的姓名:"); 45 String name = sc.nextLine(); 46 47 System.out.println("请输入第" + x + "个学生的语文成绩:"); 48 String chineseString = sc.nextLine(); 49 50 System.out.println("请输入第" + x + "个学生的数学成绩:"); 51 String mathString = sc.nextLine(); 52 53 System.out.println("请输入第" + x + "个学生的英语成绩:"); 54 String englishString = sc.nextLine(); 55 56 // 把录入的数据封装到学生对象中 57 Student s = new Student(); 58  s.setName(name); 59 s.setChinese(Integer.parseInt(chineseString)); // 把字符串类型转换为int类型 60 s.setMath(Integer.parseInt(mathString)); // 把字符串类型转换为int类型 61 s.setEnglish(Integer.parseInt(englishString)); // 把字符串类型转换为int类型 62 63 // 把学生对象添加到集合 64  ts.add(s); 65  } 66  sc.close(); 67 68 System.out.println("学生信息录入完毕"); 69 70 System.out.println("学习信息从高到低排序如下："); 71 System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩"); 72 // 遍历TreeSet集合 73 for (Student s : ts) { 74 System.out.println(s.getName() + "\t" + s.getChinese() + "\t" + s.getMath() + "\t" + s.getEnglish()); 75  } 76  } 77 }

 1 package cn.itcast_07;  2  3 import java.io.BufferedReader;  4 import java.io.BufferedWriter;  5 import java.io.FileReader;  6 import java.io.FileWriter;  7 import java.io.IOException;  8 import java.util.Arrays;  9 10 /* 11  * 已知在s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl” 12  * 请编写程序读取s.txt文件的数据内容，把读取到的数据排序后写入到ss.txt中。 13  * 14  * 分析： 15  * A:封装数据源File对象 16  * B:读取该File对象的内容，存储到一个字符串中 17  * C:把字符串转换为字符数组 18  * D:对字符数组进行排序(使用数组工具类的排序方法) 19  * E:把排序后的字符数组转换为字符串(通过字符串的构造方法实现) 20  * F:封装目的地File对象 21  * G:通过该File对象把字符串写入到ss.txt中 22 */ 23 public class StringDemo { 24 public static void main(String[] args) throws IOException { 25 // 封装数据源File对象 26 // 读取该File对象的内容，存储到一个字符串中 27 BufferedReader br = new BufferedReader(new FileReader("s.txt")); 28 String line = br.readLine(); 29  br.close(); 30 31 // 把字符串转换为字符数组 32 char[] chs = line.toCharArray(); 33 34 // 对字符数组进行排序(使用数组工具类的排序方法实现) 35  Arrays.sort(chs); 36 37 // 把排序后的字符数组转换为字符串(通过字符串的构造方法实现) 38 String s = new String(chs); 39 40 // 封装目的地File对象 41 // 通过该File对象把字符串写入到ss.txt中 42 BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt")); 43  bw.write(s); 44  bw.newLine(); 45  bw.flush(); 46 47  bw.close(); 48  } 49 }

 1 package cn.itcast_08;  2  3 import java.io.IOException;  4 import java.io.Reader;  5  6 /*  7  * 用Reader来模拟BufferedReader的readLine()功能  8  *  9  * readLine() 一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符。 10  * 11  * 12  * 思考：写一个方法，返回值是一个字符串。 13  * 14  * 我要返回一个字符串，我该怎么办呢? 15  * 因为我们现在有一个Reader对象，所以我们必须去看看r对象能够读取什么东西呢? 16  * r对象有两个读取方法：一次读取一个字符或者一次读取一个字符数组。 17  * 18  * 那么，我们要返回一个字符串，用哪个方法比较好呢? 19  * 我们很容易想到用字符数组比较好，但是问题来了，就是这个字符数组的长度是多长呢? 20  * 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。 21  * 22  * 但是呢，用这种方式的时候，我们在读取下一个字符的时候，上一个字符就丢失了。 23  * 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。 24  * 25  * 这个用谁比较合适呢? 26  * 数组、集合、字符串缓冲区三个可供选择。 27  * 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder。 28  * 29 */ 30 public class MyBufferedReader { 31 private Reader r; 32 33 public MyBufferedReader(Reader r) { 34 this.r = r; 35  } 36 37 public String readLine() throws IOException { 38 StringBuilder sb = new StringBuilder(); 39 40 // 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1。 41 int ch = 0; 42 while ((ch = r.read()) != -1) { 43 if (ch == '\r') { 44 continue; 45  } 46 47 if (ch == '\n') { 48 return sb.toString(); 49 } else { 50 sb.append((char)ch); 51  } 52  } 53 54 // 如果原始数据最后一行没有回车换行符(\r\n)，读取到的最好一行数据会丢失，所以判断读取到的最后一行的sb的长度，长度大于0说明有数据。 55 if (sb.length() > 0) { 56 return sb.toString(); 57  } 58 59 return null; 60  } 61 62 /* 63  * 先写一个关闭流的方法 64 */ 65 public void close() throws IOException { 66 this.r.close(); 67  } 68 }

 1 package cn.itcast_08;  2  3 import java.io.FileReader;  4 import java.io.IOException;  5  6 /*  7  * 注意：测试MyBufferedReader的时候，你就把它当作BufferedReader一样来使用就好。  8 */  9 public class MyBufferedReaderDemo { 10 public static void main(String[] args) throws IOException { 11 MyBufferedReader mbr = new MyBufferedReader(new FileReader("my.txt")); 12 13 String line = null; 14 while ((line = mbr.readLine()) != null) { 15  System.out.println(line); 16  } 17 18  mbr.close(); 19  } 20 }

 1 package cn.itcast_09;  2  3 import java.io.IOException;  4 import java.io.Reader;  5  6 public class MyLineNumberReader {  7 private Reader r;  8 private int lineNumber = 0;  9 10 public MyLineNumberReader(Reader r) { 11 this.r = r; 12  } 13 14 public int getLineNumber() { 15 return lineNumber; 16  } 17 18 public void setLineNumber(int lineNumber) { 19 this.lineNumber = lineNumber; 20  } 21 22 public String readLine() throws IOException { 23 lineNumber++; // 每调用一次readLine()方法后就让行号自加1 24 25 StringBuilder sb = new StringBuilder(); 26 27 int ch = 0; 28 while ((ch = r.read()) != -1) { 29 if (ch == '\r') { 30 continue; 31  } 32 33 if (ch == '\n') { 34 return sb.toString(); 35 } else { 36 sb.append((char) ch); 37  } 38  } 39 40 if (sb.length() > 0) { 41 return sb.toString(); 42  } 43 44 return null; 45  } 46 47 public void close() throws IOException { 48 this.r.close(); 49  } 50 }

 1 package cn.itcast_09;  2  3 import java.io.FileReader;  4 import java.io.IOException;  5  6 public class MyLineNumberReaderTest {  7 public static void main(String[] args) throws IOException {  8 MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader("my.txt"));  9 10 mlnr.setLineNumber(10); 11 12 String line = null; 13 while ((line = mlnr.readLine()) != null) { 14 System.out.println(mlnr.getLineNumber() + ":" + line); 15  } 16 17  mlnr.close(); 18 19  } 20 }

 1 package cn.itcast_08;  2  3 import java.io.IOException;  4 import java.io.Reader;  5  6 /*  7  * 用Reader来模拟BufferedReader的readLine()功能  8  *  9  * readLine() 一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符。 10  * 11  * 12  * 思考：写一个方法，返回值是一个字符串。 13  * 14  * 我要返回一个字符串，我该怎么办呢? 15  * 因为我们现在有一个Reader对象，所以我们必须去看看r对象能够读取什么东西呢? 16  * r对象有两个读取方法：一次读取一个字符或者一次读取一个字符数组。 17  * 18  * 那么，我们要返回一个字符串，用哪个方法比较好呢? 19  * 我们很容易想到用字符数组比较好，但是问题来了，就是这个字符数组的长度是多长呢? 20  * 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。 21  * 22  * 但是呢，用这种方式的时候，我们在读取下一个字符的时候，上一个字符就丢失了。 23  * 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。 24  * 25  * 这个用谁比较合适呢? 26  * 数组、集合、字符串缓冲区三个可供选择。 27  * 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder。 28  * 29 */ 30 public class MyBufferedReader { 31 private Reader r; 32 33 public MyBufferedReader(Reader r) { 34 this.r = r; 35  } 36 37 public String readLine() throws IOException { 38 StringBuilder sb = new StringBuilder(); 39 40 // 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1。 41 int ch = 0; 42 while ((ch = r.read()) != -1) { 43 if (ch == '\r') { 44 continue; 45  } 46 47 if (ch == '\n') { 48 return sb.toString(); 49 } else { 50 sb.append((char)ch); 51  } 52  } 53 54 // 如果原始数据最后一行没有回车换行符(\r\n)，读取到的最好一行数据会丢失，所以判断读取到的最后一行的sb的长度，长度大于0说明有数据。 55 if (sb.length() > 0) { 56 return sb.toString(); 57  } 58 59 return null; 60  } 61 62 /* 63  * 先写一个关闭流的方法 64 */ 65 public void close() throws IOException { 66 this.r.close(); 67  } 68 }

 1 package cn.itcast_09;  2  3 import java.io.IOException;  4 import java.io.Reader;  5  6 import cn.itcast_08.MyBufferedReader;  7  8 public class MyLineNumberReader2 extends MyBufferedReader {  9 private Reader r; 10 11 private int lineNumber = 0; 12 13 public MyLineNumberReader2(Reader r) { 14 super(r); 15  } 16 17 public int getLineNumber() { 18 return lineNumber; 19  } 20 21 public void setLineNumber(int lineNumber) { 22 this.lineNumber = lineNumber; 23  } 24 25 // 重写父类MyBufferedReader的readLine()方法 26  @Override 27 public String readLine() throws IOException { 28 lineNumber++; 29 return super.readLine(); 30  } 31 }

 1 package cn.itcast_09;  2  3 import java.io.FileReader;  4 import java.io.IOException;  5  6 public class MyLineNumberReaderTest2 {  7 public static void main(String[] args) throws IOException {  8 // 改进版  9 MyLineNumberReader2 mlnr2 = new MyLineNumberReader2(new FileReader("my.txt")); 10 11 mlnr2.setLineNumber(10); 12 13 String line = null; 14 while ((line = mlnr2.readLine()) != null) { 15 System.out.println(mlnr2.getLineNumber() + ":" + line); 16  } 17 18  mlnr2.close(); 19 20 21  } 22 }