目录
1.FileInputStreamDemo
package com.igeek.javase.ch15.file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 10:41
*
* FileInputStre
* 1.构造方法
* 1.1 public FileInputStream(String name)
* 1.2 public FileInputStream(File file)
*
* 2.常用API方法
* 2.1 public int read() 一个一个字节读取
* 2.2 public int read(byte b[]) 根据指定的字节数组，读取数据
* 2.3 public int read(byte b[], int off, int len) 根据指定的字节数组，读取数据
* 2.4 public void close() 关闭资源
*
* 3.使用场景
* 3.1 不适合对文本内容进行读写操作，很容易发生乱码，一个字节一个字节读取内容效率较低
* 3.2 适合图片、音视频上传下载和拷贝
*/
public class FileInputStreamDemo {
public static void main(String[] args) {
File file = new File("abc.txt");
FileInputStream fis = null;
try {
//1.创建字节输入流对象
fis = new FileInputStream(file);
//2.读取文本数据
/*byte[] bytes = new byte[(int)file.length()];
int len = fis.read(bytes , 0 , bytes.length);
System.out.println("读取的总字节数： = "+len); //6 UTF-8 3*2=6
System.out.println("读取到的文本："+new String(bytes , 0 , len)); //你好 */
byte[] bytes = new byte[1024];
int len = 0;
//len=-1 说明读到文件末尾
while ((len=fis.read(bytes))!=-1){
System.out.println("读取到的文本："+new String(bytes , 0 , len));
}
} catch (FileNotFoundException e) {
//文件找不到
try {
file.createNewFile();
} catch (IOException ex) {
ex.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//3.无论是否发生异常，都会执行，一般用于资源关闭操作
if(fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.FileOutputStreamDemo
package com.igeek.javase.ch15.file;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 10:41
*
* FileOutputStream 输出流 字节流 节点流
* 1.构造方法
* 1.1 public FileOutputStream(File file)
* 1.2 public FileOutputStream(String name)
* 1.3 public FileOutputStream(File file, boolean append) true代表可以追加文本内容
* 1.4 public FileOutputStream(String name, boolean append) true代表可以追加文本内容
*
* 2.常用API方法
* 2.1 public void write(int b) 按照一个一个字节写数据
* 2.2 public void write(byte b[]) 按照字节数组，写数据
* 2.3 public void write(byte b[], int off, int len) 第一个参数是字节数组，第二个参数是起始位置，第三个参数是写出长度
* 2.4 public void close() 关闭资源
* 2.5 public void flush() 刷新资源
*
* 3.使用场景
* 3.1 不适合对文本内容进行读写操作，很容易发生乱码，一个字节一个字节读取内容效率较低
* 3.2 适合图片、音视频上传下载和拷贝
*/
public class FileOutputStreamDemo {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//fos = new FileOutputStream("abc.txt"); //默认不追加
fos = new FileOutputStream("abc.txt" , true); //true 追加文本内容
//写数据
fos.write('\n'); //换行
fos.write('a');
byte[] bytes1 = {97,98,99,100,101};
fos.write(bytes1);
byte[] bytes2 = {65,66,67,68,69};
fos.write(bytes2 , 2 , 2);
fos.write('\n'); //换行
//刷新
fos.flush();
//刷新后，任然可以写数据操作
fos.write('中');
System.out.println("写出成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos!=null){
try {
fos.close();
//fos.write('B'); //IOException: Stream Closed 流关闭后，不可以再进行写操作
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.FileReaderDemo
package com.igeek.javase.ch15.file;
import java.io.FileReader;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 10:41
*
* FileReader 输入流 字符流 节点流
* 1.构造方法
* public FileReader(File file)
* public FileReader(String fileName)
*
* 2.常用API方法
* 2.1 public int read()
* 2.2 public int read(char cbuf[], int offset, int length)
* 2.3 public void close()
*
* 3.使用场景
* FileReader 比FileInputStream 更适合文本读取操作，效率更高；读取的时候是一个一个字符读取，比一个一个字节读取快许多
*/
public class FileReaderDemo {
public static void main(String[] args) {
try (
//1.声明流对象
FileReader fr = new FileReader("F:\\temp\\aaa.txt");
){
//2.读文本数据
char[] cs = new char[1024];
int len = 0;
//读到-1 代表读到末尾
while ((len = fr.read(cs))!=-1){
String str = new String(cs , 0 , len);
System.out.println("str = "+str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
4.FileWriterDemo
package com.igeek.javase.ch15.file;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 10:42
*
* FileWriter 输出流 字符流 节点流
* 1.构造方法
* 1.1 public FileWriter(File file)
* 1.2 public FileWriter(File file, boolean append)
* 1.3 public FileWriter(String fileName)
* 1.4 public FileWriter(String fileName, boolean append)
*
* 2.常用API方法
* 2.1 public void write(int c) 一个一个字符写
* 2.2 public void write(char cbuf[], int off, int len) 按照字符数组写数据，第一个参数字符数组，第二个参数起始值，第三个参数写的长度
* 2.3 public void write(String str, int off, int len) 按照字符串写数据，第一个参数字符串，第二个参数起始值，第三个参数写的长度
* 2.4 public void write(String str) 按照字符串写数据
* 2.5 public void flush() 刷新
* 2.6 public void close() 关闭
*
* 3.使用场景
* FileWriter 比 FileOutputStream 更适合文本写出操作，效率更高；写出的时候是一个一个字符写，比一个一个字节写快许多
*/
public class FileWriterDemo {
public static void main(String[] args) {
try (
FileWriter fw = new FileWriter("F:\\temp\\aaa.txt" , true);
){
//写数据
fw.write("\r\n");
fw.write('a');
fw.write("\r\n");
char[] cs = {'a' , 'b' , 'c' , 'd' , 'e'};
fw.write(cs , 1 , 3);
fw.write("\r\n");
fw.write("中国最强！");
System.out.println("写出完成！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
5.CloseDemo FInally简写话try（）
package com.igeek.javase.ch15.file;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 11:33
*
* JDK1.7 之前
* try...catch...finally 在finally中关闭资源
*
* JDK1.7 及以后 关闭资源的方式
* try(
* //资源类 implements Closeable
* 创建资源类的对象，用完即关闭，但是不允许放无关资源类的代码
* ){
* //代码
* }catch(Exception e){
* //捕捉异常
* }
*/
public class CloseDemo {
public static void main(String[] args) {
try(
//1.创建字节输入流对象
FileInputStream fis = new FileInputStream("abc.txt");
//System.out.println("");
Scanner sc = new Scanner(System.in);
) {
//2.读取文本数据
byte[] bytes = new byte[1024];
int len = 0;
//len=-1 说明读到文件末尾
while ((len=fis.read(bytes))!=-1){
System.out.println("读取到的文本："+new String(bytes , 0 , len));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
6.BufferedInputStreamDemo
package com.igeek.javase.ch15.buffer;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 14:02
*
* BufferedInputStream 输入流 字节流 处理流
* 缓冲高效字节输入流
* 1.构造方法
* 1.1 public BufferedInputStream(InputStream in) + int DEFAULT_BUFFER_SIZE = 8192 等价于 8kb
* 1.2 public BufferedInputStream(InputStream in, int size)
*
* 2.为什么高效
* protected volatile byte buf[] = new byte[size]; 字节数组即缓冲区
*
* 3.常用API方法
* 3.1 public synchronized int read()
* 3.2 public synchronized int read(byte b[])
* 3.3 public synchronized int read(byte b[], int off, int len)
* 3.4 public synchronized void close() 关闭资源
*
* 4.使用场景
* 4.1 File/String -> FileInputStream -> BufferedInputStream -> read(byte b[])读数据
* 4.2 JDK1.7关闭资源，可以直接在try中操作
* 4.1 不适合对文本内容进行读写操作，很容易发生乱码，一个字节一个字节读取内容效率较低
* 4.2 适合图片、音视频上传下载和拷贝
*/
public class BufferedInputStreamDemo {
public static void main(String[] args) {
try (
//1.构建FileInputStream流对象
FileInputStream fis = new FileInputStream("abc.txt");
//2.构建BufferedInputStream 高效的缓冲流对象
BufferedInputStream bis = new BufferedInputStream(fis);
){
//3.读数据
byte[] bytes = new byte[1024];
int len = 0;
while ((len = bis.read(bytes))!=-1){
System.out.println(new String(bytes , 0 , len));
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
7BufferedOutputStreamDemo
package com.igeek.javase.ch15.buffer;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 14:02
*
* BufferedOutputStream 输出流 字节流 处理流
* 缓冲高效字节输出流
* 1.构造方法
* 1.1 public BufferedOutputStream(OutputStream out)
* 1.2 public BufferedOutputStream(OutputStream out, int size)
*
* 2.为什么高效
* protected byte buf[] = new byte[size]; size默认是8192，相当于8kb
*
* 3.常用API方法
* 2.1 public synchronized void write(int b)
* 2.2 public synchronized void write(byte b[])
* 2.3 public synchronized void write(byte b[], int off, int len)
* 2.4 public synchronized void flush()
* 2.5 public synchronized void close() 关闭资源
*
* 4.使用场景
* 4.1 String/File -> FileOutputStream -> BufferedOutputStream -> write(byte b[])
* 4.2 JDK1.7资源关闭，可以放在try块中进行关闭操作
* 4.3 不适合对文本内容进行读写操作，很容易发生乱码，一个字节一个字节读取内容效率较低
* 4.4 适合图片、音视频上传下载和拷贝
*/
public class BufferedOutputStreamDemo {
public static void main(String[] args) {
try (
//1.构建FileOutputStream对象
FileOutputStream fos = new FileOutputStream("abc.txt" , true);
//2.构建BufferedOutputStream 高效的缓冲流对象
BufferedOutputStream bos = new BufferedOutputStream(fos);
){
//3.写数据
bos.write('\n');
bos.write('C');
bos.write('\n');
bos.write(new byte[]{'A','B','C','D','E'});
bos.write('\n');
bos.write(new byte[]{'A','B','C','D','E'} , 1 , 3);
//4.刷新
bos.flush();
System.out.println("写出成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
8.BufferedReaderDemo
package com.igeek.javase.ch15.buffer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 14:02
*
* BufferedReader 输入流 字符流 处理流
* 1.构造方法
* 1.1 public BufferedReader(Reader in)
* 1.2 public BufferedReader(Reader in, int sz)
*
* 2.为什么高效
* 内置缓冲区（数组） private char cb[] = new char[sz]; //sz 默认8192，即8kb
*
* 3.常用API方法
* 3.1 public int read() 读取一个一个字符
* 3.2 public int read(char cbuf[], int off, int len) 按照指定的字符数组，进行读取内容
* 3.3 public String readLine() 读取一行
*
* 4.使用场景
* 4.1 String/File -> FileReader -> BufferedReader -> readLine() 读取一行
* 4.2 JDK1.7关闭资源，直接放置在try()中
* 4.3 更适合文本读取操作，效率更高；读取的时候是可以直接读取一行，高效
*/
public class BufferedReaderDemo {
public static void main(String[] args) {
try (
//1.构建FileReader流对象
FileReader fr = new FileReader("F:\\temp\\aaa.txt");
//2.构建BufferedReader 高效缓冲流对象
BufferedReader br = new BufferedReader(fr);
){
String str = null;
while ((str=br.readLine())!=null){
System.out.println(str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
9.BufferedWriterDemo
package com.igeek.javase.ch15.buffer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* @Description TODO
* @Author chenmin
* @Version 1.0
* @Date 2022/11/11 14:02
*
* BufferedWriter 输出流 字符流 处理流
* 1.构造方法
* 1.1 public BufferedWriter(Writer out)
* 1.2 public BufferedWriter(Writer out, int sz)
*
* 2.为什么高效
* 内置缓冲区（数组） private char cb[] = new char[sz]; //sz 默认8192，即8kb
*
* 3.常用API方法
* 3.1 public void write(int c)
* 3.2 public void write(char cbuf[], int off, int len)
* 3.3 public void write(String s)
* 3.4 public void write(String s, int off, int len)
* 3.5 public void newLine() 写出换行符 \n
* 3.6 public void flush()
* 3.7 public void close()
*
* 4.使用场景
* 4.1 File/String -> FileWriter -> BufferedWriter ->
* 4.2 JDK1.7关闭资源，直接放置在try()中
* 4.3 更适合文本读取操作，效率更高；读取的时候是可以直接读取一行，高效
*/
public class BufferedWriterDemo {
public static void main(String[] args) {
try (
//1.构建FileWriter流对象
FileWriter fw = new FileWriter("F:\\temp\\aaa.txt" ,true);
//2.构建BufferedWriter 高效缓冲输出流 对象 PrintWriter
BufferedWriter bw =new BufferedWriter(fw);
){
//3.写数据
bw.newLine(); //换行
bw.write("今天有点闷");
bw.write("今天有点热");
//4.刷新
bw.flush();
System.out.println("写出成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
}
1459
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
