File文件操作类
java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关
File 能新建、删除、重命名文件和目录，但File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
File对象可以作为参数传递给流的构造器
将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。
File类常见方法：
1：创建。
File file2 = new File("F:\\cc");
System.out.println(file2.mkdir());
boolean mkdir()：创建此抽象路径名指定的目录。
File file2 = new File("F:\\cx\\vv");
System.out.println(file2.mkdirs());
boolean mkdirs()：创建多级目录。
File file = new File("F:\\cx\\vv\\cc.txt");
System.out.println(file.createNewFile());
boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。
以parent为父路径，child为子路径创建File对象。
public File(String parent,String child)
File file2 = new File("F:\\cc", "as");
System.out.println(file2.mkdir());
根据一个父File对象和子文件路径创建File
public File(File parent,String child)
File file3 = new File(new File("F:\\cc"), "vv");
System.out.println(file3.mkdirs());
成功返回TRUE,已存在文件返回false。
2：删除。
File file1 = new File("F:\\cc.txt");
System.out.println(file1.createNewFile());
System.out.println(file1.delete());
boolean delete()：删除此抽象路径名表示的文件或目录。
void deleteOnExit()：在虚拟机退出时删除。
注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。
window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。
3：获取.
File file2 = new File("F:\\cx\\vv");
System.out.println(file2.getName());//vv 获取当前文件夹名称
System.out.println(file2.getPath());// F:\cx\vv 获取相对路径
System.out.println(file2.getAbsolutePath());//F:\cx\vv 获取绝对路径
System.out.println(file2.getParent());//F:\cx 获取除当前文件夹之外的所有路径
System.out.println(file2.lastModified());//1504450501671 获取最后一次修改时间
System.out.println(file2.separator); // \. 获取路径分隔符
路径中的每级目录之间用一个路径分隔符隔开。
路径分隔符和系统有关：
windows和DOS系统默认使用“\”来表示
UNIX和URL使用“/”来表示
Java程序支持跨平台运行，因此路径分隔符要慎用。
为了解决这个隐患，File类提供了一个常量：
public static final String separator。根据操作系统，动态的提供分隔符。
String[] list();获取指定目录下的所有文件或者文件夹的名称数组
File file2 = new File("F:\\cc\\vv");
String[] l = file2.list();
List<?> l1 = Stream.of(l).collect(Collectors.toList());
l1.stream().forEach(System.out::println);
File[] listFiles()获取指定目录下的所有文件或者文件夹的Files数组
File file2 = new File("F:\\cc\\vv");
File[] l = file2.listFiles();
for (File f1 : l) {
System.out.println(f1.getName());
}
long length()：获取文件大小。字节
String getName()：返回由此抽象路径名表示的文件或目录的名称。
String getPath()：将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。
long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。
File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。
4：判断：
boolean exists()：判断文件或者文件夹是否存在。
boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
Public boolean canRead()：判断是否可读
public boolean canWrite()：判断是否可写
File file2 = new File("F:\\cc\\vv");
file2.mkdir();
System.out.println(file2.exists());// 判断文件或者文件夹是否存在。
System.out.println(file2.isDirectory());// 测试此抽象路径名表示的文件是否是一个目录。
System.out.println(file2.isFile());// 测试此抽象路径名表示的文件是否是一个标准文件。
System.out.println(file2.isHidden());// 测试此抽象路径名指定的文件是否是一个隐藏文件。
System.out.println(file2.isAbsolute());// 测试此抽象路径名是否为绝对路径名。
System.out.println(file2.canRead());// 判断是否可读
System.out.println(file2.canWrite());// 判断是否可写
过滤器功能
String[] a = file2.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith("jpg");
}
});
5：重命名。
重命名
File file1 = new File("e:\\c2c.txt");
File newFile = new File("e:\\c22c.txt");
System.out.println(file1.renameTo(newFile));
剪切
File newFile = new File("e:\\c2c.txt");
File file4 = new File("F:\\c2c.txt");
System.out.println(file4.renameTo(newFile));
// 可以实现移动的效果。剪切+重命名。
boolean renameTo(File dest)：
// 列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。
String[] list()：
// 如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。
// 如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。
// 判断File对象指定的文件或某个文件夹是否是一个隐藏文
System.out.println(f1.isHidden());
// 返回File对象指定的分区大小，以字节为单位；如果File对象没有指定分区，则返回 0L。
System.out.println(f1.getTotalSpace()+"---------");
// 返回File对象表示的文件最后一次被修改的时间，
// 用与时间点（1970年1月1日，00:00:00 GMT）之间的毫秒数表示。
// 如果该文件不存在，或者发生I/O错误，则返回0L
System.out.println(f1.lastModified()+"---------。");
IO流：
用于处理设备上数据。
IO流原理
- I/O是Input/Output的缩写，I是指Input（输入）,O是指Output（输出），I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
- Java程序中，对于数据的输入/输出操作以“流(stream)”的方式进行。
- java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
- 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
- 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备
IO流的分类
流:
可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。注意：流的操作只有两种：读和写。
- 按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
- 按数据流的流向不同分为：输入流，输出流
- 按流的角色的不同分为：节点流，处理流
流的体系因为功能不同，但是有共性内容，不断抽取，形成继承体系。该体系一共有四个基类，而且都是抽象类。
| (抽象基类) | 字节流 | 字符流 |
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
1. Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
字节流的两个顶层父类：1， InputStream 2， OutputStream.
字符流的两个顶层父类：1， Reader 2， Writer
2. 在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称。
public static void main(String[] args) throws IOException { //读、写都会发生IO异常
/*
* 1：创建一个字符输出流对象，用于操作文件。该对象一建立，就必须明确数据存储位置，是一个文件。
* 2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存储数据的文件。
* 3：如果指定位置，出现了同名文件，文件会被覆盖。
*/
FileWriter fw = new FileWriter("demo.txt"); // FileNotFoundException
/* 调用Writer类中的write方法写入字符串。字符串并未直接写入到目的地中，而是写入到了流中，(其实是写入到内存缓冲区中)。怎么把数据弄到文件中？
*/
fw.write("abcde");
fw.flush(); // 刷新缓冲区，将缓冲区中的数据刷到目的地文件中。
fw.close(); // 关闭流，其实关闭的就是java调用的系统底层资源。在关闭前，会先刷新该流。
}
InputStream& Reader
InputStream和Reader 是所有输入流的基类。
InputStream（典型实现：FileInputStream）
In tread()
Int read(byte[] b)
Int read(byte[] b, intoff, intlen)
Reader（典型实现：FileReader）
Int read()
int read(char [] c)
nt read(char [] c, intoff, intlen)
程序中打开的文件IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件IO 资源。
FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream 用于读取非文本数据之类的原始字节流。要读取字符流，需要使用FileReader
InputStream
Int read()
从输入流中读取数据的下一个字节。返回0到255范围内的int字节值。
如果因为已经到达流末尾而没有可用的字节，则返回值-1。
int read(byte[]b)
从此输入流中将最多b.length个字节的数据读入一个byte数组中。
如果因为已经到达流末尾而没有可用的字节，则返回值-1。否则以整数形式返回实际读取的字节数。
int read(byte[]b, int off, int len)
将输入流中最多len个数据字节读入byte数组。尝试读取len个字节，但读取的字节也可能小于该值。
以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值-1。
public void close() throws IOException
关闭此输入流并释放与该流关联的所有系统资源。Reader
int read()
读取单个字符。作为整数读取的字符，范围在0到65535之间(0x00-0xffff)（2个字节的Unicode码），
如果已到达流的末尾，则返回-1
int read(char[] cbuf)
将字符读入数组。如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。
int read(char[] cbuf, int off, int len)
将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。
如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。
public void close() throws IOException
关闭此输入流并释放与该流关联的所有系统资源。
OutputStream& Writer
Output Stream 和Writer 也非常相似：
Output Stream 和Writer 也非常相似：
void write(intb/intc);
void write(byte[] b/char[] cbuf);
void write(byte[] b/char[] buff,int off, int len);
void flush();
void close(); 需要先刷新，再关闭此流
因为字符流直接以字符作为操作单位，所以Writer
可以用字符串来替换字符数组，即以String 对象作为参数
void write(String str);
void write(String str, int off, int len);
FileOutputStream 从文件系统中的某个文件中获得输出字节。FileOutputStream 用于写出非文本数据之类的原始字节流。要写出字符流，需要使用FileWriter
OutputStream
void write(intb)
将指定的字节写入此输出流。write的常规协定是：向输出流写入一个字节。
要写入的字节是参数b的八个低位。b的24个高位将被忽略。即写入0~255范围的。
Void write(byte[]b)
将b.length个字节从指定的byte数组写入此输出流。write(b)的常规协定是：
应该与调用write(b,0,b.length)的效果完全相同。
void write(byte[]b,int off,int len)
将指定byte数组中从偏移量off开始的len个字节写入此输出流。
public void flush() throws IOException
刷新此输出流并强制写出所有缓冲的输出字节，
调用此方法指示应将这些字节立即写入它们预期的目标。
public void close() throws IOException
关闭此输出流并释放与该流关联的所有系统资源。
Writer
void write(int c)
写入单个字符。要写入的字符包含在给定整数值的16个低位中，16高位被忽略。
即写入0到65535之间的Unicode码。
void write(char[]cbuf)
写入字符数组。
void write(char[]cbuf, int off ,int len)
写入字符数组的某一部分。从off开始，写入len个字符
void write(String str)
写入字符串。
void write(String str,int off,int len)
写入字符串的某一部分。
void flush()
刷新该流的缓冲，则立即将它们写入预期目标。
public void close() throws IOException
关闭此输出流并释放与该流关联的所有系统资源。
IO流中close()和flush()的区别：
flush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，
该方法主要用于结束调用的底层资源。这个动作一定做。IO流缓冲区
缓冲区是提高效率用的，给谁提高呢？
提高效率的，提高流的操作数据的效率。所以创建缓冲区之前必须先有流。
缓冲区的基本思想：
其实就是定义容器将数据进行临时存储。对于缓冲区对象，其实就是将这个容器进行了封装，并提供了更多高效的操作方法。
IO流异常的处理方式：
io一定要写finally；
IO流设计模式：装饰设计模式。
IO中的使用到了一个装饰设计模式解决：对一组类进行功能的增强。
包装：写一个类(包装类)对被包装对象进行包装；
*1、包装类和被包装对象要实现同样的接口；
*2、包装类要持有一个被包装对象；
*3、包装类在实现接口时，大部分方法是靠调用被包装对象来实现的，对于需要修改的方法我们自己实现；
IO流之流对象：
其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。
流的操作规律：
1，明确源和目的。
数据源：就是需要读取，可以使用两个体系：InputStream、Reader；
数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；
2，操作的数据是否是纯文本数据？
如果是：数据源：Reader
数据汇：Writer
如果不是：数据源：InputStream
数据汇：OutputStream
3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？
明确操作的数据设备。
数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)
数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。
4，需要在基本操作上附加其他功能吗？比如缓冲。
如果需要就进行装饰。
IO流之字节流
字节流的处理单位是字节，通常用来处理二进制文件，例如音乐、图片文件
字节流类都继承自InputStream、OutputStream这两个抽象类
处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。
InputStream中重用的方法：
InputStream：是表示字节输入流的所有类的超类。
- |--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
- |--- FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
- |--- BufferedInputStream：该类实现缓冲的输入流。
- |--- Stream：
- |--- ObjectInputStream：
- |--- PipedInputStream：
-
read() 可以从流中读取单个字节的数据，其中read有多个重载的方法;public class inputStreamYH { public static void main(String[] args) { FileInputStream inputStream = null; try { inputStream = new FileInputStream("E:/Beyond - 情人.mp3"); //方式1 // int validBufferLength = 0; // while ((validBufferLength = inputStream.read()) != -1) { // System.out.println((char)validBufferLength); // } //方式2 byte[] bufferArray = new byte[1024]; int validBufferLength = 0; while ((validBufferLength = inputStream.read(bufferArray)) != -1) { System.out.println(new String(bufferArray, 0, validBufferLength)); //设置局部变量缓冲数组bufferArray，read方法会将字节保存到该数组中并 //返回实际写入bufferArray数组的元素个数，这样减少了循环次数，提高了复制效率 } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ if(inputStream != null){ try { inputStream.close(); } catch (IOException e) { e.printStackTrace(); } } System.out.println("结束"); } } }
close()关闭此输入流并释放与该流关联的所有系统资源
OutputStream中重用的方法：
OutputStream：此抽象类是表示输出字节流的所有类的超类。
- |--- FileOutputStream：文件输出流是用于将数据写入
File或FileDescriptor的输出流。 - |--- FilterOutputStream：此类是过滤输出流的所有类的超类。
- |--- BufferedOutputStream：该类实现缓冲的输出流。
- |--- PrintStream：
- |--- DataOutputStream：
- |--- ObjectOutputStream：
- |--- PipedOutputStream：
import java.io.*;
public class fileOutputStream {
public static void main(String[] args) {
FileOutputStream outputStream = null;
try {
outputStream = new FileOutputStream("for.txt", true);
byte[] bufferArray = {12,2,3,22,21,82};
outputStream.write(bufferArray);
outputStream.write("hello".getBytes());//化为2进制
outputStream.write(bufferArray, 1, 5);
outputStream.flush();//刷新outputStream缓冲区
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(outputStream != null){
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("结束");
}
}
}
write() 可以向流中写入单个字节的数据，其中write有多个重载的方法;
close()关闭此输出流并释放与此流有关的所有系统资源
这两个抽象类
import java.io.*;
public class inputStream {
//TODO 字节流
public static void main(String[] args) {
FileInputStream inputStream = null;
FileOutputStream outputStream = null;
try {
inputStream = new FileInputStream("E:/戴荃 - 悟空.mp3");//2. FileOutputStream(String name)
File outFile = new File("f:\\存在01.mp3");
outFile.createNewFile();
outputStream = new FileOutputStream(outFile, true);//FileOutputStream(File file) 里面加个true的话一直叠加。
// int byteData;
// while ((byteData = inputStream.read()) != -1) {
//逐个读取输入流中的数据
// outputStream.write(byteData);//向输出流中逐个存入字节
// }
byte[] bufferArray = new byte[1024];
int validBufferLength = 0;
while ((validBufferLength = inputStream.read(bufferArray)) != -1) {
//设置局部变量缓冲数组bufferArray，read方法会将字节保存到该数组中并
//返回实际写入bufferArray数组的元素个数，这样减少了循环次数，提高了复制效率
outputStream.write(bufferArray, 0, validBufferLength);
}
outputStream.flush();//刷新outputStream缓冲区
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
if(inputStream != null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(outputStream != null){
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("结束");
}
}
}
IO流之字符流
字符流操作的单位是字符
字符流类都继承自Reader、Writer这两个抽象类，那么为什么要有字符流呢？Reader Writer
因为字符每个国家都不一样，所以涉及到了字符编码问题，那么GBK编码的中文用unicode编码解析是有问题的，所以需要获取中文字节数据的同时+ 指定的编码表才可以解析正确数据。为了方便于文字的解析，所以将字节流和编码表封装成对象，这个对象就是字符流。只要操作字符数据，优先考虑使用字符流体系。
Reader中最重要的方法：
- Reader：用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。
- |---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
- |---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。
- |---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
- |---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
- |---CharArrayReader：
- |---StringReader：
- read() 可以从输入流中读取单个字符的数据，其中read方法有多个重载的方法;
- close()关闭此输入流并释放与该流关联的所有系统资源
Writer中最重要的方法：
- write()可以向输出流中写入单个字符的数据，其中write方法有多个重载的方法
- close()关闭此输出流并释放与此流有关的所有系统资源
- Writer：写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。
- |---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
- |---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
- |---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
- |---PrintWriter：
- |---CharArrayWriter：
- |---StringWriter：
import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class ReaderZiFuYH { public static void main(String[] args) { FileReader reader = null; FileWriter write = null; try { reader=new FileReader("E:/新建文本文档.txt"); write=new FileWriter("F:/新建文本文档.txt"); // int transition; // while((transition=reader.read())!=-1){ // write.write(transition); // } char []character=new char[1024]; int transition=0; while((transition=reader.read(character))!=-1){ write.write(character,0,transition); } write.flush();//刷新缓冲区 } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally{ try { if(reader!=null){ reader.close(); } if(write!=null){ write.close(); } } catch (IOException e) { e.printStackTrace(); } System.out.println("jieshu"); } } }
案例
A:复制文本文件 5种方式(掌握)
B:复制图片(二进制流数据) 4种方式(掌握)
C:把集合中的数据存储到文本文件
D:把文本文件中的数据读取到集合并遍历集合
E:复制单级文件夹
F:复制单级文件夹中指定的文件并修改名称
回顾一下批量修改名称
G:复制多级文件夹
H:键盘录入学生信息按照总分从高到低存储到文本文件
I:把某个文件中的字符串排序后输出到另一个文本文件中
J:用Reader模拟BufferedReader的特有功能
IO流之缓冲流：
把要操作的数据放进缓冲区,然后一次性把缓冲区的内容写入或者读出到目的地,而不是一次一次的写入或者读出
字节流BufferedInputStream，BufferedOutputStream
import java.io.*;
public class InputOutputTest {
public static void main(String[] args) {
BufferedInputStream inputStream = null;
BufferedOutputStream outputStream = null;
try {
FileInputStream fileInputStream = new FileInputStream("D:\\戴荃 - 悟空.mp3");
inputStream = new BufferedInputStream(fileInputStream);
File outFile = new File("D:\\存在.mp3");
outFile.createNewFile();
//如果指定的文件不存在并成功地创建，则返回 true；
//如果指定的文件已经存在，则返回 false；如果所创建文件所在目录不存在则创建失败并出现IOException异常
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
outputStream = new BufferedOutputStream(fileOutputStream);
byte[] bufferArray = new byte[1024];
int validBufferLength = 0;
while ((validBufferLength = inputStream.read(bufferArray)) != -1) {
//获取每次循环实际写入bufferArray数组的元素个数
outputStream.write(bufferArray, 0, validBufferLength );
}
// int validBufferLength = 0;
// while ((validBufferLength = inputStream.read()) != -1) {
// outputStream.write(validBufferLength );
// }
outputStream.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("结束");
}
}
}
字符流
BufferedWriter：
是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。
FileWriter fw = new FileWriter("bufdemo.txt");
BufferedWriter bufw = new BufferedWriter(fw);//让缓冲区和指定流相关联。
for(int x=0; x<4; x++){
bufw.write(x+"abc");
bufw.newLine(); //写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。
bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。
}
bufw.close();//关闭缓冲区，其实就是在关闭具体的流。
BufferedReader：
FileReader fr = new FileReader("bufdemo.txt");
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine())!=null){ //readLine方法返回的时候是不带换行符的。
System.out.println(line);
}
bufr.close();
import java.io.*;
public class ReaderWriterTest {
public static void main(String[] args) {
BufferedReader reader = null;
BufferedWriter writer = null;
try {
File readerFile = new File("E:/新建文本文档.txt");
reader = new BufferedReader(new FileReader(readerFile));
File writerFile = new File("E:\\笔记.txt");
writer = new BufferedWriter(new FileWriter(writerFile));
// String oneLineData;
// while ((oneLineData = reader.readLine()) != null) {//逐行从Reader缓冲流中读取
// writer.write(oneLineData);//逐行向Writer缓冲流中写入数据
// writer.newLine();//写入一个分行符，否则内容在一行显示
// }
char []character=new char[1024];
int transition=0;
while((transition=reader.read(character))!=-1){
writer.write(character,0,transition);
}
writer.flush();//刷新Writer缓冲流缓冲区
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("jieshu");
}
}
}
483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
