一，File文件类

1

File类创建功能:

public boolean createNewFiLe():当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件

如果文件不存在,就创建文件,并返回true

如果文件存在，就不创建文件，并返回false

public boolean mkdir():创建由此抽象路径名命名的目录

如果目录不存在,就创建文件，并返回true

如果文件存在，就不创建文件，并返回false

public boolean mkdirs ()。创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

如果目录不存在,就创建文件，并返回true

如果文件存在，就不创建文件，并返回false

public class FileDemo {public static void main(String[] args) throws IOException {//需求1：在D:\\xuexi\\file目录下创建一个文件java.txtFile f1 = new File("D:\\xuexi\\file\\java.txt");System.out.println(f1.createNewFile());//需求2:在D:\\xuexi\\file目录下创建一个目录javaseFile f2 = new File("D:\\xuexi\\file\\javase");System.out.println(f2.mkdir());//需求3：在D:\\xuexi\\file目录下创建一个多级目录JavaWeb\\HTMLFile f3 = new File("D:\\xuexi\\file\\JavaWeb\\HTML");System.out.println(f3.mkdirs());}}

2

File:文件和目录路径名的抽象表示

1文件和目录是可以通过FiLe封装成对象的

2:对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。

将来是要通过具体的操作把这个路径的内容转换为具体存在的

构造方法:

File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的FiLe实例。

FiLe(String parent，String child):从父路径名字符串和子路径名字符串创建新的File实例。

File(File parent，string child):从父抽象路径名和子路径名字将串创建新的File实例。

public class FileDemo01 {public static void main(String[] args) {//File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的FiLe实例。File f1 = new File("D:\\xuexi\\java.txt");System.out.println(f1);//FiLe(String parent，String child):从父路径名字符串和子路径名字符串创建新的File实例。File f2 = new File("D:\\xuexi","java.txt");System.out.println(f2);//File(File parent，string child):从父抽象路径名和子路径名字将串创建新的File实例。File f3 = new File("D:\\xuexi");File f4 = new File(f3,"java.txt");System.out.println(f4);}}

3

File类的判断和获取功能:

public boolean isDirectory():测试此抽象路径名表示的FiLe是否为目录

public boolean isFile():测试此抽象路径名表示的FilLe是否为文件

public boolean exists()。测试此抽象路径名表示的FiLe是否存在

public String getAbsoLutePath():返回此抽象路径名的绝对路径名字符串

public String getPath()。将此抽象路径名转换为路径名字符串

public string getName()。返回由此抽象路径名表示的文件或自录的名称

public String[ ] list()，返回此抽象路径名表示的目录中的文件和目录的名称字符串数组

public File[] listFiles( ),返回此抽象路径名表示的目录中的文件和目录的FiLe对象数组

public class FileDemo03 {public static void main(String[] args) throws IOException {//创建一个file对象File f1 = new File("D:\\xuexi\\myFile\\java.txt");System.out.println(f1.createNewFile());// public boolean isDirectory():测试此抽象路径名表示的FiLe是否为目录// public boolean isFile():测试此抽象路径名表示的FilLe是否为文件//public boolean exists()。测试此抽象路径名表示的FiLe是否存在System.out.println(f1.isFile());System.out.println(f1.isDirectory());System.out.println(f1.exists());System.out.println("--------");//public String getAbsoLutePath():返回此抽象路径名的绝对路径名字符串//public String getPath()。将此抽象路径名转换为路径名字符串//public string getName()。返回由此抽象路径名表示的文件或自录的名称System.out.println(f1.getAbsoluteFile());System.out.println(f1.getPath());System.out.println(f1.getName());System.out.println("--------");// System.out.println(f1.delete());//public String[] list()，返回此抽象路径名表示的目录中的文件和目录的名称字符串数组//public File[] listFiles( ),返回此抽象路径名表示的目录中的文件和目录的FiLe对象数组File f2 = new File("D:\\xuexi\\file");String[] list = f2.list();for(String s : list){System.out.println(s);}System.out.println("--------");File[] files = f2.listFiles();for(File file : files){if(file.isFile()){System.out.println(file.getName());}}}}

4

File类删除功能:

public boolean delete()。册除由此抽象路径名表示的文件或目录

删除目录时的注意事项:

如果一个目录中有内容(目录，文件)，不能直接删除。应该先删除目录中的内容，最后才能删除目录

public class FileDemo04 {public static void main(String[] args) throws IOException {//需求1：在当前模块目录下创建java.txt文件File f1 = new File("java.txt");System.out.println(f1.createNewFile());//需求2：删除当前模块目录下的java.txt文件System.out.println(f1.delete());System.out.println("---------");//需求3：在当前模块目录下创建itcast目录File f2 = new File("itcast");// System.out.println(f2.mkdir());//需求4：删除当前模块目录下的itcast目录System.out.println(f2.delete());System.out.println("---------");//需求5：在当前模块下创建一个目录itcast，然后在该目录下创建一个文件java.txtFile f3 = new File("itcast");System.out.println(f3.mkdir());File f4 = new File("itcast\\java.txt");System.out.println(f4.createNewFile());//需求6:删除当前模块下的目录itcastSystem.out.println(f3.delete());System.out.println(f4.delete());}}

二，字节流

字节输出流

1

FiLeOutputStream:文件输出流用于将数据写入file

FiLeOutputStream (String name):创建文件输出流以指定的名称写入文件

public class FileOutputStreamDemo01 {public static void main(String[] args) throws IOException {//创建字节输出流对象FileOutputStream fos = new FileOutputStream("fos.txt");//void write (int a),将指定的字节写入此文件输出流fos.write(98);//会转换为字符fos.write(57);fos.write(56);//最后都要释放资源//void close():关闭此文件输出流并释放与此流相关联的任何系统资源fos.close();}}

2

构造方法:

FiLeOutputStream (String name)，创建文件输出流以指定的名称写入文件

FiLeOutputStream (File file)创建文件输出流以写入由指定的File对象表示的文件

两个方法相同第一个更简单

写数据的三种方式;

void write (int b):将指定的字节写入此文件输出流

—次写一个字节数据

void write (byte[] b):将b.Length字节从指定的字节数组写入此文件输出流

—次写一个字节数组数据

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

—次写一个字节数组的部分数据

public class FileOutputStreamDemo02 {public static void main(String[] args) throws IOException {//FiLeOutputStream (String name)，创建文件输出流以指定的名称写入文件FileOutputStream fos = new FileOutputStream("java,txt");//void write (int b):将指定的字节写入此文件输出流/*fos.write(97);fos.write(98);fos.write(99);fos.write(100);fos.write(101);*///void write (byte[] b):将b.Length字节从指定的字节数组写入此文件输出流// byte[] bys = {97,98,99,100,101,102};//byte[] getBytes (): 返回字符串对应的字节数组byte[] bys = "abcdefg".getBytes();// fos.write(bys);//void write(byte[] b, int off, int len)：将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流fos.write(bys,1,2);//关闭资源fos.close();}}

3

字节流写数据的两个小问题:

1:字节流写数据如何实现换行呢?

写完数据后加入换行符

window :\r\n

Linux:\n

mac:\r

2:字节流写数据如何实现追加写入呢?

public FiLeOutputStream ( String name , booLean append )

创建文件输出流以指定的名称写入文件。

如具第二个参数为true ，则字节将写入文件的末尾而不是开头

public class FileOutputStreamDemo03 {public static void main(String[] args) throws IOException {//创建字节流输出对象FileOutputStream fos = new FileOutputStream("java.txt",true);//写数据for(int x = 0; x < 10; x++){fos.write("hello".getBytes());fos.write("\r\n".getBytes());}//释放资源fos.close();}}

4

字节流数据加入异常处理

public class FileOutputStreamDemo04 {public static void main(String[] args) {//加入finally来实现释放资源FileOutputStream fos = null;try {fos = new FileOutputStream("java.txt");fos.write("hello".getBytes());}catch (IOException e){e.printStackTrace();}finally {try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}

字节输入流

1

需求：

把文件java.txt中的内容读取出来在控制台输出 (一次读一个字节)

使用字节输入流读数据的步骤:

1:创建字节输人流对象

2:调用字节输入流对象的读数据方法

3:释放资源

public class FileInputStreamDemo01 {public static void main(String[] args) throws IOException {//创建字节输人流对象FileInputStream fis = new FileInputStream("java.txt");//调用字节输入流对象的读数据方法//int read():从该输入流读取一个字节的数据//第一次读取数据/* int by = fis.read();System.out.println(by);System.out.println((char)by);//第二次读取数据by = fis.read();System.out.println(by);System.out.println((char)by);//再多读取两次by = fis.read();System.out.println(by);by = fis.read();System.out.println(by);//如果到达文件末尾，输出-1*///使用循环读取文件int by ;while ((by = fis.read()) != -1){System.out.print((char) by);}//释放资源fis.close();}}

2

需求:把文件fos.txt中的内容读取出来在控制台输出(一次读一个字节数组数据)

使用字节输入流读数据的步骤;

1:创建字节输入流对象

2:调用字节输入流对象的读数据方法

3:释放资源

public class FileInputStreamDemo02 {public static void main(String[] args) throws IOException {//创建字节输入流对象FileInputStream fis = new FileInputStream("java.txt");//调用字节输入流对象的读数据方法//int read (byte[] b):从该输入流读取最多b.length个字节的数据到一个字节数组/*byte[] bys = new byte[5];//第一次读取数据int len = fis.read(bys);System.out.println(len);System.out.println(new String(bys,0,len));//第二次读取数据len = fis.read(bys);System.out.println(len);System.out.println(new String(bys,o,len));//第三次读取数据len = fis.read(bys);System.out.println(len);System.out.println(new String(bys,0,len));//多次读取数据len = fis.read(bys);System.out.println(len);len = fis.read(bys);System.out.println(len);*//*hello\r\njava\r\n第一次：hello第二次：\r\njav第三次;a\r\nav*/byte[] bys = new byte[1024];//1024及其整数倍int len;while ((len = fis.read(bys)) != -1){System.out.print(new String(bys,0,len));}//释放资源fis.close();}}

字节缓冲流

字节缓冲流;

BufferOutputStream

BufferedInputStream

构造方法:

字节缓冲输出流:BufferedOutputStream (OutputStream out)

字节缓冲输八流:BufferedInputStream (inputStream in)

public class BufferStreamDemo {public static void main(String[] args) throws IOException {//字节缓冲输出流:BufferedOutputStream (OutputStream out)/*FileOutputStream fos = new FileOutputStream("java.txt");BufferedOutputStream bis = new BufferedOutputStream(fos);*//* BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("java.txt"));//写数据bos.write("dashabi\r\n".getBytes());bos.write("das\r\n".getBytes());//释放资源bos.close();*///字节缓冲输八流:BufferedInputStream (inputStream in)BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java.txt"));/*//一次读一个int by;while ((by = bis.read()) != -1){System.out.print((char)by);}*///一次度一组byte[] bys = new byte[1024];int len;while ((len = bis.read(bys)) != -1){System.out.println(new String(bys,0,len));}//释放资源bis.close();}}

练习

/*需求:把D:\1\33.png复制到模块目录下的33.png思路:1:根据数据源创建字节输入流对象2:根据目的地创建字节输出流对象3:读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)4 :释放资源*/public class CopyPhotoTest {public static void main(String[] args) throws IOException {//1:根据数据源创建字节输入流对象FileInputStream fis = new FileInputStream("D:\\1\\33.png");//根据目的地创建字节输出流对象FileOutputStream fos = new FileOutputStream("33.png");//读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)byte[] bys = new byte[1024];//1024及其整数倍int len;while ((len = fis.read(bys)) != -1){fos.write(bys,0,len);}//释放资源fis.close();fos.close();}}

/*需求：把"11.txt"文件内容复制到"2.txt"思路:1:根据数据源创建字节输入流对象2:根据目的地创建字节输出流对象3:读写数据,复制文本艾件(一次读取一个字节，一次写入一个字节)4:释故资源*/public class CopyTxtDemo {public static void main(String[] args) throws IOException {//根据数据源创建字节输入流对象FileInputStream fis = new FileInputStream("D:\\1\\11.txt");//根据目的地创建字节输出流对象FileOutputStream fos = new FileOutputStream("D:\\1\\2.txt");//读写数据,复制文本艾件(一次读取一个字节，一次写入一个字节)int by;while ((by = fis.read()) != -1){fos.write(by);}//释放资源fis.close();fos.close();}}

/*字节缓冲流复制图片思路:1:根据数据源创建字节输入流对象2:根据目的地创建字节输出流对象3:读写数据,复制图片(一次读取一个字节数组，一次写入一个字节数组)4:释放资源四种方式实现复制视须,并记录每种方式复制视频的时间1:基本字节流一次读写—个字节2:基本字节流一次读写一个字节数组3:字节缓冲流一次读写一个字节4:字节缓冲流—次读写一个字节数组*/public class BufferStreamTest {public static void main(String[] args) throws IOException {//记录开始时间long startTime = System.currentTimeMillis();//复制视频// method1();//10171毫秒// method2();//10454毫秒//method3();//44msmethod4();//333ms//记录结束时间long endTime = System.currentTimeMillis();System.out.println("共耗时" + (endTime - startTime) + "毫秒");}//基本字节流一次读写一个字节public static void method1() throws IOException{FileInputStream fis = new FileInputStream("D:\\1\\33.png");FileOutputStream fos = new FileOutputStream("2.png");int by;while ((by = fis.read()) != -1){fos.write(by);}fis.close();fos.close();}//基本字节流一次读写—个字节数组public static void method2() throws IOException{FileInputStream fis = new FileInputStream("D:\\1\\33.png");FileOutputStream fos = new FileOutputStream("1.png");byte[] bys = new byte[1024];int len;while ((len = fis.read()) != -1){fos.write(bys,0,len);}fis.close();fos.close();}//字节缓冲流一次读写一个字节public static void method3() throws IOException{BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\1\\33.png"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("3.png"));int by;while ((by = bis.read()) != -1){bos.write(by);}bis.close();bos.close();}//字节缓冲流—次读写一个字节数组:public static void method4() throws IOException{BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\1\\33.png"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("4.png"));byte[] bys = new byte[1024];int len;while ((len = bis.read()) != -1){bos.write(bys,0,len);}bis.close();bos.close();}}

三，字符流

1

编码:

byte[ ] getBytes()﹔使用平台的默认字符集将该string编码为一系列字节，将结果存储到新的字节数组中

byte[ ] getBytes(String charsetName)。使用指定的字符集将该string编码为一系列字节，将结果存储到新的字节数组中

解码:

String(byte[ ] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的 String

String(byte[ ] bytes，String charsetName ):通过指定的字符集解码指定的字节数组来构造新的string

用什么方法编码就要用什么方法解码

public class StringDemo {public static void main(String[] args) throws UnsupportedEncodingException {//定义一个字符串String s = "中国";//编码// byte[ ] getBytes()﹔使用平台的默认字符集将该string编码为一系列字节，将结果存储到新的字节数组中byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]//byte[ ] getBytes(String charsetName)。使用指定的字符集将该―string编码为一系列字节，将结果存储到新的字节数组中// byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]// byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6]System.out.println(Arrays.toString(bys));//解码//String(byte[ ] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的 String// String ss = new String(bys);//String(byte[ ] bytes，String charsetName ):通过指定的字符集解码指定的字节数组来构造新的stringString ss = new String(bys,"GBK");System.out.println(ss);}}

2

字符输入流

构造方法:

InputStreamReader (InputStream in)。创建一个使用默认字符集的InputStreamReader

读教据的2种方式:

int read :—次读—个字符数据

int read ( char[] cbuf)。—次读一个字符数组数据

public class InputStreamReadDemo {public static void main(String[] args) throws IOException {//InputStreamReader (InputStream in)。创建一个使用默认字符集的InputStreamReaderInputStreamReader isr = new InputStreamReader(new FileInputStream("java.txt"));//int read :—次读—个字符数据/* int ch;while ((ch = isr.read()) != -1){System.out.print((char)ch);}*///int read ( char[] cbuf)。—次读一个字符数组数据char[] chs = new char[1024];int len;while ((len = isr.read(chs)) != -1){System.out.println(new String(chs,0,len));}//释放资源isr.close();}}

3

字符输出流

构造方法:

OutputStreamWriter (OutputStream out)、创建一个使用默认字符编码的outputStreamWriter

写数据的4种方式:

void write (int c):写一个字符

void write ( char[ ]cbuf)。写入一个字符数组

void write (char[ ]cbuf, int off, int len)。写入字符数组的一部分

void write (String str)。写一个字符串

void write (String str, int off , int len)。写一个字符串的一部分

public class OutputStreamWriterDemo {public static void main(String[] args) throws IOException {//OutputStreamWriter (OutputStream out)、创建一个使用默认字符编码的outputStreamWriterOutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java.txt"));/* //void write (int c):写一个字符osw.write(97);//void flush() 刷新信息osw.flush();osw.write(98);osw.close();*///void write ( char[ ]cbuf)。写入一个字符数组char[] chs = {'a','b','c','d','e'};// osw.write(chs);//void write (char[ ]cbuf, int off, int len)。写入字符数组的一部分// osw.write(chs,0,1);//void write (String str)。写一个字符串// osw.write("abcde");//void write (String str, int off , int len)。写一个字符串的一部分osw.write("abcde",1,2);//释放资源osw.close();}}

InputStreamReader是从字节流到字符减的桥梁

它读取字节,并使用指定的编码将其解码为宁符

它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

OutputStreamWriter:是从字符流到字节流的桥梁

是从字符流到字节流的桥梁,使用指定的编码将写入的字符编码为字节

它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

public class ConversionStreamDemo {public static void main(String[] args) throws IOException {//OutputStreamWriter (OutputStream out)创建一个使用默认字符绵码的outputStreamWriter。//OutputStreamWriter (OutputStream out,String charsetName)创建一个使用命名字符集的OutputStreamWriter。// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java.txt"));OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java.txt"),"GBK");osw.write("中国");osw.close();//InputStreamReader (InputStream in)创建一个使用默认字符集的InputStreamReader。//InputStreamReader (InputStream in，String charsetName)创建一个使用命名字符集的InputStreamReader。// InputStreamReader isr = new InputStreamReader(new FileInputStream("java.txt"));InputStreamReader isr = new InputStreamReader(new FileInputStream("java.txt"),"GBK");int ch;while ((ch = isr.read()) != -1){System.out.print((char)ch);}isr.close();}}

4

字符缓冲流

字符缓冲流:

BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

BufferedReader:从字符输入流读取文本，缓冲字符,以提供字符，数组和行的高效读取，可以靛缓冲区大小。或者可以使用默认大小。默认值足够大，可用于大多数用途

构造方法:

BufferedWriter(Writer out)

BufferedReader( Reader in)

public class BufferedStreamDemo01 {public static void main(String[] args) throws IOException {//BufferedWriter(Writer out)/*BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));bw.write("hello\r\n");bw.write("word\r\n");bw.close();*///BufferedReader( Reader in)BufferedReader br = new BufferedReader(new FileReader("java.txt"));//一次读一个字符/*int ch;while ((ch = br.read()) != -1){System.out.print((char)ch);}*///一次读一个字符数组char[] chs = new char[1024];int len;while ((len = br.read(chs)) != -1){System.out.println(new String(chs,0,len));}}}

字符缓冲流的特有功能

BufferedWriter:

void newLine():写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

public String readline()。读一行文字。

结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

public class BufferedStreamDemo02 {public static void main(String[] args) throws IOException {//创建字符输出流BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));;//写数据for(int x = 0; x < 10; x++){bw.write("hello" + x);bw.newLine();bw.flush();}//释放资源bw.close();//创建字符输入流BufferedReader br = new BufferedReader(new FileReader("java.txt"));//读数据String line;while ((line = br.readLine()) != null){System.out.println(line);}//释放资源br.close();}}

复制文件异常处理

public class CopyFileDemo {public static void main(String[] args) {}//jdk9private static void method4() throws IOException{FileReader fr = new FileReader("fr.txt");FileWriter fw = new FileWriter("fw.txt");try (fr;fw){char[] chs = new char[1024];int len;while ((len = fr.read()) != -1){fw.write(chs,0,len);}}catch (IOException e){e.printStackTrace();}}//jdk7private static void method3(){try(FileReader fr = new FileReader("fr.txt");FileWriter fw = new FileWriter("fw.txt");) {char[] chs = new char[1024];int len;while ((len = fr.read()) != -1){fw.write(chs,0,len);}}catch (IOException e){e.printStackTrace();}}//try...catch...finallyprivate static void method2(){FileReader fr = null;FileWriter fw = null;try {fr = new FileReader("fr.txt");fw = new FileWriter("fw.txt");char[] chs = new char[1024];int len;while ((len = fr.read()) != -1){fw.write(chs,0,len);}}catch (IOException e){e.printStackTrace();}finally {try {fr.close();} catch (IOException e) {e.printStackTrace();}try {fw.close();} catch (IOException e) {e.printStackTrace();}}}//抛出处理/*private static void method1() throws IOException{FileReader fr = new FileReader("fr.txt");FileWriter fw = new FileWriter("fw.txt");char[] chs = new char[1024];int len;while ((len = fr.read()) != -1){fw.write(chs,0,len);}fr.close();fw.close();}*/}

5 练习

1

/*需求:把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy.java思路:1 :根据数据源创建字符输入流对象2:根据目的地创建字符输出流对象3:读写数据,复制文件4:释放资源*/public class CopyJavaDemo01 {public static void main(String[] args) throws IOException {//根据数据源创建字符输入流对象InputStreamReader isr = new InputStreamReader(new FileInputStream("ConversionStreamDemo.java"));//根据目的地创建字符输出流对象OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("Copy.java"));//读写数据,复制文件//一次读写一个字符数据/* int ch;while ((ch = isr.read()) != -1){osw.write(ch);}*///一次读写一个字符组数据char[] chs = new char[1024];int len;while ((len = isr.read(chs)) != -1){osw.write(chs,0,len);}//释放资源isr.close();osw.close();}}

2

/*需求:把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy .java数据源和目的地的分析:数据源:myCharStream\lConversionStream0emo.java ---读数据---Reader --- InputStreamReader --- FileReader目的地:myCharStream]l Copy.java --.写数据--- Writer --- OutputStreamWriter .-- FiLeWriter思路:1:根据数据源创建字符输入流对象2:根据目的地创建字符输出流对象3:读写数据,复制文件4:释放资源*/public class CopyJavaDemo02 {public static void main(String[] args) throws IOException {//根据数据源创建字符输入流对象FileReader fr = new FileReader("ConversionStreamDemo.java");//根据目的地创建字符输出流对象FileWriter fw = new FileWriter("Copy.java");//读写数据,复制文件//一次读写一个字符数据/* int ch;while ((ch = fr.read()) != -1){fw.write(ch);}*///一次读写一个字符组数据char[] chs = new char[1024];int len;while ((len = fr.read(chs)) != -1){fw.write(chs,0,len);}//释放资源fr.close();fw.close();}}

3

/*需求：把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy .java思路:1:根据数据源创建字符缓冲输入流对象2:根据目的地创建字符缓冲输出流对象3:读写数据。复制文件4:释放资源*/public class CopyJavaDemo01 {public static void main(String[] args) throws IOException {//根据数据源创建字符缓冲输入流对象BufferedReader br = new BufferedReader(new FileReader("ConversionStreamDemo.java"));//根据目的地创建字符缓冲输出流对象BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));//读写数据,复制文件//一次读写一个字符数据/* int ch;while ((ch = br.read()) != -1){fw.write(ch);}*///一次读写一个字符组数据char[] chs = new char[1024];int len;while ((len = br.read(chs)) != -1){bw.write(chs,0,len);}//释放资源br.close();bw.close();}}

4

/*需求:把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy .java思路:1:根据数据源创建字符缓冲输入流对象2:根据目的地创建字符缓冲输出流对象3:读写数据,复制文件使用字符缓冲流特有功能实现4:释放资源*/public class CopyJavaDemo02 {public static void main(String[] args) throws IOException {//创建字符输入流BufferedReader br = new BufferedReader(new FileReader("ConversionStreamDemo.java"));//创建字符输出流BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));;//读数据String line;while ((line = br.readLine()) != null){bw.write(line);//写换行符bw.newLine();//刷新bw.flush();}//释放资源br.close();bw.close();}}

5

/*需求:把ArrayList集合中的字符串数据写入到文本文件。要求，每一个字符串元素作为文件中的一行数据思路:1:创建ArrayList集合2:往集合中存储字符串元素3:创建字符缓冲输出流对象4:遍历集合,得到每一个字符串数据5:调用字符缓冲输出流对象的方法写数据6:释放资源*/public class ArrayListToTxtDemo {public static void main(String[] args) throws IOException {//创建ArrayList集合ArrayList<String> list = new ArrayList<String>();//往集合中存储字符串元素list.add("hello");list.add("java");list.add("word");//创建字符缓冲输出流对象BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));//遍历集合,得到每一个字符串数据for(String s :list){//调用字符缓冲输出流对象的方法写数据bw.write(s);bw.newLine();bw.flush();}//释放资源bw.close();}}

6

/*需求:我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随点名器思路:1:创建字符缓冲输入流对象2:创建ArrayList集合对象3:调用字符缓冲输入流对象的方法读数据4:把读取到的字符串数据存储到集合中5 :释放资源6:使用Random产生一个随机数，随机数的范围在:[e,集合的长度)7:把第6步产生的随机数作为索引到ArrayList集合中获取值8:把第7线得到的数据输出在控制台*/测试类public class CallNameDemo {private static Object Random;public static void main(String[] args) throws IOException {//创建字符缓冲输入流对象BufferedReader br = new BufferedReader(new FileReader("java.txt"));//创建ArrayList集合对象ArrayList<String> list = new ArrayList<String>();//调用字符缓冲输入流对象的方法读数据String line;while ((line = br.readLine()) != null){//把读取到的字符串数据存储到集合中list.add(line);}//释放资源br.close();//使用Random产生一个随机数，随机数的范围在:[e,集合的长度)使用Random产生一个随机数，随机数的范围在:[e,集合的长度)Random r =new Random();int x = r.nextInt(list.size());//把第6步产生的随机数作为索引到ArrayList集合中获取值String name = list.get(x);//把第7线得到的数据输出在控制台System.out.println("被点名得是" + name);}}TXT文件张三李四王五韩梅梅

7

/*需求:把文本文件中的数据读取到集合中，并逾历集合。要求。文件中每一行数据是一个集合元素思路:1:创建字符缓冲输人流对象2:创建ArrayList集合对象3:调用字符缓冲输入流对象的方法读数据4:把读取到的字符串数据存储到集合中5 :释放资源6:遍历集合*/public class TxtToArrayListDemo {public static void main(String[] args) throws IOException {//创建字符缓冲输人流对象BufferedReader br = new BufferedReader(new FileReader("java.txt"));//创建ArrayList集合对象ArrayList<String> list = new ArrayList<String>();//调用字符缓冲输入流对象的方法读数据String line;while ((line = br.readLine()) != null){//把读取到的字符串数据存储到集合中list.add(line);}//释放资源br.close();//遍历集合for(String s : list){System.out.println(s);}}}

8

/*需求:把ArrayList集合中的学生数据写入到文本文件。要求，每一个学生对象的数据作为文件中的一行数据格式:学号,姓名,年龄,居住地举例;itheimae81,林青霞, 30,西安思路:1 :定义学生类2:创建ArrayList集合3:创建学生对象4:把学生对象添加到集合中5:创建字符缓冲输出流对家6:遍历集合,得到每一个学生对象7:把学生对象的数据拼接成指定格式的字符串8:调用字符缓冲输出流对象的方法写数据9:释放资源*/Student类public class Student {private String number;private String name;private int age;private String address;public Student() {}public void setNumber(String number) {this.number = number;}public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}public void setAddress(String address) {this.address = address;}public String getNumber() {return number;}public String getName() {return name;}public int getAge() {return age;}public String getAddress() {return address;}public Student(String number, String name, int age, String address) {this.number = number;this.name = name;this.age = age;this.address = address;}}测试类public class ArrayListFileDemo {public static void main(String[] args) throws IOException {//创建ArrayList集合ArrayList<Student> list = new ArrayList<Student>();//创建学生对象Student s1 = new Student("001","张三",21,"湖南");Student s2 = new Student("002","李四",43,"四川");Student s3 = new Student("003","王五",21,"山东");Student s4 = new Student("004","韩梅梅",21,"广西");//把学生对象添加到集合中list.add(s1);list.add(s2);list.add(s3);list.add(s4);//创建字符缓冲输出流对家BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));//遍历集合,得到每一个学生对象for(Student ss : list){//把学生对象的数据拼接成指定格式的字符串// String s = ss.getNumber() + "," + ss.getName() + "," + ss.getAge() + "," + ss.getAddress();// bw.write(s);StringBuilder sb = new StringBuilder();sb.append(ss.getNumber() + "," + ss.getName() + "," + ss.getAge() + "," + ss.getAddress());//调用字符缓冲输出流对象的方法写数据bw.write(sb.toString());bw.newLine();bw.flush();}//释放资源bw.close();}}

9

/*需求:把文本文件中的数据读取到集合中，并遍历集合。要求，文件中每一行数据是一个学生对象的成员变量值举例:itheima0B1i,林青霞,30,西安思路:1:定义学生类2:创建字符缓冲输入流对象3:创建ArrayList集合对家4:调用字符缓冲输入流对象的方法读数据5:把读取到的字符串数据用split()进行分割，得到一个字符串数组6:创建学生对象7:把宁符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值8:把学生对象添加到集合9:释放资源10:遍历集合*/测试类public class FileToArrayListDemo {public static void main(String[] args) throws IOException {//创建字符缓冲输入流对象BufferedReader br = new BufferedReader(new FileReader("Student.txt"));//创建ArrayList集合对家ArrayList<Student> list = new ArrayList<Student>();//调用字符缓冲输入流对象的方法读数据String line;while ((line = br.readLine()) != null){//把读取到的字符串数据用split()进行分割，得到一个字符串数组String[] array = line.split(",");//创建学生对象Student s = new Student();//把宁符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值s.setNumber(array[0]);s.setName(array[1]);s.setAge(Integer.parseInt(array[2]));s.setAddress(array[3]);//把学生对象添加到集合list.add(s);}//释放资源br.close();//遍历集合for(Student lists : list){System.out.println(lists.getNumber() + "," + lists.getName() + "," + lists.getAge() + "," + lists.getAddress());}}}Student类package com.ithema_06;public class Student {private String number;private String name;private int age;private String address;public Student() {}public void setNumber(String number) {this.number = number;}public void setName(String name) {this.name = name;}public void setAge(int age) {this.age = age;}public void setAddress(String address) {this.address = address;}public String getNumber() {return number;}public String getName() {return name;}public int getAge() {return age;}public String getAddress() {return address;}public Student(String number, String name, int age, String address) {this.number = number;this.name = name;this.age = age;this.address = address;}}Student文件

10

/*需求:键盘录入5个学生信息.(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件格式:姓名,语文成绩,数学成绩,英语成绩举例，林青霞,98, 99,100思路:1:定义学生类2:创建TreeSet集合,通过比较器排序进行排序3:键盘录入学生数据4:创建学生对象．把键盘录入的数据对应赋值给学生对象的成员变量5:把学生对象添加到TreeSet集合6:创建字符缓冲输出流对象7:遍历集合，得到每一个学生对象8:把学生对象的数据拼接成指定格式的字符串9:调用字符缓冲输出流对象的方法写数据10:释放资源*/public class TreeSetToFileDemo {public static void main(String[] args) throws IOException {//创建TreeSet集合,通过比较器排序进行排序TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s2.getScore() - s1.getScore();int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;return num4;}});//键盘录入学生数据for(int x = 0; x < 5; x++) {Scanner sc = new Scanner(System.in);System.out.println("请输入第" + (x+1) + "个学生信息");System.out.println("姓名：");String name = sc.nextLine();System.out.println("语文成绩：");int chinese = sc.nextInt();System.out.println("数学成绩：");int math = sc.nextInt();System.out.println("英语成绩：");int english = sc.nextInt();//创建学生对象．把键盘录入的数据对应赋值给学生对象的成员变量Student s = new Student();s.setName(name);s.setChinese(chinese);s.setMath(math);s.setEnglish(english);//把学生对象添加到TreeSet集合ts.add(s);}//创建字符缓冲输出流对象BufferedWriter bw = new BufferedWriter(new FileWriter("student1.txt"));//遍历集合，得到每一个学生对象for(Student list : ts){//把学生对象的数据拼接成指定格式的字符串StringBuilder sb = new StringBuilder();sb.append(list.getName()).append(",").append(list.getChinese()).append(",").append(list.getMath()).append(",").append(list.getEnglish()).append(",").append(list.getScore());//调用字符缓冲输出流对象的方法写数据bw.write(sb.toString());bw.newLine();bw.flush();}//释放资源bw.close();}}Student类package com.ithema_07;public class Student {private String name;private int chinese;private int math;private int english;private int score;public Student() {}public Student(int score) {this.score = score;}public Student(String name, int chinese, int math, int english) {this.name = name;this.chinese = chinese;this.math = math;this.english = english;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getChinese() {return chinese;}public void setChinese(int chinese) {this.chinese = chinese;}public int getMath() {return math;}public void setMath(int math) {this.math = math;}public int getEnglish() {return english;}public void setEnglish(int english) {this.english = english;}public void setScore(int score) {this.score = score;}public int getScore(){return this.chinese + this.math + this.english;}}

11

/*需求:把"E: l1itcast”复制到d盘目录下思路:1:创建数据源FiLe对象，路径是E: llitcast2:创建目的地FiLe对象，路径是F:!3:写方法实现文件夹的复制,参数为数据源FiLe对象和目的地FiLe对象4:判断数据源FiLe是否是自录是:A:在目的地下创建和数据源File名称一样的目录B:获取数据源File下所有文件或者自录的FiLe数组C:遍历该File数组，得到每一个File对象D:把该File作为数据源File对象,递归调用复制文件夹的方法不是:说明是文件，直接复制,用字节流工*/public class CopyFlodersDemo {public static void main(String[] args) throws IOException{//创建数据源FiLe对象File srcFile = new File("D:\\1");//创建目的地FiLe对象File destFile = new File("D:\\xuexi");//写方法实现文件夹的复制,参数为数据源FiLe对象和目的地FiLe对象copyFolders(srcFile,destFile);}//复制文件夹private static void copyFolders(File srcFile, File destFile) throws IOException{//判断数据源FiLe是否是 目录if(srcFile.isDirectory()){//在目的地下创建和数据源File名称一样的目录String srcFileName = srcFile.getName();File newFolder = new File(destFile,srcFileName);//复制首目录if(!newFolder.exists()){newFolder.mkdir();}//取数据源File下所有文件或者自录的FiLe数组File[] array = srcFile.listFiles();//遍历该File数组，得到每一个File对象for(File file : array){//把该File作为数据源File对象,递归调用复制文件夹的方法copyFolders(file,newFolder);}}else {//不是:说明是文件，直接复制,用字节流File newFile = new File(destFile,srcFile.getName());copyFile(srcFile,newFile);}}//字节缓冲流复制文件private static void copyFile(File srcFile, File destFile) throws IOException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));byte[] chs = new byte[1024];int len;while ((len = bis.read()) != -1) {bos.write(chs, 0, len);}bos.close();bis.close();}}

12

/*需求。把E:\\itcast这个文件夹复制到模块目录下思路,1:创建数据源目录FiLe对象,路径是E:\\itcast2:获取数据源目录File对象的名称(itcast)3:创建目的地目录FiLe对象，路径名是模块名+itcast组成(myCharStream \\itcast)4:判断目的地目录对应的File是否存在，如果不存在，就创建5 :获取数据源目录下所有文件的File故组6:遍历FiLe数组，得到每一个File对象，该FiLe对象，其实就是数据源文件数据源文件:E:\\itcast\\mn . jpg7:获取数据源文件FiLe对象的名称( mn.jpg)8 :创建目的地文件FiLe对象，路径名是目的地目录+mn.jpg组成(myCharStream\\itcast \\mrn.jpg)9:复制文件由于文件不仅仅是文本文件，还有图片，视频等文件，所以采用字节流复制文件*/public class CopyFolderDemo {public static void main(String[] args) throws IOException {//创建数据源目录FiLe对象,路径是File srcFolder = new File("D:\\1");//获取数据源目录File对象的名称String srcFolderName = srcFolder.getName();//创建目的地目录FiLe对象，File destFolder = new File(srcFolderName);//判断目的地目录对应的File是否存在，如果不存在，就创建if (!destFolder.isDirectory()) {destFolder.mkdir();}//获取数据源目录下所有文件的File数组File[] listFiles = srcFolder.listFiles();//遍历FiLe数组，得到每一个File对象，该FiLe对象，其实就是数据源文件for (File srcFile : listFiles) {//获取数据源文件FiLe对象的名称String srcFilesName = srcFile.getName();//创建目的地文件FiLe对象File destFile = new File(destFolder, srcFilesName);//复制文件copyFile(srcFile, destFile);}}private static void copyFile(File srcFile, File destFile) throws IOException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));byte[] chs = new byte[1024];int len;while ((len = bis.read()) != -1) {bos.write(chs, 0, len);}bos.close();bis.close();}}

四，标准流

1标谁输入流

public static final InputStream in:标谁输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源

public class SystemInDemo {public static void main(String[] args) throws IOException {//public static final InputStream in:标谁输入流。/* InputStream is = System.in;int by;while ((by = is.read()) != -1){System.out.println((char)by);}*///将字节流转换为字符流，并且能够一次读取一行数据BufferedReader br = new BufferedReader(new InputStreamReader(System.in));System.out.println("请输入一个字符串：");String line = br.readLine();System.out.println("你输入的字符串是：" + line);System.out.println("请输入一个整数：");int i = Integer.parseInt(br.readLine());System.out.println("你输入的整数是：" + i);}}

2标准输出流

public static final PrintStream out。标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

public class SystemOutDemo {public static void main(String[] args) {//public static final PrintStream out。标准输出流PrintStream ps = System.out;//能够方便打印各种数据/* ps.print(10);ps.print("hello");ps.println(23);ps.println("word");*///System.out本质是一个字节输出流System.out.println("hello");//print()必须要有参数System.out.print(2);}}

3打印流的特点:

只负责输出数据,不负责读取数据

有自己的特有方法

字节打印流

PrintStream (String fileName):使用指定的文件名创建新的打印流

public class PrintStreamDemo {public static void main(String[] args) throws IOException {//PrintStream (String fileName):使用指定的文件名创建新的打印流PrintStream ps = new PrintStream("ps.txt");//写数据//字节输出流有的方法// ps.write(98);//会转码//自己特有的方法,不会转码原样输出ps.println(98);ps.println(99);}}

字符打印流的构造方法:

PrintWriter (String fileName):使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新

PrintWriter (Writer out，boolean autoFlush)。创建一个新的PrintWriter

out:字符输出流

autoFlush:一个布尔值，如果为真，则println , printf ，或format方法将刷新输出缓冲区

public class PrintWriterDemo {public static void main(String[] args) throws IOException {//PrintWriter (String fileName):使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新/*PrintWriter pw = new PrintWriter("pw.txt");// pw.write("hello");//换行要加\r\npw.println("hello");pw.flush();pw.println("word");pw.flush();*/// PrintWriter (Writer out，boolean autoFlush)。创建一个新的PrintWriterPrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true);pw.println("java");pw.println("dad");}}

五，对象序列化流

1

输入流

构造方法:

ObjectInputStream (InputStream in):创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法:

Object readObject ():从ObjectInputStream读取一个对象

public class ObjectInputStreamDemo {public static void main(String[] args) throws IOException, ClassNotFoundException {// ObjectInputStream (InputStream in):创建从指定的InputStream读取的ObjectInputStreamObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));//Object readObject ():从ObjectInputStream读取一个对象Object obj = ois.readObject();Student s = (Student) obj;System.out.println(s.getName() + "," + s.getAge() );ois.close();}}Student类public class Student implements Serializable {private static final long serialVersionUID = 42L;private String name;private transient int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}*/}

2

输出流

构造方法:

ObjectOutputStream (OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream

序列化对象的方法:

void writeObject (Object obj):将指定的对象写入ObjectOutputStream

NotSerializableException:抛出一个实例需要一个serializable接口。序列化运行时或实例的类可能会抛出此异常

类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化

public class ObjectOutputStreamDemo {public static void main(String[] args) throws IOException {// ObjectOutputStream (OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStreamObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));//创建对象Student s = new Student("张三",83);//void writeObject (Object obj):将指定的对象写入ObjectOutputStreamoos.writeObject(s);//释放资源oos.close();}}

用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢?

java.io.InvalidCLassException :

当序列化运行时检初到类中的以下问题之一时抛出。

类的串行版本与从流中读取的类描述符的英型不匹配

该类包含未知的数据类型

该类没有可访问的无参数构造函数

com.itheima_03.Student; Local class incompatible:

stream classdesc serialVersionUID = -3743788623620386195,

local class serialVersionUID = -247282590948988173

如果出间题了，如何解决呢?

显示声明，给对象所底的类加一个值: private static final long serialVersionUID = 42L;

如果—个对象中的某个成员变量的值不想被序列化,又该如何实现呢?

把成员变量用transient修饰

private transient int age;

测试类public class ObjectStreamDemo {public static void main(String[] args) throws IOException, ClassNotFoundException {// write();read();}//反序列化public static void read() throws IOException, ClassNotFoundException {// ObjectInputStream (InputStream in):创建从指定的InputStream读取的ObjectInputStreamObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));//Object readObject ():从ObjectInputStream读取一个对象Object obj = ois.readObject();Student s = (Student) obj;System.out.println(s.getName() + "," + s.getAge());ois.close();}//序列化public static void write() throws IOException {// ObjectOutputStream (OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStreamObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));//创建对象Student s = new Student("张三", 83);//void writeObject (Object obj):将指定的对象写入ObjectOutputStreamoos.writeObject(s);//释放资源oos.close();}}Student类public class Student implements Serializable {private static final long serialVersionUID = 42L;private String name;private transient int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}*/}

3

Properties函数

作为Map集合的使用

public class PropertiesDemo01 {public static void main(String[] args) {//创建集合对象Properties prop = new Properties();//存储元素prop.put("001","张三");prop.put("002","王五");//遍历集合Set<Object> keySet = prop.keySet();for(Object key : keySet){Object value = prop.get(key);System.out.println(key + "," + value);}}}

Properties作为集合的特有方法:

Object setProperty(String key,String value)：设该集合的键和值，都是string类型，底层调用Hashtable方法put

String getProperty(String key):使用此属性列表中指定的键搜索属性

Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中链及其对应的值是字符串

public class PropertiesDemo02 {public static void main(String[] args) {//创建集合对象Properties prop = new Properties();// Object setProperty(String key,String value)：设百集合的键和值，都是string类型，底层调用Hashtable方法putprop.setProperty("001","张三");prop.setProperty("002","李四");prop.setProperty("003","王五");//String getProperty(String key):使用此属性列表中指定的键搜索属性/*System.out.println(prop.getProperty("001"));System.out.println(prop.getProperty("0001"));System.out.println(prop);*///Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中链及其对应的值是字符串Set<String> names = prop.stringPropertyNames();for(String key : names){Object value = prop.get(key);System.out.println(key + "," + value);}}}

Properties和IO流结合的方法:

void Load(Reader reader):

从输入字符流读取压性列表(键和元素对)

void store( Writer writer, String comments):

将此属性列表（键和元素对)写入此Properties表中，以适合使用Load(Reader)方法的格式写入输出字符流

public class PropertiesDemo03 {public static void main(String[] args) throws IOException{//把集合中的数据保存到文件//myStore();//把文件中的数据加载到集合myLoad();}private static void myLoad() throws IOException{Properties prop = new Properties();FileReader fr = new FileReader("fw.txt");prop.load(fr);fr.close();System.out.println(prop);}private static void myStore() throws IOException {Properties prop = new Properties();prop.setProperty("001","张三");prop.setProperty("002","王五");prop.setProperty("003","李四");FileWriter fw = new FileWriter("fw.txt");prop.store(fw,null);fw.close();}}

4

练习

/*需求:请写程序实现猜数字小游戏只能试玩3次，如果还想玩，提示。游戏试玩已结束，想玩请充值(mw .)思路:1:写一个游戏类,里面有—个猜数字的小游戏2:写一个测试类,测试类中有main方法，main()方法中按照下面步骤完成A:从文件中读取数据到Properties集合,用Load()方法实现文件已经存在:game.txt里面有一个数据值:count=0B:通过Properties集合获取到玩游戏的次数c:判断次数是否到3如果到了，给出提示:游戏试玩已结束,想玩请充值()如果不到3次。玩游戏次数+1。重新写回文件,用Properties的store()方法实现*/测试类public class PropertiesTest {public static void main(String[] args) throws IOException {//从文件中读取数据到Properties集合,用Load()方法实现Properties prop = new Properties();FileReader fr = new FileReader("game.txt");prop.load(fr);fr.close();//通过Properties集合获取到玩游戏的次数String count = prop.getProperty("count");int x = Integer.parseInt(count);//判断次数是否到3if(x >= 3){System.out.println("游戏试玩已结束,想玩请充值()");}else {//如果不到3次:玩游戏 次数+1。重新写回文件,用Properties的store()方法实现GuessNumber.start();x++;prop.setProperty("count",String.valueOf(x));FileWriter fw = new FileWriter("game.txt");prop.store(fw,null);fw.close();}}}游戏类public class GuessNumber {private GuessNumber() {}public static void start() {Random r = new Random();int number = r.nextInt(100) + 1;while (true) {Scanner sc = new Scanner(System.in);System.out.println("请输入你猜的数字：");int i = sc.nextInt();if (number > i) {System.out.println("你猜的数字" + i + "小了");}else if (number < i){System.out.println("你猜的数字" + i + "大了");}else {System.out.println("你猜对了");break;}}}}