java_IO_文件的基本操作

首先明白：程序与流打交道，是以程序为中心

IO流的分类：

1、流向：输入流输出流

2、数据：字节流：二进制，可以处理一切文件，包括纯文本、视频等

字符流：文本文件，只能处理文本

3、功能：

节点流：包裹源头

处理流：增强功能，提供性能

关于文件处理的字节流和字符流

1、字节流：

输入流：InputStream read(byte[] b) read(byte[] b,int off,int len) +close()

FileInputStream()

输出流：OutputStream write(byte[] b) write(byte[] b,int off, int len) +flush() + close()

FileOutputStream()

2、字符流：

输入流：Reader read(char[] cbuf) read(char[] cbuf,int off,int len) +close()

FileReader()

输出流：Writer write(char[] cbuf) write(char[] cbuf,int off ,int len) write(String str, int off, int len) +flush() +close()

FileWriter()

3、节点流：

Reader FileReader

Writer FileWriter

4、处理流

（1）字节缓冲流：

BufferedInputStream

BufferedOutputStream

（2）字符缓冲流

BufferedReader readLine()读取一个文本行。

BufferedWriter newLine() 写入一个行分隔符。

5、转换流：字节流转为字符流处理乱码（编码集、解码集），中心是程序

编码：字符 --------编码字符集--->二进制

解码：二进制-------解码字符集--->字符

1、输出流 OutputStreamWriter 编码

2、输入流 InputStreamReader 解码

----------------------------------------------------------------------------------------------------

关于处理流的基本写法：

InputStream is=new BufferedInputStream(new FileInputStream(new File(.....)))

BufferedReader reader=new BufferedReader(new FileReader(new Filer(.......)))

关于转换流的基本写法：

//指定解码字符集,要知道原编码的字符编码集，假设原编码集是“UTF-8”

InputStream is=new BufferedInputStream(new InputStreamReader(new FileInputStream(new File(.....))，"UTF-8"))

以下是File类-------------------------------------------------------------------------------------------------

File 类 ,实际是一中文件与路径的联系，操作文件使用 IO 流

package com.lucas.testIO;

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;

/**
* 读取文件：
* 1、建立联系，File对象（源头）
* 2、选择流，文件输入流 InputStream FileInputStream
* 3、操作 byte[] b=new byte[1024]; + read + 读取大小输出
* 4、释放资源关闭
*
* 写出文件
* 1、建立联系，File对象（目的地）
* 2、选择流，文件输出流 OuputStream FileOuputStream
* 3、操作：write() + flush
* 4、释放资源关闭
*
* 拷贝文件
* 1、建立联系，File对象（源头和目的地）
* 2、选择流，
* 文件输入流 InputStream FileInputStream
* 文件输出流 OuputStream FileOuputStream
* 3、操作：拷贝
* byte[] b=new byte[1024];
* int len=0;
* while(-1 != (len=输入流.read(b))){
* 输出流.write(b,0,len)
* }
* 输出流.flush
* 4、释放资源关闭两个流
* @author lx
*
*/
public class Demo5 {

public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
String path="H:/java/127.0.0.4/a.txt";
File src=new File(path);

//------------------------------读取文件--------------
// InputStream is=new FileInputStream(src);
// byte[] b=new byte[1024];//操作不断读取缓存数组
// int len=0; //接收实际读取的大小
// //循环读取
// while( -1!=(len = is.read(b))){
// //输出字节数组转成字符串
// String info = new String(b,0,len);
// System.out.println(info);
// }
//
// if(null != is){
// is.close();
// }
//------------------------------写出文件--------------
// OutputStream os=new FileOutputStream(src,true);//以追加的形式，必须写成true，默认为false
// String str="welcome to beijing";
// byte[] data=str.getBytes();
// os.write(data,0,data.length);
// os.flush();//强制刷新出去
// if(null != os){
// os.close();
// }
//-------------------------------拷贝文件------------------

// 1、建立联系源头：存在且是文件目的地：文件可以不存在
File src1=new File("H:/java/127.0.0.4/2.jpg");
File src2=new File("H:/java/127.0.0.4/999.jpg");

// 2、选择流
InputStream is=new FileInputStream(src1);
OutputStream os=new FileOutputStream(src2);
// 3、文件拷贝循环读取写出
byte[] b=new byte[1024];
int len=0;
while(-1 != (len=is.read(b))){
os.write(b, 0, len);
}
os.flush();
if(null != os){
os.close();
}
if(null!= is){
is.close();
}
}

/**
* 文件的拷贝
* @param 源文件路径
* @param 目的文件路径
* @return
* @throws Exception
*/
public static void copyFile(String srcPath,String destPath) throws Exception{
File src1=new File(srcPath);
File src2=new File(destPath);

InputStream is=new FileInputStream(src1);
OutputStream os=new FileOutputStream(src2);
byte[] b=new byte[1024];
int len=0;
while(-1 != (len=is.read(b))){
os.write(b, 0, len);
}
os.flush();
if(null != os){
os.close();
}
if(null!= is){
is.close();
}
}
}

--------------------------------------------------------------------------------------------------------------------------

