DAY16 字节流、字符流、IO资源的处理、Properties、ResourceBundle
学习目标
- 能够使用字节输入流读取数据到程序1.创建FileInputStream对象,构造方法中绑定要读取的数据源FileInputStream fis = new FileInputStream("day15\\a.txt");2.FileInputStream对象中的方法read,以字节的方式读取文件int len = 0;while ((len = fis.read())!=-1){System.out.print((char)len);}3.释放资源fis.close();
- 能够理解读取数据read(byte[])方法的原理1.read方法的参数byte[]字节数组的作用?起到缓冲作用,把读取到的字节依次存储到数组中把数组一次性的由操作系统返回给JVM,由JVM返回给java程序,效率高数组的长度一般都使用:1024或者1024的整数倍2.read方法的返回值int是什么?每次读取到的有效字节个数FileInputStream fis = new FileInputStream("day15\\a.txt");byte[] bytes = new byte[1024];int len = 0;while ((len = fis.read(bytes))!=-1){System.out.print(new String(bytes,0,len));}fis.close();
- 能够使用字节流完成文件的复制(一读一写)1.创建FileInputStream对象,构造方法中绑定要读取的数据源2.创建FileOutputStream对象,构造方法中绑定要写的目的地3.使用FileInputStream对象中的方法read,以字节的方式读取文件4.使用FileOutputStream对象中的方法write,把读取到的字节写入到文件中5.释放资源
- 能够使用FileWriter写数据的5个方法- public void write(int c) ：写出一个字符。- public void write(char[] cbuf) 写字符数组中的多个字符- public abstract void write(char[] b, int off, int len) 写字符数组的一部分- public void write(String str) ：写出一个字符串。- void write(String str, int off, int len) 写入字符串的某一部分。
- 能够说出FileWriter中关闭和刷新方法的区别- flush ：刷新缓冲区，把内存缓冲区中的数据刷新到文件中,刷新完后,流对象可以继续使用。- close ：关闭流，释放系统资源。关闭前会刷新缓冲区。把内存缓冲区中的数据刷新到文件中,流关闭之后就不能在使用了
- 能够使用FileWriter写数据实现换行和追加写1.续写(追加写):使用两个参数的构造方法FileWriter(File file, boolean append)FileWriter(String fileName, boolean append)2.换行:使用换行符号windows:\r\nlinux: /nmac: /r 从Mac OS X开始与linux统一
- 能够使用FileReader读数据一次一个字符//1.创建FileReader对象,构造方法中绑定要读取的数据源FileReader fr = new FileReader("day15\\c.txt");//2.使用FileReader对象中的方法read,以字符的方式读取文件//public int read() 一次读取一个字符并返回int len = 0;while ((len = fr.read())!=-1){System.out.print((char)len);}//3.释放资源fr.close();
- 能够使用FileReader读数据一次一个字符数组//1.创建FileReader对象,构造方法中绑定要读取的数据源FileReader fr = new FileReader("day15\\c.txt");//2.使用FileReader对象中的方法read,以字符的方式读取文件//public int read() 一次读取一个字符并返回char[] chars = new char[1024];int len = 0;while ((len =fr.read(chars))!=-1){System.out.println(new String(chars,0,len));}//3.释放资源fr.close();
- 能够使用Properties的load方法加载文件中配置信息(必须会)//1.创建Properties集合对象Properties prop = new Properties();//2.使用Properties集合对象中的方法load,把硬盘中保存键值对的文件,读取到内存中使用//prop.load(new FileInputStream("day15\\prop.properties"));prop.load(new FileReader("day15\\prop.properties"));//3.遍历Properties集合Set<String> set = prop.stringPropertyNames();for (String key : set) {String value = prop.getProperty(key);System.out.println(key+"\t"+value);}第一章 字节流
1.字节输入流的介绍(了解)
/*java.io.InputStream:字节输入流此抽象类是表示字节输入流的所有类的超类。InputStream里边定义了所有字节输入流共性的成员方法,所有的字节输入流都可以使用这些方法共性的成员方法:int read() 从输入流中读取数据的下一个字节。int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。void close() 关闭此输入流并释放与该流关联的所有系统资源。java.io.FileInputStream:文件字节输入流 extends InputStream作用:把文件中的数据,以字节的方式读取到内存中构造方法:FileInputStream(File file)FileInputStream(String name) 参数:传递要读取的数据源String name:要读取的数据源是一个文件的路径File file:要读取的数据源是一个文件构造方法的作用:1.会创建FileInputStream对象2.会把创建好的FileInputStream对象指向要读取文件的第一个字节 注意:使用构造方法创建对象,如果要读取的文件不存在,会抛出文件找不到异常使用字节输入流读取文件到内存中底层原理:java程序==>JVM==>操作系统==>调用系统中读取文件的方法==>读取文件 */
2.字节输入流的基本使用:一次读取一个字节(重点)
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;/*字节输入流的使用步骤(重点):1.创建FileInputStream对象,构造方法中绑定要读取的数据源2.使用FileInputStream对象中的方法read,以字节的方式读取文件3.释放资源*/
public class Demo01InputStream {public static void main(String[] args) throws IOException {//1.创建FileInputStream对象,构造方法中绑定要读取的数据源FileInputStream fis = new FileInputStream("day16\\a.txt");//2.使用FileInputStream对象中的方法read,以字节的方式读取文件//int read() 从文件中一次读取一个字节并返回/*我们发现读取文件是一个重复的过程,所以我们可以使用循环优化我们不知道文件中有多少个字节,使用while循环循环结束的条件,read方法读取到-1的时候结束布尔表达式((len =fis.read())!=-1)1.fis.read():读取文件中的一个字节2.len =fis.read():把读取到的字节赋值给变量len3.((len =fis.read())!=-1):判断变量len的值是否为-1len不是-1就执行循环体打印lenlen是-1结束循环*/int len =0;while ((len =fis.read())!=-1){System.out.print((char)len);}/*int len = fis.read();System.out.println(len);//97len = fis.read();System.out.println(len);//98len = fis.read();System.out.println(len);//99len = fis.read();System.out.println(len);//-1*///3.释放资源fis.close();}
}
3.使用字节输入流一次读取多个字节(重点)
package com.itheima.demo01InputStream;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;/*使用字节输入流一次读取多个字节(重点)int read(byte[] b)从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。明确两个内容:1.read方法的返回值int是什么?每次读取的有效字节个数2.read方法的参数byte[]字节数组的作用?起到缓冲的作用,把读取到的字节依次存储到数组中把数组一次性的由操作系统返回JVM,由JVM返回个java程序数组的长度一般定义为1024或者1024的整数倍String类的构造方法:String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。根据编码表查询字节对应的编码,把字节转换为字符串 97-->a 65-->AString(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串int offset:数组中的开始索引int length:转换的字节个数*/
public class Demo02InputStream {public static void main(String[] args) throws IOException {//1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源FileInputStream fis = new FileInputStream("day16\\b.txt");//2.使用FileInputStream对象中的方法read,以字节的方式读取文件//int read(byte[] b) 使用字节数组缓冲一次读取多个字节/*我们发现读取数据,是一个重复的过程,所以可以使用循环优化不知道文件中有多少数据,使用while循环循环结束的条件,read方法返回-1的时候结束*/byte[] bytes = new byte[1024];int len = 0;while ((len = fis.read(bytes))!=-1){System.out.println(len);//5//把字节数组的一部分转换为字符串System.out.println(new String(bytes,0,len));}/*byte[] bytes = new byte[2];int len = fis.read(bytes);System.out.println(len);//2System.out.println(Arrays.toString(bytes));//[65, 66]System.out.println(new String(bytes));//ABlen = fis.read(bytes);System.out.println(len);//2System.out.println(new String(bytes));//CDlen = fis.read(bytes);System.out.println(len);//1System.out.println(new String(bytes));//EDlen = fis.read(bytes);System.out.println(len);//-1System.out.println(new String(bytes));//ED*///3.释放资源fis.close();}
}
4.文件复制(重点)
原理:
代码实现:
package com.itheima.demo02copyFile;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;/*文件复制原理:一读一写数据源: c:\\1.jpg目的地: d:\\1.jpg实现步骤:1.创建FileInputStream对象,构造方法中绑定要读取的数据源2.创建FileOutputStream对象,构造方法中绑定要写的目的地3.使用FileInputStream对象中的方法read,以字节的方式读取文件4.使用FileOutputStream对象中的方法write,把读取到的字节写入到文件中5.释放资源(先关写的,后关的读的)*/
public class Demo01CopyFile {public static void main(String[] args) throws IOException {long s = System.currentTimeMillis();//1.创建FileInputStream对象,构造方法中绑定要读取的数据源FileInputStream fis = new FileInputStream("c:\\1.exe");//2.创建FileOutputStream对象,构造方法中绑定要写的目的地FileOutputStream fos = new FileOutputStream("d:\\1.exe");//3.使用FileInputStream对象中的方法read,以字节的方式读取文件//一次读取一个字节,写入一个字节的方式复制文件:效率低下/*int len = 0;while ((len = fis.read())!=-1){//4.使用FileOutputStream对象中的方法write,把读取到的字节写入到文件中fos.write(len);}*///一次读取多个字节,写入多个字节的方式复制文件:效率高byte[] bytes = new byte[1024*1000];int len = 0;while ((len = fis.read(bytes))!=-1){fos.write(bytes,0,len);//写有效字节个数(最后一次读取不一定是1024个)}//5.释放资源(先关写的,后关的读的)fos.close();fis.close();long e = System.currentTimeMillis();System.out.println("复制文件共耗时:"+(e-s)+"毫秒!");}
}
第二章 字符流
1.使用字节输入流读取含有中文的文件
package com.itheima.demo03Reader;import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;/*使用字节输入流读取含有中文的文件文件的编码GBK:一个中文占用2个字节文件的编码UTF-8:一个中文占用3个字节*/
public class Demo01FileInputStream {public static void main(String[] args) throws IOException {FileInputStream fis = new FileInputStream("day16\\c.txt");//c.txt 你好int len = 0;while ((len = fis.read())!=-1){System.out.print((char)len);//ä½ å¥½ 一次读取一个字节(1/3个中文),把中文的1/3转换为字符,出现乱码}fis.close();}
}
2.字符输入流介绍
/*java.io.Reader:字符输入流用于读取字符流的抽象类,是所有字符输入流的最顶层的父类,里边定义了所有字符输入流中共性的成员方法,所有的字符输入流都可以使用共性的成员方法:int read()读取单个字符。int read(char[] cbuf)将字符读入数组。void close() 关闭该流并释放与之关联的所有资源。java.io.FileReader:文件字符输入流 extends InputStreamReader(转换流) extends Reader作用:把文件中的数据以字符的方式读取到内存中构造方法:FileReader(File file) FileReader(String fileName) 参数:传递要读取的数据源String fileName:数据源就是一个文件的路径File file:数据源就是一个文件 */
3.使用字符输入流读取文件的步骤(重点)
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;/*使用字符输入流读取文件的步骤(重点)1.创建FileReader对象,构造方法中绑定要读取的数据源2.使用FileReader对象中的方法read,以字符的方式读取文件3.释放资源String类的构造方法:String(char[] value) 把字符数组转换为字符串String(char[] value, int offset, int count) 把字符数组的一部分转换为字符串*/
public class Demo02Reader {public static void main(String[] args) throws IOException {//1.创建FileReader对象,构造方法中绑定要读取的数据源FileReader fr = new FileReader("day16//c.txt");//2.使用FileReader对象中的方法read,以字符的方式读取文件//int read() 一次读取一个字符并返回/*int len = 0;while ((len = fr.read())!=-1){System.out.print((char)len);}*///int read(char[] cbuf) 使用字符数组缓冲一次读取多个字符char[] chars = new char[1024];int len = 0;while ((len = fr.read(chars))!=-1){System.out.println(new String(chars,0,len));}//3.释放资源fr.close();}
}
4.字符输出流介绍
/*java.io.Writer:字符输出流写入字符流的抽象类。是所有字符输出流的最顶层的父类,里边定义了所有字符输出流中共性的成员方法,所有的字符输出流都可以使用共性的成员方法:public abstract void close() ：关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush() ：刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int c) ：写出一个字符。public void write(char[] cbuf) ：将 b.length字符从指定的字符数组写出此输出流。public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。public void write(String str) ：写出一个字符串。public void write(String str, int off, int len) 写入字符串的某一部分。java.io.FileWriter:文件字符输出流 extends OutputStreamWriter(转换流) extends Writer作用:把内存中的数据,以字符的方式写入到文件中构造方法:FileWriter(File file) FileWriter(String fileName) 参数:传递要写入的目的地String fileName:目的地就是一个文件的路径File file:目的地就是一个文件构造方法的作用:1.会创建FileWriter对象2.会根据构造方法中传递的文件|文件的路径,创建一个新的空白文件3.会把FileWriter对象,指向空白的文件 */
5.使用字符输出流基本步骤(重点)
import java.io.FileWriter;
import java.io.IOException;/*字符输出流基本使用步骤(重点)1.创建FileWriter对象,构造方法中绑定要写入的目的地2.使用FileWriter对象中的方法write,把数据写入到内存缓冲区中3.使用FileWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中4.释放资源(close方法会先调用flush,把内存缓冲区中的数据刷新到文件中,再释放资源)*/
public class Demo01Writer {public static void main(String[] args) throws IOException {//1.创建FileWriter对象,构造方法中绑定要写入的目的地FileWriter fw = new FileWriter("day16\\d.txt");//2.使用FileWriter对象中的方法write,把数据写入到内存缓冲区中fw.write(100);//3.使用FileWriter对象中的方法flush,把内存缓冲区中的数据刷新到文件中//fw.flush();//4.释放资源(close方法会先调用flush,把内存缓冲区中的数据刷新到文件中,再释放资源)fw.close();}
}
6.关闭和刷新的区别(面试)
package com.itheima.demo04Writer;import java.io.FileWriter;
import java.io.IOException;/*关闭和刷新的区别(面试)flush:把内存缓冲区中的数据刷新到文件中,刷新完之后,流对象可以继续使用close:释放资源(释放流相关的所有系统资源和流对象),在释放之前把内存缓冲区中的数据刷新到文件中刷新完之后,流对象已经关闭了,就不能在使用了问题:1.程序执行完毕后e.txt中有没有内容?2.程序执行会不会抛出异常?*/
public class Demo02Writer {public static void main(String[] args) throws IOException {FileWriter fw = new FileWriter("day16\\e.txt");fw.write(65);//Afw.write(66);//Bfw.flush();//把内存缓冲区中的数据刷新到文件中,刷新完之后,流对象可以继续使用fw.write(67);//Cfw.close();//把内存缓冲区中的数据刷新到文件中,刷新完之后,流对象已经关闭了,就不能在使用了fw.write(68);//D IOException: Stream closed}
}
7.字符输出流写数据的其他方法(重点)
package com.itheima.demo04Writer;import java.io.FileWriter;
import java.io.IOException;/*字符输出流写数据的其他方法(重点)public void write(int c) ：写出一个字符。public void write(char[] cbuf) ：写字符数组中的多个字符public abstract void write(char[] b, int off, int len) ：写字符数组的一部分字符;off:开始索引, len:写的字符个数public void write(String str) ：写出一个字符串。public void write(String str, int off, int len) 写入字符串的某一部分。off:开始索引, len:写的字符个数*/
public class Demo03Writer {public static void main(String[] args) throws IOException {FileWriter fw = new FileWriter("day16\\f.txt");//public void write(char[] cbuf) ：写字符数组中的多个字符char[] chars = {'a','b','c','1','2','3','中','国','@','#','$'};fw.write(chars);//abc123中国@#$//public abstract void write(char[] b, int off, int len) ：写字符数组的一部分字符;off:开始索引, len:写的字符个数fw.write(chars,6,2);//中国//public void write(String str) ：写出一个字符串。fw.write("我是一个中国人,我骄傲!");//public void write(String str, int off, int len) 写入字符串的某一部分。off:开始索引, len:写的字符个数fw.write("我是一个中国人,我骄傲!",4,3);//中国人fw.close();}
}
8.字符输出流的续写和换行(重点)
package com.itheima.demo04Writer;import java.io.FileWriter;
import java.io.IOException;/*字符输出流的续写和换行(重点)1.续写(追加写):使用两个参数的构造方法FileWriter(File file, boolean append)FileWriter(String fileName, boolean append)参数:File file|String fileName:写入数据的目的地boolean append:续写开关true:可以续写,使用构造方法创建对象,文件名相同的,不会创建新的文件覆盖之前同名的文件会继续往文件的末尾写数据false:不可以续写,使用构造方法创建对象,文件名相同,会创建一个新的空白的文件覆盖之前同名的文件在新的文件中写数据2.换行:使用换行符号windows: \r\nlinux: /nmac: /r Mac OS X开始与Linux统一*/
public class Demo04Writer {public static void main(String[] args) throws IOException {FileWriter fw = new FileWriter("day16\\g.txt",true);for (int i = 1; i <=10; i++) {fw.write("hellworld"+i+"\r\n");}fw.flush();fw.close();}
}
第三章 IO资源的处理(重点)
1.JDK7前异常处理
package com.itheima.demo05tryCatch;import java.io.FileWriter;
import java.io.IOException;/*JDK7前异常的处理:使用try...catch...finally处理异常throws:声明抛出异常对象,出现了异常,程序就停止了(JVM中断),如果有后续代码,执行不到了try...catch...finally:出现了异常,如果有后续代码,可以继续执行格式:try{可能会产生异常的代码(没有异常的代码可以放)}catch(定义一个异常变量,接收异常对象){异常的处理逻辑}finally{一定会执行的代码,一般用于资源释放(无论是否有异常,流对象都需要释放了)}快捷键:ctrl+alt+t*/
public class Demo01JDK7Before {public static void main(String[] args) {/*1.把fw.close();放在finally中:无论是否有异常,流对象都需要释放了Cannot resolve symbol 'fw':出了变量fw的作用域,不能使用,需要提高fw的作用域,定义在try外边2.Variable 'fw' might not have been initialized:变量fw没有一个初始化的值FileWriter fw = null; 赋一个默认值null,创建对象成功了,把对象赋值给fw;创建对象失败使用默认值null*/FileWriter fw = null;try {fw = new FileWriter("w:\\g.txt",true);for (int i = 1; i <=10; i++) {fw.write("hellworld"+i+"\r\n");}fw.flush();} catch (IOException e) {e.printStackTrace();} finally {//4.增加一个非空判断,防止空指针异常,流对象的值是null,就不需要关闭了if(fw!=null){try {//3.fw.close方法本身会声明抛出异常,需要try...catchfw.close();} catch (IOException e) {e.printStackTrace();}}}System.out.println("后续代码!");System.out.println(1);System.out.println(2);System.out.println(3);}
}
2.JDK7后异常处理
package com.itheima.demo05tryCatch;import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.concurrent.Executors;/*JDK7后异常处理:使用try...catch处理异常格式:try(//定义流对象,只能定义流对象AAA aaa = new AAA(读);BBB bbb = new BBB(写);){可能产生异常的代码aaa.read();bbb.write():}catch(定义一个异常相关的变量,接收异常对象){异常的处理逻辑}注意:在try的后边增加一个(),在()中定义流对象那么这些流对象的作用域,就在try中有效,执行完try中的代码,会自动帮助我们释放流对象的省略finally*/
public class Demo02JDK7After {public static void main(String[] args) {try(//定义流对象FileWriter fw = new FileWriter("day16\\1.txt");){fw.write("哈哈,你猜我能写入到文件中吗?");}catch (Exception e){e.printStackTrace();}try(//定义流对象FileInputStream fis = new FileInputStream("c:\\2.jpg");FileOutputStream fos = new FileOutputStream("d:\\2.jpg");){byte[] bytes = new byte[1024*1000];int len = 0;while ((len = fis.read(bytes))!=-1){fos.write(bytes,0,len);//写有效字节个数(最后一次读取不一定是1024个)}}catch (Exception e){e.printStackTrace();}}
}
第四章 Properties集合
1.Properties集合的基本使用
package com.itheima.demo06Properties;import java.util.Properties;
import java.util.Set;/*java.util.Properties集合 extends Hashtable<k,v>双列集合1.Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。Properties集合是一个唯一和IO流相结合的集合我们可以使用Properties集合中的方法store,把集合中的临时数据,持久化存储到硬盘中(内存-->硬盘)我们可以使用Properties集合中的方法load,把硬盘中保存的键值对文件,读取到内存集合中使用(硬盘-->内存)2.属性列表中每个键及其对应值都是一个字符串。Properties集合是一个双列集合,可以不用写泛型,默认key和value都是String类型*/
public class Demo01Properties {public static void main(String[] args) {show01();}/*Properties集合的基本使用:使用Properties集合存储数据,遍历集合获取集合中元素Properties集合健和值默认都是String类型,集合中有一些和String相关的方法Object setProperty(String key, String value) 往Properties集合中添加键值对,相当于Map集合中的put方法String getProperty(String key) 根据key获取vlaue,相当于Map集合中的get(key)方法Set<String> stringPropertyNames() 返回此属性列表中的键集,相当于Map集合中的keySet方法*/private static void show01() {//创建Properties集合对象Properties prop = new Properties();//使用Properties集合中的方法setProperty往集合中添加键值对prop.setProperty("迪丽热巴","168");prop.setProperty("古力娜扎","165");prop.setProperty("赵丽颖","160");prop.setProperty("唐嫣","170");//使用Properties集合中的方法stringPropertyNames,获取集合中所有的key,把Key存储到一个Set集合中返回Set<String> set = prop.stringPropertyNames();//遍历Set集合,获取Properties集合中的每一个keyfor (String key : set) {//使用Properties集合中的方法getProperty根据key获取value值String value = prop.getProperty(key);System.out.println(key+"="+value);}}
}
2.Properties集合中的方法store(了解)
/*我们可以使用Properties集合中的方法store,把集合中的临时数据,持久化存储到硬盘中(内存-->硬盘)void store(OutputStream out, String comments)void store(Writer writer, String comments)方法的参数:OutputStream out:传递字节输出流,不能写中文,会出现乱码,可以传递OutputStream任意的子类对象Writer writer:传递字符输出流,能写中文,不会出现乱码,可以传递Writer任意的子类对象String comments:注释,解释说明我们保存的文件是什么用的,一般传递""注释不能写中文,默认使用Unicode编码,会出现乱码使用步骤:1.创建Properties集合对象,往集合中添加数据2.使用Properties集合中的方法store,把集合中的临时数据,持久化存储到硬盘中*/
private static void show02() throws IOException {//1.创建Properties集合对象,往集合中添加数据Properties prop = new Properties();prop.setProperty("迪丽热巴","168");prop.setProperty("古力娜扎","165");prop.setProperty("赵丽颖","160");prop.setProperty("唐嫣","170");//2.使用Properties集合中的方法store,把集合中的临时数据,持久化存储到硬盘中//FileOutputStream fos = new FileOutputStream("day16\\prop1.txt");//prop.store(fos,"save data");//fos.close();//如果对象只使用一次,可以使用匿名对象prop.store(new FileOutputStream("day16\\prop1.txt"),"save data");prop.store(new FileWriter("day16\\prop2.txt"),"save data");//一般使用存储键值对的文件,叫配置文件,结尾一般都使用.propertiesprop.store(new FileWriter("day16\\prop.properties"),"save data");
}
3.Properties集合中的方法load(重点)
/*我们可以使用Properties集合中的方法load,把硬盘中保存的键值对文件,读取到内存集合中使用(硬盘-->内存)void load(InputStream inStream) 传递字节输入流,不能读取含有中文的文件,可以传递InputStream任意的子类对象void load(Reader reader) 传递字符输入流,可以读取含有中文的文件,可以传递Reader任意的子类对象使用步骤:1.创建Properties集合对象2.使用Properties集合中的方法load,把硬盘中保存的键值对文件,读取到内存集合中使用3.遍历Properties集合注意:1.在Properties集合的配置文件中,可以使用#进行注释,被注释的键值对不会被读取2.在Properties集合的配置文件中,健和值之间可以使用=,空格,冒号等一些符号作为键与值的分割符号3.在Properties集合的配置文件中,健和值默认都是字符串类型,不需要添加引号,否则会画蛇添足*/
private static void show03() throws IOException {//1.创建Properties集合对象Properties prop = new Properties();//2.使用Properties集合中的方法load,把硬盘中保存的键值对文件,读取到内存集合中使用//prop.load(new FileInputStream("day16\\prop.properties"));prop.load(new FileReader("day16\\prop.properties"));//3.遍历Properties集合Set<String> set = prop.stringPropertyNames();for (String key : set) {String value = prop.getProperty(key);System.out.println(key+"\t"+value);}
}
第五章 ResourceBundle工具类(重点)
前面我们学习了Properties工具类，它能够读取资源文件，当资源文件是以.properties结尾的文件时，
我们可以使用JDK提供的另外一个工具类ResourceBundle来对文件进行读取，使得操作更加简单。
1.ResourceBundle类对象的创建
package com.itheima.demo07ResourceBundle;import java.util.ResourceBundle;/*java.util.ResourceBundle:操作资源的工具类作用:我们可以使用ResourceBundle类中的方法读取以.properties结尾的文件ResourceBundle是一个抽象类,无法直接创建对象使用,我们可以使用ResourceBundle类中的静态方法获取ResourceBundle的子类对象static ResourceBundle getBundle(String baseName)参数:String baseName:传递以.properties结尾的文件名称prop.properties==>propdata.properties==>data注意:.properties结尾的文件必须放在当前模块的src下边,否则获取对象找不到配置文件,会抛出异常*/
public class Demo01ResourceBundle {public static void main(String[] args) {//多态 父类 = 子类对象ResourceBundle bundle = ResourceBundle.getBundle("data");System.out.println(bundle);//java.util.PropertyResourceBundle@74a14482}
}
2.ResourceBundle类的getString方法
package com.itheima.demo07ResourceBundle;import java.util.ResourceBundle;/*ResourceBundle类中提供了一个方法叫getString,用于读取配置文件String getString(String key) 根据配置文件中key,读取配置文件中的value注意:配置文件中key和value不要使用中文 */
public class Demo02ResourceBundle {public static void main(String[] args) {//获取ResourceBundle对象ResourceBundle bundle = ResourceBundle.getBundle("data");//使用ResourceBundle对象中的方法getString,根据配置文件中key,读取配置文件中的valueString username = bundle.getString("username");System.out.println(username);//jackString password = bundle.getString("password");System.out.println(password);//1234String sex = bundle.getString("sex");System.out.println(sex);//sex=女 Å®//String age = bundle.getString("年龄");//MissingResourceException: Can't find resource for bundle java.util.PropertyResourceBundle, key 年龄//System.out.println(age);}
}
data.properties(放在src的下边)
username=jack
password=1234
sex=女
年龄=18
总结
字符流和字节流的区别
1.字节流读取的和写入都是字节;字符流读取的和写入的都是字符
2.所有的数据(文本,音乐,视频,图片…),都是以字节的方式存储的,使用字节流可以读写任意的文件
3.使用字节流读取的文件中包含中文,如果一次读取一个字节(1/2GBK,1/3UTF-8个中文),使用起来不方便,可能会出现乱码
4.使用字符流读取含有中文文本文件,一次读取一个字符(中文,英文,数字,符号…),使用起来很方便
什么时候使用字符流:读写文本文件(使用记事本打开能看懂)
什么时候使用字节流:读写非文本文件(图片,视频,音频…)