文件

什么是文件

获取文件的相关信息

packagecom.hspedu.file;

importorg.junit.jupiter.api.Test;

importjava.io.File;

/**

*@author韩顺平

*@version1.0

*/public class FileInformation{

   publicstaticvoidmain(String[]args){

   

   }

   //获取文件的信息

   @Test

   publicvoidinfo(){

   //先创建文件对象

     Filefile=newFile("e:\\news1.txt");

   //调用相应的方法，得到对应信息

     System.out.println("文件名字="+file.getName());

       //getName、getAbsolutePath、getParent、length、exists、isFile、isDirectorySystem.out.println("文件绝对路径="+file.getAbsolutePath());

       System.out.println("文件绝对路径="+file.getAbsolutePath());

       System.out.println("文件父级目录="+file.getParent());

       System.out.println("文件大小(字节)="+file.length());

       System.out.println("文件是否存在="+file.exists());//T

       System.out.println("是不是一个文件="+file.isFile());//T

       System.out.println("是不是一个目录="+file.isDirectory());//F

       }

}

目录的操作和文件删除

IO流的分类

JavaIO流原理

• I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。
  如读/写文件，网络通讯等。
• Java程序中，对于数据的输入/输出操作以”流(stream)”的方式进行。
• java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方
  法输入或输出数据
• 输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。
• 输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中

流的分类

• 这四个都是抽象类

常用的类

InputStream 常用类

• 继承关系图

补充说明：

• 
  

• ctrl+shift+F 全局搜索（快捷键，可以快速的搜索查找一个类）
• 选中你查找的那个类，快捷键 ctrl+h------->点击--------->Diagrams，共两种选择，任选一种就可da以看到类的关系图。

FileInputStream

• 请使用FileInputStream读取hello.txt文件，并将文件内容显示到控制台.

package com.hspedu.inputstream_;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

/**

* @author 韩顺平

* @version 1.0

* 演示FileInputStream的使用(字节输入流 文件--> 程序)

*/

public class FileInputStream_ {

   public static void main(String[] args) {

   }

   /**

    * 演示读取文件...

    * 单个字节的读取，效率比较低

    * -> 使用 read(byte[] b)

    */

   @Test

