Java中的IO流
IO流
IO流的概述和分类
1.字节流
FileOutputStream写数据
字节流&字符流的抽象父类
字节流：
InputStream 字节输入流
OutputStream 字节输出流
字符流：
Reader 字符输入流
Writer 字符输出流
字节流写出数据
字节流写数据
OutputStream:此抽象类是表示输出字节流的所有类的超类
FileOutputStream:文件输出流是用于将数据写入 File
构造方法：
FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的
输出文件流。
字节流写数据的步骤：
A:创建字节输出流对象
B:调用写数据的方法
C:释放资源
package com.scy12;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("a.txt");
/* 1.调用系统功能创建文件
2.创建字节输出流对象
3.让fos指向a.txt
*/
// write(int b)
fos.write(65);
fos.write(66);
fos.close();
}
}
字节流写数据的三种方式
写出数据的三个方法:
* public void write(int b):一次写一个字节
* public void write(byte[] b):一次写一个字节数组
* public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
String类中的方法
* byte[] getBytes() 将字符串转换为字节数组
package com.scy12;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("b.txt");
//FileOutputStream fos = new FileOutputStream(new File("a.txt")); 与上面等价
/* 1.调用系统功能创建文件
2.创建字节输出流对象
3.让fos指向a.txt
*/
// write(int b)： 一次写一个字节
fos.write(65);
fos.write(66);
// write(byte[] b):一次写一个字节数组
byte[] bys = {65,66,67,68,69};
fos.write(bys);
//如果是字符串可以执行么
//String中有一个方法：public byte[] getBytes()
//byte[] byss = "AAKSJDN".getBytes(); 一次写一个字符串转化字节后的数组
fos.write("AAKSJDN".getBytes());
//public void write(byte[] b,int off,int len) 一次写一个字节数组的一部分
fos.write("AAKSJDN".getBytes(),0,2);
fos.close();
}
}
FileOutputStream如何实现换行和追加写数据
如何实现数据的换行
不同的操作系统，针对换行的符号识别是不一样的。
windows:\r\n
linux:\n
mac:\r
如何实现数据的追加写入?
用构造方法带第二个参数是true的情况即可
package com.scy12;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
// FileOutputStream fos = new FileOutputStream("c.txt");
//FileOutputStream(File file, boolean append) 字节追加输出
FileOutputStream fos = new FileOutputStream("c.txt",true);
//调用写数据方法
for(int i=0;i<10;i++){
fos.write("hello".getBytes());
fos.write("\r\n".getBytes());
}
fos.close();
}
}
FileOutputStream写数据加入异常处理
try..catch.finally
格式:
try{
可能发生问题的代码
}catch(){
处理异常代码
}finally{
一定会被执行的代码. // 通常用于释放资源, 做善后的动作
}
public class FileOutputStreamDemo4 {
public static void main(String[] args) {
FileOutputStream fos = null;
try{
//FileOutputStream fos = new FileOutputStream("d.txt");
// fos = new FileOutputStream("z:\\d.txt");
fos = new FileOutputStream("d.txt");
fos.write("hello".getBytes());
}catch(IOException e) {
e.printStackTrace();
}finally {
if(fos!=null) {
//释放资源
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileInputStream读数据方式1一次读取一个字节
字节流读取数据的三个步骤
字节流读数据的步骤：
A:创建字节输入流对象
B:调用读数据的方法
C:释放资源
public int read() 一次读取一个字节
返回下一个数据字节；如果已到达文件末尾，则返回 -1。
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");
int by;
int by = fis.read();
// 方式1
/*while(by !=-1){
System.out.print((char)by);
by = fis.read()
}*/
// 用by不断的记录读取到的每一个数据
//方式2
while((by=fis.read())!=-1) {
System.out.print((char)by);
}
//释放资源
fis.close();
}
}
FileInputStream读数据方式2一次读取一个字节数组
public int read(byte[] b):
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
返回值是读入缓冲区的字节总数，也就是实际的读取个数
如果因为已经到达文件末尾而没有更多的数据，则返回 -1。
public int read(byte[] b) 一次读取一个字节数组
package com.scy13;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("b.txt");
/*
//定义一个字节数组
byte[] bys = new byte[5];
//第一次读取数据
int len = fis.read(bys);
System.out.println(len);
//byte[] -- String
//String(byte[] bytes)
//String(byte[] bytes, int offset, int length)
System.out.println(new String(bys));
//第二次读取数据
len = fis.read(bys);
System.out.println(len);
System.out.println(new String(bys));
//第三次读取数据
len = fis.read(bys);
System.out.println(len);
System.out.println(new String(bys));
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\n
* world\r\n
*
* hello
* \r\nwor
* ld\r\nr
*
*
*/
/*byte[] bys = new byte[5];
int len = fis.read(bys);
while (len !=-1){
System.out.print(new String(bys,0,len)); //已经有换行符
len = fis.read(bys);
}*/
//最终版
byte[] bys = new byte[1024];
//1G=1024MB
//1MB = 1024KB
//1KB = 1024B
int len;
while ((len=fis.read(bys)) != -1){
System.out.print(new String(bys,0,len));
}
//释放资源
fis.read();
}
}
字节流练习之复制文本文件
需求： 拷贝文本文件
分析：
第一步: 创建输入输出流对象关联数据源和数据目的
数据源: d\\窗里窗外.txt---读数据---InputStream---FileInputStream
目的地:林青霞.txt---写数据---OutputStream---FileOutputStream
第二步: 定义字节数组,为了提高效率
第三步: 将数据通过while循环不断读取到字节数组中
第四步: 将数据从字节数组中取出并写出
第五步: 释放资源
把d\\窗里窗外.txt内容复制到项目目录下的林青霞.txt文件中
package com.scy13;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyTxtTest {
public static void main(String[] args) throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("d:\\窗里窗外.txt");
//封装目的地
FileOutputStream fos = new FileOutputStream("林青霞.txt");
//读写数据
//方式1
/*int by;
while ((by=fis.read()) !=-1){
fos.write(by);
}
//释放资源
fos.close();
fis.close();
*/
//方式2：一次读取一个字节数组
byte[] by = new byte[1024];
int len;
while ((len=fis.read()) !=-1){
fos.write(by,0,len);
}
fos.close();
fis.close();
}
}
字节流练习之复制图片
把d:\\mn.jpg内容复制到当前项目目录下的mn.jpg中
package com.scy13;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyJpfTest {
public static void main(String[] args) throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("d:\\mn.jpg");
//封装目的地
FileOutputStream fos = new FileOutputStream("mn.jpg");
//读取数据
//方式1
/*int bys ;
while((bys =fis.read()) != -1){
fos.write(bys);
}*/
//方式2
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys)) !=-1){
fos.write(bys,0,len);
}
fos.close();
fis.close();
}
}
字节缓冲区流的概述和使用
字节缓冲流的作用是?
字节流一次读写一个数组的速度比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身
在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流
为什么字节缓冲流的构造方法需要传入一个OutputStream
BufferedOutputStream(OutputStream out, int size)
BufferedOutputStream(OutputStream out)：使用这个构造方法，它提供了一个默认的缓冲区大小（*推荐使用）
为什么构造方法传递一个:OutputStream ，而不是具体的文件或者路径呢？
字节缓冲区流仅仅提供缓冲区，而真正的底层的读写数据还是需要基本的流对象进行操作
字节缓冲流 :
BufferedOutputStream:字节缓冲输出流
BufferedInputStream:字节缓冲输入流
package com.scy14;
import java.io.*;
public class BufferedOutputStreamDemo {
public static void main(String[] args) throws IOException {
// bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
//bos.write("hello".getBytes());
//bos.close();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
//方式1
/*int by;
while ((by=bis.read()) !=-1){
System.out.print((char)by);
bis.close();
}*/
//方式2
int len;
byte[] bys = new byte[1024];
while ((len=bis.read(bys)) !=-1){
System.out.println(new String(bys,0,len));
}
bis.close();
}
}
字节流四种方式复制AVI并测试效率
System类的方法实现：
public static long currentTimeMillis():返回以毫秒为单位的当前时间。
package com.scy14;
import java.io.*;
public class CopyAviTest {
public static void main(String[] args) throws IOException {
//记录开始时间
long start = System.currentTimeMillis();
method1();
// method2();
// method3();
// method4();
//记录结束时间
long end = System.currentTimeMillis();
System.out.println("共耗时："+(end-start)+"毫秒");
}
//缓冲字节流一次读写一个字节数组
private static void method4() throws IOException {
//封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
byte[] bys = new byte[1024];
int len;
while((len=bis.read(bys))!=-1) {
bos.write(bys,0,len);
}
bos.close();
bis.close();
}
//缓冲字节流一次读写一个字节
private static void method3() throws IOException {
//封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
int by;
while((by=bis.read())!=-1) {
bos.write(by);
}
bos.close();
bis.close();
}
//基本字节流一次读写一个字节数组
private static void method2() throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
//封装目的地
FileOutputStream fos = new FileOutputStream("copy.avi");
byte[] bys = new byte[1024];
int len;
while((len=fis.read(bys))!=-1) {
fos.write(bys,0,len);
}
fos.close();
fis.close();
}
//基本字节流一次读写一个字节
private static void method1() throws IOException, IOException {
//封装数据源
FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
//封装目的地
FileOutputStream fos = new FileOutputStream("copy.avi");
int by;
while((by=fis.read())!=-1) {
fos.write(by);
}
fos.close();
fis.close();
}
}
2.转换流
转换流出现的原因
字节流读数据可能出现问题
字节流一次读取一个字节的方式读取带有汉字的文件是有问题的，因为你读取到一个字节后就转为字符在控制台
输出了，
而汉字是由2个字节组成的，所以这里会出问题。
文件复制的时候，字节流读取一个字节，写入一个字节，这个没有出现问题，是因为最终底层会根据字节做
拼接，得到汉字。
汉字存储的规则：
左边的字节数据肯定是负数，右边的字节数据可能是负数，也可能是正数，大部分情况下是负数。
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
//基本字节流一次读取一个字节
// FileInputStream fis = new FileInputStream("a.txt");
//
// int by;
// while((by=fis.read())!=-1) {
// System.out.print((char)by);
// }
//
// fis.close();
//String s = "hello";
//[104, 101, 108, 108, 111]
String s = "你好";
//[-60, -29, -70, -61]
byte[] bys = s.getBytes();
System.out.println(Arrays.toString(bys));
}
}
转换流的组成部分
转换流 = 字节流 + 编码表
这句话怎么理解 ? 往下看, 先说编码表
编码表概述和常见编码表
String类中的编码和解码问题
方法摘要&编码和解码
•编码
把看得懂的变成看不懂的
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException
使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
•解码
把看不懂的变成看得懂的
public String(byte[] bytes, String charsetName)
通过使用指定的 charset解码指定的 byte 数组，构造一个新的 String。
重点强调 : 编码和解码的方式需要一致
public class StringDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
//定义一个字符串
String s = "你好";
//编码
//byte[] bys = s.getBytes();//使用平台的默认字符集将此 String 编码为 byte 序列
//默认编码是GBK
//[-60, -29, -70, -61]
//byte[] bys = s.getBytes("GBK"); //指定编码GBK
//[-60, -29, -70, -61]
byte[] bys = s.getBytes("UTF-8"); //指定编码UTF-8
//[-28, -67, -96, -27, -91, -67]
System.out.println(Arrays.toString(bys));
//解码
//String ss = new String(bys); //通过使用平台的默认字符集解码指定的 byte 数组
// String ss = new String(bys,"GBK");//指定编码GBK
String ss = new String(bys,"UTF-8");//指定编码UTF-8
System.out.println(ss);
}
}
转换流中的编码和解码问题
转换流指的是?
转换流其实就是一个字符流。
转换流 = 字节流 + 编码表
转换流的构造方法
OutputStreamWriter 字符输出流
public OutputStreamWriter(OutputStream out)
根据默认编码把字节流的数据转换为字符流
public OutputStreamWriter(OutputStream out,String charsetName)
根据指定编码把字节流数据转换为字符流
InputStreamReader 字符输入流
public InputStreamReader(InputStream in)
用默认的编码读数据
public InputStreamReader(InputStream in,String charsetName)
public class ConversionStreamDemo {
public static void main(String[] args) throws IOException {
//public OutputStreamWriter(OutputStream out):默认编码GBK
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));
//public OutputStreamWriter(OutputStream out,String charsetName)
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"GBK");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"UTF-8");
//调用写数据的方法
osw.write("你好");
//释放资源
osw.close();
System.out.println("------------------------");
//public InputStreamReader(InputStream in):默认编码GBK
//InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));
//public InputStreamReader(InputStream in,String charsetName)
//InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"GBK");
InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"UTF-8");
//读数据：一次读取一个字符数据
int ch;
while((ch=isr.read())!=-1) {
System.out.print((char)ch);
}
//释放资源
isr.close();
}
}
3.字符流
OutputStreamWriter写数据的5种方式
方法摘要
* OutputStreamWriter写数据方法
* public void write(int c):写一个字符
* public void write(char[] cbuf):写一个字符数组
* public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
* public void write(String str):写一个字符串
* public void write(String str,int off,int len):写一个字符串的一部分
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
//创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
//public void write(int c):写一个字符
// osw.write(97);
// osw.write('a');
//写完数据后，没有发现数据，为什么呢?
//1字符=2字节
//文件中的数据存储的基本单位是字节,所以需要推一下
//void flush() 刷新该流的缓冲
osw.flush();
//public void write(char[] cbuf):写一个字符数组
// char[] chs = {'a','b','c','d','e'};
// osw.write(chs);
//public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
// char[] chs = {'a','b','c','d','e'};
// osw.write(chs, 1, 3);
//public void write(String str):写一个字符串
// osw.write("hello");
//public void write(String str,int off,int len):写一个字符串的一部分
osw.write("hello", 0, 3);
// //void flush():刷新该流的缓冲
// osw.flush();
//
// //释放资源
osw.close(); //关闭此流，但要先刷新它
}
}
InputStreamReader读数据的2种方式
方法摘要
* public int read():一次读取一个字符
* public int read(char[] cbuf):一次读取一个字符数组
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
//创建字符输入流对象
// InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
InputStreamReader isr = new InputStreamReader(new FileInputStream("OutputStreamWriterDemo.java"));
//public int read():一次读取一个字符
// int ch;
// while((ch=isr.read())!=-1) {
// System.out.print((char)ch);
// }
//public int read(char[] cbuf):一次读取一个字符数组
char[] chs = new char[1024];
int len;
while((len=isr.read(chs))!=-1) {
System.out.print(new String(chs,0,len));
}
//释放资源
isr.close();
}
}
字符流的练习之复制Java文件
把当前项目目录下的StringDemo.java内容复制到当前项目目录下的Copy.java中
*
* 数据源：
* StringDemo.java---读数据---字符流---InputStreamReader
* 目的地：
* Copy.java---写数据---字符流---OutputStreamWriter
public class CopyJavaTest {
public static void main(String[] args) throws IOException {
//封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream("StringDemo.java"));
//封装目的地
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("Copy.java"));
//读写数据
//方式1：一次读写一个字符
// int ch;
// while((ch=isr.read())!=-1) {
// osw.write(ch);
// }
//方式2：一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len=isr.read(chs))!=-1) {
osw.write(chs, 0, len);
}
//释放资源
osw.close();
isr.close();
}
}
字符流的练习之复制Java文件改进版
改进原因
转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化我们的书写，
转换流提供了对应的子类。
FileWriter--->继承---->OutputStreamWriter = FileOutputStream + 编码表（默认GBK）
FileReader--->继承---->InputStreamReader = FileInputStream + 编码表（默认GBK）
构造方法:
FileWriter(String fileName)
public class CopyJavaTest2 {
public static void main(String[] args) throws IOException {
//封装数据源
FileReader fr = new FileReader("StringDemo.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);
}
//释放资源
fw.close();
fr.close();
}
}
字符缓冲区流的概述和使用
字符缓冲区流的概述
BufferedWriter
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
构造方法：
BufferedWriter(Writer out)
BufferedReader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
构造方法：
BufferedReader(Reader in)
public class BufferedStreamDemo {
public static void main(String[] args) throws IOException {
// //创建字符缓冲输出流对象
// BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
// //调用写数据的方法
// bw.write("hello");
// //释放资源
// bw.close();
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("BufferedStreamDemo.java"));
//方式1：一次读取一个字符
// int ch;
// while((ch=br.read())!=-1) {
// System.out.print((char)ch);
// }
//方式2：一次读取一个字符数组
char[] chs = new char[1024];
int len;
while((len=br.read(chs))!=-1) {
System.out.print(new String(chs,0,len));
}
//释放资源
br.close();
}
}
字符缓冲区流的练习之复制文本文件
把项目目录下的a.txt内容复制到项目目录下的b.txt中
*
* 数据源：
* a.txt---读数据---字符流---InputStreamReader---FileReader---BufferedReader
* 目的地：
* b.txt---写数据---字符流---OutputStreamWriter---FileWriter---BufferedWriter
public class CopyTxtTest {
public static void main(String[] args) throws IOException {
//封装数据源
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
//封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
//读写数据
//一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len=br.read(chs))!=-1) {
bw.write(chs, 0, len);
}
//释放资源
bw.close();
br.close();
}
}
字符缓冲区流的特殊功能
方法摘要
* BufferedWriter
* void newLine():写入一个行分隔符,这个行分隔符是由系统决定的
*
* BufferedReader
* String readLine():包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，
* 则返回 null
public class BufferedStreamDemo {
public static void main(String[] args) throws IOException {
// //创建字符缓冲输出流对象
// BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
//
// //写数据
// for(int x=0; x<3; x++) {
// bw.write("hello");
bw.write("\r\n");
// bw.newLine();
// bw.flush();
// }
//
// //释放资源
// bw.close();
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
// //读取一次
// String line = br.readLine();
// System.out.println(line);
// //在读取一次
// line = br.readLine();
// System.out.println(line);
// line = br.readLine();
// System.out.println(line);
// //多读取两次
// line = br.readLine();
// System.out.println(line);
// line = br.readLine();
// System.out.println(line);
//最终版代码
String line;
while((line=br.readLine())!=null) {
System.out.println(line);
}
//释放资源
br.close();
}
}
字符缓冲区流的特殊功能复制Java文件
* 字符缓冲流特殊功能复制Java文件
*
* 数据源：
* BufferedStreamDemo.java---BufferedReader
* 目的地：
* Copy.java---BufferedWriter
public class CopyJavaTest {
public static void main(String[] args) throws IOException {
//封装数据源
BufferedReader br = new BufferedReader(new FileReader("BufferedStreamDemo.java"));
//封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
//读写数据
String line;
while((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
br.close();
}
}
字符流的练习之5种方式复制文本文件
字符流复制文本文件的五种方式分别是?
基本字符流一次读写一个字符
基本字符流一次读写一个字符数组
缓冲字符流一次读写一个字符
缓冲字符流一次读写一个字符数组
缓冲字符串一次读写一个字符串
public class CopyFileTest {
public static void main(String[] args) throws IOException {
method1();
// method2();
// method3();
// method4();
// method5();
}
//缓冲字符流一次读写一个字符串
private static void method5() throws IOException {
BufferedReader br = new BufferedReader(new FileReader("d:\\林青霞.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("窗里窗外.txt"));
String line;
while((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
//缓冲字符流一次读写一个字符数组
private static void method4() throws IOException {
BufferedReader br = new BufferedReader(new FileReader("d:\\林青霞.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("窗里窗外.txt"));
char[] chs = new char[1024];
int len;
while((len=br.read(chs))!=-1) {
bw.write(chs, 0, len);
}
bw.close();
br.close();
}
//缓冲字符流一次读写一个字符
private static void method3() throws IOException {
BufferedReader br = new BufferedReader(new FileReader("d:\\林青霞.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("窗里窗外.txt"));
int ch;
while((ch=br.read())!=-1) {
bw.write(ch);
}
bw.close();
br.close();
}
// 基本字符流一次读写一个字符数组
private static void method2() throws IOException {
FileReader fr = new FileReader("d:\\林青霞.txt");
FileWriter fw = new FileWriter("窗里窗外.txt");
char[] chs = new char[1024];
int len;
while((len=fr.read(chs))!=-1) {
fw.write(chs, 0, len);
}
fw.close();
fr.close();
}
// 基本字符流一次读写一个字符
private static void method1() throws IOException {
FileReader fr = new FileReader("d:\\林青霞.txt");
FileWriter fw = new FileWriter("窗里窗外.txt");
int ch;
while ((ch = fr.read()) != -1) {
fw.write(ch);
}
fw.close();
fr.close();
}
}
字符流的练习之把集合中的字符串数据存储到文本文件
案例分析:
A:创建集合对象
B:往集合中添加字符串元素
C:创建字符缓冲输出流对象
D:遍历集合，得到每一个字符串元素，把字符串元素作为数据写入到文本文件
E:释放资源
public class ArrayListToFileTest {
public static void main(String[] args) throws IOException {
//创建集合对象
ArrayList<String> array = new ArrayList<String>();
//往集合中添加字符串元素
array.add("hello");
array.add("world");
array.add("java");
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));
//遍历集合，得到每一个字符串元素，把字符串元素作为数据写入到文本文件
for(String s : array) {
bw.write(s);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
}
}
字符流的练习之把文本文件中的字符串数据读取到集合
案例分析
需求: 从文本文件中读取数据到ArrayList集合中，并遍历集合
每一行数据作为一个字符串元素
分析:
A:创建字符缓冲输入流对象
B:创建集合对象
C:读取数据，每一次读取一行，并把该数据作为元素存储到集合中
D:释放资源
E:遍历集合
public class FileToArrayListTest {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("array.txt"));
//创建集合对象
ArrayList<String> array = new ArrayList<String>();
//读取数据，每一次读取一行，并把该数据作为元素存储到集合中
String line;
while((line=br.readLine())!=null) {
array.add(line);
}
//释放资源
br.close();
//遍历集合
for(String s : array) {
System.out.println(s);
}
}
}
字符流的练习之把集合中的学生对象数据存储到文本文件
案例分析
需求:
把ArrayList集合中的学生数据存储到文本文件
每一个学生数据作为文件中的一行数据
定义一个学生类。
学生：
学号，姓名，年龄，所在城市
it001,张曼玉,35,北京
it002,王祖贤,33,上海
it003,林青霞,30,西安
分析:
A:创建集合对象
B:创建学生对象
C:把学生对象添加到集合中
D:创建字符缓冲输出流对象
E:遍历集合，得到每一个学生对象，然后把该对象的数据拼接成一个指定格式的字符串写到文本文件
F:释放资源
package com.scy14;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) throws IOException {
//创建集合对象
ArrayList<Student> array = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("s001","林青霞",30,"北京");
Student s2 = new Student("s002","张曼玉",33,"南京");
Student s3 = new Student("s003","王祖贤",34,"武汉");
array.add(s1);
array.add(s2);
array.add(s3);
BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));
//遍历集合，得到每个学生对象，然后把该对象的数据拼接成一个指定格式的字符串写到文本文件
for (Student s :array){
StringBuilder sb = new StringBuilder();
sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getCity());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
bw.close();
}
}
字符流的练习之把文本文件中的学生对象数据读取到集合
案例分析
需求:
从文本文件中读取学生数据到ArrayList集合中，并遍历集合
每一行数据作为一个学生元素
it001,张曼玉,35,北京
这里我们要使用String类中的一个方法：split()
分析:
A:创建字符缓冲输入流对象
B:创建集合对象
C:读取数据，每一次读取一行数据，把该行数据想办法封装成学生对象，并把学生对象存储到集合中
D:释放资源
E:遍历集合
package com.scy14;
import java.io.*;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("student.txt"));
ArrayList<Student> array = new ArrayList<Student>();
String line;
while ((line=br.readLine()) !=null){
String[] strArray = line.split(",");
Student s = new Student();
s.setSid(strArray[0]);
s.setName(strArray[1]);
s.setAge(Integer.parseInt(strArray[2]));
s.setCity(strArray[3]);
array.add(s);
}
br.close();
for (Student s:array){
System.out.println(s.getSid()+s.getName()+s.getAge()+s.getCity());
}
}
}
扫一扫
292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
