1. Java File 类
1.1. 路径
public static void main(String[] args) throws IOException, InterruptedException {
// 1. 路径
// Widnow下 路径分隔符号是 \
// linux下 是 /
System.out.println(File.separator);
// 绝对路径： windows下是盘符下
// Linux是 /根路径下
String name="a.txt";
// 这里是相对路径，
File file=new File(name);
System.out.println(file.getAbsolutePath());
// 2. File方法
System.out.println("文件是否可写:"+file.canWrite());
System.out.println("是否文件夹:"+file.isDirectory());
// 程序执行完毕那么久删除文件
File temp=File.createTempFile("tes", ".temp",new File("E:\\test"));
Thread.sleep(5000);
temp.deleteOnExit();
}1.2. File 方法
// 2. File方法
System.out.println("文件是否可写:"+file.canWrite());
System.out.println("是否文件夹:"+file.isDirectory());
// 程序执行完毕那么久删除文件
File temp=File.createTempFile("tes", ".temp",new File("E:\\test"));
Thread.sleep(5000);
temp.deleteOnExit();1.3. 操作目录
public static void main(String[] args) throws IOException, InterruptedException {
// 3. 操作目录
// mkdir :创建目录,必须保证父目录存在，如果不存在，创建失败
// mkdirs: 创建目录，父目录不存在,一起创建
File mkFile=new File("E:\\test\\bb");
mkFile.mkdir();
if(mkFile.isDirectory()){
// 获取目录 下 文件
// File[] mkDir= mkFile.listFiles(); //遍历文件夹
// 遍历文件夹过滤
File[] srcFileDir=mkFile.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
// TODO Auto-generated method stub
return (name.endsWith(".txt") && new File(dir,name).isFile()) ;
}
});
for (int i = 0; i < srcFileDir.length; i++) {
System.out.println(srcFileDir[i].getAbsolutePath());
}
}
System.out.println("--------------------------------------------");
File bbFile=new File("E:\\test\\bb");
// 递归遍历 文件夹下所有 文件路径
logFileName(bbFile);
}
public static void logFileName(File file){
// 文件直接输出
if(file.isFile()){
System.out.println(file.getAbsolutePath());
} else if(file.isDirectory()){
for (File sub : file.listFiles()) {
logFileName(sub);
}
}
}2. FileInputStream、FileOutputStream
实现 文本内容读写
** 流的源头：文件、内存、控制台
/**
* 什么是流：
* 网络资源、本地资源、内存资源从一端到另外一端
* 划分：
* 按照流向： 输入流、输出流
* 按照数据类型： 字节流， 存文本文件
* 二进制流： 包括一切文件
* 按照功能划分： 节点流、 处理流(包装类)
*/
// 案例1： 文本读取,必须要关闭资源记得
// 实现 文件的拷贝
File src1=new File("E:\\test\\bb\\aa.txt");
File dest1=new File("E:\\test\\bb\\cc.txt");
BufferedInputStream bifs=new BufferedInputStream(new FileInputStream(src1));
// 默认是false，覆盖
BufferedOutputStream bofs=new BufferedOutputStream(new FileOutputStream(dest1,true));
byte flush[]=new byte[1024];
int len=-1;
while( (len = bifs.read(flush)) !=-1 ){
// 文件编码是 gbk
System.out.println(new String(flush,0,len,"gbk"));
bofs.write(flush, 0, len);
}
bofs.flush();
bofs.close();
bifs.close();
3. 文件夹 拷贝
public class Mani5 {
public static void main(String[] args) throws IOException, InterruptedException {
// 案例2：文件夹 拷贝
copyDir(new File("E:\\test\\bb"),new File("D:\\test\\bb"));
}
public static void copyDir(File srcFile,File destDst) throws UnsupportedEncodingException, IOException{
// 文件直接拷贝
if(srcFile.isFile()){
copyFile(srcFile,destDst);
}else if(srcFile.isDirectory()){
// 目录，创建目标目录
destDst.mkdirs();
// 遍历目录下文件，递归拷贝
for (File sub : srcFile.listFiles()) {
if(sub.isDirectory()){
copyDir(sub, new File(destDst,sub.getName()));
}else if(sub.isFile()){
copyFile(sub, new File(destDst,sub.getName()));
}
}
}
}
public static void copyFile(File src1,File dest1) throws IOException{
BufferedInputStream bifs=new BufferedInputStream(new FileInputStream(src1));
// 默认是false，覆盖
BufferedOutputStream bofs=new BufferedOutputStream(new FileOutputStream(dest1));
byte flush[]=new byte[1024];
int len=-1;
while( (len = bifs.read(flush)) !=-1 ){
// 文件编码是 gbk
// System.out.println(new String(flush,0,len,"gbk"));
bofs.write(flush, 0, len);
}
bofs.flush();
bofs.close();
bifs.close();
}
}
4. FileReader、FileWriter
实现文件读写，返回char[] 文件乱码解决 InputStreamReader OutputStreamWriter
public class Mani5 {
public static void main(String[] args) throws IOException, InterruptedException {
// 文本流 Reader 、Writer ， 文件乱码
// 出现 问题： 文件乱码
// BufferedReader bufreader=new BufferedReader(new FileReader("D:\\test\\bb\\aa.txt"));
// BufferedWriter bufwriter=new BufferedWriter(new FileWriter("D:\\test\\bb\\ff.txt",true));
/** 转化流： 字节转化为 字符
* 文件乱码解决方法
* InputStreamReader: 输出流,编码，把InputStream 转化为文本流， InputStream才有编码解码的条件
* OutputStreamWriter: 解码
*
*/
BufferedReader bufreader=new BufferedReader(
new InputStreamReader(
new FileInputStream("D:\\test\\bb\\aa.txt"),"gbk"));
BufferedWriter bufwriter=new BufferedWriter(new FileWriter("D:\\test\\bb\\ff.txt",true));
char[] cFlush=new char[1024];
int len=0;
while( (len=bufreader.read(cFlush)) !=-1 ){
// 字符串数组转化字符串
System.out.println(new String(cFlush,0,len));
bufwriter.write(new String(cFlush,0,len));
}
bufwriter.flush();
bufwriter.close();
bufreader.close();
}
}
5. BufferedReader、BufferedWriter
新增api: readLine()、newLine() 逐行读取、换行
BufferedReader bufreader=new BufferedReader((new FileReader("D:\\test\\bb\\aa.txt")));
BufferedWriter bufwriter=new BufferedWriter(new FileWriter("D:\\test\\bb\\ff.txt",true));
String line =null;
while( (line= bufreader.readLine()) !=null){
System.out.println(line);
bufwriter.write(line);
bufwriter.newLine(); // 相当于 bufwriter.append("\r\n")
}
bufwriter.flush();
bufwriter.close();
bufreader.close();
6. 乱码问题研究
乱码条件：1. . 编码 解码 字符集 不统一 2. 2. 字节数 不完整
文件乱码解决：看4 ， InputStreamReader ，OutputStreamWriter
public static void main8888(String[] args) throws UnsupportedEncodingException {
//1. 编码 解码 字符集 不统一
String str="中国";
// 编码
byte[] data= str.getBytes("utf-8");
System.out.println(new String(data,"gbk")); // 解码
// 2. 字节数 不完整
System.out.println(new String(data,0,str.length()-1,"gbk"));
}
7. ByteArrayOutputStream 内存字节流,在内存中是流，不是二进制,网络传输是流
package com.denganzhi.pp;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
public class MainOther {
public static void main(String[] args) throws IOException {
/**
* 字节数组 输入流 ByteArrayInputStream 就是内存流,网络传输是流
* 字节数组 输出流 ByteArrayOutputStream
*/
String msg="hello ---> 我是小明";
byte[] src= msg.getBytes();
// 传入 byte
InputStream is=new BufferedInputStream(
new ByteArrayInputStream(
src));
// 操作
byte[] flush=new byte[1024];
int len= 0;
while( (len=is.read(flush))!=-1 ){
System.out.println(new String(flush,0,len));
}
is.close();
byte[] dest;
ByteArrayOutputStream bos=new ByteArrayOutputStream();
bos.write(src, 0, src.length);
// 获取流
dest= bos.toByteArray();
System.err.println(new String(dest,0,dest.length));
bos.close();
}
}
8. 使用 ByteArrayOutputStream 读写文件
可以把文本内容异常读取内存中
package com.denganzhi.pp;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class FileCopy {
public static void main(String[] args) throws IOException {
// 把文件中数据一次性 读到内存 中
File src1=new File("D:\\test\\bb\\aa.txt");
InputStream inputStream=new BufferedInputStream(new FileInputStream(src1));
ByteArrayOutputStream bos=new ByteArrayOutputStream();
byte[] flush = new byte[1024];
int len=0;
while( (len= inputStream.read(flush))!=-1 ){
bos.write(flush,0,len);
}
bos.flush();
byte[] dest = bos.toByteArray();
System.out.println(new String(dest,0,dest.length,"gbk"));
File dest1=new File("D:\\test\\bb\\cc.txt");
InputStream isS=new BufferedInputStream(new ByteArrayInputStream(dest));
OutputStream osS =new BufferedOutputStream(new FileOutputStream(dest1));
byte[] flushS=new byte[1024];
int lenS=0;
while( (lenS=(isS.read(flushS)))!=-1 ){
osS.write(flushS, 0, lenS);
}
osS.flush();
isS.close();
osS.close();
}
}
9、 基本数据类型+String
可以读写、基本数据类型
public static void main001(String[] args) throws IOException {
// 处理 流： 基本数据类型+String
/**
* 输入流： DataInputStream
* 输出流： DataOutputSteam
*/
File src1=new File("E:\\test\\bb\\aa.txt");
double point=4.5;
String str1="abc";
DataOutputStream dos=new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(src1)));
// 写出数据保留 基本数据类型
dos.writeDouble(point);
dos.writeUTF(str1);
dos.flush();
dos.close();
// 读取
// 读取和写入 操作一致，必须存在才可可以读取
DataInputStream dataInput=new DataInputStream(
new BufferedInputStream(
new FileInputStream(src1)));
System.out.println(dataInput.readDouble());
System.out.println(dataInput.readUTF());
dataInput.close();
System.out.println("---------------------------");
ByteArrayOutputStream bos1=new ByteArrayOutputStream();
DataOutputStream dos1=new DataOutputStream(
new BufferedOutputStream(
bos1));
dos1.writeDouble(11.1);
dos1.writeUTF("小明");
dos1.flush();
dos1.close();
DataInputStream dataInput1=new DataInputStream(
new BufferedInputStream(
new ByteArrayInputStream(bos1.toByteArray())));
System.out.println(dataInput1.readDouble());
System.out.println(dataInput1.readUTF());
dataInput1.close();
}10.引用类型(对象)
对象序列化到文件中
/**
* 引用类型(对象) 保留数据
* 反序列化 ： 输入流 ： ObjectInputStream
* 序列化： 输出流： ObjectOutputStream
* 序列化必须实现 java.io.Serializable 接口
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
File src1=new File("E:\\test\\bb\\aa.txt");
Employee employee=new Employee("xiaoming", 200);
ObjectOutputStream dataOutput=new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(src1)));
int arr[]={1,2,3};
dataOutput.writeObject(employee);
dataOutput.writeObject(arr);
dataOutput.flush();
ObjectInputStream dataInput=new
ObjectInputStream(new BufferedInputStream(
new FileInputStream(src1)));
Employee employee2=(Employee) dataInput.readObject();
int arrNew[]=(int[]) dataInput.readObject();
System.out.println(employee2);
System.out.println(Arrays.toString(arrNew));
// dataInput.close();
// dataOutput.close();
closeAll(dataInput,dataOutput);
}11. 可变参数，Closeable接口
// 可变参数 ，工具类关闭流
// 规则： 如果有其他参数，只能在最后一个位置,处理方式和数组一致
//
public static void closeAll(Closeable ... io){
for (Closeable closeable : io) {
if(closeable!=null){
try {
closeable.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}