IO就是Input和Ouput的缩写，表示输入输出，在IO操作中，操作的对象是流，比如将A数据写入到B中，那么就可以使用字节流或者字符流完成。JDK 中的IO操作类、接口等都定义在java.io包中。
Java.io.File类：代表文件和目录，File是唯一可以代表磁盘本身的类，可以对磁盘上的文件进行操作。File不能访问文件内容。常用的构造方法：
public File(String pathname) : 构造带有指定路径的File对象，File对象 可以是文件或文件夹。 一个File对象可以代表一个文件或目录（文件夹）常用的静态的常量：
public static final String pathSeparator：表示的一个分号 “;” public static final String separator：表示的是一层路径 “\”常用的方法：
public boolean createNewFile() throws IOException : 创建一个新文件 public boolean delete()：删除文件或者空的文件夹 public boolean exists()：判断文件或者文件夹是否存在 public String getAbsolutePath()：取得文件的绝对路径 public String getName()：获得文件或文件夹名称 public boolean isDirectory()：判断文件是否是文件夹（目录就是文件夹） public boolean isFile()：判断是否是文件 public long length()：获得文件的字节长度 public String[] list()：读取文件夹中所有的文件，并将所有的文件名称返回到一个String数组中 public boolean mkdir()：创建单层路径文件夹 在D盘创建abc文件夹 public boolean mkdirs()：创建多层路径的文件夹 在D盘创建abc/bcd/efg/xyz 其余方法可自行查看API范例：在D盘中创建wanbangee.txt文件
public static void main(String[] args) throws IOException { String path = "D:" + File.separator + "wanbangee.txt"; File file = new File(path);//创建File类的实例 if(file.exists()) {//如果文件存在 file.delete();//删除文件 } file.createNewFile();//创建一个新的文件 }范例：在D盘中创建abc文件夹
public static void main(String[] args) throws IOException { String path = "D:" + File.separator + "abc"; File file = new File(path);//创建File类的实例 if(file.exists()) {//如果文件夹存在 file.delete();//删除文件夹 } file.mkdir();//创建文件夹 }范例：在D盘中创建efg/xyz/ink/qwe文件夹，file.mkdirs();//创建多层目录的文件夹
public static void main(String[] args) throws IOException { String path = "D:" + File.separator + "efg" + File.separator + "xyz" + File.separator + "ink" + File.separator + "qwe"; File file = new File(path);//创建File类的实例 if(file.exists()) {//如果文件夹存在 file.delete();//删除文件夹 } file.mkdirs();//创建多层目录的文件夹 }范例：列出D:\workspace\libs目录中所有的文件，如果是文件夹，则继续读取文件夹中的内容。用递归思路 递归结构（工作中常见）： 递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。 递归结构包括2个部分：1.定义递归头，也就是递归的结束条件，什么时候不调用自身方法。 如果没有头，将陷入死循环。2.递归体，什么时候需要调用自身方法。
public static void main(String[] args) { loop("D:"+File.separator+"workspace"+File.separator+"libs"); } public static void loop(String path) { File file = new File(path); if(file.isDirectory()) {//如果是文件夹 String dir[] = file.list();//读取文件夹中所有的内容 for (String string : dir) { String newPath = path + File.separator + string; loop(newPath);//递归，方法自己调用自己 } }else {//如果不是文件夹则打印列出 System.out.println(path); } }输出：将程序数据输出到磁盘、光盘、内存等存储设备中，将程序中的数据写入到文件 输入：将磁盘、光盘、内存等存储设备的数据写入到程序中，从文件中读取数据到程序中 如果要进行文件的复制，原理如下图： 计算机可以连接很多的外部设备，所有输入输出还可以目标位置可以是任意的外部设备。 现在以硬盘作为我们输入输出的目标。那么IO操作的具体步骤有哪些呢？
创建指定路径的文件对象（指定路径的文件或文件夹） File file = new File(“D:” + File.separator + “hello.txt”);创建一个字节流或者字符流，这个字节操作流或者字符操作流要连接到文件（创建文件输出流对象） OutputStream out = new FileOutputStream(file);进行输入输出的操作关闭流 最终关闭流用于释放操作流所占用的资源，无论程序运行有没有异常，都需要关闭。IO操作中，流的操作可以分为两类：
字节流字节输出流：OutputStream字节输入流：InputStream字符流字符输出流：Writer字符输入流：Reader 所以流的分类可以根据操作的数据单位不同分为： 英文字母，一个字母1个字节，中文，一个中文2个字节字节流 ： 8 bit字符流 : 16 bit 根据数据流的方向不同分为：输出流输入流 Java的IO操作包中，输入输出流总共有40多个类，但是这40多个类都是OutputStream，InputStream，Writer，Reader的后代类。而且后代类的特点非常明显，在命名上面是祖先是哪个，类名的后面就是这个祖先类的命名，比如FileInputStream文件的字节输入流，FileOutputStream文件字节输出流。字节输出流的最高父类是OutputStream，此类的定义如下：
public abstract class OutputStream extends Object implements Closeable, Flushable发现OutputStream是一个抽象类，所以在实例化其对象的时候，必须依靠子类。如果现在输出的目标是文件，我们就可以使用FileOutputStream。FileOutputStream常用的构造器如下：
创建一个带有指定文件的FileOutputStream对象：public FileOutputStream(File file); 创建一个带有指定文件的FileOutputStream对象，第二个参数表示输出内容是否追加，如果为true表示内容追加，如果为false表示内容覆盖。默认为false表示内容覆盖：public FileOutputStream(File file, boolean append)
OutputSteam字节输出流中常见的操作方法：
public void close() throws IOException：关闭流 public void flush() throws IOException：刷新流 public void write(byte[] b) throws IOException：将整个字节数组写入到流中 public void write(byte[] b,int off,int len)throws IOException：将字节数组的一部分写入到流中 public abstract void write(int b)throws IOException：将一个字节写入到流中范例：程序向文件中输出内容
public static void main(String[] args) { String content = "Hello 万邦易嵌\n"; String path = "D:" + File.separator + "hello.txt"; File file = new File(path); //实例化文件对象 //在进行文件输出流操作的时候，如果文件不存在，会先创建文件 OutputStream out = null; try { // out = new FileOutputStream(file);//new不同的流对象 out = new FileOutputStream(file,true);//表示为内容的追加 //将字符串转换成字节数组 byte b[] = content.getBytes(); out.write(b);//将字节数组写入到流中 } catch (Exception e) { e.printStackTrace(); } finally { try { out.close(); } catch (IOException e) { e.printStackTrace(); } } }以上是将字符串转换成字节数组进行输出，当然也可以一个字节一个字节的输出。 但是对于单个字节的输出的话，非必要不推荐。
public static void main(String[] args) { String content = "Hello 万邦易嵌"; String path = "D:" + File.separator + "hello.txt"; File file = new File(path); //实例化文件对象 //在进行文件输出流操作的时候，如果文件不存在，会先创建文件 OutputStream out = null; try { out = new FileOutputStream(file); //将字符串转换成字节数组 byte b[] = content.getBytes(); for (byte c : b) { out.write(c);//将单个字节写入到流中 } } catch (Exception e) { e.printStackTrace(); } finally { try { out.close(); } catch (IOException e) { e.printStackTrace(); } } }字节输入流的最高父类是InputStream，也是个抽象类，类的声明如下：
public abstract class InputStream extends Object implements Closeable如果现在我们要从文件中输入内容到程序，那么必须依靠其子类FileInputStream， FileInputStream常用的构造器如下：
public FileInputStream(File file) throws FileNotFoundException：构造连接到指定文件的文件字节输入流InputStream的操作方法如下：
public abstract int read() throws IOException ： 读取单个字节 public int read(byte[] b) throws IOException ： 将内容（流中的字节）读取到一个字节数组中 public int read(byte[] b,int off,int len)throws IOException：将内容（流中的字节）读取到字节数组的一部分范例：将D盘中的hello.txt文件内容读取到程序中
public static void main(String[] args) throws Exception { File file = new File("D:" + File.separator + "hello.txt"); InputStream in = new FileInputStream(file); byte b[] = new byte[1024]; in.read(b); //将内容读取到字节数组中 String s = new String(b);//将字节数组转换称字符串对象 System.out.println(s); in.close(); }发现问题，对于字节数组的长度定义，我们不好把握，太长了，导致读取的内容不够填满整个字节数组，太短了，又放不下，所以我们使用文件的字节长度作为开辟数组的空间大小。
public static void main(String[] args) throws Exception { File file = new File("D:" + File.separator + "hello.txt"); InputStream in = new FileInputStream(file); byte b[] = new byte[(int)file.length()];//用文件的字节长度定义数组的大小 in.read(b); //将文件内容读取到字节数组中 String s = new String(b);//将字节数组转换称字符串对象 System.out.println(s); in.close(); }当然我们也可以一个字节一个字节的读取：
public static void main(String[] args) throws Exception { File file = new File("D:" + File.separator + "hello.txt"); InputStream in = new FileInputStream(file); StringBuffer sb = new StringBuffer();//字符串操作类 int temp = 0; while((temp = in.read())!=-1) { //判断是否读取到了最后一个，！=-1表示没有读取到最后一个继续读 char c = (char)temp;//将字节强制转换成字符 sb.append(c);//将读取的内容追加到字符串 } System.out.println(sb); in.close(); }以上的程序就是一个字节一个字节读取，但是如果读取的内容是中文，则出现问题。
字符流操作的对象是字符，Writer是字符输出的最高父类，也是一个抽象类，定义如下：
public abstract class Writer extends Object implements Appendable, Closeable, Flushable如果现在要使用字符输出流向文件中输出内容，则必须使用其后代类FileWriter， FileWriter的常用的构造器如下：
public FileWriter(File file)throws IOException ： 构造连接到了指定文件的文件字符输出流 public FileWriter(File file,boolean append)throws IOException ： 构造连接到了指定文件的FileWriter，第二个参数表示是否是内容的追加，如果追加，传递true，否则传递falseWriter类中的字符流输出的方法：
abstract void close() ： 关闭流 abstract void flush() ： 刷新流 void write(char[] cbuf) ：将字符数组写入到流中 abstract void write(char[] cbuf, int off, int len) ：将字符数组的一部分写入到流中 void write(int c) ： 将单个字符写入到流中 void write(String str) ： 将字符串写入到流中 void write(String str, int off, int len) ： 将字符串的一部分写入到流中 public static void main(String[] args) throws Exception{ String s = "我们的大中国啊啊啊啊啊啊啊啊"; File file = new File("D:" + File.separator + "wanbang.doc"); Writer out = new FileWriter(file); // Writer out = new FileWriter(file,true); // out.write(s);//将字符串写入到流中 char c[] = s.toCharArray();//将字符串转换成字符数组 // out.write(c);//将字符数组写入到流中 for (char d : c) { out.write(d);//将单个字符写入到流中 } out.close(); }Reader是字符输入流的最高的父类，也是一个抽象类，定义如下：
public abstract class Reader extends Object implements Readable, Closeable如果现在想要从文件中读取内容，那么可以使用后代类FileReader完成，FileReader的构造方法如下：
public FileReader(File file) throws FileNotFoundException：构造一个连接到指定文件的FileReader对象Reader类的常用的操作方法如下：
int read()throws IOException：读取单个字符 read(char[] cbuf)throws IOException：将内容（流中的数据）读取到一个字符数组中 int read(char[] cbuf,int off,int len)：将内容（流中的数据）读取到字节数组的一部分中范例：从d盘的wanbang.doc读取内容
public static void main(String[] args) throws Exception{ File file = new File("D:" + File.separator + "wanbang.doc"); Reader in = new FileReader(file); // char c[] = new char[(int)file.length()];//如果使用文件的字节长度定义字符数组的大小，则会存在中文字导致字节长度笔字符数量大 // in.read(c);//将文件内容读取到字符数组中 StringBuffer sb = new StringBuffer(); int temp = 0; while((temp = in.read()) != -1) {//读取单个字符 char c = (char)temp; sb.append(c);//添加到sb中 } // String s = new String(c); System.out.println(sb); }对于流的操作都有两组： 字节流： - 字节输出：OutputStream - 字节输入：InputStream 字符流： - 字符输出：Writer - 字符输入：Reader 有两组操作，那么我们在开发中使用哪一组更好呢？ 现在通过一组代码进行测试：使用字节输出流和字符输出流分别向文件输出内容
字节输出流 public static void main(String[] args) throws Exception { String content = "Hello world"; String path = "D:" + File.separator + "hello.txt"; File file = new File(path); OutputStream out = new FileOutputStream(file, true); byte b[] = content.getBytes(); out.write(b); }字节输出流不需要流的关闭，也可以向流中输出内容。
字符输出流 public static void main(String[] args) throws Exception { String content = "Hello world"; String path = "D:" + File.separator + "hello.txt"; File file = new File(path); Writer out = new FileWriter(file, true); out.write(content); //刷新 out.flush(); }字符输出流在不关闭流的情况下，内容不会写入到流中，但是在刷新的时候会将内容写到流中，也就意味着字符流是在刷新的时候进行操作，在关闭字符流的时候会自动的进行刷新，那么刷新的是什么地方呢？字符流操作的时候是用来刷新缓冲区的，得出结论： 字节流-----------------------------文件 字符流----------缓冲区------------文件 所以，在开发的时候，使用字节流的效率会比字符流的更高，因为字节流是字节操作的，而字符流需要通过缓冲区进行间接操作，但是在处理中文的时候，字符流更方便，因为一个中文占用两个字节，但是却是一个字符。
打印流是最方便输出的流：PrintStream,里面有非常方便的输出的方法，先看构造方法：
public PrintStream(File file) throws FileNotFoundException:创建一个连接到文件的打印流对象，则打印流可以向文件中打印。 public PrintStream(OutputStream out)：实例化一个带有指定字节输出流的打印流对象。 PrintStream是OutputStream 是子类，但是PrintStream构造器中，传入的是其父类对象， 这种模式在开发中叫做装饰模式，表示根据传入父类的对象不同，打印流就可以向不同的地方输出。打印流可以通过构造方法连接到任意的字节输出流，比如文件字节输出流，内存字节输出流，管道流，对象流…,范例如下：
public static void main(String[] args) throws Exception { File file = new File("D:"+File.separator+"c.txt"); //OutputStream out = new FileOutputStream(file); PrintStream out = new PrintStream(file);//创建打印流连接到文件 PrintStream out1 = new PrintStream(new FileOutputStream(file));//创建打印流连接到文件 //OutputStream o = new ByteArrayOutputStream();//内存输出流,将字节输出到内存中 PrintStream ou = new PrintStream(new ByteArrayOutputStream());//创建打印流连接到内存 }其实这是一种装饰模式：PrintStream是OutputStream的后代类，而且PrintStream构造方法中传递的就是OutputStream的对象，并且根据传入的OutputStream对象的不同，而连接到不同的位置。常用的打印方法如下：
public void println(任意类型)：换行输出任意类型的数据 public void print(任意类型)：不换行输出任意类型的数据 public static void main(String[] args) throws Exception { File file = new File("D:" + File.separator + "wanbang.txt"); PrintStream out = new PrintStream(new FileOutputStream(file,true));//创建打印流连接到文件 //PrintStream out = new PrintStream(file);//创建打印流连接到文件 out.println("西游记中的女儿国王真漂亮"); out.println("水浒传中的潘金莲也很漂亮"); out.println("红楼梦中的贾宝玉特别帅气"); out.println("三国演义中的小乔是老马的梦中情人"); out.println(true); out.println(123456); out.println(12345.12345); out.close(); }System类中有三个常量：
public static final PrintStream out ：标准的输出，输出的位置是控制台，是PrintStream对象 public static final PrintStream err ：标准的错误输出，输出的位置是控制台，是PrintStream对象 public static final InputStream in ：标准的输入，输入的位置是键盘，是InputStream的对象这个时候我们可以解释System.out.println()可以向控制台输出的原因， System.out（类名.常量）是PrintStream(打印流)的对象，而println()方法就是PrintStream提供的方法，对象.方法。System.out和System.err实际上都是标准输出，输出的位置也都是控制台，只是out表示普通信息的输出，而err是错误信息的输出，也仅仅只有在集成开发环境中err打印出来呈现红色。所有对于信息输出，不管是普通信息还是错误信息，都能够理解，现在关键是System.in，表示的是键盘的标准输出。
public static void main(String[] args) throws Exception { InputStream in = System.in;//标注的键盘输入 byte b[] = new byte[9]; System.out.println("请输入内容："); in.read(b);//将内容读取到字节数组中 String s = new String(b);//将字节数组转换为字符串 System.out.println("您输入的内容为：" + s); }以上的程序可以完成键盘的输入，但是存在问题，受到数组长度的限制，中文还可能乱码。如果说不想受到长度的限制，我们可以一个一个字节的读取：
public static void main(String[] args) throws Exception { InputStream in = System.in;//标注的键盘输入 System.out.println("请输入内容："); StringBuffer sb = new StringBuffer(); int temp = 0; while((temp = in.read()) != -1) { char c = (char)temp; if(c == '\n') {//如果按下的回车键，直接中断字节接收 break; } sb.append(c); } System.out.println("您输入的内容为：" + sb); }以上的程序一个字节一个字节的读取内容，不受到长度的限制了，任意的长度都可以，但是，如果是中文则出现乱码，因为一个中文占两个字节。现在如果出现一个方法，一次性能够读取一行键盘输入的内容，以上的问题都可以解决了。在BufferedReader（缓冲字符输入流）类中提供了一次性读取一行的方法：
public String readLine() throws IOException ：一次性读取一行内容 构造方法如下： public BufferedReader(Reader in)：构造BufferedReader对象现在关键是BufferedReader是字符输入流的子类，并且构造方法中传入的Reader对象(字符输入流对象)，而System.in是字节输入流，所以现在的关键是将字节输入流转换成字符输入流。在IO操作中提供了两个类：
InputStreamReader：将字节输入流转换成字符输入流OutputStreamWriter：将字节输出流转换成字符输出流 以InputStreamReader为例，类的定义如下： public class InputStreamReader extends Reader发现InputStreamReader是Reader字符输入流的子类，构造方法如下：
public InputStreamReader(InputStream in) ： 实例化InputStreamReader对象，传入InputStream对象通过字节输入流可以获得InputStreamReader对象，而InputStreamReader是Reader的子类，所以InputStreamReader对象是Reader对象。
public static void main(String[] args) throws Exception { InputStream in = System.in;//标注的键盘输入 System.out.println("请输入内容："); InputStreamReader insr = new InputStreamReader(in); Reader reader = insr; BufferedReader buf = new BufferedReader(reader); String s = buf.readLine();//一次性读取一行 System.out.println("您输入的内容为：" + s); }以上完美解决了键盘输入的问题，可以简写一下：
public static void main(String[] args) throws Exception { System.out.println("请输入内容："); BufferedReader buf = new BufferedReader(new InputStreamReader(System.in)); String s = buf.readLine();//一次性读取一行 System.out.println("您输入的内容为：" + s); }输出输出重定向表示修改输入输出的目标位置，现在输入的位置是键盘，输出的位置是控制台，在System类中提供了三个方法：
public static void setErr(PrintStream err) ： 重定向错误的输出位置 public static void setOut(PrintStream out)：重定向标准信息输出的位置 public static void setIn(InputStream in)：重定向输入的位置通过以上的三个方法，我们就可以更改输入输出的位置。 范例：输出重定向
public static void main(String[] args) throws Exception { PrintStream out = new PrintStream(new FileOutputStream(new File("D:" + File.separator + "wanbang.txt"))); System.setOut(out);//设置重定向 System.out.println("现在输出的内容就不是在控制台而是在文件中"); }范例：输入重定向
public static void main(String[] args) throws Exception { //输入重定向 System.setIn(new FileInputStream(new File("D:\\wanbang.txt"))); //System.out.println("请输入内容："); BufferedReader buf = new BufferedReader(new InputStreamReader(System.in)); String s = null; while((s = buf.readLine()) != null) { System.out.println(s); } }对象序列化实际上是非常重要的，以后我们会接触到缓存技术，缓存实际上就是将查询的数据集通过某种形式放入到缓存中(内存的一块区域)，第二次查找相同的数据就不再去数据库中查询，而是从缓存中获得，这样一来可以减轻数据的查询次数（减轻数据库的压力），二来可以更加高效快速的获得数据。现在关键就是如何将数据写入到缓存呢？数据库表中的每一笔数据实际上就是一个对象，我们只需要将数据封装成对象之后写入到缓存，这个时候就需要使用对象序列化。
对象序列化：将对象写入到流中，使用ObjectOutputStream类，是OutputStream的后代类，除了继承OutputStream中方法外，还额外的提供了将对象写入到流中的方法：writeObject(Object object)对象的反序列化：从流中将对象读取，使用ObjectInputStream，是InputStream的后代类，ObjectInputStream除了继承InputStream的方法外，还额外的提供了从流中读取对象的方法：Object readObject()对象序列化的前提：如果要对一个类的对象进行序列化，那么这个类必须要先实现序列化接口Serializable
public class IODemo21 { public static void main(String[] args) throws Exception { //对象序列化 start // Person person = new Person(); // person.setAge(18); // person.setName("紫霞仙子"); // ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File("D:\\wan.txt"))); // out.writeObject(person); // out.close(); //对象序列化end //对象反序列化 start ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("D:\\wan.txt"))); Person person = (Person)in.readObject();//从流中读取对象 System.out.println(person); in.close(); //对象非按序列化end } } class Person implements Serializable{ //实现序列化接口 private int age ; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { //方便测试打印对象信息 return "Person [age=" + age + ", name=" + name + "]"; } } 序列化中还有一个小细节，刚才序列化的person对象来说，如果是一个女生，不希望年龄被序列化， 我们可以在序列化的过程中，排除年龄这个属性，使用transient关键字。 private transient int age ;//年龄不被序列化 private String name;总结：
java.io.File类是IO操作中唯一代表磁盘本身的类，里面提供了一系列对文件及文件夹的操作方法。IO 操作的原理就是 使用输入输出流连接到磁盘或者其他设备上，从而进行输入输出的操作，步骤主要是创建流的连接，进行读写操作，最后关闭流。InputStream叫做字节输入流，OutputStream叫做字节输出流，Reader叫做字符输入流，Writer叫做字符输出流，这四个类都是抽象类，各自代表了字节或者字符，输入或者输出的最高父类，总共有40多个子类，用于完成不同输入输出目标位置的流的连接。字节流是直接和文件进行操作的，字符流是通过缓冲区和文件简洁进行操作的。打印流PrintStream是OutputStream的子类，里面提供了一系列的打印方法，可以打印任意类型的数据，而且打印流可以连接到其他的输出流，所以打印流用于流的输出是最方便的。System类中有in,out,err三个静态常量，in是InputStream的对象，err和out是PrintStream的对象，而且in表示键盘的输入，out，err表示输出，输出的位置是控制台。System类中提供了setOut(PrintStream )，setErr(PrintStream )，SerIn(InputStream)三个静态方法，表示将输入输出的默认的位置进行改变，也就是输入输出重定向。对象序列化，实际意义是将对象写入到流中，使用ObjectOutputStream完成，对象反序列化就是从流中读取对象，使用ObjectInputStream完成，其中要注意的是transient关键字可以修饰类中的属性，表示次类的对象再进行序列化的时候使用transient修饰的属性不被序列化。如果一个类的对象要进行序列化的时候，这个类必须实现序列化接口。练习： 1.在D中创建一个文件 wanbangee.doc,往文件中写入内容：大家好才是真的好；而后将这个文件复制到C盘中。WORD文档不能进行内容追加，因为自身文档格式原因。
//将内容写入到源文件 String path = "D:" + File.separator + "wanbangee.doc"; String content = "大家好才是真的好"; File sourceFile = new File(path); PrintStream out = new PrintStream(new FileOutputStream(sourceFile,true)); out.println(content); out.close(); //读取源文件内容 InputStream in = new FileInputStream(sourceFile); byte b[] = new byte[(int)sourceFile.length()]; in.read(b);//将内容读取到字节数组 in.close(); //将源文件内容写入到新的文件 path = "C:" + File.separator + "wanbangee.docx"; File destFile = new File(path); if(destFile.exists()) {//判断目标文件是否存在 destFile.delete(); } OutputStream os = new FileOutputStream(destFile); os.write(b);//将字节数组写入到新的文件 os.close();2.递归实现输入任意目录，列出目录中的文件及文件夹
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));//键盘输入 System.out.print("请输入目录："); String path = buf.readLine();//读取键盘输入的一行内容 loop(path); } public static void loop(String path) { File file = new File(path); if(file.isDirectory()) {//如果是文件夹 System.out.println(path); String dir[] = file.list();//读取文件夹中所有的内容 for (String string : dir) { String newPath = path + File.separator + string; loop(newPath);//递归，方法自己调用自己 } }else {//如果不是文件夹则打印列出 System.out.println(path); }3.递归实现列出当前工程下所有的.java文件
public static void main(String[] args) { String path = "D:\\workspace\\workspace\\20201020\\JavaDemo"; loop(path); } public static void loop(String path) { File file = new File(path); if(file.isDirectory()) {//如果是文件夹 String dir[] = file.list();//读取文件夹中所有的内容 for (String string : dir) { String newPath = path + File.separator + string; loop(newPath);//递归，方法自己调用自己 } }else {//如果不是文件夹判断文件是否以.java结尾 if(path.endsWith(".java")) { System.out.println(path); } } }4.移动一张图片，从一个目录移动到另外一个目录（是移动不是拷贝） 图片用字节流，不能用字符流，先关文件再删文件，没关字节输入流删除不掉
public static void main(String[] args) throws Exception { File sourceFile = new File("D:" + File.separator + "abc.jpg"); if(!sourceFile.exists()) { System.out.println("文件不存在"); return; } //读取源文件 byte b[] = new byte[(int)sourceFile.length()]; InputStream in = new FileInputStream(sourceFile); in.read(b); in.close(); String sourceFileName = sourceFile.getName();//取的源文件的名称 File destFile = new File("C:" + File.separator + sourceFileName); OutputStream out = new FileOutputStream(destFile); out.write(b); out.close(); sourceFile.delete();//删除源文件 }5.统计一个文件中A 和 a各出现的次数
public static void main(String[] args) throws Exception { String path = "C:\\Users\\Administrator\\Desktop\\GenericDemo01.java"; File file = new File(path); BufferedReader buf = new BufferedReader(new InputStreamReader(new FileInputStream(file)));//读取的内容从文件中来 String temp = null; int countA = 0; int counta = 0; while((temp = buf.readLine()) != null) {//每次读取文件一行内容 //将读取的内容转换成字符数组 char tempc[] = temp.toCharArray(); for (char c : tempc) { if(c == 'A') { countA ++; }else if (c == 'a') { counta ++; } } } System.out.println("A出现的次数为：" + countA); System.out.println("a出现的次数为：" + counta); } 流:流动、流向，从一端移动到另一端。 流是一个抽象、动态的概念，是一连 串连续动态的数据集合。 数据源：提供原始数据的原始媒介 ， 常见的数据源 ：数据库、文件、其他程序、内存、网络连接、I O 设备。 在Java 程序中，对于数据的输入输出操作以“流”( stream) 方式进行 ；