I/O流

​ 数据结构 集合存储数据 存储到内存中

​ 持久化存储 IO流 Excel 数据库 云

1.I/O流分类：

输出/输入：输入流 输出流 字符/字节：字符流 字节流

2.字节流：

​ 计算机中一切数据都是字节 因为计算机中所有的文件都是二进制保存的 1个字节=8个二进制位

3.字节流中常用的API:

​ 1.字节流是 java.io.outputStream包中的

​ 2.outputStream是一个抽象类表示输出字节流的所有类的超类

​ 3.定义的方法：

- public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。 - public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。 - public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。 - public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。 - public abstract void write(int b) ：将指定的字节输出流。

4.FileOutputStream类

​ 1.FileOutputStream 文件输出流类

​ 2.public class FileOutputStream extends OutputStream

​ 案例：

```

package IODemo;

import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;

public class IOTest {

/** * 把字符a写入到 MyPro中 a.txt里面 * @param args * @throws IOException */ public static void main01(String[] args) throws IOException { FileOutputStream fos=new FileOutputStream("MyPro\\a.txt"); //有创建文件夹的功能 如果没有a.txt 会创建a.txt //1.创建文件输出流对象 fos.write(100); //2.写入 97 fos.write(97); fos.write(49); fos.write(48); fos.write(48); fos.close(); //3.关闭流 释放资源 }

} ```

案例2：

```

package IODemo;

import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Arrays; public class IOTest { /** * 用数组一次性写入多个 * @param args * @throws IOException */ public static void main02(String[] args) throws IOException { FileOutputStream fos=new FileOutputStream(“MyPro\a.txt”);

byte [] arr={65,66,67,68,69,70};//ABCDEF fos.write(arr); //字节数组 byte [] arr1={-65,-66,-67,-68,-69,-70}; //fos.write(arr1); //fos.write(arr,2,3);//off偏移位置 len 长度 CDE byte [] arr2="小丽".getBytes(); fos.write(arr2); System.out.println(Arrays.toString(arr2)); //[-27, -68, -96, -28, -72, -119] fos.close(); }

} ```

5.续写

```

package IODemo; import java.io.FileNotFoundException; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class IOTest { public static void main(String[] args) throws IOException { FileOutputStream fos=new FileOutputStream(“MyPro\a.txt”); for (int i = 0; i < 10; i++) { fos.write(“欢迎你”.getBytes()); } fos.close(); }

}

```

6.追加

