文件

什么是文件

网络异常，图片无法展示

获取文件的相关信息

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相关方法

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

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());

//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

}

介绍

InputStreamReader:Reader的子类，可以将InputStream(字节流)包装成(转换)Reader(字符流)
OutputStreamWriter:Writer的子类，实现将OutputStream(字节流)包装成Writer(字符流
当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成宇符流
可以在使用时指定编码格式(比如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();

}

基本介绍

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

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文件

Java进阶部分详解（七）--->IO流

文件

什么是文件

获取文件的相关信息

目录的操作和文件删除

IO流的分类

JavaIO流原理

流的分类

常用的类

InputStream 常用类

FileInputStream

FileOutputStream

FileReader和FileWriter

FileReader相关方法

FileWriter常用方法

FileReader和FileWriter应用案例

字节流和处理流

节点流和处理流一览图

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

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

处理流-BufferedReader和BufferedWriter

处理流-BufferedInputStream和BufferedOutputStream

介绍BufferedOutputStream

对象流-ObjectInputStream和ObjectOutputStream

对象流介绍

标准输入输出流

转换流-InputStreamReader和OutputStreamWriter

打印流-PrintStream和PrintWriter

Properties类

导读

基本介绍

应用案例

本章作业

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java进阶部分详解（七）--->IO流

文件

什么是文件

获取文件的相关信息

目录的操作和文件删除

IO流的分类

JavaIO流原理

流的分类

常用的类

InputStream 常用类

FileInputStream

FileOutputStream

FileReader和FileWriter

FileReader相关方法

FileWriter常用方法

FileReader和FileWriter应用案例

字节流和处理流

节点流和处理流一览图

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

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

处理流-BufferedReader和BufferedWriter

处理流-BufferedInputStream和BufferedOutputStream

介绍BufferedOutputStream

对象流-ObjectInputStream和ObjectOutputStream

对象流介绍

标准输入输出流

转换流-InputStreamReader和OutputStreamWriter

打印流-PrintStream和PrintWriter

Properties类

导读

基本介绍

应用案例

本章作业

热门文章

最新文章

相关课程

相关电子书

相关实验场景