java的IO流
IO流:
面试题：小数组的读写和带Buffered的读取哪个更快?
* 定义小数组如果是8192个字节大小和Buffered比较的话
* 定义小数组会略胜一筹,因为读和写操作的是同一个数组
* 而Buffered操作的是两个数组
IO流(flush和close方法的区别)
flush()方法： 用来刷新缓冲区的,刷新后可以再次写出（字节缓冲流内置缓冲区，如果没有读取出来，可以使用flush()刷新来）
close()方法：用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
8：字符流FileReader和FileWriter
字符流是什么
* 字符流是可以直接读写字符的IO流
* 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出.
IO流(什么情况下使用字符流)
* 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.
* 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流
* 读取的时候是按照字符的大小读取的,不会出现半个中文
* 写出的时候可以直接将字符串写出,不用转换为字节数组
IO流(字符流是否可以拷贝非纯文本的文件)
* 不可以拷贝非纯文本的文件
* 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去
* 如果是?,直接写出,这样写出之后的文件就乱了,看不了了
File:
package ioDemo;
import java.io.File;
/*
* java.io.File
* 将系统中的文件,目录,路径封装成File对象
* 提供方法操作系统中的内容
* File与系统无关
*/
public class FileDemo {
public static void main(String[] args) {
//separator名称分割符,Windows是\,Linux是/
System.out.println(File.separator);
//pathSeparator路径分隔符,Windows是; ,Linux是:
System.out.println(File.pathSeparator);
/*
* File类的构造方法
* 三种重载形式
*/
function();
function_2();
function_3();
}
/*
* File(File parent,String child)
* 传递路径:传递File父路径,字符串子路径
*/
private static void function_3() {
File parent = new File("G:");
File file = new File(parent,"javase");
System.out.println(file);
}
/*
* File(String parent,String child)
* 传递路径:传递字符串父路径,字符串子路径
*/
private static void function_2() {
File file = new File("G:","javase");
System.out.println(file);
}
/*
* File(String pathname)
* 传递路径名:可以写到文件夹,可以写到一个文件
* 将路径封装为File类型对象
*/
private static void function() {
//写两个\\是转译符号表示一个\
//windows文件夹名和文件名不区分大小写
File file = new File("G:\\javase");
System.out.println(file);
}
}
*******************************************************************
package ioDemo;
import java.io.File;
import java.io.IOException;
/*
* File类的创建和删除功能
* 文件或目录
*/
public class FileDemo2 {
public static void main(String[] args) {
//function();
//function_1();
function_2();
}
/*
* boolean delete() 删除文件和文件夹,彻底删除不进回收站
*删除目录时，如果目录中有内容，无法直接删除。
*/
private static void function_2() {
File file = new File("G:\\a.txt");
boolean b = file.delete();
System.out.println(b);
}
/*
* boolean mkdir() 创建文件夹必须有父文件夹
* boolean mkdirs() 创建文件夹包括不存在的父文件夹
*/
private static void function_1() {
File file = new File("G:\\java\\java\\java");
boolean b = file.mkdirs();
System.out.println(b);
}
/*
* boolean cteateNewFile() 创建文件
*/
private static void function() {
File file = new File("G:\\java.doc");
try {
boolean b = file.createNewFile();
System.out.println(b);
} catch (IOException e) {
e.printStackTrace();
}
}
}
***********************************************************************
package ioDemo;
import java.io.File;
public class FIleDemo3 {
public static void main(String[] args) {
File file = new File("G:\\a.txt");
//String getName()获取文件名,就近的路径名
File filePath = new File("G:\\java\\eclipse");
String name = file.getName();
String namePath = filePath.getName();
System.out.println(name);//a.txt
System.out.println(namePath);//eclipse
//long length() 返回文件的字节数
long length = file.length();
System.out.println(length);
//File getParentFile() 获取父路径
File parent = file.getParentFile();
System.out.println(parent);
//File getAbsoluteFile() 返回抽象路径名的绝对路径名
File fdfa = new File("dfa");
//工程根目录 G:\Users\Administrator\eclipse-workspace\MyStudyJavaSe\dfa
System.out.println(fdfa.getAbsolutePath());
File absoluteFile = file.getAbsoluteFile();
System.out.println(absoluteFile);
//boolean exists() 判断文件或目录是否存在
File fsrc = new File("src");
//不写绝对路径默认相对路径为工程根目录,src存在所以返回true
System.out.println(fsrc.exists());
boolean b = file.exists();
System.out.println(b);
//boolean isDirectory() 判断是否是文件夹
//boolean isFile() 判断是否是文件
}
}
*************************************************************************************
package ioDemo;
import java.io.File;
public class FileDemo4 {
public static void main(String[] args) {
/*
* String[] list()
* 获取到File构造方法中封装路径中的文件和文件夹名(遍历)
* 只能获取当前路径下的,子路径不可获取
*/
File file1 = new File("G:\\学习文档");
String[] s = file1.list();
for(String i : s) {
System.out.println(i);
}
/*
* File[] listFiles()
* 获取到File构造方法中封装路径中的文件和文件夹(遍历)
* 只能获取当前路径下的,子路径不可获取
*/
File file2 = new File("G:\\JavaTest");
File[] f2 = file2.listFiles();
for(File f : f2) {
System.out.println(f);
}
System.out.println("**************************************");
function();
}
/*
* 文件过滤器
* 遍历目录时根据需要,只获取满足条件的文件
* listFiles(FileFilter filter)
* 传递FileFilter接口的实现类
* 自定义FileFilter接口实现类,重写抽象方法
* 接口实现类对象传递到遍历方法listFiles中
*/
public static void function(){
File file = new File("G:\\Javatest");
File[] f = file.listFiles(new MyFilter());
for(File f1 : f) {
System.out.println(f1);
}
}
}
package ioDemo;
import java.io.File;
import java.io.FileFilter;
public class MyFilter implements FileFilter{
public boolean accept(File f) {
//endWith区分大小写
return f.getName().endsWith(".txt");
}
}
***********************************************************************************************
package ioDemo;
import java.io.File;
/*
* 封装getAllDir方法,打印路径下所有目录和文件
*/
public class FileDemo5 {
public static void main(String[] args) {
File file = new File("G:\\系统");
getAllDir(file);
}
private static void getAllDir(File file) {
//System.out.println(file);
File[] arr = file.listFiles();
for(File f : arr) {
System.out.println(f);
//递归调用,不可思议
if(f.isDirectory()) {
getAllDir(f);
}
}
}
}
***********************************************************************************************
一个简单的递归调用:
/**
* 斐波那契数列
* 1对兔子,第一个月不生,第二个月不生,第三个月生1对兔子
* 生下的1对兔子,第一个月不生,第二个月不生,第三个月生1对兔子
* 求12个月后共有多少对兔子
*/
package test;
public class TuZi {
public static void main(String[] args) {
System.out.println(Number(12));
}
public static int Number(int month) {
if(month==1)
return 1;
if(month==2)
return 1;
return Number(month-1)+Number(month-2);
//其实就是1,1,3,5,8 后一个数等于前面两个数字相加
}
}
读文件FileInputStream:
package ioDemo;
/*
* 字节输入流
* java.io.InputStream 所有字节输入流的超类
* 作用:读取任意文件,每次只读一个字节
* 读取的方法read
* int read()
* int read(Byte[] b)
* int read(Byte[] b,int off,int len)
* 抽象类不能用,请看下集FileInputStream子类
*/
public class InputSteamDemo {
}
***********************************************************************
package ioDemo;
import java.io.FileInputStream;
import java.io.IOException;
/*
* int read() 方法:
* read(),执行一次就会自动读取下一字节
* 返回的是读取到的字节,读到结尾返-1
*/
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException{
FileInputStream fis = new FileInputStream("G:\\java\\a.txt");
int i;
while((i = fis.read()) != -1) {
System.out.print((char)i);
}
/*System.out.println(fis.read());
System.out.println(fis.read());
System.out.println(fis.read());*/
fis.close();
}
}
********************************************************************************
package ioDemo;
import java.io.FileInputStream;
import java.io.IOException;
/*
* 读取方法 int read(byte[] b) 读取字节数组
* 数组作用:缓冲,提高效率 读取的内容存在数组b中
* 返回值int:表示读取到多少个有效的字节数,结尾是返回-1,len表示读取的长度
*/
public class FileInputStreamDemo1 {
public static void main(String[] args) throws IOException{
FileInputStream fis = new FileInputStream("G:\\java\\a.txt");
byte[] b = new byte[1024];//默认为1024,或1024整数倍,大幅度提高效率
int len = 0;
while((len = fis.read(b)) != -1) {
System.out.println(new String(b,0,len));
}
}
}
写文件FileOutputStream:
package ioDemo;
/*
* 字节输出流
* java.io.OutputStream; 所有字节输出流的超类
* 从java程序写出文件,每次只能操作文件中一个字节
*/
public class OutputStreamDemo {
}
*********************************************************
package ioDemo;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* FileOutputStream
* 写入数据文件,学习父类方法使用子类数据
*
* 子类的构造方法:绑定输出的输出目的
* 参数:File 封装文件 String 字符串的文件名
*
* 流对象使用步骤:
* 1.创建子类对象,绑定数据目的
* 2.调用该对象的方法write写
* 3.close释放资源
* 流对象的构造方法可以创建文件,如果文件存在直接覆盖
*/
public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("G:\\java\\a.txt");
//写一个字节
fos.write(97);//流对象存入的是97对应的ASKⅡ字母a
//写字节数组
byte[] b = {65,66,67,68};//65,66,67,68对应ABCD
fos.write(b);
//写字节数组的一部分
fos.write(b, 1, 3);//写数组b ,第1个开始写3个
//写入的便捷方式,写字符串.getBytes()
fos.write("HelloWorld".getBytes());
fos.close();
}
}
************************************************************************
package ioDemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* FileOutputStream文件的续写和换行
* 续写 FileOutputStream的构造方法中,第二个参数写true
* 换行符 \r\n
*/
public class FileOutputStreamDemo1 {
public static void main(String[] args) throws IOException{
File file = new File("G:\\java\\a.txt");
FileOutputStream fos = new FileOutputStream(file,true);
fos.write("Hello".getBytes());//第二个参数有true,把Hello加在文件末尾
fos.write("\r\nworld".getBytes());
fos.write("\r\n".getBytes());//其实是"\r\n".getBytes()
fos.close();
}
}
**********************************************************************
复制文件:
package ioDemo;
/*
* 复制文件
*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Copy {
public static void main(String[] args) throws IOException{
FileInputStream fis = new FileInputStream("G:\\java\\aa.zip");
FileOutputStream fos = new FileOutputStream("G:\\java\\新建文件夹\\b.zip");
/* int len = 0;
while((len = fis.read()) != -1) {
fos.write(len);
}
fos.close();
fis.close();*/
int len = 0;
byte[] b = new byte[1024];
//速度大幅度提升
while((len = fis.read(b)) != -1){
fos.write(b,0,len);
}
fos.close();
fis.close();
}
}
************************************************************************
Writer和Reader:
package ioDemo;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/*
* 字符输出流
* java.io.Writer 所有字符输出流的超类
* 写文件,专门写文本文件
* 写的方法write
* write(int c) 写一个字符
* write(char[c]) 写字符数组
* write(char[c],int,int) 字符数组的一部分
* write(String s) 写字符串
* 用它的子类FileWriter
* 构造方法:写入的数据目的: File 类型对象 String 文件名
* 字符输出流写数据时必须运行flush()刷新才能显示出数据
*/
public class WriterDemo {
public static void main(String[] args) throws IOException{
File file = new File("G:\\java\\a.txt");
FileWriter fw = new FileWriter(file);
fw.write(101);
fw.flush();
fw.write('a');
fw.flush();
char[] c = {'d','f','f','v'};
fw.write(c);
fw.flush();
fw.write(c,0,3);
fw.write("\r\nhelloworld");//换行依然能用
fw.flush();
fw.close();
}
}
**********************************************************
package ioDemo;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
/*
* 字符输入流读取文本文件, 所有字符输入流的超类
* java.io.Reader
* 专门读取文本文件
*
* 读取方法:read()
* int read() 读一个字符
* int read(char[] c) 读字符数组
*
* Reader类是抽象类,找到子类对象FileReader
* 构造方法:绑定数据源 File 数据类型 String 文件名
*/
public class ReaderDemo {
public static void main(String[] args) throws IOException{
FileReader fir = new FileReader("G:\\java\\a.txt");
int len = 0;
while((len=fir.read()) != -1) {
System.out.print((char)len);
}
//不能讲上面注释解除,否则下面代码无法执行?
//read()读完就返回-1,不会刷新
char[] c = new char[5];
while((len = fir.read(c)) != -1) {
System.out.print(new String(c,0,len));
}
fir.close();
}
}
***************************************************************
小题目,给学生改作业:
package scoreDemo;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/*
* 模拟改试卷
* 规定考试全是选择题
* 标准答案以文本形式放在电脑中,有20个选择题答案 G:\\java\\答案
* 90个学生的答题卡以文本形式放在电脑中,有学生班级,姓名,学号,考试答案 G:\\java\\学生答题卡
* 对比正确答案和学生的答题卡,对一题得一分,将最终的成绩按班级生成不用文档显示出来,放在 G:\\java\\成绩
*/
public class ScoreDemo {
static FileReader answer = null; //正确答案文件
static FileReader student = null; //读取单个学生答案
static ArrayList<FileReader> studentList = new ArrayList<FileReader>(); //读取学生答案集合
static int[] score = new int[90]; //学生成绩
static FileWriter one = null; //一班成绩单
static FileWriter two = null; //二班成绩单
static FileWriter three = null; //三班成绩单
public static void main(String[] args) throws IOException{
Get();
Compare();
Print();
}
/**
* 取出学生答案和正确答案,学生答案存储在studentList集合中
*/
private static void Get() {
//取出学生答案,并存储在studentFile中
try {
for(int i = 1;i <= 90;i++) {
if(i <= 30)
student = new FileReader("G:\\java\\考试测试\\学生答题卡\\"
+ "计科一班 201430"+i+".txt");
else if(i > 30 && i<= 60)
student = new FileReader("G:\\java\\考试测试\\学生答题卡\\"
+ "计科二班 201430"+i+".txt");
else
student = new FileReader("G:\\java\\考试测试\\学生答题卡\\"
+ "计科三班 201430"+i+".txt");
//获取学生答案并存储在studentList集合中
studentList.add(student);
}
//获取答案存储在answer中
answer = new FileReader("G:\\java\\考试测试\\答案\\标准答案.txt");
}catch(IOException e ) {
e.printStackTrace();
}
}
/**
* 比较学生答案和正确答案,并获取成绩存储在数组score[]中
*/
private static void Compare() {
try {
for(int j = 0;j < 20;j++) {
int len = answer.read();
for(int i = 0;i < 90;i++) {
if(studentList.get(i).read() == len) {
score[i]++;//判断是否相等,相等加一分
}
}
}
}catch(IOException e) {
e.printStackTrace();
}finally {
try {
//此处关闭流,不能在上面关闭否自会出错
answer.close();
for(int i = 0;i < 90;i++) {
studentList.get(i).close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 按班级打印出学生的学号,成绩,班级平均分.最高分.最低分
*/
private static void Print() {
int sum1 = 0;int sum2 = 0;int sum3 = 0;
int average1 =0;int average2 =0;int average3 =0;
try {
one = new FileWriter("G:\\java\\考试测试\\成绩\\一班成绩.txt",true);//true续写功能
two = new FileWriter("G:\\java\\考试测试\\成绩\\二班成绩.txt",true);
three = new FileWriter("G:\\java\\考试测试\\成绩\\三班成绩.txt",true);
for(int i = 0;i < 30;i++) {
sum1 += score[i];sum2 += score[i+30];sum3 += score[i+60];
}
average1 = sum1 /30;average2 = sum2 /30;average3 = sum3 /30;
String total1 = "一班成绩 平均分:"+average1+" 以下是各位同学成绩!\r\n";
String total2 = "二班成绩 平均分:"+average2+" 以下是各位同学成绩!\r\n";
String total3 = "三班成绩 平均分:"+average3+" 以下是各位同学成绩!\r\n";
one.write(total1);
two.write(total2);
three.write(total3);
for(int i = 0;i < 30;i++) {
//将int类型转换为String类型
String s1 = "学号"+201430261+i+"的成绩为:"+score[i]+"\r\n";
//将int类型转换为String类型
String s2 = "学号"+2014302631+i+"的成绩为:"+score[i+30]+"\r\n";
//将int类型转换为String类型
String s3 = "学号"+2014302661+i+"的成绩为:"+score[i+60]+"\r\n";
one.write(s1);
two.write(s2);
three.write(s3);
one.flush();
two.flush();
three.flush();
}
one.close();
two.close();
three.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
*********************************************************************************************
package scoreDemo;
import java.io.FileWriter;
import java.io.IOException;
/**
* 创建学生答案类
* 自动生成90个学生的答案,并存储在"G:\\java\\考试测试\\学生答题卡" 文件夹中
*/
public class CreateStudent {
public static void main(String[] args) {
FileWriter file =null;
int[] select = new int[20]; //存20个答案的数组
int i = 0;
int j = 1;
for(j = 1;j <=90;j++) {
try {
//判断j的值学号1-30,31-60,61-90分别为1,2,3班
if(j<=30)
file = new FileWriter("G:\\java\\考试测试\\学生答题卡\\计科一班 201430"+j+".txt");
else if(30<j && j<=60)
file = new FileWriter("G:\\java\\考试测试\\学生答题卡\\计科二班 201430"+j+".txt");
else
file = new FileWriter("G:\\java\\考试测试\\学生答题卡\\计科三班 201430"+j+".txt");
for(i = 0;i < 20;i++) {
char r = (char)(int)(Math.random()*4+97);
select[i] = r; //随机生成abcd,并存入数组select中
file.write(select[i]);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
file.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
字节输出转换流 OutputStreamWriter:
package ioChange;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
* 转换流
* java.io.OutputStreamWrite; 继承Writer类
* 就是一个字符输出流写文本文件
* write() 字符,字符数组,文本文件
* 子类FileWriter,方便使用,但是不能改变编码表
*
* 字符通向字节的桥梁,将字符流转为字节流
*
* OutputStreamWriter 使用方式:
* 构造方法:
* OutputStreamWriter(OutputStream out) 接收所有的字节输出流
* 字节输出流只学过:FileOutputStream
* OutputStreamWriter(OutputStream out,String charsetName)
* String charsetName 传递编码表的名字: GBK UTF-8 不区分大小写
*/
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
//writeGBK();
writeUTF_8();
}
/*
* 转换流对象OutputStreamWriter写文本
* 文本采用UTF-8
*/
private static void writeUTF_8() throws IOException {
//创建字节输出流,绑定数据文件
FileOutputStream fos8 = new FileOutputStream("G:\\java\\fosUTF.txt");
//创建转换流对象,绑定字节输出流,使用UTF-8
OutputStreamWriter osw = new OutputStreamWriter(fos8, "UTF-8");
osw.write("你好");
osw.close();
}
/*
* 转换流对象OutputStreamWriter写文本
* 文本采用GBK的形式写入
*/
private static void writeGBK() throws IOException {
//创建字节输出流,绑定数据文件
FileOutputStream fos = new FileOutputStream("G:\\java\\fos.txt");
//创建转换流对象,绑定字节输出流,使用GBK(不写就是默认使用GBK)
OutputStreamWriter osw = new OutputStreamWriter(fos);
osw.write("你好");
osw.close();
}
}
字节读取转换流 InputStreamReader:
package ioChange;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* 转换流
* java.io.InputStreamReader 继承自Reader
* 字符流,读取文本文件
*
* 字节流向字符流转换,将字节流转为字符流,支持多种编码
*
* InputStreamReader读取文件
* 构造方法:
* InputStreamReader(InputStream in)
* InputStreamReader(InputStream in,String charsetName)
* 可以传递的字节输入流:FileInputStream
*
*/
public class InputStreanReaderDemo {
public static void main(String[] args) throws IOException {
// read_G();
read_U();
}
//读取UTF-8文件
private static void read_U() throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("G:\\java\\fosUTF.txt");
//创建转换流对象
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
int len = 0;
char[] c = new char[1024];
while((len = isr.read(c)) != -1) {
System.out.println(new String(c,0,len));
}
isr.close();
/*byte[] b = new byte[1024];
while((len = fis.read(b)) != -1) {
System.out.println(new String(b,0,len));
}*/
}
//读取GBK文件
private static void read_G() throws IOException {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("G:\\java\\fos.txt");
//创建转换流对象绑定字节输入流
InputStreamReader ise = new InputStreamReader(fis);
int len = 0;
char[] c = new char[1024];
while((len = ise.read(c)) != -1) {
System.out.print(new String(c,0,len));
}
ise.close();
}
}
字节输出流的缓冲流BufferedOutputStream
package ioStreamDemo;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 字节输出流的缓冲流
* java.io.BufferedOnputStream
* BufferedOnputStream 继承自 OnputStream
* 方法:写入write 字节,字节数组
*
*构造方法:
* BufferedOnputStream(OnputStream out)
* 可以传递任意的字节输出流
* FileOutputStream
*/
public class BufferedOnputStreamDemo {
public static void main(String[] args) throws IOException {
BufferedOutputStream bos = new BufferedOutputStream
(new FileOutputStream("G:\\java\\buffer.txt"));
bos.write(32);
bos.write("hello ".getBytes());
byte[] b = "hello world".getBytes();
bos.write(b, 0, b.length);
bos.close();
}
}
字节输入流的缓冲流BufferedInputStream
package ioStreamDemo;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/*
* 字节输入流的缓冲流,
* java.io.BufferedInputStream
* 继承自InputStream,字节输入流
* 读取方法,read() 单个字节,字节数组
*
* 构造方法:
* BufferedInputStream(InputStream)
* 可以传入任意的字节输入流 FileInputStream
*
*/
public class BufferedInputStreamDmeo {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream
(new FileInputStream("G:\\java\\buffer.txt"));
int len = 0;
byte[] b = new byte[1024];
while((len = bis.read(b)) != -1) {
System.out.println(new String(b,0,len));
}
bis.close();
}
}
复制比赛:
package ioStreamDemo;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
比较那种方法复制速度快
1.字节流读写单个字节 204444
2.字节流读写字节数组 199
3.字节缓冲区读写单个字节 700
4.字节缓冲区读写字节数组 55
*/
public class CopyRace {
public static void main(String[] args) throws IOException{
File src = new File("G:\\java\\src.txt");
File desc = new File("G:\\java\\desc.txt");
long start = System.currentTimeMillis();
copy_4(src,desc);
long end = System.currentTimeMillis();
System.out.println("复制完成,共用时:"+(end-start)+"毫秒");
}
//4.字节缓冲区读写字节数组 用时55
private static void copy_4(File src, File desc) throws IOException{
FileInputStream in = new FileInputStream(src);
FileOutputStream out = new FileOutputStream(desc);
BufferedInputStream fis = new BufferedInputStream(in);
BufferedOutputStream fos = new BufferedOutputStream(out);
int len = 0;
byte[] b = new byte[1024];
while((len = fis.read(b)) != -1) {
fos.write(b,0,len);
}
fis.close();
fos.close();
}
//3.字节缓冲区读写单个字节 用时700
private static void copy_3(File src,File desc) throws IOException{
FileInputStream in = new FileInputStream(src);
FileOutputStream out = new FileOutputStream(desc);
BufferedInputStream fis = new BufferedInputStream(in);
BufferedOutputStream fos = new BufferedOutputStream(out);
int len;
while((len = fis.read()) != -1) {
fos.write(len);
}
fis.close();
fos.close();
}
//2.字节流读写字节数组 用时199
private static void copy_2(File src, File desc) throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len = 0;
byte[] b = new byte[1024];
while((len = fis.read(b)) != -1) {
fos.write(b,0,len);
}
fis.close();
fos.close();
}
//1.字节流读写单个字节 用时204444
private static void copy_1(File src,File desc) throws IOException{
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(desc);
int len;
while((len = fis.read()) != -1) {
fos.write(len);
}
fis.close();
fos.close();
}
}
字符输出流缓冲流BufferedWriter
package ioStreamDemo;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/*
* 字符输出流缓冲流
* java.io.BufferedWriter
* 写入方法:writer() 单个字符,字符数组,字符串
*
* 构造方法:
* BufferedWriter(Writer w) 任意字符输出流
* FileWriter OutputStreamWriter
* bw.newLine();//换行方法,跨平台使用,
\r\n只能在Windows中有用不推荐使用
*/
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException{
BufferedWriter bw = new BufferedWriter(new FileWriter("G:\\java\\a.txt"));
bw.write('你');
bw.write('好');
bw.newLine();
char[] c = "我很好,你呢".toCharArray();//字符串变字符数组
bw.write(c);
bw.newLine();
bw.write("我也是");
bw.close();
}
}
字节输入缓冲流BufferedReader
package ioStreamDemo;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
*
* java.io.BufferedReader 继承自Reader
* 方法:read()
*
* 构造方法:
* BufferedReader(Reader r)
* FileReader InputStreamReader
* BufferedReader特有的方法: String readLine() 读取一行遇换行返回String,读完返回null 没有换行符号
*/
public class BufferedReaderDmeo {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("G:\\java\\a.txt"));
String line = null;
while((line = br.readLine()) != null) {
System.out.println(line);
}
/*int len = 0;
char[] c = new char[3];
while((len = br.read(c)) != -1) {
System.out.print(new String(c,0,len));
}*/
br.close();
}
}
用BufferedReader和BufferedWriter复制文件
package ioStreamDemo;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
* 用BufferedReader和BufferedWriter复制文件
* 读一行,写一行
*/
public class Copy1 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("G:\\java\\src.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("G:\\java\\desc.txt"));
String len = null;
while((len = br.readLine()) != null) {
bw.write(len);
bw.newLine();
}
bw.close();
br.close();
}
}
集合对象Properties:
package io04;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
/*
* 集合对象Properties继承自HashTable,实现Map接口
* 泛型是固定的<String,String>
* 可以和IO对象结合使用,实现数据的持久存储
*/
public class PropertiesDmeo {
public static void main(String[] args) throws IOException {
// function();
// load();
store();
}
/*
*Properties的特有方法store
*store(OutputStream out,String s)
*store(Writer w,String s) s是改写文件的原因,不能写中文,一般不写
*接收所有的字节或字符输出流,将集合中的键值对写回文件保存
*/
private static void store() throws IOException{
FileWriter fw = new FileWriter("G:\\java\\properties\\pro.properties");
Properties pro = new Properties();
pro.setProperty("name","lisi");
pro.setProperty("age","1");
pro.store(fw, "");
}
/*
* Properties集合特有方法load
* load(InputStream in)
* load(Reader r)
* 传递任意的字节或字符输入流
* 流对象读取文件的键值对,保存到集合
*/
private static void load() throws IOException {
Properties pro = new Properties();
FileReader fr = new FileReader("G:\\java\\properties\\pro.properties");
pro.load(fr);
System.out.println(pro);
}
/*
* 使用Properties集合,存储键值对
* setProperty(String key,String value) 相当于Map中的put
* getProperty(String key) 通过键获取值
*/
public static void function() {
Properties p = new Properties();
p.setProperty("日本","Honda");
p.setProperty("Honda","锋范");
p.setProperty("锋范","cvt");
System.out.println(p.getProperty("日本"));
System.out.println(p.getProperty("Honda"));
System.out.println(p.getProperty("锋范"));
System.out.println(p);
//方法stringPropertyNames,将集合中的键存储带set中,类似于Map中的keySet
Set<String> key = p.stringPropertyNames();
for(String s : key) {
System.out.println(s+" "+p.getProperty(s));
}
}
}
对象Person的序列化和反序列化
ObjectOutputStrea和ObjietOutputStream
package io04;
import java.io.Serializable;
//Person只有实现Serializable接口才能被序列化,标记性接口没有抽象方法
public class Person implements Serializable{
//自定义***,类改变时不会改变***
private static final long serialVersionUID = 3249235442L;
private String name;
private int age;
private transient int id=1;//transient关键字只有一个用途,阻止序列化
public Person(String name, int age, int id) {
super();
this.name = name;
this.age = age;
this.id = id;
}
public Person() {}
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", id=" + id + "]";
}
}
package io04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/*
* IO流对象实现对象Person的序列化和反序列化
* ObjectOutputStream实现对象的序列化
* ObjietOutputStream实现对象的反序列化
*/
public class ObjectStreamDemo {
public static void main(String[] args) throws IOException,ClassNotFoundException {
function_out();
function_in();
}
/*
* 构造方法:ObjectInputStream(InputStream in)
* 传递任意的字节输入流
* Object readObject(Object obj) 读取对象
*/
private static void function_in() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("G:\\java\\person.txt"));
Object obj = ois.readObject();
//需要抛出ClassNotFoundException异常,必须有Person的class文件才能反序列
System.out.println(obj);
ois.close();
}
/*
* 构造方法:ObjectOutputStream(OutputStream out)
* 传递任意的字节输出流
* void writeObject(Object obj) 写出对象的方法
*/
private static void function_out() throws IOException {
ObjectOutputStream oos = new ObjectOutputStream
(new FileOutputStream("G:\\java\\person.txt"));
Person p = new Person("nihao",18,1);
//必须实现Serializable接口,且静态的变量不能序列化,transient修饰的也不能序列化,打印值为0
oos.writeObject(p);
oos.close();
}
}
打印流PrintWriter
package io04;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流
* PrintStream
* PrintWriter
* 打印流的特点:
* 1.此流不负责数据源,只负责数据目的
* 2.为其他输入流添加功能
* 3.永远不会抛出IO异常,但是可能会抛出其他异常
*
* 两个打印流的方法完全一致
* 构造方法,就是打印流的输出目的端
* PrintStream
* 构造方法:接受File类型,接收字符串文件名,接收字节输出流OutputStream
* PrintWriter
* 构造方法:接受File类型,接收字符串文件名,接收字节输出流OutputStream,接收字符输出流Writer
*/
public class PrintWriteDemo {
public static void main(String[] args) throws IOException {
//打印流,向File对象的数据目的写入数据
File file = new File("G:\\java\\print.txt");
PrintWriter pri = new PrintWriter(file);
pri.println(100);//原样打印,写啥打印啥
pri.write(100);//这是d
pri.close();
//向文件名写入数据
PrintWriter p1 = new PrintWriter("G:\\java\\1.txt");
p1.print("suibianxie");
p1.close();
//向字节输出流写入数据
PrintWriter p2 = new PrintWriter(new FileOutputStream("G:\\java\\2.txt"));
p2.println(" ");
p2.close();
//向字符输出流写入数据
PrintWriter p3 = new PrintWriter(new FileWriter("G:\\java\\3.txt"));
p3.println(22222);
p3.close();
function_auto();
}
/*
* 打印流开启自动刷新功能
* 需满足以下两个条件:
* 1.输出的目的对象必须是流对象 OutputStream Writer
* 2.必须使用println printf format三个方法中的一个
*/
private static void function_auto() throws IOException {
PrintWriter pw = new PrintWriter(new FileWriter("G:\\java\\4.txt"),true);
//true表示开启自动刷新
pw.printf("i");
pw.printf("love");
pw.printf("you");
pw.close();//不关闭也能刷新
}
}
工具类FilenameUtils
package ioApache;
import org.apache.commons.io.FilenameUtils;
public class Commons_iodemo {
public static void main(String[] args) {
//String getExtension(文件名) 获取文件的扩展名
String name = FilenameUtils.getExtension("a.txt.b");
System.out.println(name);
//String getName(文件名) 获取文件名
String name2 = FilenameUtils.getName("你好世界.txt");
System.out.println(name2);
//boolean isExtension(文件名,后缀名) 判断文件是否以后缀名结尾,区分大小写
boolean b = FilenameUtils.isExtension("nihao.txt", "txt");
System.out.println(b);
}
}
工具类FileUtils
package ioApache;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
/*
* FileUtils工具类方法
*/
public class Commons_iodemo2 {
public static void main(String[] args) throws IOException {
//String readFileToString(File src) 读取文本返回字符串
String s = FileUtils.readFileToString(new File("g:\\mysql\\b.txt"));
System.out.println(s);
//writeStringToFile(File,String) 将字符串写到文件中(覆盖)
FileUtils.writeStringToFile(new File("g:\\mysql\\b.txt"), "i love you");
//copyFile(File,File) 复制文件
FileUtils.copyFile(new File("g:\\mysql\\b.txt"), new File("g:\\mysql\\a\\a.txt"));
//copyDirectoryToDirectory() 复制目录到另一个目录
FileUtils.copyDirectoryToDirectory(new File("G:\\JavaTest"), new File("g:\\mysql\\b"));
}
}