package IODemo; import java.io.FileNotFoundException; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class IOTest { public static void main(String[] args) throws IOException { FileOutputStream fos=new FileOutputStream("MyPro\\a.txt",true); //构造函数中第二个参数 就是打开 追加 append for (int i = 0; i < 10; i++) { fos.write("欢迎你".getBytes()); fos.write("\r\n".getBytes()); //\r\n表示换行 //Windows \r\n //Linux /n //Mac /r } fos.close(); } }

7.字节输入流

​ 1.FileInputStream 字节输入流

​ 2.定义了所有共性的方法：

int read()从输入流中读取数据的下一个字节。 int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。 void close() 关闭此输入流并释放与该流关联的所有系统资源。

​ 案例1：

```

package IODemo;

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class IOTest1 { public static void main01(String[] args) throws IOException { FileInputStream fis=new FileInputStream(“MyPro\a.txt”); //1创建输入流对象

int len= fis.read();// a 97 读取第一个字节 System.out.println(len); len=fis.read(); //b 98读取的第二个字节 System.out.println(len); len=fis.read(); // 读取第三次-1 表示读完了 System.out.println(len); } fis.close(); }

结果： 97 98 -1 ```

案例2使用循环输出：

```

package IODemo;

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class IOTest1 { public static void main01(String[] args) throws IOException { FileInputStream fis=new FileInputStream(“MyPro\a.txt”);

//重复的事情用循环 (len=fis.read())!=-1 复制加判断 int len=0; while ((len=fis.read())!=-1) { System.out.println(len); } fis.close(); } 结果： 97 98 -1 ```

3.读取到数组：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.Arrays; public class IOTest1 { public static void main(String[] args) throws IOException { byte [] byteArr=new byte[7];//创建长度为2的字节数组 int len=fis.read(byteArr);//读取内容存储到数组中 System.out.println(Arrays.toString(byteArr)); //如果想打印数组对的a和b System.out.println(new String(byteArr)); //new String(byteArr) 创建字符串 用字节数组创建字符串 System.out.println(len);//2 fis.close(); } } 运行结果： [97,98,99,100,101,102,103] abcdefg 7

4.重复读：

```

package IODemo;

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.Arrays; public class IOTest1 { public static void main(String[] args) throws IOException { byte [] byteArr=new byte[2];//创建长度为2的字节数组 int len=fis.read(byteArr); System.out.println(Arrays.toString(byteArr)); len=fis.read(byteArr); System.out.println(Arrays.toString(byteArr));

fis.close(); }

} 运行结果： [97,98] [99,100] ```

5.循环去读

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.Arrays; public class IOTest1 { public static void main(String[] args) throws IOException { byte [] byteArr=new byte[2];//创建长度为2的字节数组 int len=0; while ((len=fis.read(byteArr1))!=-1) { System.out.println(new String(byteArr1)); } fis.close(); } } 运行结果： ab cd ef gf

案例的升级：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.util.Arrays; public class IOTest1 { public static void main(String[] args) throws IOException { byte [] byteArr=new byte[3];//创建长度为2的字节数组 int len=0; while ((len=fis.read(byteArr1))!=-1) { System.out.println(len)； // if (len<byteArr1.length) { //System.out.println(new String(byteArr1,0,len)); //} //System.out.println(new String(byteArr1)); System.out.println(new String(byteArr1,0,len)); new String(byteArr1,0,len) } fis.close(); } } 运行结果： 3 abc 3 def 1 g

6.练习 复制 文本数据 a.txt 复制到 b.txt

​ FileOutStream write

​ FileinputStream read

```

一个一个读一个一写 package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class IOTest3 { //复制图片 public static void main(String[] args) throws IOException { FileInputStream fis=new FileInputStream(“MyPro\1.png”); FileOutputStream fos=new FileOutputStream(“MyPro\123\2.png”); //读 int len=0; while ((len=fis.read())!=-1) { fos.write(len); } fos.close(); fis.close();

} } ```

案例2测试复制话费的时间：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;import javax.sound.sampled.LineListener; public class IOTest3 { //复制图片 public static void main(String[] args) throws IOException { long start=System.currentTimeMillis(); FileInputStream fis=new FileInputStream("MyPro\\1.png"); FileOutputStream fos=new FileOutputStream("MyPro\\123\\2.png"); //读 int len=0; while ((len=fis.read())!=-1) { fos.write(len); } //写 fos.close(); fis.close(); long end=System.currentTimeMillis();//4毫秒 System.out.println(end-start);//1389毫秒 1秒多 } }

案例3复制换成数组：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;import javax.sound.sampled.LineListener; public class IOTest3 { //复制图片 public static void main(String[] args) throws IOException { long start=System.currentTimeMillis(); FileInputStream fis=new FileInputStream("MyPro\\1.png"); FileOutputStream fos=new FileOutputStream("MyPro\\123\\2.png"); int len=0; byte [] bytes=new byte[1024]; while ((len=fis.read(bytes))!=-1) { fos.write(bytes,0,len); } fos.close(); fis.close(); long end=System.currentTimeMillis(); System.out.println(end-start);//4毫秒 } }

8.字符流

write reader

​

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; public class IOTest4 { //字节流存在的问题 //1中文字符字符 //GBK 占用两个字节 //UTF-8 占三个字节 你 public static void main01(String[] args) throws IOException { FileInputStream fis=new FileInputStream("MyPro\\a.txt"); int len=0; while ((len=fis.read())!=-1) { System.out.println((char)len); } fis.close(); } } 结果： æ O ǎ ¼

注：一个汉字占两个或者三个字节一个字节一个字节的去读就会出现错误

2.字符流：可以读取一个字符

3.Java.Io.Reader 字符输入流

4.是字符输入流的最顶层的父亲 定义了一些成员方法 是一个抽象类

5.共性的成员方法：

int read() 读取单个字符并返回。 int read(char[] cbuf)一次读取多个字符,将字符读入数组。 void close() 关闭该流并释放与之关联的所有资源。

6.java.IO.FileReader extends Reader

案例：

```

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class IOTest4 { public static void main(String[] args) throws IOException { FileInputStream fr=new FileInputStream(“MyPro\a.txt”); int len= fr.read(); System.out.println((char)len);//字符类型 len= fr.read(); System.out.println((char)len);//字符类型 len= fr.read(); System.out.println((char)len);//字符类型 int len= fr.read(); System.out.println((char)len);//字符类型 len= fr.read(); System.out.println((char)len);//字符类型 len= fr.read(); System.out.println((char)len);//字符类型 int len= fr.read(); System.out.println((char)len);//字符类型 len= fr.read(); System.out.println((char)len);//字符类型 len= fr.read(); System.out.println((char)len);//字符类型 int len= fr.read(); System.out.println(len);//字符类型

} } 结果： 你 好 你 好 周 杰 伦 -1

```

案例3：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.nio.charset.spi.CharsetProvider; /** * 字符流:可以读取一个字符 * * Java.Io.Reader 字符输入流 * 是字符输入流的最顶层的父亲 定义了一些成员方法 是一个抽象类 * 共性的成员方法: int read() 读取单个字符并返回。 int read(char[] cbuf)一次读取多个字符,将字符读入数组。 void close() 关闭该流并释放与之关联的所有资源。 Java.IO.FileReader extends Reader * * Writer reader * * @author XuYang * */ public class IOTest4 { public static void main(String[] args) throws IOException { FileReader fr=new FileReader("MyPro\\a.txt"); //while循环 int len=0; while ((len=fr.read())!=-1) { System.out.println((char)len); } fr.close(); } }

案例用字符数组来读：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.nio.charset.spi.CharsetProvider; public class IOTest4 { public static void main(String[] args) throws IOException { FileReader fr=new FileReader("MyPro\\a.txt"); char [] arr=new char[1024];//存储字符的数组 int len=0; while ((len=fr.read(arr))!=-1) { System.out.println(new String(arr,0,len)); } fr.close(); } }

7.字符输出流

1.java.IO.writer

2.字符输出流 是所有字符输出流最顶层的父亲 是一个抽象类

共性的成员方法:

void write(int c) 写入单个字符。 void write(char[] cbuf)写入字符数组。 abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。 void write(String str)写入字符串。 void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。 void flush()刷新该流的缓冲。 void close() 关闭此流，但要先刷新它。

案例：

```

package IODemo;

import java.io.FileWriter; import java.io.IOException;

public class IOTest5 {

public static void main01(String[] args) throws IOException { FileWriter fw=new FileWriter("MyPro\\a.txt"); fw.write(97); //写字符数组 char [] arr={'你','我'}; fw.write(arr); //fw.flush();。//把缓冲区数据刷新到文件 fw.write("你好好我不好",0,3); fw.close();//close之前 会先把缓冲区的数据刷新到文件 } /** * 字符流的续写和换行 * @param args * @throws IOException */ public static void main(String[] args) throws IOException { FileWriter fw=new FileWriter("MyPro\\a.txt",true); for (int i = 0; i < 10; i++) { fw.write("HelloWorld"+"\r\n"); } fw.close(); }

}

```

9.I/O流中异常的实现

1.异常的语法：

IO中异常

try{

可能会产生异常的代码

}

Catch(异常类变量 变量名)

{

异常处理逻辑

}

finally{

一定会指定的代码

释放资源

}

案例：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; import java.util.Set; public class IOTest6 { public static void main01(String[] args) { FileWriter fw=null; try { fw = new FileWriter("MyPro\\a.txt",true); for (int i = 0; i < 10; i++) { fw.write("HelloWorld"+"\r\n"); } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { if (fw!=null) { try { fw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } JDK 7新特性 格式:

​ try(定义流对象;定义流对象;) {

可能会产生异常的代码

}

Catch(异常类变量 变量名)

{

异常处理逻辑

}

在try的后面增加一个() 在括号中定义了流对象

那么这个流对象 作用域就是try中有效

try中的代码执行完毕 会自动释放流对象 不用写finally

案例：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; import java.util.Set; public class IOTest6 { public static void main01(String[] args) { try(FileInputStream fis=new FileInputStream("MyPro\\a.txt");FileOutputStream fos=new FileOutputStream("MyPro\\a.txt")){ fis.read(); }catch (Exception e) { // TODO: handle exception e.printStackTrace(); } } }

10.Properties集合

1.Java.util.properties 集合 extends Hashtable implements Map<K,V>

2.该集合是唯一一个和IO流结合的集合

3.1可以使用集合中store方法 把集合中的临时数据 持久化存储到因硬盘中

2.可以使用集合中load方法 把硬盘中保存的数据读取到集合中

4.使用双列集合注意事项 1.存储键值对文件中 键值默认的链接符 可以使用 = 空格 (其他符号) 2.存储键值对文件中 可以使用#进行注释 被注释的键值对 不会再进行读取 3.存储键值对的文件中 键值默认都是靠字符串 不用添加引号

案例：

```

package IODemo;

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; import java.util.Set; public class IOTest6 { public static void main02(String[] args) throws IOException { Properties prop=new Properties();

prop.put("迪丽热巴", "165"); prop.put("赵丽颖", "160"); prop.put("林志玲", "170"); prop.put("范冰冰", "167"); Set<Object> set= prop.keySet(); for (Object object : set) { System.out.println((String)object+prop.get(object)); } FileWriter fw=new FileWriter("MyPro\\a.txt"); prop.store(fw, "Sava data"); //使用prop写入硬盘的 键值 默认String /** */ fw.close(); }

} 运行结果：

#Sava data #Wed Oct 07 11:15:47 CST 2020 范冰冰=167 林志玲=170 赵丽颖=160 迪丽热巴=165

案例2：

package IODemo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; import java.util.Set; public class IOTest6 { public static void main(String[] args) throws IOException { Properties prop=new Properties(); FileReader fr=new FileReader("MyPro\\a.txt"); prop.load(fr); Set<Object> set= prop.keySet(); for (Object s : set) { System.out.println((String)s); System.out.println((String)s+prop.get(s)); } fr.close(); } }

11.缓冲流

package IODemo;

/**

缓冲流 *使用普通的基本流进行一个个字节的Copy 毫秒：13269 FileInputStream *使用普通的缓冲流进行一个个字节的Copy 毫秒：60 BufferInputStream *使用普通的基本流通过byte[1024]的Copy 毫秒：20 *使用普通的缓冲流通过byte[1024]的Copy 毫秒：10@author XuYang

*/

package IODemo; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;import javax.sound.sampled.LineListener; public class IOTest3 { //复制图片 public static void main(String[] args) throws IOException { long start=System.currentTimeMillis(); FileInputStream fis=new FileInputStream("MyPro\\1.png"); BufferedInputStream bfis=new BufferedInputStream(fis); FileOutputStream fos=new FileOutputStream("MyPro\\123\\2.png"); BufferedOutputStream bfos=new BufferedOutputStream(fos); // //读 // int len=0; // while ((len=fis.read())!=-1) { // fos.write(len); // } // //写 int len=0; byte [] bytes=new byte[1024]; while ((len=bfis.read(bytes))!=-1) { bfos.write(bytes,0,len); } bfos.close(); bfis.close(); fos.close(); fis.close(); long end=System.currentTimeMillis();//4毫秒 System.out.println(end-start);//1389毫秒 1秒多 } }