Java：IO流，复制图片或视频等，字节流，输入，剪切文件，复制，测试效率【诗书画唱】
字节流可以读取任何类型的文件，因此也可以读取文本类型的文件
自己出题，自己深入了解和理解思考是一种很好的学习方法。
复制删除（剪切）图片，设置每次读取字节长度为100，求出共读取的字节总长度，求出复制所用的时间
package IO;
import java.io.*;
public class lizi4 {
public static void main(String[] args) throws Exception{
File weJianLuJing=new File("D://集成开发工具/7.jpg");
//用FileInputStream声明读取的字节流：
FileInputStream shuRuLiu=new FileInputStream(weJianLuJing);
//用FileOutputStream声明写入的字节流：
//用XXX getName()得到XXX的名字，这里当作相对路径，这样的话，
//XXX就会复制到相对路径
FileOutputStream shuChuLiu=
new FileOutputStream(weJianLuJing . getName());
long startTime=System. currentTimeMillis() ;
//用字节数组byte[]当作容器
byte[] ziJieShuZu=new byte [100];
// 这里的100表示每次读取的字节的长度
int xiaBiaoLength;
// xiaBiaoLength：下标的长度，就是数组长度
int ziJieZongChangDu=0;
int count=0;
while((xiaBiaoLength=shuRuLiu.read(ziJieShuZu))!=-1){
System. out . println("这次读取的字节长度："+xiaBiaoLength);
count++;
ziJieZongChangDu=ziJieZongChangDu+xiaBiaoLength;
// 下面会写出下标0到xiaBiaoLength-1（含头含尾）的字节
shuChuLiu.write(ziJieShuZu,0,xiaBiaoLength) ;
shuChuLiu. flush();
}
System. out . println("读取的文件的字节总长度："
+ziJieZongChangDu);
System. out . println("读取文件的次数："
+count+"次");
long endTime=System. currentTimeMillis();
System. out . println("复制花费的时间为"
+(endTime-startTime)+"毫秒");
shuChuLiu. close();shuRuLiu.close();
weJianLuJing .delete();
//读的同时要进行写入。
}
// newFileLuJing：新的文件路径
// oldFileLuJing：旧的文件路径
//public static void fuZhiFangFa(String oldFileLuJing , String
// newFileLuJing)throws Exception{
// File oldWenJian=new File(oldFileLuJing);
// if(oldWenJian.exists()){
//// wenJianDuQuDaoDeNeiRong:
//// 文件读取到的内容
// FileReader wenJianDuQuDaoDeNeiRong=new FileReader(oldWenJian);
// String wenJianName=oldWenJian . getName();
// File NewWenjian=new File (newFileLuJing, wenJianName) ;
//// wenJianXieLuDeNeiRong:文件写入的内容
// FileWriter wenJianXieLuDeNeiRong
// =new FileWriter(NewWenjian);
// char[] ziJieShuZu=new char[30];
// int ziJieShuZuLength;
// while((ziJieShuZuLength=
//wenJianDuQuDaoDeNeiRong .read(ziJieShuZu))!=-1){
//wenJianXieLuDeNeiRong .
//write(new String(ziJieShuZu,0,ziJieShuZuLength));
//wenJianXieLuDeNeiRong. flush();}
//wenJianXieLuDeNeiRong. close();
//wenJianDuQuDaoDeNeiRong.close();
// }else{
// System. out. println("文件不存在");
// }
// }
}
案例1:使用字节流读取文本文件后打印到控制
台
package IO;
import java.io.*;
import java.sql.*;
import java.util.Scanner;
public class one {
public static void main(String[] args) throws Exception {
// duQu：读取
FileReader duQu=new FileReader("xiangDui.txt");
char [] shuZu=new char[10];
int xiaBiao;
while((xiaBiao=duQu.read(shuZu))!=-1){
System.out.print(new String(shuZu,0,xiaBiao));
}
duQu.close();
}
}
案例2:提示用户输入一句话，在项目根目录建
立文本文件aa.txt，将用户输入的这句话打印到
aa.txt中
//在项目的相对路径下新建一个txt文件，内容为你对IO流字符流的总结，
//使用IO流读取该文件的内容显示在控制台
package IO;
import java.io.*;
import java.sql.*;
import java.util.Scanner;
public class two {
public static void main(String[] args)throws Exception {
File wenjian=new File("src//aa.txt");
wenjian.createNewFile();
System. out . println("创建文件成功！");
Scanner s=new Scanner(System. in);
System. out . println("请输入一句话");
String neiRong=s.next() ;
FileWriter xieRu=new FileWriter(wenjian);
xieRu.write(neiRong);
xieRu.flush();
xieRu.close();
System. out . println("输入内容到文件,在文件中打印输入的内容成功");
}
}
案例3:使用字节流复制一张图片到项目根目录
package IO;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class three {
public static void main(String[] args) throws Exception{
System.out.println("开始复制...");
copyFangFa("不感兴趣侦探动漫OP.gif","Copy不感兴趣侦探动漫OP.gif");
System.out.println("复制成功!");
}
private static void copyFangFa(String yuanLaiWenJian
,String fuZhiWenJian) throws Exception{
File srcFile = new File(yuanLaiWenJian);
File targetFile = new File(fuZhiWenJian);
InputStream shuRuLiu = null;
OutputStream shuChuLiu = null;
shuRuLiu = new FileInputStream(srcFile);
shuChuLiu = new FileOutputStream(targetFile);
byte[] byteShuZu = new byte[1024];
// xiaBiaoEnd：下标的结尾
int xiaBiaoEnd = -1;
// 下面的代码的意思是：当没!=-1的时候就一直循环查询，当查询
// 到下标末尾-1时，表明已经都从头到尾查找完了
// shuRuLiu.read(byteShuZu)也是在读取内容数值下标，
// 这里是int类型的字节
// 数组的下标
while((xiaBiaoEnd = shuRuLiu.read(byteShuZu))!=-1) {
shuChuLiu.write(byteShuZu,0,xiaBiaoEnd);
}
if(shuRuLiu != null){ shuRuLiu.close();}
if(shuChuLiu != null) {shuChuLiu.close();}
}
}
案例4:使用字节流剪切一个文件
package IO;
import java.io.*;
public class lizi4 {
public static void main(String[] args) throws Exception{
File weJianLuJing=new File("D://集成开发工具/7.jpg");
//用FileInputStream声明读取的字节流：
FileInputStream shuRuLiu=new FileInputStream(weJianLuJing);
//用FileOutputStream声明写入的字节流：
//用XXX getName()得到XXX的名字，这里当作相对路径，这样的话，
//XXX就会复制到相对路径
FileOutputStream shuChuLiu=
new FileOutputStream(weJianLuJing . getName());
//用字节数组byte[]当作容器
byte[] ziJieShuZu=new byte [1000];
int xiaBiaoLength;
// xiaBiaoLength：下标的长度，就是数组长度
int index=0;
while((xiaBiaoLength=shuRuLiu.read(ziJieShuZu))!=-1){
// 下面会写出下标0到xiaBiaoLength-1（含头含尾）的字节
shuChuLiu.write(ziJieShuZu,0,xiaBiaoLength) ;
shuChuLiu. flush();}
shuChuLiu. close();shuRuLiu.close();
weJianLuJing .delete();
//读的同时要进行写入。
}
// newFileLuJing：新的文件路径
// oldFileLuJing：旧的文件路径
public static void fuZhiFangFa(String oldFileLuJing , String
newFileLuJing)throws Exception{
File oldWenJian=new File(oldFileLuJing);
if(oldWenJian.exists()){
// wenJianDuQuDaoDeNeiRong:
// 文件读取到的内容
FileReader wenJianDuQuDaoDeNeiRong=new FileReader(oldWenJian);
String wenJianName=oldWenJian . getName();
File NewWenjian=new File (newFileLuJing, wenJianName) ;
// wenJianXieLuDeNeiRong:文件写入的内容
FileWriter wenJianXieLuDeNeiRong
=new FileWriter(NewWenjian);
char[] ziJieShuZu=new char[30];
int ziJieShuZuLength;
while((ziJieShuZuLength=
wenJianDuQuDaoDeNeiRong .read(ziJieShuZu))!=-1){
wenJianXieLuDeNeiRong .
write(new String(ziJieShuZu,0,ziJieShuZuLength));
wenJianXieLuDeNeiRong. flush();}
wenJianXieLuDeNeiRong. close();
wenJianDuQuDaoDeNeiRong.close();
}else{
System. out. println("文件不存在");
}
}
}
执行前：
执行后：
案例5.字节流复制一个文件夹(测试效率，就是求运行的时间)
package IO;
import java.io.*;
public class liZi5 {
public static void main(String[] args) throws Exception{
long startTime=System. currentTimeMillis() ;
copyFangFa(new File("D://集成开发工具/NewFile"),
new File("D://集成开发工具/NewFileCopy99"));
long endTime=System. currentTimeMillis();
System. out . println("复制花费的时间为"+(endTime-startTime));
}
//copyFangFa:复制文件夹的方法
public static void copyFangFa
(File oldWenJianJia, File CopyOldWenJianJia)throws Exception{
// 思路：
//1.写一个复制文件夹的方法,两个参数，1个参数是你要复制的文件夹的原位置
//第二个参数是你要复制到的位置
//2.判断原位置是不是存在，如果存在就获取文件夹里的所有的文件
//3.获取到所有的文件后得到的是一个文件的数组，遍历这个数组
//判断每个文件是文件夹还是文件，如果是文件夹，就重新调用这个方法
//进行递归，直到文件的子目录,如果是文件的话，读取该文件的信息
//写入到新文件夹里
CopyOldWenJianJia . mkdir();//创建文件夹
if(!oldWenJianJia. isHidden()){
if(oldWenJianJia.exists()){
File[] FileShuZu=oldWenJianJia. listFiles();
for(File FileShuZuXiaBiao:FileShuZu){
// FileShuZuXiaBiao:文件数组下标
if(FileShuZuXiaBiao.isFile()){
FileInputStream fis=new
FileInputStream(FileShuZuXiaBiao.getAbsolutePath() );
FileOutputStream fos=new FileOutputStream
(new File(CopyOldWenJianJia.getAbsolutePath(),
FileShuZuXiaBiao.getName() ));
//--long startTime=System. currentTimeMillis() ;
byte[] bs=new byte [1];
int len;
while((len=fis.read(bs))!=-1){
fos. write(bs, 0,len);
fos. flush();}
//currentTimeMillis:当前时间转化的总毫秒数
//--long endTime=System. currentTimeMillis();
fos. close();
fis. close();
//--System. out . println("复制花费的时间为"+(endTime-startTime));
//flush()用于清理缓存
//close()用于关闭缓存
}
else{
copyFangFa(FileShuZuXiaBiao,
new File( CopyOldWenJianJia
+" /"+FileShuZuXiaBiao. getName()));
}
}
}}
}
}
