文件 - File
代表文件或者目录(文件夹)的类。
- 练习:删除目录
思路:写一个单独的方法来删除目录或者文件:判断是一个目录还是还是一个文件;如果是文件(isFile())直接删除(delete()),如果是目录(isDirectory()),获取这个目录下的所有的子目录和子文件(listFiles()) — 后续功能和当前方法要完成的事情是一致的,所以使用递归
package cn.tedu.map;
import java.io.File;
import java.io.IOException;
public class FileExer {
public static void main(String[] args) throws IOException {
File file = new File("D:\\a\\c.java");
// boolean b = file.mkdirs();
// boolean a = file.createNewFile();
delDir(file);
}
public static void delDir (File file){
if(file.isDirectory()){
File[] fs = file.listFiles();
for(File f : fs)
delDir(f);
}
file.delete();
}
public static void del(File file) {
// 判断参数是否为空
if (file == null)
throw new NullPointerException("亲,文件不能为空哦~~~");
// 判断file对象是文件还是目录
if (file.isDirectory()) {
// 如果是目录,需要获取这个目录下的所有的子文件和子目录
File[] fs = file.listFiles();
for (File f : fs) {
// 逐个遍历每一个元素,判断这个元素是文件还是目录
del(f);
}
}
// 无论是文件还是目录都需要删除
file.delete();
}
}
- 练习:统计工作空间中Java文件和class文件的个数
思路:定义一个新的方法进行统计:先获取工作空间中所有的子文件和子目录。如果是子目录—递归;如果子文件,需要判断这个文件是否是一个Java文件还是一个class文件
package cn.tedu.file;
import java.io.File;
public class FileExer2 {
static int javaCount = 0;
static int classCount = 0;
public static void main(String[] args) {
File file = new File("C:\\Users\\Administrator\\Desktop\\笔记\\老师笔记");
count(file);
System.out.println(javaCount);
System.out.println(classCount);
}
public static void count(File file) {
// 判断file对象是否为空
if (file == null)
throw new NullPointerException();
// 判断是否是一个目录
if (file.isDirectory()) {
// 获取这个目录下的所有的子文件和子目录
File[] fs = file.listFiles();
for (File f : fs) {
count(f);
}
} /* file如果不是目录就是文件 */ else if (file.getName().endsWith(".java"))
javaCount++;
else if (file.getName().endsWith(".class"))
classCount++;
}
}
File - 知识点
// 表示创建了一个代表D盘下a.txt的File对象
// file对象创建的时候并不会去计算机中检查文件是否真实存在
// 只是将传入的路径标记为了一个file对象
File file = new File("D:\\test");
// 删除文件/目录 --- 不可逆
// 表示将文件/目录从计算机中彻底移除,不可撤销
// 在删除目录的时候要求目录是空目录
boolean b = file.delete();
// 创建文件
// 如果这个文件不存在,则创建该文件
// 如果文件已经存在,则创建失败
// 在创建这个文件的时候要求这个文件的存放路径必须真实存在
// 只能创建文件不能创建目录
// boolean b = file.createNewFile();
// 创建目录
// make directory
// 当且仅当这个目录不存在的时候才会创建
// 只能创建一层目录
// boolean b = file.mkdir();
// 表示可以创建一层或者多层目录
// boolean b = file.mkdirs();
System.out.println(b);
File file = new File("E:\\");
// 获取E盘下的所有的子目录和子文件
File[] fs = file.listFiles();
for (File f : fs) {
// 获取文件的名字
System.out.println(f.getName());
}
// 判断file对象是否是一个目录
System.out.println(file.isDirectory());
// 判断file对象是否是一个文件
System.out.println(file.isFile());
File file = new File("D:\\a");
// 判断file所代表的文件或者目录是否真实存在
System.out.println(file.exists());
// 判断是否可写
System.out.println(file.canWrite());
// 判断是否是一个隐藏文件
System.out.println(file.isHidden());
// 判断是不是一个绝对路径
System.out.println(file.isAbsolute());
File file = new File("D:\\a.txt");
// 获取文件的修改时间,也就是文件第一次创建时间,也是最后一次修改时间
System.out.println(file.lastModified());
// 设置文件的最后一次修改时间,要比文件的修改时间大。
// file.setLastModified(74617964131L);
// 设置文件是否可执行
// System.out.println(file.setExecutable(false));
// 设置文件是否可读
// System.out.println(file.setReadable(false));
// 设置文件是否可写
// System.out.println(file.setWritable(false));
package cn.tedu.file;
import java.io.File;
import java.io.IOException;
public class FileDemo5 {
public static void main(String[] args) throws IOException {
// File file = new File(/*"D:" + File.separatorChar + "a" + File.separatorChar + */"aaa.txt");
// 在Windows中,分隔目录用的\
// 在Linux中,分隔目录用的/
// 在Windows中,分隔路径用的;
// 在Linux中,分隔路径用的:
// File file = new File(/*"D:" + File.separatorChar + "a" + File.separatorChar + */"aaa.txt");
// File file = new File("a/aaa.txt");
File file = new File("aaa.txt");
// boolean a = file.mkdirs();
// boolean b = file.createNewFile();
// 获取父路径 从斜杠的位置往前截。不管文件是否真实存在,只看传入的路径(参数)。
System.out.println(file.getParent());
// 获取文件名 从斜杠的位置往后截。不管文件是否真实存在,只看传入的路径(参数)。
System.out.println(file.getName());
// 获取绝对路径
System.out.println(file.getAbsolutePath());
// 获取路径(文件名)
System.out.println(file.getPath());
}
}
package cn.tedu.file;
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
public class FileDemo6 {
public static void main(String[] args) {
File file = new File("D:\\");
// 获取指定目录下的所有的子目录和子文件
// File[] fs = file.listFiles();
// 获取E盘下所有的子文件
// File[] fs = file.listFiles(new FileFilter() {
//
// @Override
// // 写过滤规则
// // 过滤之后如果返回true,则自动放入数组中
// public boolean accept(File pathname) {
// return pathname.isFile();
// }
// });
// 获取E盘下名字中含有数字的子文件或者是子目录
// File[] fs = file.listFiles(new FileFilter() {
//
// @Override
// public boolean accept(File pathname) {
// return pathname.getName().matches(".*\\d.*");
// }
// });
File[] fs = file.listFiles(new FilenameFilter() {
@Override
// dir表示文件所存储的路径
public boolean accept(File dir, String name) {
return name.matches(".*\\d.*");
}
});
for (File f : fs) {
System.out.println(f);
}
// 获取内存空间 --- 返回的是字节个数
// long count = file.getTotalSpace();
// System.out.println(count);
// 获取可以使用的空间大小
// System.out.println(file.getUsableSpace());
}
}
File file = new File("E:\\b.txt");
// 将文件重命名b.txt
// file.renameTo(new File(file.getParent(),"b.txt"));
// file.renameTo(new File("D:\\b.txt"));
// 路径改变的前提下做的是剪切操作
// file.renameTo(new File("E:\\b.txt"));
file.renameTo(new File("D:\\a.txt"));
路径
绝对路径:以盘符或者/开头的路径。指定的位置和文件当前所处的位置没有任何关系
相对路径:不以盘符或者/开头的路径。以当前路径为基准来计算指定的文件的所在路径
IO流
- 用于数据的传输的机制。File不能操作文件内容,所以引入IO。
- IO -> Input Output Stream -> 输入输出流。
可以利用输入输出流向程序中写入写出数据。其中传输的是数据的流。
按照数据流流动的方向,流分为输入流 和 输出流。流的方向由程序的角度来思考,将数据写入程序的流称之为输入流,从程序中写出数据的流,称之为输出流。 - 根据数据传输方向:输入流和输出流
根据数据传输形式:字符流和字节流
这四大基本流是流的继承结构的根,都是抽象类,无法直接使用,一般用的都是他们的具有具体功能的子孙类。 - 数据的来源/目的地:存储设备、物理设备、内存、网络
向一个TXT文件中写入字符串 -> 输出流、字符流、和文件相关的流 -> FileWriter
流中的异常处理
- 将流对象放在try之外声明并且赋值为null;放到try之内进行初始化
- 在关流之前需要判断流对象是否为空
- 为了防止关流失败导致流依然占用文件,所以需要将流对象强制置为null
- 为了防止关流的时候自动冲刷缓冲区失败导致一部分数据产生丢失,需要在关流之前进行一次手动的冲刷
字符流
-
字符输入流Reader - FileReader
构造方法:
FileReader(File file)
FileReader(String fileName)
读取数据的方法:
int read()
int read(char[] cbuf)
关闭流:
close()
为什么read方法返回的不是char而是Int?
因为read如果返回的是char,则无法用任意的char表示到达了文件的结尾,所以此处不返回char 而是返回int,正常情况下返回的是正数,强转为char即可得到对应字符,而当读取到文件结尾返回-1表示 -
字符输出流Writer - FileWriter
构造方法:
FileWriter(File file)
FileWriter(String fileName)
输出数据的方法:
void write(int c)
write(char[] cbuf)
刷新流:
flush()
关闭流:
close()案例:利用字符流来复制文件 案例:利用带有自定义缓冲的流来复制文件提高效率
缓冲流
java.io.BufferedReader
构造方法:
BufferedReader(Reader in)
BufferedReader(Reader in, int sz)
将一个Reader传入BufferedReader后 BufferedReader会在原来Reader的基础上增加缓冲区,从而实现高效的读取数据,这个过程中BufferedReader不会改变原有Reader的功能,只是为底层的流提供了缓冲的能力,用来提高读取效率。
方法:
int read()
int read(char[] cbuf)
int read(char[] cbuf, int off, int len)
String readLine()
close()
java.io.BufferedWriter
构造方法:
BufferedWriter(Writer out)
BufferedWriter(Writer out, int sz)
将一个Writer传入BufferedWriter后 BufferedWriter会在原来Writer的基础上增加缓冲区,从而实现高效的写出数据,这个过程中BufferedWriter不会改变原有Writer的功能,只是为底层的流提供了缓冲的能力,用来提高写出效率。
方法:
write(int c)
write(String str)
write(char[] cbuf)
write(char[] cbuf, int off, int len)
newLine()装饰设计模式
-
设计模式
前人对编写java代码的套路的总结,java一共有23种通用设计模式。
装饰设计模式主要的能力,是通过装饰者包装被装饰者,在被装饰者原有的功能的基础上,增加额外的能力。
装饰设计模式实现方式:
写一个类 使其具有和被装饰者相同的方法
提供构造方法 将被装饰者 传入保存在类的内部
对于不想改造的方法直接调用原有对象本来的方法
对于想改造的方法 进行改造。
对于想增加的方法 直接增加。
这样可以将被装饰者传入,装饰,增加特定的功能。StringReader
数据来源是字符串的字符输入流,可以将一个字符串作为数据来源 以流的方式获取其中的数据
字节流
InputStream - FileInputStream
以字节为基本单位来操作数据
构造方法:
FileInputStream(File file)
FileInputStream(String name)
方法:
int read()
int read(byte[] b)
int read(byte[] b, int off, int len)
int available()
void close()案例:以字节为单位从文件中读取数据
OutputStream - FileOutputStream
以字节为基本单位来操作数据
构造方法:
FileOutputStream(File file)
FileOutputStream(String name)
方法:
void write(int b)
void write(byte[] b)
void write(byte[] b, int off, int len)
void flush()
void close()案例:以字节为单位向文件写出数据 案例:利用字节流实现文件的拷贝 文本文件 和 非文本文件都可以拷贝 案例:利用字节流实现文件的拷贝 - 自定义缓冲区提升性能
转换流
目录,再往上一拉
字符流的底层也是通过字节来操作数据的 只不过在字节流的基础上增加了 默认的转换器 可以经字节和字符进行映射 采用的编码集为系统码 且无法更改
所以当使用字符流 操作 非系统码的文件时 可能产生乱码
此时可以通过转换流 将自己构建的字节流 转换为字符流 并在这个过程中 指定需要的编码集 来解决问题
InputStreamReader - 可以将字节输入流转换为字符输入流 在转换的过程中 其实内部就是多了一个将字节 映射为 字符的操作 而采用的编码集 可以由程序来指定
构造方法:
InputStreamReader(InputStream in) //将字节输入流转换为字符输入流 内部增加的转换器 采用默认的码表(系统码)
InputStreamReader(InputStream in, String charsetName) //将字节输入流转换为字符输入流 内部增加的转换器 采用的码表由charsetName来指定
方法:
int read()
int read(char[] cbuf)
int read(char[] cbuf, int offset, int length)
void close()
OutputStreamWriter - 可以将字节输出流转换wie字符输出流 在转换的过程中 其实内部就是多了一个将字符 映射为 字节的操作 而采用的编码集 可以由程序来指定
构造方法:
OutputStreamWriter(OutputStream out)//将字节输出流转换为字符输出流 内部增加的转换器 采用默认的码表(系统码)
OutputStreamWriter(OutputStream out, String charsetName) //将字节输出流转换为字符输出流 内部增加的转换器 采用的码表由charsetName来指定
方法:
void write(int c)
void write(char[] cbuf)
void write(char[] cbuf, int off, int len)
void write(String str)
案例5:利用转换流实现utf-8编码集的文本文件的拷贝
案例6(作业):请写程序将gbk的文本文件转换为utf-8的文本文件 实现一个转码的过程
案例7(作业):请写程序将utf-8的文本文件转换为gbk的文本文件 实现一个转码的过程
// 在流使用完成之后会自动的进行关流操作
// try-with-resources 从JDK1.7开始的
// 要求能够使用try-with-resources方式的流必须实现AutoCloseable
// 要求流的创建过程必须在try之内
try (FileWriter writer = new FileWriter("D:\\c.txt")) {
writer.write("def");
writer.write("abe");
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}
package cn.tedu.io;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo1 {
public static void main(String[] args) throws IOException {
// 表示创建了一个输出流指向D盘下的a.txt
// 创建一个新的文件:如果原文件已存在则用新文件覆盖原文件
// 如果原文件不存在,创建一个新的文件,则将新文件作为目标文件进行操作
FileWriter writer = new FileWriter("D:\\b.txt");
// 追加方式
// 原文件已存在,不会创建新文件而是直接利用原文件
// FileWriter writer = new FileWriter("D:\\a.txt", true);
// 写出数据
// 数据不是直接写到文件中
// 而是先写到缓冲区中
// 缓冲区被填满之后再将缓冲区中的数据放到文件中
// 缓冲区还没有被填满,然后程序结束了
// 就导致有一部分数据死在缓冲区中没有来得及放到文件中
// 导致数据产生了丢失
writer.write("xyz");
// 冲刷缓冲区
// writer.flush();
// 关闭流
// 流在关闭的时候会自动冲刷一次缓冲区
writer.close();
// 流关闭了,流对象在内存中还存在吗?--- 存在
System.out.println(writer);
// 表示将流对象的引用置为null,手动标记它是一个垃圾对象(值为null)可以被回收
writer = null;
}
}
package cn.tedu.io;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo2 {
public static void main(String[] args) {
// 将writer放到try之外声明并赋值为null
FileWriter writer = null;
try {
// 将writer放到try之内初始化
writer = new FileWriter("H:\\b.txt");
writer.write("abc");
// 为了防止关流的时候自动冲刷失败导致数据的丢失
writer.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 需要判断writer是否初始化成功
if (writer != null)
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 如果关流失败,则强制将流对象置为null进行回收以释放文件
// 如果关流成功,则将流对象标记为垃圾对象
writer = null;
}
}
}
}
4.系统流
System是java内置的代表当前系统的类 其上提供了很多和系统相关的属性和方法 方便我们对系统进行操作
常用的属性:
static InputStream in - 标准输入流
static PrintStream out - 标准输出流
static PrintStream err - 标准错误输出流
常用的方法:
static void exit(int status) //退出虚拟机
static void gc() //启动垃圾回收 虚拟机通常会根据自身的内存使用情况 自动决定什么时候来进行垃圾回收 但是也可以通过这个方法 通知虚拟机该垃圾回收 但是注意 这个方法调用并不会触发垃圾回收 只是一个通知告诉虚拟机该回收垃圾了 至于是否启动垃圾回收 仍然由虚拟机自己决定
static void setIn(InputStream in) //设定系统标准输入流
static void setOut(PrintStream out) //设定系统标准输出流
static void setErr(PrintStream err) //设定系统标准错误输出流
系统流
其中System上提供的 in out err三个字节流 称之为系统流
系统流其实也是字节流 只不过这个字节流不需要我们自己创建 是系统创建好 直接提供给我们用的 不要关 也不能关
其中 in 是系统输入流 从系统标准输入流中获取数据 默认的系统标准输入流的来源 是控制台
其中 out err 是系统输出流 向系统标准输出流中写出数据 默认的系统标准输出流的目的地 是控制台
所以,平常大家写的 System.out.println(“hello world~”); 起始就是通过System.out得到的了系统输出流 向这个流中 通过println方法写出了 数据 最终去往了控制台显示
也可以用 System.err.println(“xxx”) 写出数据 和 System.out 唯一的不同是 打印出来将会是红色的文本 更加醒目 通常用来打印错误信息 平常大家见到的异常信息 就是通过System.err打印的
系统输出流的默认位置是控制台 也可以通过System.setOut() 或System.setErr() 方法修改out或err指向的 系统输出流
而 其中的System.in代表标准输入流 默认数据来源是控制台 所以可以利用它从控制台中读取数据
所以平常从控制态中读取数据可以写成:
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))
简单写法
Scanner scanner = new Scanner(System.in)
系统标准输入流默认的位置是控制台 也可以通过System.setIn() 方法来修改系统默认输入流 从而从其他位置读取数据
打印流
采用了装饰设计模式 为普通输出流 增加打印功能
PrintStream
可以讲普通的字节流转换为打印字节流 这也是一个装饰设计模式 增加了打印的机制 有如下的三个好处
打印流增加了打印各种类型数据的方法,省去了将各种类型的数据转换为字节再输出的过程。
打印流会自动刷新流,不需要手动进行flush。
打印流永远不抛异常,它的内部自动解决异常。
PrintWriter
可以将普通的字符流转换为打印字符流 这也是一个装饰设计模式 增加了打印的机制 有如下的三个好处
打印流增加了打印各种类型数据的方法,省去了将各种类型的数据转换为字符再输出的过程。
打印流会自动刷新流,不需要手动进行flush。
打印流永远不抛异常,它的内部自动解决异常。
练习
1
目录,再往上一拉
/**
* 案例:编写一个流 来读取外部文件中的字符数据
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
//1.创建文件字符输入流链接到 1.txt上
Reader reader = new FileReader("1.txt");
//2.通过流读取文件中的数据
int i = 0;
while((i=reader.read())!=-1){
System.out.println((char)i);
}
//3.关闭流
reader.close();
}
}
2
目录,再往上一拉
/**
* 案例:编写一个流 来将指定的字符写出到外部文件中
*/
public class Demo02 {
public static void main(String[] args) throws Exception {
//1.创建文件字符输出流
Writer writer = new FileWriter("2.txt");
//2.通过字符输出流输出数据
writer.write((int)'a');
writer.write((int)'b');
writer.write((int)'c');
writer.write((int)'d');
writer.write((int)'e');
//3.刷新流
//writer.flush();
//--关闭流,关闭流过程中会隐含的刷新一次流
writer.close();
}
}
3
目录,再往上一拉
/**
* 案例:利用字符流实现字符文件的拷贝 1.txt -> 3.txt
*/
public class Demo03 {
public static void main(String[] args) {
Reader reader = null;
Writer writer = null;
try {
//1.创建字符输入流 连接1.txt 创建字符输出流 连接3.txt
reader= new FileReader("1.txt");
writer = new FileWriter("3.txt");
//2.从1.txt读取数据
int i = 0;
while((i = reader.read())!=-1){
writer.write(i);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//3.关闭流
if(reader!=null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally{
reader = null;
}
}
if(writer!=null){
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
} finally{
writer = null;
}
}
}
}
}
4
目录,再往上一拉
/**
* 通过字符流 拷贝字符文件 讨论效率问题
*/
public class Demo04 {
public static void main(String[] args){
//--开始时间
long begin = System.currentTimeMillis();
Reader reader = null;
Writer writer = null;
try {
//1.创建流
reader = new FileReader("4.txt");
writer = new FileWriter("5.txt");
//2.拷贝数据
//int count = 0;
int i = 0;
char [] buf = new char [1024];
while ((i = reader.read(buf)) != -1) {
//System.out.println("读取了"+(++count)+"次");
writer.write(buf,0,i);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//3.关闭流
if(reader!=null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally{
reader = null;
}
}
if(writer!=null){
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
writer = null;
}
}
}
//--结束时间
long end = System.currentTimeMillis();
System.out.println("====共耗时:"+(end-begin)+"ms====");
}
}
5
目录,再往上一拉
/**
* 使用 缓冲流 BufferedReader BufferedWriter复制文本文件
*/
public class Demo05 {
public static void main(String[] args) throws Exception {
//1.创建 带有缓冲区的 文件输入流 文件输出流
FileReader reader = new FileReader("4.txt");
BufferedReader breader = new BufferedReader(reader);
FileWriter writer = new FileWriter("5.txt");
BufferedWriter bwriter = new BufferedWriter(writer);
//2.连接流 复制文件
int i = 0;
char [] buf = new char[1024];
while((i = breader.read(buf))!=-1){
bwriter.write(buf,0,i);
}
//3.关闭流
breader.close();
bwriter.close();
}
}
6
目录,再往上一拉
/**
* BufferedReader和BufferedWriter提供的新方法
*
* BufferedReader
* readline()
*
* BufferedWriter
* newLine()
*/
public class Demo06 {
public static void main(String[] args) throws Exception {
//1.创建流 并用缓冲流包装
BufferedReader reader = new BufferedReader(new FileReader("1.txt"));
BufferedWriter writer = new BufferedWriter(new FileWriter("2.txt"));
//2.对接流 拷贝文件
String line = null;
while((line = reader.readLine())!=null){
writer.write(line);
writer.newLine();
}
//3.关闭流
reader.close();
writer.close();
}
}
7 - 装饰设计模式
目录,再往上一拉
package cn.tedu.io1;
public class Demo07 {
public static void main(String[] args) {
//--继承
// Man man = new Man("zs",19);
// man.eat();
// man.sleep();
//
// SuperMan1 sp = new SuperMan1("zs", 19);
// sp.eat();
// sp.sleep();
// sp.fly();
//--装饰
Man man = new Man("ls",20);
man.eat();
man.sleep();
SuperMan2 sman = new SuperMan2(man);
sman.eat();
sman.sleep();
sman.fly();
}
}
/**
* 装饰设计模式
*/
class SuperMan2 implements Ani{
private Man man = null;
public SuperMan2(Man man) {
this.man = man;
}
@Override
public void eat() {
System.out.println("绕地球飞一圈。。");
man.eat();
System.out.println("到太平洋里游一圈。。");
}
@Override
public void sleep() {
man.sleep();
}
public void fly(){
System.out.println(man.name + "飞。。。");
}
}
interface Ani{
public void eat();
public void sleep();
}
class Man implements Ani{
protected String name;
protected int age;
public Man() {
}
public Man(String name, int age) {
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name+"吃。。。");
}
public void sleep(){
System.out.println(name+"睡。。。");
}
}
/**
* 继承方式
*/
class SuperMan1 extends Man{
public SuperMan1() {
}
public SuperMan1(String name,int age){
super(name,age);
}
public void fly(){
System.out.println(super.name+"飞。。。");
}
}
8
目录,再往上一拉
/**
* StringReader的用法
*/
public class Demo08 {
public static void main(String[] args) throws Exception {
//1.创建StringReader
String str = "hello java~ hello world~ 这是一段中文~";
StringReader reader = new StringReader(str);
//2.创建FileWriter
FileWriter writer = new FileWriter("7.txt");
//2.对接流输出
int i = 0;
char [] cs = new char[1024];
while((i = reader.read(cs))!=-1){
writer.write(cs,0,i);
}
//3.关闭流
reader.close();
writer.close();
}
}
9
目录,再往上一拉
/**
* 利用字节流实现文件的复制
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
//1.创建流
InputStream in = new FileInputStream("1.wmv");
OutputStream out = new FileOutputStream("2.wmv");
//2.对接流 实现复制
int i = 0;
while((i = in.read())!=-1){
out.write(i);
}
//3.关闭流
in.close();
out.close();
}
}
10
目录,再往上一拉
/**
* 利用字节流实现文件的复制 - 使用缓冲区
*/
public class Demo02 {
public static void main(String[] args) throws Exception {
//1.创建流
InputStream in = new FileInputStream("1.wmv");
OutputStream out = new FileOutputStream("2.wmv");
//2.对接流 实现复制
int i = 0;
byte [] tmp = new byte[1024];
while((i = in.read(tmp))!=-1){
out.write(tmp,0,i);
}
//3.关闭流
in.close();
out.close();
}
}
11
目录,再往上一拉
/**
* 案例:通过转换流 生成自定义码表的字符流 复制文件 解决乱码
*/
public class Demo04 {
public static void main(String[] args) throws Exception {
//1.创建字节流
InputStream in = new FileInputStream("d://8.txt");
OutputStream out = new FileOutputStream("d://9.txt");
//2.创建转换流 将字节流转换为字符流 并显式指定码表为utf-8
InputStreamReader reader = new InputStreamReader(in,"utf-8");
OutputStreamWriter writer = new OutputStreamWriter(out,"utf-8");
//3.对接流 复制文件
char [] data = new char[1024];
int i = 0;
while((i=reader.read(data))!=-1){
writer.write(data,0,i);
}
//4.关闭流
reader.close();
writer.close();
}
}
12
目录,再往上一拉
/**
* 案例:通过转换流 生成自定义码表的字符流 复制文件 将utf-8文件转换为gbk格式的文件
*/
public class Demo05 {
public static void main(String[] args) throws Exception {
//1.创建字节流
InputStream in = new FileInputStream("d://8.txt");
OutputStream out = new FileOutputStream("d://9.txt");
//2.创建转换流 将字节流转换为字符流 并显式指定码表为utf-8
InputStreamReader reader = new InputStreamReader(in,"utf-8");
OutputStreamWriter writer = new OutputStreamWriter(out,"gbk");
//3.对接流 复制文件
char [] data = new char[1024];
int i = 0;
while((i=reader.read(data))!=-1){
writer.write(data,0,i);
}
//4.关闭流
reader.close();
writer.close();
}
}
13
目录,再往上一拉
public class Demo06 {
public static void main(String[] args) throws Exception {
// System.setOut(new PrintStream(new FileOutputStream("out.txt")));
// System.setErr(new PrintStream(new FileOutputStream("err.txt")));
// System.out.println("abc");
// System.err.println("xyz");
// InputStream in = System.in;
// System.out.println((char)in.read());
// BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// String line = reader.readLine();
// System.out.println(line);
// Scanner scanner = new Scanner(System.in);
// String line = scanner.nextLine();
// System.out.println(line);
// System.setIn(new FileInputStream("in.txt"));
// BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// String line = null;
// while((line = reader.readLine())!=null){
// System.out.println(line);
// }
}
}