File对象
概述
File类在包java.io.File下,代表操作系统的文件对象(文件、文件夹)
File类提供了诸如:定位文件、获取文件本身信息、删除文件、创建文件(文件、文件夹)等功能
创建File对象的方式
public File(String pathname) 根据文件路径创建文件对象
pulbic File(String parent,String child) 从父路径名字符串或子路径名字符串创建对象
public File(File parent,String child) 根据父路径对应文件对象和子路径字符串创建文件对象
package com.spark.study;
import java.io.File;
/**
* FileDemo class
* description: file对象创建
*
* @author Administrator
* @date 2023/4/30
*/
public class FileDemo {
public static void main(String[] args) {
// 根据路径创建File对象,绝对路径
File file = new File("D:\\IDEA 2020\\workplaces\\io-study\\src\\data.txt");
// 该文件路径对应的文件对象是否存在
System.out.println(file.exists());
// 文件字节大小
System.out.println(file.length());
// 根据路径创建File对象,相对路径
File file2 = new File("io-study\\src\\data.txt");
// 判断该路径对应的文件对象是否存在
System.out.println(file2.exists());
// 文件字节大小
System.out.println(file2.length());
}
}
常用方法
判断文件类型、获取文件信息功能
- boolean isDirectory() 判断File对象是否是文件夹
- boolean isFile() 判断File对象是否是文件
- boolean exists() 判断File是否存在
- String getAbsolutePath() 返回File的绝对路径
- String getPath() 返回File定义时的路径
- String getName() 返回File对象的文件或文件夹名称
- long getModified() 返回文件最后修改时间
package com.spark.study;
import java.io.File;
import java.text.SimpleDateFormat;
/**
* FileApi class
* description: File类对象的常用方法
*
* @author Administrator
* @date 2023/4/30
*/
public class FileApi {
public static void main(String[] args) {
// 创建File对象
File file = new File("src/data.txt");
// 判断路径对应的文件或文件夹是否存在
System.out.println(file.exists());
// 判断File对象是否为文件
System.out.println(file.isFile());
// 判断File对象是否为路径
System.out.println(file.isDirectory());
// 获取File对象的绝对路径
System.out.println(file.getAbsolutePath());
// 获取File对象定义时的路径
System.out.println(file.getPath());
// 获取File对象的字节大小
System.out.println(file.length());
// 获取File对象的名称
System.out.println(file.getName());
// 获取文件最后修改时间
System.out.println(file.lastModified());
// 获取文件最后修改时间,格式化
System.out.println("文件最后修改时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(file.lastModified()));
}
}
创建和删除功能
- boolean createNewFile() 创建一个新的空文件
- boolean mkdir() 创建一级文件夹
- boolean mkdirs() 创建多级文件夹
- boolean delete() 删除空文件夹
delete方法直接删除不走回收站;如果删除的是一个文件,并且文件没有被占用则直接删除;delete方法默认只能删除空文件夹。
package com.spark.study;
import java.io.File;
import java.io.IOException;
/**
* FileApi2 class
* description: 创建和删除
*
* @author Administrator
* @date 2023/4/30
*/
public class FileApi2 {
public static void main(String[] args) throws IOException {
File file = new File("tempfiles/a.txt");
// 创建新文件
System.out.println(file.createNewFile());
// 删除文件
System.out.println(file.delete());
File file2 = new File("tempfiles/aaa");
// 创建一级目录
System.out.println(file2.mkdir());
// 删除空目录
System.out.println(file2.delete());
File file3 = new File("tempfiles/bbb/ccc");
// 创建多级目录
System.out.println(file3.mkdirs());
}
}
遍历功能
- String [] list() 获取当前目录下的所有一级文件夹名称到一个字符数组中去
- File [] listFiles() 获取当前目录下的所有一级文件对象到一个文件对象数组中去
package com.spark.study;
import java.io.File;
/**
* FileApi3 class
* description: 遍历功能
*
* @author Administrator
* @date 2023/4/30
*/
public class FileApi3 {
public static void main(String[] args) {
File file = new File("tempfiles/");
// 获取指定目录下一级文件名称到字符数组中
String[] list = file.list();
for (String s : list) {
System.out.println(s);
}
// 获取指定目录下所有一级文件对象到File数组中
File[] files = file.listFiles();
for (File f : files) {
System.out.println(f.getAbsolutePath());
}
}
}
listFiles()方法注意事项
- 当调用者不存在时,返回null
- 当调用者是一个文件时,返回null
- 当调用者是一个空文件夹时,返回一个长度为0的数组
- 当调用者是一个有内容的文件夹时,将里面所有的文件和文件夹路径存放到File数组中返回
- 当调用者是一个有隐藏文件的文件夹时,将里面所有的文件和文件夹路径存放到File数组中返回,包含隐藏内容
- 当调用者是一个需要权限才能进入的文件夹时,返回null
方法递归
形式和特点
方法直接调用自己或者间接调用自己的形式称为方法递归
递归作为一种算法在程序设计语言中广泛使用
递归的形式
- 直接递归:自己调用自己
- 间接递归:方法调用其他方法,其他方法又回调方法自己
流程和核心要素
需求:计算1-n的阶乘,使用递归思想解决
① 阶乘公式:f(n) = 1*2*3*4*...*(n-1)*n
② 公式等价形式:f(n) = f(n-1)*n
③ 如果求1-5的阶乘
f(5) = f(4) * 5
f(4) = f(3) * 4
f(3) = f(2) * 3
f(2) = f(1) * 2
f(1) = 1
package com.spark.recursion;
/**
* Test class
* description: 1-n的阶乘
*
* @author Administrator
* @date 2023/5/1
*/
public class Test {
public static void main(String[] args) {
System.out.println(test(5));
}
public static int test(int n){
if(n==1){
return 1;
}
return test(n-1) * n;
}
}
核心要素:
- 递归的公式
- 递归的终结点
- 递归的方向必须走向终结点
递归案例
猴子吃桃问题:猴子第一天摘下若干桃子,当即吃了一半,觉得不够,于是又吃了一个;第二天又吃了前一天的一半,觉得不够,于是又吃了一个;以后每天都是吃前一天剩余桃子数量一半,觉得不够又多吃一个;到了第10天发现桃子只剩一个,请问猴子第一天摘了多少桃子
① 递归的公式:f(n) = ( f(n+1) + 1) * 2 ====> f(n) = 2*f(n+1) + 2
② 递归的终点:f(10) = 1
package com.spark.recursion;
/**
* Test2 class
* description: 猴子吃桃问题
*
* @author Administrator
* @date 2023/5/1
*/
public class Test2 {
public static void main(String[] args) {
System.out.println(f(10));
System.out.println(f(1));
System.out.println(f(2));
}
public static int f(int n){
if(n==10){
return 1;
}
return 2*f(n+1) + 2;
}
}
非规律化递归案例——文件搜索
从本地磁盘中,搜索出某个文件名称并输出绝对路径
① 先定位一级文件对象
② 遍历全部一级对象判断是否是文件
③ 如果是文件判断是否是搜索的文件名
④ 如果是文件夹,进入继续递归重复上述过程
package com.spark.recursion;
import java.io.File;
/**
* Test3 class
* description: 文件搜索
*
* @author Administrator
* @date 2023/5/1
*/
public class Test3 {
public static void main(String[] args) {
File dir = new File("D:\\JAVA");
searchFile(dir,"IO流.md");
}
public static void searchFile(File dir, String fileName){
// 判断是否是目录
if(dir!=null && dir.isDirectory()){
// 获取一级对象
File[] files = dir.listFiles();
// 判断files是否为空
if(files!=null && files.length>0){
// 遍历
for (File file : files) {
// file是文件就判断名称是否是查询的名称
if(file.isFile()){
if(file.getName().contains(fileName)){
System.out.println("文件找到了:"+file.getAbsolutePath());
}
}else{
// 递归查找,重复上述操作
searchFile(file,fileName);
}
}
}
}else{
System.out.println("指定的路径不是目录,无法查找!");
}
}
}
字符集
当需要不同的字符集时,如何使用代码来完成编码和解码操作?
① 编码
- byte [] getBytes() 使用平台的默认字符集将该String编码为一系列字节,将结果存储到新的字节数组中
- byte [] getBytes(String charsetName) 使用指定字符集将该String编码为一系列字节,将结果存储到新的字节数组中
② 解码
- String (byte [] bytes) 使用平台的默认字符集解码指定的字节数组来构造新的String
- String (byte [] bytes,String charsetName) 通过指定的字符集解码指定的字节数组来构造新的String
package com.spark.charset;
import java.util.Arrays;
/**
* Test class
* description: 字符集编码和解码
*
* @author Administrator
* @date 2023/5/1
*/
public class Test {
public static void main(String[] args) throws Exception {
String str = "我爱你China";
// 使用默认字符集进行编码 UTF-8
byte[] bytes = str.getBytes();
System.out.println(bytes.length);
System.out.println(Arrays.toString(bytes));
// 使用指定字符集进行编码 GBK
byte[] gbks = str.getBytes("GBK");
System.out.println(gbks.length);
System.out.println(Arrays.toString(gbks));
// 使用系统默认字符集进行解码
String s1 = new String(bytes);
System.out.println(s1);
String s2 = new String(gbks); // 乱码
System.out.println(s2);
// 使用指定字符集进行解码
String s3 = new String(gbks,"GBK");
System.out.println(s3);
}
}
IO流概述
IO流是输入、输出流用于读写数据
I表示input,是数据从磁盘文件中读取到内存的过程,称之为输入,负责读操作
O表示output,是内存程序的数据从内存写入到磁盘文件的过程,称之为输出,负载写操作
IO流的分类
① 按照流的方向分为输入流和输出流
② 按照流中的数据最小单位分为字节流和字符流
使用场景:
- 字节流适合做一切文件数据的拷贝(音视频、文本)
- 字节流不适合读取中文内容输出
- 字符流适合文本文件的操作(读、写)
字节流基本用法
① 文件字节输入流——每次读取一个字节
流程:
- 创建FileInputStream对象建立与源文件的链接
- 通过read方法每次读取一个字节
package com.spark.input;
import java.io.FileInputStream;
import java.io.InputStream;
/**
* Test class
* description: 文件字节输入流——每次读取一个字节
*
* @author Administrator
* @date 2023/5/1
*/
public class Test {
public static void main(String[] args) throws Exception {
// 创建FileInputStream对象
InputStream inputStream = new FileInputStream("src/data.txt");
// 每次读取一个字节
int read;
while((read=inputStream.read())!=-1){
System.out.print((char)read);
}
}
}
存在的弊端:
- 每次只能一个一个字节去读取,效率慢
- 无法避免中文乱码问题
② 文件字节输入流——每次读取一个字节数组
流程:
- 创建FileInputStream对象
- 使用read(byte [] buffer) 方法每次读取一个字节数组
package com.spark.input;
import java.io.FileInputStream;
import java.io.InputStream;
/**
* Test2 class
* description: 文件字节输入流——每次读取一个字节数组长度
*
* @author Administrator
* @date 2023/5/1
*/
public class Test2 {
public static void main(String[] args) throws Exception {
// 创建FileInputStream对象
InputStream inputStream = new FileInputStream("src/data.txt");
// 创建字节数组
byte [] buffer = new byte[3];
int len;
while((len = inputStream.read(buffer)) != -1) {
System.out.print(new String(buffer,0,len));
}
}
}
存在的弊端:虽然提升了读取效率,但是依然无法避免中文乱码问题
③ 文件字节输入流——一次读完全部字节
过程:
- 创建FileInputStream对象建立与源文件的链接
- 创建字节数组,长度为源文件中字节的长度一次性读取完毕
package com.spark.input;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
/**
* Test3 class
* description: 文件字节输入流——一次性读取全部
*
* @author Administrator
* @date 2023/5/1
*/
public class Test3 {
public static void main(String[] args) throws Exception {
// 创建FileInputStream对象
File file = new File("src/data.txt");
InputStream inputStream = new FileInputStream(file);
// 创建字节数组,长度为源文件字节长度
byte [] buffer = new byte[(int)file.length()];
System.out.println("文件字节数:"+inputStream.read(buffer));
System.out.println(new String(buffer));
}
}
存在的弊端:虽然可以解决中文乱码问题,但是当文件过大时可能会出现内存溢出
JDK9提供了一次性读取全部字节的API——readAllBytes()
④ 文件字节输出流——写字节数据到文件
流程:
- 创建FileOutputStream对象
- 调用write方法写出数据
- 刷新数据
- 释放资源
package com.spark.output;
import java.io.FileOutputStream;
import java.io.OutputStream;
/**
* Test class
* description: 文件字节输出流
*
* @author Administrator
* @date 2023/5/2
*/
public class Test {
public static void main(String[] args) throws Exception {
// 创建FileOutputStream对象
// 向文件中写内容以追加的形式
//OutputStream outputStream = new FileOutputStream("src/outdata.txt",true);
// 默认每次向文件中写内容时先清空数据
OutputStream outputStream = new FileOutputStream("src/outdata.txt");
// 向文件中写入一个字节
outputStream.write('a');
outputStream.write('b');
outputStream.write('c');
// 换行
outputStream.write("\r\n".getBytes());
// 向文件中写入一个字节数组
outputStream.write("我爱你中国".getBytes());
// 换行
outputStream.write("\r\n".getBytes());
// 刷新数据
outputStream.flush();
// 释放资源
outputStream.close(); // 释放资源会自动刷新数据
}
}
文件拷贝
字节流支持一切文件类型的复制,使用字节流复制文件的流程:
- 创建文件字节输入流链接源文件
- 创建文件字节输出流输出到目标文件
- 定义一个字节数组用于读取存储字节数据
- 释放资源
package com.spark.output;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Test2 class
* description: 文件的拷贝
*
* @author Administrator
* @date 2023/5/2
*/
public class Test2 {
public static void main(String[] args) throws Exception {
// 1.创建文件字节输入流
InputStream inputStream = new FileInputStream("src/outdata.txt");
// 2.创建文件字节输出流
OutputStream outputStream = new FileOutputStream("src/newout.txt");
// 3.定义一个字节数组
byte [] buffer = new byte[1024];
// 读取数据
int len;
while((len = inputStream.read(buffer))!=-1){
outputStream.write(buffer, 0, len);
}
// 4.释放资源
outputStream.close();
inputStream.close();
}
}
资源释放方式
try-catch-finally
finally:在异常处理时提供finally块来执行所有清除操作,比如IO流中的释放资源
特点: 被finally控制的语句最终一定会执行,除非JVM退出
语法格式:
try{
// 执行语句
}catch(Exception e){
// 捕获到异常
}finally{
// 最终执行语句
}
使用try-catch-finally语句块释放IO流资源
package com.spark.resource;
import java.io.*;
/**
* TryCatchFinally class
* description: try catch finally释放IO流资源
*
* @author Administrator
* @date 2023/5/2
*/
public class TryCatchFinally {
public static void main(String[] args) {
InputStream inputStream = null;
OutputStream outputStream = null;
try {
// 1.创建文件字节输入流
inputStream = new FileInputStream("src/outdata.txt");
// 2.创建文件字节输出流
outputStream = new FileOutputStream("src/newout.txt");
// 3.定义一个字节数组
byte[] buffer = new byte[1024];
// 读取数据
int len;
while ((len = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 4. 释放资源
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
try-catch-resources
由于try-catch-finally方式手动释放资源的方式过于繁琐,JDK7对释放资源进行了优化
package com.spark.resource;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
/**
* TryWithResource class
* description: try with resource 释放IO流资源
*
* @author Administrator
* @date 2023/5/2
*/
public class TryWithResource {
public static void main(String[] args) {
try (
// 这里只能放置资源对象,用完会自动调用close关闭资源
// 即使出现BUG也会做关闭操作
// 1.创建文件字节输入流
InputStream inputStream = new FileInputStream("src/outdata.txt");
// 2.创建文件字节输出流
OutputStream outputStream = new FileOutputStream("src/newout.txt");
) {
// 3.定义一个字节数组
byte[] buffer = new byte[1024];
// 读取数据
int len;
while ((len = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
字符流基本用法
① 文件字符输入流——一次读取一个字符
过程:
- 创建文件字符输入流FileReader对象
- 读出一个字符
package com.spark.input;
import java.io.FileReader;
import java.io.Reader;
/**
* Test4 class
* description: 文件字符输入流——一次读取一个字符
*
* @author Administrator
* @date 2023/5/2
*/
public class Test4 {
public static void main(String[] args) throws Exception {
// 创建文件字符输入流
Reader reader = new FileReader("src/data.txt");
// 每次读取一个字符
int read;
while((read = reader.read()) != -1){
System.out.print((char)read);
}
}
}
② 文件字符输入流——一次读取一个字符数组
过程:
- 创建文件字符输入流FileReader
- 创建字符数组,用于存储读取到的字符数据
- 读取数据
package com.spark.input;
import java.io.FileReader;
import java.io.Reader;
/**
* Test5 class
* description: 文件字符输入流——一次读取一个字符数组
*
* @author Administrator
* @date 2023/5/2
*/
public class Test5 {
public static void main(String[] args) throws Exception {
// 创建文件字符输入流
Reader reader = new FileReader("src/data.txt");
// 创建一个字符数组进行接收
char [] buffer = new char[1024];
// 读取数据
int len;
while((len = reader.read(buffer))!=-1){
String str = new String(buffer,0,len);
System.out.print(str);
}
}
}
③ 文件字符输出流
过程:
- 创建文件字符输出流FileWriter对象
- 输出字符到目标文件
package com.spark.output;
import java.io.FileWriter;
import java.io.Writer;
/**
* Test3 class
* description: 文件字符输出流
*
* @author Administrator
* @date 2023/5/2
*/
public class Test3 {
public static void main(String[] args) throws Exception {
// 创建文件字符输出流
Writer writer = new FileWriter("src/newout2.txt");
// 写字符追加方式
//Writer writer = new FileWriter("src/newout2.txt",true);
// 写一个字符
writer.write(97);
writer.write('b');
// 换行
writer.write("\r\n");
// 写一个字符串
writer.write("我爱你中国");
// 换行
writer.write("\r\n");
// 写一个字符数组
writer.write("我爱你中国".toCharArray());
// 换行
writer.write("\r\n");
// 写一个字符串一部分
writer.write("abcdefg",1,4);
// 换行
writer.write("\r\n");
// 写一个字符数组一部分
writer.write("Java从入门到放弃".toCharArray(),0,4);
// 释放资源
writer.close();
}
}
缓冲流
缓冲流也称为高效流、高级流。缓冲流自带缓冲区,可以提高原始字节流、字符流读写数据的性能。
缓冲字节流
缓冲字节输入流:BufferedInputStream
缓冲字节输出流:BufferedOutputStream
缓冲字节流性能优化原理:缓冲字节输入输出流自带了8KB缓冲池,读取数据时,直接从缓冲池中读取数据;写数据时,数据直接输出到缓冲池中,所以性能较好
缓冲字节流的基本用法
package com.spark.buffer;
import java.io.*;
/**
* Test class
* description: 缓冲字节流
*
* @author Administrator
* @date 2023/5/9
*/
public class Test {
public static void main(String[] args) {
try(
// 包装原字节输入流为缓冲输入流
InputStream in = new BufferedInputStream(new FileInputStream("src/data.txt"));
// 包装原字节输出流为缓冲输出流
OutputStream out = new BufferedOutputStream(new FileOutputStream("src/newdata.txt"));
){
int len;
byte [] buffer = new byte[1024];
while((len = in.read(buffer))!=-1){
out.write(buffer,0,len);
}
System.out.println("文件复制成功...");
}catch (Exception e){
e.printStackTrace();
}
}
}
缓冲字符流
字符缓冲输入流:BufferedReader
字符缓冲输出流:BufferedWriter
缓冲字符流的基本用法
package com.spark.buffer;
import java.io.*;
/**
* Test2 class
* description: 字符缓冲流
*
* @author Administrator
* @date 2023/5/9
*/
public class Test2 {
public static void main(String[] args) {
try(
// 包装原始字符输入流为字符缓冲输入流
Reader reader = new BufferedReader(new FileReader("src/outdata.txt"));
// 包装原始字符输出流为字符缓冲输出流
Writer writer = new BufferedWriter(new FileWriter("src/outdata3.txt"));
){
int len;
char [] buffer = new char[1024];
while((len = reader.read(buffer))!=-1){
writer.write(buffer,0,len);
}
System.out.println("文件复制成功");
}catch (Exception e){
e.printStackTrace();
}
}
}
转换流
当文件的编码与代码的编码不一致时,使用字符流读取文本内容依然会出现乱码情况,这时就需要使用转换流进行读写数据
字符输入转换流:InputStreamReader
字符输出转换流:InputStreamWriter
解决读取文件乱码
- 可以提取文件的原始字节流,原始字节不会存在问题
- 把字节流以指定的编码转换成字符输入流,这样字符输入流的字符就不会乱码了
package com.spark.changestream;
import java.io.*;
/**
* Test class
* description: 解决字符流读取不同编码文件乱码
*
* @author Administrator
* @date 2023/5/13
*/
public class Test {
public static void main(String[] args) throws Exception {
// 链接GBK编码文件
InputStream in = new FileInputStream("D:\\test.txt");
// 将字节流转换为字符流
//Reader isr = new InputStreamReader(in); // 默认以UTF-8编码,读取依然乱码
Reader reader = new InputStreamReader(in,"GBK"); // 指定编码
int len;
char [] buffer = new char[1024];
while((len = reader.read(buffer)) != -1){
String str = new String(buffer,0,len);
System.out.print(str);
}
}
}
解决以指定的编码写到文件中
package com.spark.changestream;
import java.io.*;
/**
* Test2 class
* description: 以指定编码将数据写入到文件中
*
* @author Administrator
* @date 2023/5/13
*/
public class Test2 {
public static void main(String[] args) throws Exception {
OutputStream out = new FileOutputStream("D:\\data2.txt");
// 使用转换流,以指定编码将数据写入文件
Writer writer = new OutputStreamWriter(out,"GBK");
// 将低级流转换为高级流
BufferedWriter os = new BufferedWriter(writer);
// 写入数据
os.write("我爱你中国1~");
// 换行
os.newLine();
os.write("我爱你中国2~");
os.close();
}
}
序列化对象
对象序列化:以内存为基准,把内存中的对象存储到磁盘文件中去,称为对象序列化
使用到的流是对象字节输出流:ObjectOutputStream
package com.spark.serializable;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
/**
* Test class
* description: 对象序列化
*
* @author Administrator
* @date 2023/5/13
*/
public class Test {
public static void main(String[] args) throws Exception {
// 创建字节流链接文件
OutputStream out = new FileOutputStream("src/obj.txt");
// 创建对象字节输出流
ObjectOutputStream os = new ObjectOutputStream(out);
// 创建对象
Student student = new Student("张三",22);
os.writeObject(student);
os.close();
}
}
对象反序列化:以内存为基准,把存储在磁盘文件中的对象数据恢复成内存中的对象
使用到的流是对象字符输入流:ObjectInputStream
package com.spark.serializable;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
* Test2 class
* description: 对象反序列化
*
* @author Administrator
* @date 2023/5/13
*/
public class Test2 {
public static void main(String[] args) throws Exception {
// 创建对象字节输入流包装低级流链接文件
ObjectInputStream in = new ObjectInputStream(new FileInputStream("src/obj.txt"));
// 读取文件中的对象
Student student = (Student) in.readObject();
System.out.println(student);
}
}
拓展:当对象中的某些字段不想让其序列化时,比如:密码等重要信息,可以使用transient修饰属性
public class User implements Serializable{
private String name;
private transient String password;
}
打印流
打印流可以实现方便、高效的打印数据到文件中去。打印流一般指:PrintStream,PrintWrite两个类可以实现打印什么数据就是什么数据
PrintStream
构造器:
-
public PrintStream(OutputStream os) 打印流直接通向字节输出流管道
-
public PrintStream(File f) 打印流直接通向文件对象
-
public PrintStream(String filePath) 打印流直接通向文件路径
方法:
- print() 打印任意类型的数据出去
PrintWriter
构造器:
-
public PrintWriter(OutputStream os) 打印流直接通向字节输出流管道
-
public PrintWriter(Writer w) 打印流直接通向字符输出流管道
-
public PrintWriter(File f) 打印流直接通向文件对象
-
public PrintWriter(String filePath) 打印流直接通向文件路径
方法:
- print() 打印任意类型的数据出去
package com.spark.print;
import java.io.FileWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* Test class
* description: 打印流
*
* @author Administrator
* @date 2023/5/13
*/
public class Test {
public static void main(String[] args) throws Exception {
// 创建打印流
PrintStream ps = new PrintStream("src/print.txt");
ps.println("我爱你中国");
ps.println(123456);
ps.println('a');
ps.println(true);
ps.close();
// 创建打印流
//PrintWriter pw = new PrintWriter("src/print.txt");
// 如果需要追加内容,在低级流中指定为追加方式
PrintWriter pw = new PrintWriter(new FileWriter("src/print.txt",true));
pw.println("我爱你中国2");
pw.println(123);
pw.println('b');
pw.println(false);
pw.close();
}
}
PrintSteam和PrintWriter区别:
- 打印数据功能上是一模一样,都是使用方便,性能高效(核心优势)
- PrintStream继承自字节输出流OutputStream,支持写字节数据的方法
- PrintWriter继承自字符输出流Writer,支持写字符数据
补充知识:Properties
Properties其实就是一个Map集合,继承自HashTable,但是一般不会当集合使用,而是用于将对象中的键值对信息存储到属性文件中去
作用:
- Properties代表的是一个属性文件,可以将自己对象中的键值对信息写入到一个属性文件中去
- 属性文件:后缀是.properties结尾的文件,里面的内容都是key=value,后续做系统配置信息的 例如框架中的application.properties
方法:
- void load(Reader reader) 从输入字符流读取属性列表
- void load(InputStream inputStream) 从输入字节流读取属性列表
-
void stroe(OutputStream out , String comments) 将此属性列表写入此properties表中,以适合于使用load方法写入输出字节流
-
void store(Writer writer , String comments) 将此属性列表写入此properties表中,以适合于使用load方法写入输出字符流
-
Object setProperty(String key , String value) 保存键值对 (put)
-
Object getProperty(String key) 通过key获取属性值 (get)
package com.spark.properties;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Properties;
import java.util.Set;
/**
* Test class
* description: Properties
*
* @author Administrator
* @date 2023/5/13
*/
public class Test {
public static void main(String[] args) throws Exception {
// 创建Properties对象
Properties properties = new Properties();
// 设置 key value
properties.setProperty("name","张三");
properties.setProperty("password","123456");
// 将 key value写入到属性文件中
properties.store(new FileWriter("src/user.properties"),"这个是用户相关的信息");
// 加载属性文件
properties.load(new FileReader("src/user.properties"));
// 根据key获取value
String name = properties.getProperty("name");
String password = properties.getProperty("password");
System.out.println("name=" + name+" password=" + password);
// 获取属性文件中所有的key
Set<String> keys = properties.stringPropertyNames();
keys.forEach(key -> System.out.println(key));
}
}
补充知识:IO框架
commons-io是apache开源基金组织提供的一组有关io操作的类库,可以提高IO功能开发的效率。
commons-io工具包提供了很多有关io操作的类,有两个主要的类FileUtils,IOUtils
FileUtils主要有如下方法:
-
String readFileToString(File file,String encoding) 读取文件中的数据,返回字符串
-
void copyFile(File srcFile, File destFile) 复制文件
-
void copyDirectoryToDirectory(File srcDir, File destDir) 复制文件夹
-
void copyFileToDirectory(File file , File dir) 复制文件到指定文件夹
-
void delete(File file) 删除指定文件
-
void deleteDirectory(File dir) 删除指定文件夹