目录
BufferedInputStream与BufferedOutputStream
使用BufferedInputStream与BufferedOutputStream拷贝二进制文件
InputStreamReader与OutputStreamWriter
文件基础知识
文件的创建方法
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;
/**
* @auther xcz
* @data 2024/4/21
* @project PACKAGE_NAME
*/
public class FileCreate {
public static void main(String[] args) {
}
//方式一 new File(String[], args)
@Test
public void create01(){
String filePath = "e:\\news1.txt"; //等价于 e:/news1.txt
File file = new File(filePath);
try {
file.createNewFile();
System.out.println("文件创建成功!");
}catch (IOException e){
e.printStackTrace();
}
}
//方式2 new File(File parent,String child) //根据父目录文件 + 子路径构建
//目标创建文件 e:\\news2.txt
@Test
public void create02(){
File parentFile = new File("e:\\");
String chileFile = "news2.txt";
//这里只是创建一个java对象
File file1 = new File(parentFile,chileFile);
try {
//真正创建文件的语句
file1.createNewFile();
System.out.println("创建成功!");
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
// 方式3 new File(String parent,String child) //根据父目录 + 子路径构建
public void create03(){
String parentPath = "e:\\";
String fileName = "news3.txt";
File file = new File(parentPath, fileName);
try {
file.createNewFile();
System.out.println("创建成功!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
常用文件操作
常用方法
import java.io.File;
/**
* @auther xcz
* @data 2024/4/22
* @project PACKAGE_NAME
*/
public class fileInfomation {
public static void main(String[] args) {
fileInfomation fileInfomation = new fileInfomation();
fileInfomation.info();
}
//获取文件信息
public void info(){
//先创建文件对象
File file = new File("e:\\news1.txt");
//调用对应方法,得到对应信息
System.out.println("文件名字: " + file.getName());
System.out.println("文件绝对路径: " + file.getAbsolutePath());
System.out.println("文件父级目录: " + file.getParent());
System.out.println("文件大小(字节): " + file.length());
System.out.println("文件是否存在: " + file.exists());
System.out.println("是不是一个文件: " + file.isFile());
System.out.println("是不是一个目录: " + file.isDirectory());
}
}
创建文件与目录
import org.junit.jupiter.api.Test;
import java.io.File;
/**
* @auther xcz
* @data 2024/4/22
* @project PACKAGE_NAME
*/
public class Directory_ {
public static void main(String[] args) {
}
@Test
//判断 e:\\news1.txt 是否存在,如果存在就删除
public void m1(){
String filePath = "e:\\news1.txt";
File file = new File(filePath);
if (file.exists()){
if(file.delete()) {
System.out.println("文件已删除!");
}else {
System.out.println("文件删除失败!");
}
}else {
System.out.println("文件不存在!");
}
}
//判断目录 e:\\demo02 是否存在 ,存在就删除,否则提示不存在并创建
//java编程中,目录也被当做文件,只是特别的文件
@Test
public void m2(){
String filePath = "e:\\demo02";
File file = new File(filePath);
if (file.exists()){
if(file.delete()) {
System.out.println(file.getName() + "该目录已删除!");
}else {
System.out.println(file.getName() + "该目录删除失败!");
}
}else {
System.out.println(file.getName() + "该目录不存在!");
System.out.println("正在创建该目录");
if (file.mkdir()){ //mkdir()创建单级目录 mkdirs()创建多级目录
System.out.println("该目录创建成功!");
}else {
System.out.println("该目录创建失败!");
}
}
}
}
IO流原理及流的分类
演示FileInputStream的使用
package InputStream;
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* @auther xcz
* @data 2024/4/22
* @project 演示 FileInputStream 的使用(字节输如 文件 ->程序 )
*/
public class fileInputStream {
public static void main(String[] args) {
}
/**
* 读取文件 ....
* 单个字节读取,效率比较低....
* 使用read(byte[]) 方式读取字节,提高效率
*/
@Test
public void readFile1() {
String filePath = "e:\\hello.txt";
int readDate = 0;
FileInputStream fileInputStream = null;
try {
//创建 FileInputStream 对象,用于读取 文件
fileInputStream = new FileInputStream(filePath);
//从该输入流读取一个字节数据,如果没有字节可用,则方法将阻止
//如果返回 -1 表示读取完毕
while ((readDate = fileInputStream.read()) != -1) {
System.out.print((char) readDate); //转换成 char 显示
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
//使用 read(byte[]) 方式读取文件,提高效率
public void readFile2() {
String filePath = "e:\\hello.txt";
//字节数组
byte[] buffer = new byte[8]; //一次读 8个字节
int readLen = 0;
FileInputStream fileInputStream = null;
try {
//创建 FileInputStream 对象,用于读取 文件
fileInputStream = new FileInputStream(filePath);
//从该输入流读取最多 b.length 字节的数据到字节数组
//如果返回 -1 表示读取完毕
//如果读取正常返回实际读取的字节数
while ((readLen = fileInputStream.read(buffer)) != -1) {
System.out.print(new String(buffer, 0, readLen)); //转化为字符串显示
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
演示FileOutPutStream的使用
package outPutStream;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**
* @auther xcz
* @data 2024/4/22
* @project outPutStream
*/
public class FileOutPutStream01 {
public static void main(String[] args) {
}
/**
* 演示使用 FileOutPutStream 将数据写到文件中
* 如果文件不存在 ,则创建该文件
*/
@Test
public void WriteFile01() throws IOException {
//创建 FileOutPutStream 对象
String filePath = "e:\\a.txt";
//得到 utleInputStream1 对象
//new FileOutputStream(filePath)创建方式,当写入内容时会覆盖原来的内容
//new FileOutputStream(filePath, true) 创建方式,当写入内容时会追加在原来内容后面
FileOutputStream fileOutputStream1 = new FileOutputStream(filePath,true);
//写入一个字节
fileOutputStream1.write('X');
//写入一个字符串
String str = "xcz ai qinli!";
//str.getByts() String --> byte[]
//write(Byte[] byte)
fileOutputStream1.write(str.getBytes());
//写入一个字符串,指定起始于截止位置
//write(Byte[] byte , int off, int len) -->从哪到哪写进去
fileOutputStream1.write(str.getBytes(),0,str.length() - 4);
//关闭文件
fileOutputStream1.close();
}
}
文件拷贝
package FileCopy;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @auther xcz
* @data 2024/4/22
* @project FileCopy 完成文件拷贝
*/
public class fileCopy {
public static void main(String[] args) throws IOException {
//完成文件拷贝 将 e:\\nyp.jpg 拷贝到d:\\
//思路分析
//1、创建文件输入流, 将文件读入到程序
//2、创建文件输出流, 将读入的文件数据,写入指定的文件
String srcfilePath = "E:\\npy.jpg"; //指定copy文件的地址
String destfilePath = "e:\\nyp2.jpg"; //目标存放文件地址
FileInputStream fileInputStream = new FileInputStream(srcfilePath);
FileOutputStream fileOutputStream = new FileOutputStream(destfilePath);
//定义一个字节数组提高效率
byte[] bytes = new byte[1024];
int readLen = 0;
while ((readLen = fileInputStream.read(bytes)) != -1){
//读入的数据就保存到想要的文件夹 通过使用 FileOutputStream
//即 边读边写
fileOutputStream.write(bytes,0,readLen); //一定使用write(bytes 数组,int 起始位置,len 结束位置)
}
System.out.println("拷贝成功");
if (fileInputStream != null){
fileInputStream.close();
}
if (fileOutputStream != null){
fileOutputStream.close();
}
}
}
IO流体系常用的类
FileReader与FileWriter
文件读取方法及使用
package reder;
import org.junit.jupiter.api.Test;
import java.io.FileReader;
import java.io.IOException;
/**
* @auther xcz
* @data 2024/4/22
* @project FileReader 的两种使用方式
*/
public class fileReader {
public static void main(String[] args) throws IOException {
String filePath = "e:\\story.txt";
char a = ' ';
int data = 0;
//1. 创建 FileReader 对象
FileReader fileReader = new FileReader(filePath);
//while 循环读取使用read ,单个字符读取
while ((data = fileReader.read()) != -1){
System.out.print((char) data);
}
if (fileReader != null){
fileReader.close();
}
}
/**
使用字符数组读取文件,提高读取效率
*/
@Test
public void file_Reader02() throws IOException {
String file_Path = "e:\\story.txt";
char[] buf = new char[8];
int readLen = 0;
//1. 创建 FileReader 对象
FileReader fileReader = new FileReader(file_Path);
//while 循环读取使用read(buf) ,实际读取到的字符数 :8
//如果返回 -1 ,说明文件读取结束
while ((readLen = fileReader.read(buf)) != -1){
System.out.print(new String(buf,0,readLen));
}
if (fileReader != null){
fileReader.close();
}
}
}
文件写入方法及使用
package fileWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/**
* @auther xcz
* @data 2024/4/22
* @project fileWriter
*/
public class file_Writer {
public static void main(String[] args) throws IOException {
String filePath = "e:\\note.txt";
char[] chars = {'a','b','c'};
//判断是否存在文件,不存在则创建文件
File file = new File(filePath);
if (file.exists()){
System.out.println("文件已存在");
}else {
file.createNewFile();
System.out.println(file.getName() + " 文件创建成功");
}
//创建 FileWriter 对象
FileWriter fileWriter = new FileWriter(filePath); //默认是覆盖写入
// Write(int) : 写入单个字符
fileWriter.write('H');
// Write(char[]) : 写入指定数组
fileWriter.write(chars);
// Write(char[].off,len) 写入指定数组的指定部分
fileWriter.write("韩顺平java".toCharArray(),0,3);
// Write(String) 写入指定的字符串
fileWriter.write("北京 你好!");
// Write(String) 写入指定字符串的指定部分
fileWriter.write("天津上海",0,2);
//数据量大的时候,可以使用循环,循环加入
//对于 FileWriter ,一定要关闭流,或者flush 才能真正把数据写入文件
fileWriter.close();
}
}
节点流与处理流
BufferReader与BufferWriter
BufferedReader
package reder;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* @auther xcz
* @data 2024/4/22
* @project 演示 bufferedReader 的使用
*/
public class bufferedReader {
public static void main(String[] args) throws IOException {
String filePath = "e:\\story.java";
// 创建bufferedReader
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
//读取数据
String line; //按行读取
// 1、bufferedReader.readLine() 实现按行读取,提高效率
// 2、当返回 null 时表示文件读取完毕
while ((line = bufferedReader.readLine()) != null){
System.out.println(line);
}
//关闭流 ,只需处理流关闭 BufferedReader,因为底层会自动关闭 节点流
//FileReader
bufferedReader.close();
}
}
BufferedWriter
package fileWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/**
* @auther xcz
* @data 2024/4/22
* @project 演示 BufferedWriter 的使用
*/
public class bufferedWriter {
public static void main(String[] args) throws IOException {
String filePath = "e:\\note.txt";
//new FileWriter(filePath,true) 表示以追加的方式进行写入
//new FileWriter(filePath) 表示以覆盖的方式进行写入
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
//write()
bufferedWriter.write("大王叫我来巡上");
bufferedWriter.newLine(); //表示插入一个和系统相关的换行
bufferedWriter.write("大王叫我来巡山");
bufferedWriter.newLine();
bufferedWriter.write("大王叫我来巡山");
bufferedWriter.close();
}
}
结合Buffered 拷贝文件
注意:!!!BufferedReader是按照字符操作,不能去操作二进制文件,否则可能造成二进制文件损坏
package FileCopy;
import reder.bufferedReader;
import java.io.*;
/**
* @auther xcz
* @data 2024/4/23
* @project 使用 BufferedReader 和 BufferedWrite 拷贝文件
*/
public class bufferedCopy {
public static void main(String[] args) throws IOException {
String srcFilePath = "e:\\story.java"; //源文件地址
String newFilePath = "e:\\story2.java"; //拷贝文件地址
String line;
//创建源文件读取 创建拷贝文件写入
BufferedReader bufferedReader = new BufferedReader(new FileReader(srcFilePath));
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(newFilePath));
while ((line = bufferedReader.readLine()) != null){
//每读取一行,就马上写入
bufferedWriter.write(line);
//插入换行
bufferedWriter.newLine();
System.out.println("拷贝中......");
}
System.out.println("拷贝完成!");
//关闭流
bufferedWriter.close();
bufferedReader.close();
}
}
BufferedInputStream与BufferedOutputStream
使用BufferedInputStream与BufferedOutputStream拷贝二进制文件
package FileCopy;
import java.io.*;
/**
* @auther xcz
* @data 2024/4/23
* @project 使用 BufferedInputStream 与 BufferedOutputStream 可以拷贝二进制文件
*/
public class bufferedInput_Output {
public static void main(String[] args) throws IOException {
String srcPath = "e:\\npy.jpg"; //原文件地址
String newPath = "e:\\npy3.jpg"; //拷贝文件地址
byte[] bytes = new byte[1024];
int readLen;
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(srcPath));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(newPath));
//循环读取文件并写入
while ((readLen = bufferedInputStream.read(bytes)) != -1){
bufferedOutputStream.write(bytes,0,readLen);
}
//关闭外层处理流,底层自动关闭节点流
bufferedInputStream.close();
bufferedOutputStream.close();
System.out.println("文件拷贝完毕~");
}
}
对象流
ObjectOutputStream
将数据写入文件
package outPutStream;
import java.io.*;
/**
* @auther xcz
* @data 2024/4/23
* @project 演示 objectOutPutStream 的使用,完成数据的序列化
*/
public class objectOutputStream {
public static void main(String[] args) throws IOException {
//序列化后,保存的文件格式,不是存文本,而是按照他的格式来保存
String filePath = "e:\\data.dat";
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到 e:\data.dat
objectOutputStream.write(100); //int -> Integer (实现了 Serializable)
objectOutputStream.writeBoolean(true); //boolean -> Boolean (实现了 Serializable)
objectOutputStream.write('a'); //char -> Character (实现了 Serializable)
objectOutputStream.writeDouble(9.5); //double -> Double (实现了 Serializable)
objectOutputStream.writeUTF("小城之春"); //String
//保存一个Dog对象
objectOutputStream.writeObject(new Dog("旺财",10));
//关闭处理流
objectOutputStream.close();
System.out.println("已将数据(序列化)写入文件");
}
}
//如果需要序列化某个类的对象 必须实现 Serializable 接口
class Dog implements Serializable {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
ObjectInputStream
package InputStream;
import java.io.*;
/**
* @auther xcz
* @data 2024/4/23
* @project ObjectInputStream 反序列化文件 -> 读取序列化后的文件
*/
public class objectInputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 指定反序列化的文件
String filePath = "e:\\data.dat";
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
//读取(反序列化)的顺序需要和你保存数据(序列化)顺序一致
//否则会出现异常
System.out.println(objectInputStream.readInt()); // 读取 Integer -> Int
System.out.println(objectInputStream.readBoolean());
System.out.println(objectInputStream.readChar());
System.out.println(objectInputStream.readDouble());
System.out.println(objectInputStream.readUTF());
System.out.println("运行类型 = " + objectInputStream.getClass());
//dog 的编译类型是 Object dog 的运行类型是 Dog
Object dog = objectInputStream.readObject();
System.out.println("dog信息= " + dog.toString()); //底层 Object -> Dog
//这里是重要的细节:
//1、如果我们希望调用Dog方法,需要向下转型
//2、需要我们将Dog类的定义,拷贝到可以引用的位置
// Dog dog2 = (Dog) dog;
//关闭流
objectInputStream.close();
}
}
标准输入输出流
package standard_;
/**
* @auther xcz
* @data 2024/4/23
* @project 标准输入 标准输出流
*/
public class standard {
public static void main(String[] args) {
//System 底层 public final static InputStream in = null;
//System.in 编译类型 InputStream
//System.in 运行类型 BufferedInputStream
// 表示标准输入 即键盘
System.out.println(System.in.getClass());
// public final static PrintStream out = null;
// System.out 编译类型 PrintStream
// System.out 运行类型 PrintStream
// 表示标准输出 即显示器
System.out.println(System.out.getClass());
}
}
转换流
InputStreamReader与OutputStreamWriter
设置文件编码 读取文件
package tansformation;
import com.sun.istack.internal.localization.NullLocalizable;
import com.sun.org.apache.bcel.internal.generic.NEW;
import java.io.*;
import java.nio.charset.StandardCharsets;
/**
* @auther xcz
* @data 2024/4/23
* @project tansformation
* 看一个中文乱码问题
* 演示使用 InputStreamReader 转换流解决中文乱码问题
* 将字节流 FileInputStream 转换成 字符流
*/
public class CodeQuestion {
public static void main(String[] args) throws IOException {
String filePath = "e:\\a.txt";
String readLen;
// 把 FileInputStream 转换成 InputStreamReader
// 指定编码为 gbk
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath),"gbk");
// 把InputStreamReader 传入 BufferedReader
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
// 等价于 BufferedReader bufferedReader =
// new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
//读取
while((readLen = bufferedReader.readLine()) != null){
System.out.println("读取内存 = " + readLen);
}
}
}
写入文件 指定文件编码
package tansformation;
import fileWriter.bufferedWriter;
import java.io.*;
/**
* @auther xcz
* @data 2024/4/23
* @project 演示 OutputStreamWriter 使用
* 把 FileOutputStream 字节流 转换为 字符流 OutputStreamWriter
* 指定处理的编码 gbk / utf-8 / utf8
*/
public class OuterPutStreamWriter {
public static void main(String[] args) throws IOException {
String filePath = "e:\\a.txt";
String charSet = "gbk";
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
outputStreamWriter.write("xczcxczcwesdfsdfdsferr");
//关闭流
System.out.println("文件修改成功");
outputStreamWriter.close();
}
}
打印流
PrintStream 字节流
PrintWriter 字符流
PrintStream 字节流
package printStream;
import java.io.IOException;
import java.io.PrintStream;
/**
* @auther xcz
* @data 2024/4/23
* @project printStream
* 演示 PrintStream (字节打印流)
*/
public class print_Stream {
public static void main(String[] args) throws IOException {
PrintStream out = System.out;
//默认情况下,PrintStream 输出的位置是 标准输出 ,即显示器
out.println("可爱的女孩");
//因为 print 底层使用的是 write ,所以可以直接调用 write 进行打印/输出
out.write("女孩很可爱".getBytes());
//我们可以修改打印流输出的位置/设备
//输出修改成了 "e:\\t1.txt" 位置
//"hello"将会输出到 "e:\\t1.txt"
System.out.println(new PrintStream("e:\\f1.txt"));
System.out.println("hello");
out.close();
}
}
PrintWriter
package printStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* @auther xcz
* @data 2024/4/24
* @project printStream
* 演示 PrintWriter 使用方法
*/
public class printWriter {
public static void main(String[] args) throws IOException {
PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f1.txt"));
printWriter.println("你好,北极!");
// 相当于 flush + 关闭流
printWriter.close();
}
}
Properties类
读取MySQL文件
package properties_;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
/**
* @auther xcz
* @data 2024/4/24
* @project properties_
*/
public class properties_01 {
public static void main(String[] args) throws IOException {
//使用 Properties 类来读取 mySql.properties 文件
// 1、创建一个 Properties 对象
Properties properties = new Properties();
// 2、加载指定配置文件
properties.load(new FileReader("D:\\idea_java_project\\javaSE\\chapter19\\src\\mySql.properties"));
// 3、把 k-v 显示控制台
properties.list(System.out);
// 4、根据key 获取对应的值
String user = properties.getProperty("user");
String pwd = properties.getProperty("pwd");
System.out.println("用户名:"+ user +
" 密码:" + pwd);
}
}