IO流
IO流的分类:
1）按方向划分:
a.输入流:读取数据
b.输出流:写输出数
2）按数据类型分:
a.字节流(图片文件,音频,视频等等....使用字节流)
字节输入流 :InputStream 抽象类:FileInputStream
字节输出流: OutputStream 抽象类:FileOutputStream
b.字符流:(针对是文本文件操作,优先采用字符流)
字符输入流:Reader
字符输出流:Writer
文件的字节输入流
public FileInputStream(String name)
读数据的两种方式:
1)public int read():一次读取一个字节
2)public int read(byte[] b):一次读取一个字节数组
例：
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
//创建文件输入流对象
FileInputStream fis = new FileInputStream("fis.txt");
/*//方式一 public int read():一次读取一个字节
int by = 0;
while((by = fis.read()) != -1) {
System.out.print((char)by);
}
//释放资源
fis.close();*/
//方式二 public int read(byte[] b):一次读取一个字节数组
byte[] bys = new byte [1024];
int len = 0;
while((len = fis.read(bys)) != -1) {
System.out.println(new String(bys, 0, len));//从0开始,读取实际长度
}
//释放资源
fis.close();
}
}
(一个代码中只能使用一种方式，不然会出错)
将一个在D盘下a.txt文件的内容复制到E盘下b.txt文件中
1). 使用FileInputStream:输入流------->读数据（封装数据源）
FileOutputStream:输出流------>写数据（封装目的地）
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
//FileInputStream:输入流------->读数据
//FileOutputStream:输出流------>写数据
public class CopyDemo1 {
public static void main(String[] args) throws IOException {
//封装数据源:
//创建一个文件字节输入流对象
FileInputStream fis= new FileInputStream("d:\\a.txt");
//封装目的地
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("e:\\b.txt") ;
// 一次读取一个字节
int by = 0;
while ((by = fis.read()) != -1) {
//写入数据
fos.write(by);
}
//关闭资源
fis.close();
fos.close();
}
}
2).一次读取一个字节数组
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo2 {
public static void main(String[] args) throws IOException {
// 封装数据源:
// 创建一个文件字节输入流对象
FileInputStream fis = new FileInputStream("d:\\a.txt");
// 封装目的地
// 创建文件输出流对象
FileOutputStream fos = new FileOutputStream("e:\\b.txt");
//一次读取一个字节数组
byte [] buffer = new byte [1024];
int len = 0;
while ((len = fis.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
//关闭资源
fis.close();
fos.close();
}
}
引出：
字节缓冲输入流:BufferedInputStream
构造方法:
public BufferedInputStream(InputStream in) :指定默认缓冲区大小创建字节缓冲输入流对象
字节缓冲输出流:BufferedOutputStream
构造方式:
public BufferedOutputStream(OutputStream out):默认缓冲区大小
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 字节缓冲输入流:BufferedInputStream
* 构造方法:
* public BufferedInputStream(InputStream in) :指定默认缓冲区大小创建字节缓冲输入流对象
*
* 字节缓冲输出流:BufferedOutputStream
* 构造方式:
* public BufferedOutputStream(OutputStream out):默认缓冲区大小
* */
public class CopyDemo3 {
public static void main(String[] args) throws IOException {
//封装数据源
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream("d:\\a.txt"));
//封装目的地
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("e:\\b.txt"));
//一次读取一个字节
/*int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
//关闭资源
bis.close();
bos.close();*/
//一次读取一个字节数组
byte [] buffer = new byte[1024];
int len = 0;
while ((len = bis.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
//关闭资源
bis.close();
bos.close();
}
}
字符转换流:可以将字节输出流转换字符流
字符输入流InputStreamReader:继承自Reader
字节输入流+编码格式(默认GBK)----->字符输入流
构造方式：
public InputStreamReader(InputStream in,charset sc) ;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputSrteamReaderDemo {
public static void main(String[] args) throws IOException {
//创建字符输入流对象
InputStreamReader isr = new InputStreamReader(
new FileInputStream("isr.txt"),"GBK");
//读取
char [] buffer = new char [1024];
int len = 0;
while ((len = isr.read(buffer)) != -1) {
System.out.println(new String (buffer,0,len));
}
isr.close();
}
}
字符输出流OutputStreamWriter:继承自Writer
字节输出流+编码格式---->字符输出流
构造方式：
public OutputStreamWriter(OutputStream out,Charset cs):创建一字符输出转换流对象,指定编码格式
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
//创建一个字符输出流对象
//public OutputStreamWriter(OutputStream out,Charset cs)
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"osw.txt"));//默认GBK
//写数据
osw.write("乖女儿，马二蛋...") ;
//释放资源
osw.close() ;
}
}
便捷类:
由于使用字符转换流进行操作数据的时候书写代码名称非常长,于是Java提供了一种更简单的类:
字符转换输入流:InputStreamReader----->FileReader
FileReder(String fileName)
字符转换输出流:OutputStreamWriter---->FileWriter
FileWriter(String fileName)
需求：使用便捷类复制文件
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyDemo {
public static void main(String[] args) throws IOException {
//封装数据源和目的地
FileReader fr = new FileReader("D:\\a.txt");
FileWriter fw = new FileWriter("E:\\b.txt");
//读取
int by = 0;
while((by = fr.read()) != -1) {
fw.write((char)by);
}
//释放资源
fr.close();
fw.close();
}
}
字符缓冲输入流 ：BufferedReader
public class BufferedReader
extends Reader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw.txt")) ;
//一次读取一个字符
/*int ch = 0 ;
while((ch=br.read())!=-1){
System.out.print((char)ch);
}*/
//一次读取一个字符数组
char[] chs = new char[1024] ;
int len = 0 ;
while((len = br.read(chs))!=-1){
System.out.println(new String(chs, 0, len));
}
//关闭资源
br.close() ;
}
}
字符缓冲输出流 ：BufferedWriter
public class BufferedWriter
extends Writer
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException {
//创建字符缓冲输出流对象
//public BufferedWriter(Writer out)
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")) ;
//写数据
bw.write("hello") ;
bw.write("world") ;
bw.write("java") ;
//刷新流
bw.flush() ;
//关闭资源
bw.close() ;
}
}
注意：可以指定缓冲区的大小，或者默认缓冲区的大小，一般情况下，默认的已经足够大了！
关于字符缓冲流的特有功能:
BufferedWriter:
public void newLine():写入一个换行符号
BufferReader:
public String readLine():一次读取一行
public class BufferedDemo {
public static void main(String[] args) throws IOException {
write();
read();
}
private static void read() throws FileNotFoundException, IOException {
//创建一个字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw.txt")) ;
//读数据
//public String readLine():一次读取一行
String line = null ;
while((line=br.readLine())!=null){
System.out.println(line);
}
//释放资源
br.close() ;
}
private static void write() throws IOException {
//创建一个字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")) ;
//写数据
for(int x = 0 ; x <10 ; x ++){
bw.write("hello"+x) ;
//使用特有功能
bw.newLine() ;
//刷新该流
bw.flush() ;
}
//释放资源
bw.close() ;
}
}
bw.write("hello"+x) ;
//使用特有功能
bw.newLine() ;
//刷新该流
bw.flush() ;
}
//释放资源
bw.close() ;
}
}
关于字符流和字节流的使用:
当我们操作的是一个文本文件,优先采用字符流,如果是视频,音频,动画,图片资源文件这些记事本读不懂,那么使用字节流
关于复制文件：
将D盘下 喵.jpg图片复制到当前项目下copy.jpg
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyImageDemo {
public static void main(String[] args) throws IOException {
//封装数据源和目的地
FileInputStream fis = new FileInputStream("D:\\喵.jpg") ;
FileOutputStream fos = new FileOutputStream("copy.jpg") ;
//一次读取一个字节数组
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=fis.read(bys))!=-1){
//写数据的
fos.write(bys, 0, len) ;
}
//释放资源
fis.close() ;
fos.close() ;
}
}
复制视频文件同理
关于速度问题：
高效字节流比基本字节流快，一次读取一个字节数组比一次读取一个字节快
递归：
三个条件:
1)定义一个方法
2)必须有规律
3)要有出口条件
例：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问
第二十个月的兔子对数为多少？
public class Test {
public static void main(String[] args) {
int i = 20;
for(i=1;i <=20 ;i++) {
System.out.println("兔子第"+i+"个月的总数为："+f(i));
}
}
public static int f(int x) {
//第一月和第二月都是1对
if(x == 1 || x == 2) {
return 1;
}else {//第三个月开始是之前两个月的数量之和
return f(x-1)+f(x-2);
}
}
}