System.out.println(File.pathSeparator); //路径分割符
System.out.println(File.separator); //文件分隔符

路径表示方式
String path="H:\\java\\127.0.0.4\\2.jpg";
path="H:"+File.separator+"java"+File.separator+"127.0.0.4"+File.separator+"2.jpg";
推荐使用
path="H:/java/127.0.0.4/2.jpg";

String path="H:/java/127.0.0.4";
String name="2.jpg";

根据相对路径
File file=new File(path,name);
file=new File(new File(path),name);
System.out.println(file.getName());
System.out.println(file.getPath());

绝对路径
file=new File("H:/java/127.0.0.4/2.jpg");
System.out.println(file.getName());
System.out.println(file.getPath());

没有盘符，以user.dir构建
file=new File("test.txt");
file=new File(".");
System.out.println(file.getName());
System.out.println(file.getPath());
System.out.println(file.getAbsolutePath());

-------------------------------------------------------------------------------------------------------------------------------------

package com.lucas.testIO;

/*
* File 对象既可以是文件也可以是文件夹
*
*/
import java.io.File;
import java.io.IOException;

public class Demo2 {

public static void main(String[] args) {
// TODO Auto-generated method stub
try {
test3();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件创建失败");
}
}
// 1、名称
public static void test1(){
//建立联系
File src=new File("2.txt");
}
// 2、判断信息
public static void test2(){
// String path="2.txt";
String path="H:/java/127.0.0.4/2.jpg";
// String path="H:/java/127.0.0.4";
//建立联系
File src=new File(path);
//是否存在
System.out.println("文件是否存在"+ src.exists());
//是否可读写canWrite() canRead()
System.out.println("文件是否可写" + src.canWrite());

//是否是文件 ,没有真实存在的文件默认是文件夹
if(src.isFile()){
System.out.println("文件");
}else if(src.isDirectory()){
System.out.println("文件夹");
}else{
System.out.println("文件不存在");
}

System.out.println("是否为绝对路径"+src.isAbsolute());
//长度：length() 字节数，不能读取文件夹的长度
System.out.println("长度为："+src.length());
}

//创建删除文件
public static void test3() throws IOException{
//String path="H:/java/127.0.0.4/con"; 创建失败con为系统关键字
String path="H:/java/127.0.0.4/200";
File src=new File(path);
if(!src.exists()){
boolean flag=src.createNewFile();
System.out.println(flag?"成功":"失败");
}
boolean flags=src.delete();
System.out.println(flags?"成功":"失败");

//static createTempFile (前缀 3 字节场，后缀默认为.temp) 默认临时空间
//static createTempFile (前缀 3 字节场，后缀默认为.temp,目录)
File temp=File.createTempFile("tes", ".temp", new File("H:/java/127.0.0.4"));
temp.deleteOnExit();
}
}

-----------------------------------------------------------------------------------------------------------------------------

package com.lucas.testIO;

import java.io.File;
import java.io.FileFilter;
/**file.mkdir(); 创建目录，如果父目录不存在，创建失败
* file.mkdirs(); 创建目录，如果父目录不存在，一同创建
* file.isDirectory(): 文件路径存在并且为目录为真
* file.list(); 返回目录下的文件名或者子目录名，不是路径
*
*
* @author lx
*
*/
public class Demo3 {

public static void main(String[] args) {
// TODO Auto-generated method stub
String path="H:/java/127.0.0.4";
File file=new File(path);
// file.mkdir();
if(file.isDirectory()){
String[] paths=file.list();
for(String pathss:paths){
System.out.println(pathss);
}
System.out.println("-------------------------------------");

File[] fileTemp=file.listFiles();
for(File f:fileTemp){
System.out.println(f.getAbsolutePath());
}

System.out.println("--------------------------------------");
fileTemp=file.listFiles(new FileFilter() {

@Override
public boolean accept(File pathname) {
// TODO Auto-generated method stub
// System.out.println(pathname.getName().endsWith(".jpg"));
return pathname.isFile() && pathname.getName().endsWith(".jpg");
}
});
for(File f:fileTemp){
System.out.println(f.getAbsolutePath());
}
System.out.println("--------------------------------------");
}
}

}

------------------------------------------------------------------------------------------------------------------

package com.lucas.testIO;
import java.io.*;
import java.util.Arrays;
/**
* 输出子孙级目录或者文件的名称
* 递归
* File.listRoots(); 获取根路径
*
* @author lx
*
*/
public class Demo4 {

public static void main(String[] args) {
// TODO Auto-generated method stub
String path="H:/java/127.0.0.4";
File parentSrc=new File(path);
// printName(parentSrc);

System.out.println("---------------------------");
File [] roots=File.listRoots();
System.out.println(Arrays.toString(roots));
System.out.println("---------------------------");
for(File root:roots){
printName(root);
}
}
//写递归函数时：将递归尾找到，递归头找到，递归头调用本身的函数
public static void printName(File src){
if( src==null || !src.exists()){
return;
}

System.out.println(src.getAbsolutePath());
if(src.isDirectory()){
for(File sub:src.listFiles()){
printName(sub);
}
}

}

}

java_IO_文件的基本操作

猜你喜欢