8.Java中的IO流

976-沈同学

发表文章数:65

首页 » Java » 正文

Java中的IO流

IO流

IO流的概述和分类

8.Java中的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));
	}
}

转换流的组成部分

转换流 = 字节流 + 编码表

	这句话怎么理解 ? 往下看, 先说编码表

编码表概述和常见编码表

8.Java中的IO流

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

拜师教育学员文章:作者:976-沈同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《8.Java中的IO流》 发布于2020-03-17

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录