1.根据路径构建File
File file = new File("d:\\1.txt");
2.根据父目录文件+子路径构建文件
File parentFile = new File("d:\\");
String fileName = "2.txt";
File file = new File(parentFile, fileName);
3.父目录+子路径构建
String parentPath = "d:\\";
String fileName = "3.txt";
File file = new File(parentPath, fileName);
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
File file = new File("d:\\2.txt");
file.getName();//获取文件名
file.getAbsolutePath();//文件绝对路径
file.getParent();//得到文件的父级目录
file.length();//文件大小 字节(utf-8 汉字3个字节)
file.exists();//文件是否存在
file.isDirectory();//是否是目录
file.isFile();//是否是文件
file.mkdir();//创建目录
file.mkdirs();//创建多级目录
file.delete();//删除文件、空目录
字节流:二进制文件
字符流:文本文件
都是抽象类,使用的时候都要创建子类使用
一个字节读取
public static void main(String[] args) {
String path = "d:\\2.txt";//hello world
int data;
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(path);
while ((data=fileInputStream.read())!= -1){ //读取一个字节 遇到汉字乱码
System.out.print((char)(data));
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
多个字节读取
public static void main(String[] args) {
String path = "d:\\2.txt";//hello world
byte[] data = new byte[8];
int readLen =0;
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(path);
while ((readLen = fileInputStream.read(data))!= -1){ //读取正常 返回实际读取的字节数
System.out.println(new String(data,0,readLen));
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
文件不存在的话会创建,write会覆盖前面的内容,使用new FileOutputStream(filePath,true);创建则会追加
@Test
public void writeFile(){
FileOutputStream fileOutputStream = null;
String filePath = "d:\\hello.txt";
try {
fileOutputStream = new FileOutputStream(filePath);
// fileOutputStream.write('H');
String s = "hello,world"; //String.getBytes
// fileOutputStream.write(s.getBytes(StandardCharsets.UTF_8));
fileOutputStream.write(s.getBytes(),0,s.length());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void copyFile(){
String srcPath = "d:\\胡歌.jpeg";
String descPath = "e:\\1.jpeg";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream(srcPath);
fileOutputStream = new FileOutputStream(descPath);
byte[] buffer = new byte[1024];
int readLen = 0;
while ((readLen = fileInputStream.read(buffer)) != -1){
fileOutputStream.write(buffer,0,readLen);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fileInputStream != null){
fileInputStream.close();
}
if(fileOutputStream != null) {
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
使用单个字符读取文件
public void fileReader(){
FileReader fileReader = null;
int data =0;
try {
fileReader = new FileReader("d:\\2.txt");
while ( (data = fileReader.read()) != -1){
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fileReader != null){
fileReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符数组读取文件
public void fileReader(){
FileReader fileReader = null;
int dataLen =0;
char[] buff = new char[8];
try {
fileReader = new FileReader("d:\\2.txt");
while ( (dataLen = fileReader.read(buff)) != -1){
System.out.print(new String(buff,0,dataLen));
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fileReader != null){
fileReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
使用FileWriter 一定要close 或者 flush 方法 否则数据写不进去
writeBytes();
public static void main(String[] args) {
String path = "d:\\hello.txt";
char[] chars = {'a','b','c'};
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(path,true);
fileWriter.write('h');//写入单个字符
fileWriter.write(chars);//写数组
fileWriter.write("往者不可谏".toCharArray(),0,2);//写入数组指定部分
fileWriter.write("来者犹可追");//写入字符串
fileWriter.write("今天你好",0,2);//指定字符串
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileWriter.close();
// fileWriter.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
1.节点流可以从一个特定的数据源读写数据,如FileReader 、FileWriter
2.处理流(也叫包装流)是连接在已存在的流(节点流或者处理流)之上为程序提供更为强大的读写功能,如BufferedReader bufferedWriter
(bufferedReader类中有属性Reader,可以封装一个节点流,只要是Reader的子类就可以)
1.节点流是底层流/低级流,直接跟数据源连接
2.处理流(包装流)包装节点流,既可以消除不同节点流的实现差异,也可以提供更方便的方法来完成输入输出。
3.处理流对节点流进行包装,使用修饰器设计模式 不会直接与数据源相连
处理流的功能主要体现在以下两个方面:
1.性能的提高:主要增加缓冲的方式来提高输入输出的效率。
2.操作的便捷:处理流可以提供一系列的便捷方法来一次输入输出大批量的数据,使用更加灵活方便。
关闭只需要关闭外层流 bufferedReader.close();
public void close() throws IOException {
synchronized (lock) {
if (in == null)
return;
try {
in.close(); //Reader
} finally {
in = null;
cb = null;
}
}
}
父类 Reader_
public abstract class Reader_ {
// abstract void readFile(); //如果写的是抽象方法,则子类要实现全部的抽象方法
// abstract void readString();
void readFile(){ //子类重写父类的方法
System.out.println("read_file");
};
void readString(){
System.out.println("read_string");
};
}
public class FileReader_ extends Reader_ {
public void readFile(){
System.out.println("readFile");
}
}
public class StringReader_ extends Reader_ {
public void readString(){
System.out.println("readString");
}
}
public class BufferedReader_ extends Reader_ {
private Reader_ reader_;
public BufferedReader_(Reader_ reader_) { //调用子类的
this.reader_ = reader_;
}
public void readFiles(){
this.reader_.readFile();
}
public void readStrings(){
this.reader_.readString();
}
}
public class Test {
public static void main(String[] args) {
BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
bufferedReader_.readFiles(); //readFile
bufferedReader_.readFile(); //read_file
BufferedReader_ bufferedReader_1 = new BufferedReader_(new StringReader_());
bufferedReader_1.readStrings();//readString
bufferedReader_1.readString();//read_string
}
}
@Test
public void bufferedReader_(){
BufferedReader bufferedReader = null;
String path = "d:\\2.txt";
try {
bufferedReader = new BufferedReader(new FileReader(path));
String line;//按行读取
while( (line = bufferedReader.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(bufferedReader != null){
bufferedReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void bufferedWriter_(){
String path = "d:\\3.txt";
BufferedWriter bufferedWriter = null;
try {
bufferedWriter =new BufferedWriter(new FileWriter(path,true));//追加方式 在节点流加true
bufferedWriter.write("时间就像火车一样,飞速驶离,但我却象在车厢内熟睡的乘客般毫无知觉。一旦醒来,已经错过很多的东西,甚至错过停靠的站。");
bufferedWriter.newLine();//插入和系统相关的换行
bufferedWriter.write("在不了解一个人之前,不要轻易下结论,在了解一个人之后,也不要轻易下结论。人这么复杂,岂是你一句结论就能概全的?");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(bufferedWriter != null){
bufferedWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void bufferedCopy(){
String srcPath ="d:\\2.txt";
String descPath = "d:\\4.txt";
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try {
bufferedReader = new BufferedReader(new FileReader(srcPath));
bufferedWriter = new BufferedWriter(new FileWriter(descPath));
String line;
while ((line = bufferedReader.readLine()) != null){
bufferedWriter.write(line);
bufferedWriter.newLine();//得加上换行符 要不然格式会乱
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(bufferedReader != null) {
bufferedReader.close();
}
if(bufferedWriter != null) {
bufferedWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void bufferedCopy2(){
String srcPath ="d:\\5.doc";
String descPath = "d:\\6.doc";
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream = null;
byte[] data = new byte[1024];
int len;
try {
bufferedInputStream = new BufferedInputStream(new FileInputStream(srcPath));
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(descPath));
while ((len = bufferedInputStream.read(data)) != -1){
bufferedOutputStream.write(data,0,len);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(bufferedInputStream != null) {
bufferedInputStream.close();
}
if(bufferedOutputStream != null) {
bufferedOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
序列化和反序列化
序列化:保存数据的时候保存数据的值和数据类型。
反序列化:恢复数据的时候恢复数据的值和数据类型。
对象要能序列化 要实现 Serializable Externalizable中的一个,建议Serializable
public static void main(String[] args) {
//序列化的格式不是纯文本的 按照他的格式保存的
String path = "d:\\1.bat";
ObjectOutputStream objectOutputStream = null;
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
objectOutputStream.writeInt(100);//int --Integer
objectOutputStream.writeBoolean(true);
objectOutputStream.writeChar('h');
objectOutputStream.writeDouble(1.1);
objectOutputStream.writeUTF("没有人是生来就无情的,都是经历并看到了太多自己不想看到的,而最终选择了关上自己的某扇门。");
objectOutputStream.writeObject(new A(1));
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(objectOutputStream != null) {
objectOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class A implements Serializable {
private int n;
public A(int n) {
this.n = n;
}
}
@Test
public void readObject(){
String path = "d:\\1.bat";
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(path));
//防范序列化的顺序得和序列化顺序一致
System.out.println(objectInputStream.readInt());
System.out.println(objectInputStream.readBoolean());
System.out.println(objectInputStream.readChar());
System.out.println(objectInputStream.readDouble());
System.out.println(objectInputStream.readUTF());
System.out.println(objectInputStream.readObject().getClass());//Object-->A (class的位置得一致)
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if (objectInputStream != null) {
objectInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public final static InputStream in = null;
编译类型 InputStream
运行类型 BufferedInputStream
public final static PrintStream out = null;
编译类型 PrintStream
运行类型 PrintStream
默认文件是UTF-8 如果是其他格式 用fileReader 会乱码 所以FileInputStream–>inputStreamReader 字节–>字符
public void code(){
String path = "d:\\7.txt"; //默认文件是UTF-8 如果不是用fileReader 会乱码 所以FileInputStream-->inputStreamReader 字节-->字符
BufferedReader bufferedReader = null;
String readLine;
try {
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(path),"gbk");
bufferedReader = new BufferedReader(inputStreamReader);
while( (readLine = bufferedReader.readLine())!=null){
System.out.println(readLine);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(bufferedReader != null) {
bufferedReader.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
默认writer保存文件utf8 可以使用字节流 指定格式 转换为字符流
@Test
public void code2(){
String path = "d:\\8.txt";
OutputStreamWriter outputStreamWriter = null;
try {
outputStreamWriter = new OutputStreamWriter(new FileOutputStream(path),"gbk");//utf8 utf-8
outputStreamWriter.write("人应该支配习惯,而决不能让习惯支配人;一个人不能去掉他的坏习惯,那简直一文不值。");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (outputStreamWriter != null) {
outputStreamWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void printf() throws IOException{
PrintStream printStream = System.out;
printStream.print("hello");
printStream.write("world".getBytes());
printStream.close();
// System.setOut(new PrintStream(""));//可以修改打印输出的位置
}
// PrintWriter printWriter = new PrintWriter(System.out);
PrintWriter printWriter = new PrintWriter("d:\\9.txt");
printWriter.write("haha");
printWriter.close();
@Test
public void readProperties() throws IOException{
String readLine ;
BufferedReader bufferedReader = new BufferedReader(new FileReader("E:\\java_han\\src\\my.properties"));
while((readLine =bufferedReader.readLine()) != null){
System.out.println(readLine);
}
bufferedReader.close();
}
@Test
public void readProperties02() throws IOException{
Properties properties = new Properties();
properties.load(new FileReader("E:\\java_han\\src\\my.properties"));//加载
properties.list(System.out);
System.out.println(properties.get("user"));
properties.setProperty("name","tom");//可以增加
properties.setProperty("user","jack"); //可以修改
// properties.store(); 保存
properties.list(System.out);
}