   public void readFile01() {

       String filePath = "e:\\hello.txt";

       int readData = 0;

       FileInputStream fileInputStream = null;

       try {

           //创建 FileInputStream 对象，用于读取 文件

           fileInputStream = new FileInputStream(filePath);

           //从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。

           //如果返回-1 , 表示读取完毕

           while ((readData = fileInputStream.read()) != -1) {

               System.out.print((char)readData);//转成char显示

           }

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           //关闭文件流，释放资源.

           try {

               fileInputStream.close();

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

   /**

    * 使用 read(byte[] b) 读取文件，提高效率

    */

   @Test

   public void readFile02() {

       String filePath = "e:\\hello.txt";

       //字节数组

       byte[] buf = new byte[8]; //一次读取8个字节.

       int readLen = 0;

       FileInputStream fileInputStream = null;

       try {

           //创建 FileInputStream 对象，用于读取 文件

           fileInputStream = new FileInputStream(filePath);

           //从该输入流读取最多b.length字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。

           //如果返回-1 , 表示读取完毕

           //如果读取正常, 返回实际读取的字节数

           while ((readLen = fileInputStream.read(buf)) != -1) {

               System.out.print(new String(buf, 0, readLen));//显示

           }

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           //关闭文件流，释放资源.

           try {

               fileInputStream.close();

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

}

FileOutputStream

• 要求:请使用FileOutputStream在a.txt文件，中写入“hello，world”.,如果文件不存在，会创建文件(注意：前提是目录已经存在.)

package com.hspedu.outputstream_;

import org.junit.jupiter.api.Test;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

/**

* @author 韩顺平

* @version 1.0

*/

public class FileOutputStream01 {

   public static void main(String[] args) {

   }

   /**

    * 演示使用FileOutputStream 将数据写到文件中,

    * 如果该文件不存在，则创建该文件

    */

   @Test

   public void writeFile() {

       //创建 FileOutputStream对象

       String filePath = "e:\\a.txt";

       FileOutputStream fileOutputStream = null;

       try {

           //得到 FileOutputStream对象 对象

           //老师说明

           //1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容

           //2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面

           fileOutputStream = new FileOutputStream(filePath, true);

           //写入一个字节

           //fileOutputStream.write('H');//

           //写入字符串

           String str = "hsp,world!";

           //str.getBytes() 可以把 字符串-> 字节数组

           //fileOutputStream.write(str.getBytes());

           /*

           write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流

            */

           fileOutputStream.write(str.getBytes(), 0, 3);

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           try {

               fileOutputStream.close();

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

}

• FileOutputStream应用实例2FileCopy.java
  要求:编程完成图片/音乐的拷贝

package com.hspedu.outputstream_;

import com.hspedu.inputstream_.FileInputStream_;

import java.io.*;

/**

* @author 韩顺平

* @version 1.0

*/

public class FileCopy {

   public static void main(String[] args) {

       //完成 文件拷贝，将 e:\\Koala.jpg 拷贝 c:\\

       //思路分析

       //1. 创建文件的输入流 , 将文件读入到程序

       //2. 创建文件的输出流， 将读取到的文件数据，写入到指定的文件.

       String srcFilePath = "e:\\Koala.jpg";

       String destFilePath = "e:\\Koala3.jpg";

       FileInputStream fileInputStream = null;

       FileOutputStream fileOutputStream = null;

       try {

           fileInputStream = new FileInputStream(srcFilePath);

           fileOutputStream = new FileOutputStream(destFilePath);

           //定义一个字节数组,提高读取效果

           byte[] buf = new byte[1024];

           int readLen = 0;

           while ((readLen = fileInputStream.read(buf)) != -1) {

               //读取到后，就写入到文件 通过 fileOutputStream

               //即，是一边读，一边写

               fileOutputStream.write(buf, 0, readLen);//一定要使用这个方法

           }

           System.out.println("拷贝ok~");

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           try {

               //关闭输入流和输出流，释放资源

               if (fileInputStream != null) {

                   fileInputStream.close();

               }

               if (fileOutputStream != null) {

                   fileOutputStream.close();

               }

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

}

FileReader和FileWriter

                         

网络异常，图片无法展示

|

FileReader相关方法

1. new FileReader(File/String)
2. read:每次读取单个字符，返回该字符，如果到文件末尾返回-1
3. read(char[]):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1

相关API:

1. new String(char[]):将char[]转换成String

2. new String(char[],off,len):将char[]的指定部分转换成String

FileWriter常用方法

FileReader和FileWriter应用案例

• 使用FileReader从story.txt读取内容，并显示

package com.hspedu.reader_;

import org.junit.jupiter.api.Test;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/**

* @author 韩顺平

* @version 1.0

*/

public class FileReader_ {

   public static void main(String[] args) {

   }

   /**

    * 单个字符读取文件

    */

   @Test

   public void readFile01() {

       String filePath = "e:\\story.txt";

       FileReader fileReader = null;

       int data = 0;

       //1. 创建FileReader对象

       try {

           fileReader = new FileReader(filePath);

           //循环读取 使用read, 单个字符读取

           while ((data = fileReader.read()) != -1) {

               System.out.print((char) data);

           }

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           try {

               if (fileReader != null) {

                   fileReader.close();

               }

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

   /**

    * 字符数组读取文件

    */

   @Test

   public void readFile02() {

       System.out.println("~~~readFile02 ~~~");

       String filePath = "e:\\story.txt";

       FileReader fileReader = null;

       int readLen = 0;

       char[] buf = new char[8];

       //1. 创建FileReader对象

       try {

           fileReader = new FileReader(filePath);

           //循环读取 使用read(buf), 返回的是实际读取到的字符数

           //如果返回-1, 说明到文件结束

           while ((readLen = fileReader.read(buf)) != -1) {

               System.out.print(new String(buf, 0, readLen));

           }

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           try {

               if (fileReader != null) {

                   fileReader.close();

               }

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

}

• 使用FileWriter将“风雨之后，定见彩虹”写入到note.txt文件中

package com.hspedu.writer_;

import java.io.FileWriter;

import java.io.IOException;

/**

* @author 韩顺平

* @version 1.0

*/

public class FileWriter_ {

   public static void main(String[] args) {

       String filePath = "e:\\note.txt";

       //创建FileWriter对象

       FileWriter fileWriter = null;

       char[] chars = {'a', 'b', 'c'};

       try {

           fileWriter = new FileWriter(filePath);//默认是覆盖写入

//            3) write(int):写入单个字符

           fileWriter.write('H');

//            4) write(char[]):写入指定数组

           fileWriter.write(chars);

//            5) write(char[],off,len):写入指定数组的指定部分

           fileWriter.write("韩顺平教育".toCharArray(), 0, 3);

//            6) write（string）：写入整个字符串

           fileWriter.write(" 你好北京~");

           fileWriter.write("风雨之后，定见彩虹");

//            7) write(string,off,len):写入字符串的指定部分

           fileWriter.write("上海天津", 0, 2);

           //在数据量大的情况下，可以使用循环操作.

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           //对应FileWriter , 一定要关闭流，或者flush才能真正的把数据写入到文件

           //老韩看源码就知道原因.

           /*

               看看代码

               private void writeBytes() throws IOException {

       this.bb.flip();

       int var1 = this.bb.limit();

       int var2 = this.bb.position();

       assert var2 <= var1;

       int var3 = var2 <= var1 ? var1 - var2 : 0;

       if (var3 > 0) {

           if (this.ch != null) {

               assert this.ch.write(this.bb) == var3 : var3;

           } else {

               this.out.write(this.bb.array(), this.bb.arrayOffset() + var2, var3);

           }

       }

       this.bb.clear();

   }

            */

           try {

               //fileWriter.flush();

               //关闭文件流，等价 flush() + 关闭

               fileWriter.close();

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

       System.out.println("程序结束...");

   }

}

字节流和处理流

节点流和处理流一览图

节点流和处理流的区别和联系

处理流的功能主要体现在以下两个方面:

处理流-BufferedReader和BufferedWriter

• BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的
• 关闭时处理流，只需要关闭外层流即可
• 应用案例1：使用BufferedReader读取文本文件，并显示在控制台 BufferedReader.java

package com.hspedu.reader_;

import java.io.BufferedReader;

import java.io.FileReader;

/**

* @author 韩顺平

* @version 1.0

* 演示bufferedReader 使用

*/

public class BufferedReader_ {

   public static void main(String[] args) throws Exception {

       String filePath = "e:\\a.java";

       //创建bufferedReader

       BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));

       //读取

       String line; //按行读取, 效率高

       //说明

       //1. bufferedReader.readLine() 是按行读取文件

       //2. 当返回null 时，表示文件读取完毕

       while ((line = bufferedReader.readLine()) != null) {

           System.out.println(line);

       }

       //关闭流, 这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭 节点流

       //FileReader。

       /*

           public void close() throws IOException {

               synchronized (lock) {

                   if (in == null)

                       return;

                   try {

                       in.close();//in 就是我们传入的 new FileReader(filePath), 关闭了.

                   } finally {

                       in = null;

                       cb = null;

                   }

               }

           }

        */

       bufferedReader.close();

   }

}

• 应用案例2：使用BufferedWriter 将”hello,韩顺平教育”，写入到文件中 BufferedWriter.java

package com.hspedu.writer_;

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

/**

* @author 韩顺平

* @version 1.0

* 演示BufferedWriter的使用

*/

public class BufferedWriter_ {

   public static void main(String[] args) throws IOException {

       String filePath = "e:\\ok.txt";

       //创建BufferedWriter

       //说明:

       //1. new FileWriter(filePath, true) 表示以追加的方式写入

       //2. new FileWriter(filePath) , 表示以覆盖的方式写入

       BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));

       bufferedWriter.write("hello, 韩顺平教育!");

       bufferedWriter.newLine();//插入一个和系统相关的换行

       bufferedWriter.write("hello2, 韩顺平教育!");

       bufferedWriter.newLine();

       bufferedWriter.write("hello3, 韩顺平教育!");

       bufferedWriter.newLine();

       //说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭

       bufferedWriter.close();

   }

}

• 应用案例3：综合使用BufferedReader 和BufferedWriter完成文本文件拷贝，注意文件编码BufferedCopy_. java

package com.hspedu.writer_;

import java.io.*;

/**

* @author 韩顺平

* @version 1.0

*/

public class BufferedCopy_ {

   public static void main(String[] args) {

       //老韩说明

       //1. BufferedReader 和 BufferedWriter 是安装字符操作

       //2. 不要去操作 二进制文件[声音，视频，doc, pdf ], 可能造成文件损坏

       //BufferedInputStream

       //BufferedOutputStream

       String srcFilePath = "e:\\a.java";

       String destFilePath = "e:\\a2.java";

//        String srcFilePath = "e:\\0245_韩顺平零基础学Java_引出this.avi";

//        String destFilePath = "e:\\a2韩顺平.avi";

       BufferedReader br = null;

       BufferedWriter bw = null;

       String line;

       try {

           br = new BufferedReader(new FileReader(srcFilePath));

           bw = new BufferedWriter(new FileWriter(destFilePath));

           //说明: readLine 读取一行内容，但是没有换行

           while ((line = br.readLine()) != null) {

               //每读取一行，就写入

               bw.write(line);

               //插入一个换行

               bw.newLine();

           }

           System.out.println("拷贝完毕...");

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           //关闭流

           try {

               if(br != null) {

                   br.close();

               }

               if(bw != null) {

                   bw.close();

               }

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

}

处理流-BufferedInputStream和BufferedOutputStream

介绍BufferedOutputStream

               

网络异常，图片无法展示

|

• 应用案例 要求:编程完成图片/音乐的拷贝(要求使用Buffered..流).[老师代码演示]  BufferedCopy02.java

package com.hspedu.outputstream_;

import java.io.*;

/**

* @author 韩顺平

* @version 1.0

* 演示使用BufferedOutputStream 和 BufferedInputStream使用

* 使用他们，可以完成二进制文件拷贝.

* 思考：字节流可以操作二进制文件，可以操作文本文件吗？当然可以

*/

public class BufferedCopy02 {

   public static void main(String[] args) {

//        String srcFilePath = "e:\\Koala.jpg";

//        String destFilePath = "e:\\hsp.jpg";

//        String srcFilePath = "e:\\0245_韩顺平零基础学Java_引出this.avi";

//        String destFilePath = "e:\\hsp.avi";

       String srcFilePath = "e:\\a.java";

       String destFilePath = "e:\\a3.java";

       //创建BufferedOutputStream对象BufferedInputStream对象

       BufferedInputStream bis = null;

       BufferedOutputStream bos = null;

       try {

           //因为 FileInputStream  是 InputStream 子类

           bis = new BufferedInputStream(new FileInputStream(srcFilePath));

           bos = new BufferedOutputStream(new FileOutputStream(destFilePath));

           //循环的读取文件，并写入到 destFilePath

           byte[] buff = new byte[1024];

           int readLen = 0;

           //当返回 -1 时，就表示文件读取完毕

           while ((readLen = bis.read(buff)) != -1) {

               bos.write(buff, 0, readLen);

           }

           System.out.println("文件拷贝完毕~~~");

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

           //关闭流 , 关闭外层的处理流即可，底层会去关闭节点流

           try {

               if(bis != null) {

                   bis.close();

               }

               if(bos != null) {

                   bos.close();

               }

           } catch (IOException e) {

               e.printStackTrace();

           }

       }

   }

}

对象流-ObjectInputStream和ObjectOutputStream

对象流介绍

功能：提供了对基本类型或对象类型的序列化和反序列化的方法

 ObjectOutputStream提供序列化功能

 ObjectInputStream提供反序列化功能

应用案例1:使用ObjectOutputStream序列化基本数据类型和一个Dog对象(name, age),并保存到data.dat文件中ObjectOutStream.java

package com.hspedu.outputstream_;

import java.io.FileOutputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

/**

* @author 韩顺平

* @version 1.0

* 演示ObjectOutputStream的使用, 完成数据的序列化

*/

public class ObjectOutStream_ {

   public static void main(String[] args) throws Exception {

       //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存

       String filePath = "e:\\data.dat";

       ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));

       //序列化数据到 e:\data.dat

       oos.writeInt(100);// int -> Integer (实现了 Serializable)

       oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)

       oos.writeChar('a');// char -> Character (实现了 Serializable)

       oos.writeDouble(9.5);// double -> Double (实现了 Serializable)

       oos.writeUTF("韩顺平教育");//String

       //保存一个dog对象

       oos.writeObject(new Dog("旺财", 10, "日本", "白色"));

       oos.close();

       System.out.println("数据保存完毕(序列化形式)");

   }

}

应用案例2:使用ObjectInputStream读取data.dat并反序列化恢复数据

//1.创建流对象

ObjectInputStreamois=newObjectInputStream(newFileInputStream("src\\data.dat"));

//2.读取，注意顺序System.out.println(ois.readInt());

System.out.println(ois.readBoolean());

System.out.println(ois.readChar());

System.out.println(ois.readDouble());

System.out.println(ois.readUTF());

System.out.println(ois.readObject());

System.out.println(ois.readObject());

System.out.println(ois.readObject());

//3.关闭ois.close();

System.out.println("以反序列化的方式读取(恢复)ok~");

• 注意事项和细节说明

• 读写顺序要一致
• 要求序列化或反序列化对象，需要实现Serializable
• 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
• 序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
• 序列化对象时，要求里面属性的类型也需要实现序列化接口
• 序列化具备可继承性,也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化[在案例上演示下,看data.dat即可

标准输入输出流

转换流-InputStreamReader和OutputStreamWriter

com.hspedu.transformation CodeQuestion.java

先看一个文件乱码问题，引出学习转换流必要性

package com.hspedu.transformation;

import java.io.*;

/**

* @author 韩顺平

* @version 1.0

* 看一个中文乱码问题

*/

public class CodeQuestion {

   public static void main(String[] args) throws IOException {

       //读取e:\\a.txt 文件到程序

       //思路

       //1.  创建字符输入流 BufferedReader [处理流]

       //2. 使用 BufferedReader 对象读取a.txt

       //3. 默认情况下，读取文件是按照 utf-8 编码

       String filePath = "e:\\a.txt";

       BufferedReader br = new BufferedReader(new FileReader(filePath));

       String s = br.readLine();

       System.out.println("读取到的内容: " + s);

       br.close();

       //InputStreamReader

       //OutputStreamWriter

   }

}

介绍

1. InputStreamReader:Reader的子类，可以将InputStream(字节流)包装成(转换)Reader(字符流)
2. OutputStreamWriter:Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流
3. 当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成宇符流
4. 可以在使用时指定编码格式(比如utf-8,gbk,gb2312, ISO8859-1等)

应用案例1:编程将字节流FilelnputStream包装成(转换成)字符流InputStreamReader,对文件进行读取(按照utf-8/gbk格式),进而在包装成BufferedReader
InputStreamReader_ java

package com.hspedu.transformation;

import java.io.*;

/**

* @author 韩顺平

* @version 1.0

* 演示使用 InputStreamReader 转换流解决中文乱码问题

* 将字节流 FileInputStream 转成字符流  InputStreamReader, 指定编码 gbk/utf-8

*/

public class InputStreamReader_ {

   public static void main(String[] args) throws IOException {

       String filePath = "e:\\a.txt";

       //解读

       //1. 把 FileInputStream 转成 InputStreamReader

       //2. 指定编码 gbk

       //InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");

       //3. 把 InputStreamReader 传入 BufferedReader

       //BufferedReader br = new BufferedReader(isr);

       //将2 和 3 合在一起

       BufferedReader br = new BufferedReader(new InputStreamReader(

                                                   new FileInputStream(filePath), "gbk"));

       //4. 读取

       String s = br.readLine();

       System.out.println("读取内容=" + s);

       //5. 关闭外层流

       br.close();

   }

}

应用案例2:编程将字节流FileOutputStream包装成(转换成)字符流OutputStreamWriter,对文件进行写入(按照gbk格式,可以指定其他，比如utf-8)

//1.创建流对象

OutputStreamWriterosw=newOutputStreamWriter(newFileOutputStream("d:\\a.txt"),"gbk");

//2.写入

osw.write("hello,韩顺平教育~");

//3.关闭

osw.close();

System.out.println("保存成功~");

打印流-PrintStream和PrintWriter

com..hspedu.printstream PrintStream.java PrintWriter.java
用实例,打印流只有输出流，没有输入流

packagecom.hspedu.transformation;

importjava.io.FileWriter;

importjava.io.IOException;

importjava.io.PrintWriter;

/**

*@author韩顺平

*@version1.0*演示PrintWriter使用方式*/

public class PrintWriter_{

publicstaticvoidmain(String[]args)throwsIOException{

//PrintWriterprintWriter=newPrintWriter(System.out);

PrintWriterprintWriter=newPrintWriter(newFileWriter("e:\\f2.txt"));

 

 

packagecom.hspedu.printstream;

importjava.io.IOException;

importjava.io.PrintStream;

/**

*@author韩顺平

*@version1.0

*演示PrintStream（字节打印流/输出流）

*/

publicclassPrintStream_{

publicstaticvoidmain(String[]args)throwsIOException{

PrintStreamout=System.out;

//在默认情况下，PrintStream输出数据的位置是标准输出，即显示器

/*

       publicvoidprint(Strings){

           if(s==null){

           s="null";

       }

       write(s);

    }*/

    out.print("john,hello");

    //因为print底层使用的是write,所以我们可以直接调用write进行打印/输出

    out.write("韩顺平,你好".getBytes());out.close();

    //我们可以去修改打印流输出的位置/设备

    //1.输出修改成到"e:\\f1.txt"

    //2."hello,韩顺平教育~"就会输出到e:\f1.txt

    //3.publicstaticvoidsetOut(PrintStreamout){

    //checkIO();

    //setOut0(out);

    //native方法，修改了out

    // }

    System.setOut(newPrintStream("e:\\f1.txt"));

    System.out.println("hello,韩顺平教育~");

    }

    }

    printWriter.print("hi,北京你好~~~~");

    printWriter.close();//flush+关闭流,才会将数据写入到文件..

    }

     }

Properties类

导读

• 看一个需求
  
  网络异常，图片无法展示

  |

package com.hspedu.properties_;

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

/**

* @author 韩顺平

* @version 1.0

*/

public class Properties01 {

   public static void main(String[] args) throws IOException {

       //读取mysql.properties 文件，并得到ip, user 和 pwd

       BufferedReader br = new BufferedReader(new FileReader("src\\mysql.properties"));

       String line = "";

       while ((line = br.readLine()) != null) { //循环读取

           String[] split = line.split("=");

           //如果我们要求指定的ip值

           if("ip".equals(split[0])) {

               System.out.println(split[0] + "值是: " + split[1]);

           }

       }

       br.close();

   }

}

基本介绍

1. 专门用于读写配置文件的集合类
   配置文件的格式:
   键=值
2. 注意:键值对不需要有空格，值不需要用引号一起来。默认类型是 String

3. Properties的常见方法

• load: 加载配置文件的键值对到Properties对象
• list: 将数据显示到指定设备
• getProperty(key): 根据键获取值
• setProperty(key,value): 设置键值对到Properties对象
• store: 将Properties中的键值对存储到配置文件,在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码
  http://tool.chinaz.com/tools/unicode.aspx  unicode码查询工具

应用案例

1.使用Properties类完成对 mysql.properties的读取,看老师代码演示
2.使用Properties类添加key-val到新文件mysql2.properties 中
3.使用Properties类完成对mysql2.properties的读取 并修改某个key-val

package com.hspedu.properties_;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.util.Properties;

/**

* @author 韩顺平

* @version 1.0

*/

public class Properties02 {

   public static void main(String[] args) throws IOException {

       //使用Properties 类来读取mysql.properties 文件

       //1. 创建Properties 对象

       Properties properties = new Properties();

       //2. 加载指定配置文件

       properties.load(new FileReader("src\\mysql.properties"));

       //3. 把k-v显示控制台

       properties.list(System.out);

       //4. 根据key 获取对应的值

       String user = properties.getProperty("user");

       String pwd = properties.getProperty("pwd");

       System.out.println("用户名=" + user);

       System.out.println("密码是=" + pwd);

   }

}

package com.hspedu.properties_;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Properties;

/**

* @author 韩顺平

* @version 1.0

*/

public class Properties03 {

   public static void main(String[] args) throws IOException {

       //使用Properties 类来创建 配置文件, 修改配置文件内容

       Properties properties = new Properties();

       //创建

       //1.如果该文件没有key 就是创建

       //2.如果该文件有key ,就是修改

       /*

           Properties 父类是 Hashtable ， 底层就是Hashtable 核心方法

           public synchronized V put(K key, V value) {

               // Make sure the value is not null

               if (value == null) {

                   throw new NullPointerException();

               }

               // Makes sure the key is not already in the hashtable.

               Entry tab[] = table;

               int hash = key.hashCode();

               int index = (hash & 0x7FFFFFFF) % tab.length;

               @SuppressWarnings("unchecked")

               Entry entry = (Entry)tab[index];

               for(; entry != null ; entry = entry.next) {

                   if ((entry.hash == hash) && entry.key.equals(key)) {

                       V old = entry.value;

                       entry.value = value;//如果key 存在，就替换

                       return old;

                   }

               }

               addEntry(hash, key, value, index);//如果是新k, 就addEntry

               return null;

           }

        */

       properties.setProperty("charset", "utf8");

       properties.setProperty("user", "汤姆");//注意保存时，是中文的 unicode码值

       properties.setProperty("pwd", "888888");

       //将k-v 存储文件中即可

       properties.store(new FileOutputStream("src\\mysql2.properties"), null);

       System.out.println("保存配置文件成功~");

   }

}

本章作业

1.编程题Homework01.java5min一定要自己做.
(1)在判断e盘下是否有文件夹mytemp,如果没有就创建mytemp       (2)在e:l\mytemp目录下，创建文件hello.txt
(3)如果hello.txt已经存在，提示该文件已经存在，就不要再重复创建了
(4)并且在hello.txt文件中，写入hello, world~

2.编程题Homework02.java
要求:使用BufferedReader读取一个文本文件，为每行加上行号，再连同内容一并输出到屏幕上。
//如果老韩把文件的编码改成了gbk,出现中文乱码，大家思考如何解决
//1.默认是按照utf-8处理,开始没有乱码
//2.提示:使用我们的转换流，将FilelnputStream -> InputStreamReader[可以指定编码]
->BufferedReader ...

3.编程题
(1)Homework03.java 5min
要编写一个dog.properties
name=tom
age=5
color=red
(2)编写Dog类(name,age,color) 创建一个dog对象，
读取dog.properties用相应的内容完
成属性初始化,并输出
(3)将创建的Dog对象，序列化到文件dog.dat文件