流：
流的概念：
流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流 I/O（Input/Output）流提供类一条通道程序，可以使用这条通道把源中的字节序列送到目的地；
输入流：（读字符或字节）
InputStream类：是字节输入流的抽象类，是所有字节输入流的父类；
Reader类：是字符输入流的抽象类，所有字符输入流的实现都是他的子类；
OutputStream类：是多有字节输出流的抽象类，此抽象类是所有字节流的所有类的超类；
Writer类：是字符输出流的抽象类，所有字符输出类的实现都是他的子类；
File类：
表示文件或者目录的路径的抽象表现形式，IO流就是对文件进行操作的；
创建文件：
举例：
public class FileDemo {
public static void main(String[] args) {
//表示:e盘下的demo文件夹中的a.txt文件
//E:\\dmeo\\a.txt
//public File(String pathname):表示pathname的抽象路径表现的形式
File file = new File("E:\\demo\\a.txt") ;
System.out.println(file);
//public File(String parent,String child)
File file2 = new File("E:\\demo","a.txt");
System.out.println(file2);
//3.public File(File parent, String child)
File file3 = new File("E:\\demo") ;
File file4 = new File(file3, "a.txt") ;
System.out.println(file4);
//三种方式都可以使用(表示文件/目录的路径的抽象形式),根据具体的要求(第一种方式最常用的)
}
}public boolean createNewFile()：创建文件,当文件不存在的时候,创建此抽象路径下的文件；
注意：检查文件是否存在，若不存在则创建该文件，如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false ；
public boolean mkdir()：创建一个文件夹,如果文件夹存在，不创建；
public boolean mkdirs()：创建文件夹，如果父目录不存在，会创建此目录；
举例：
public class FileDemo2 {
public static void main(String[] args) throws IOException {
//E盘下创建demo文件夹
File file = new File("e:\\demo") ;
File file6 = new File("e:\\test") ;
System.out.println("mkdir:"+file.mkdir());
//System.out.println("mkdir:"+file6.mkdir());
System.out.println("------------------------");
//public boolean createNewFile():创建文件,当文件不存在的时候,创建此抽象路径下的文件
//本身方法异常:IOException
File file2 = new File("e:\\demo\\a.txt") ;
System.out.println("createNewfile:"+file2.createNewFile());
///java.io.IOException: 系统找不到指定的路径。
File file3 = new File("e:\\test\\b.txt") ;
System.out.println("createNewFile:"+file3.createNewFile());
//创建文件的前提:文件夹一定要存在,如果不存在,IOException
//public boolean mkdirs():创建文件夹,如果父目录不存在,会创建此目录
//在E盘下创建E:\\aaa\\bbb\\ccc
File file4 = new File("e:\\aaa") ;
System.out.println("mkdir:"+file.mkdir());
File file5 = new File("E:\\aaa\\bbb\\ccc") ;
System.out.println("mkdirs:"+file5.mkdirs());
}
}public boolean delete()：删除文件或者文件夹(目录不能是空的) ，逐一删除文件或者目录的；
举例：
public class FileDemo3 {
public static void main(String[] args) throws IOException {
//创建File对象
File file = new File("e:\\demo\\a.txt") ;
System.out.println("delete :" +file.delete());
File file2 = new File("e:\\demo") ;
System.out.println("delete:"+file2.delete());
System.out.println("----------------------------");
File file3 = new File("a.txt") ;
System.out.println("createNewFile():"+file3.createNewFile());
System.out.println("-----------------------------");
File file4 = new File("aaa\\bbb\\ccc\\ddd") ;
System.out.println("mkdirs():"+file4.mkdirs());
//需求:删除aaa\\bbb\\ccc\\ddd
//File(File parent,String Child)
File file5 = new File("aaa\\bbb\\ccc\\ddd") ;
System.out.println(file5.delete());
File file6 = new File("aaa\\bbb\\ccc") ;
System.out.println(file6.delete());
}
}public boolean renameTo(File dest)：重新命名此抽象路径名表示的文件；
如果路径名一致的情况，那么只是重命名，如果两次路径名称不一致，那么不只是重命名，并且剪切；
举例：
public class FileDemo {
public static void main(String[] args) {
//表示当前项目下的高圆圆.jpg这个文件
File file = new File("高圆圆.jpg") ;
File newFile =new File("杨桃.jpg") ;
System.out.println("renameTo():"+file.renameTo(newFile));
System.out.println("-------------------------");
File file2 = new File("杨桃.jpg") ;
File file3 = new File("e:\\高圆圆.jpg") ;
System.out.println("renameTo():"+file2.renameTo(file3));
}
}public boolean isDirectory()：判断是否是文件夹（目录）；
public boolean isFile()：判断是否是文件；
public boolean canRead()：是否可读；
public boolean canWriter()：是否可写；
public boolean exists()：测试此抽象路径名表示的文件或目录是否存在；
public boolean isHidden()：是否是隐藏文件；
举例：
public class FileDemo2 {
@Test
public void demo() { //测试环境
//表示一个当前项目下的a.txt
File file = new File("a.txt") ;
//public boolean isDirectory():判断是否是文件夹(目录)
System.out.println("isDirectory:"+file.isDirectory());
//public boolean isFile() :判断是否是文件
System.out.println("isFile:"+file.isFile());
//public boolean canRead(): 是否可读
System.out.println("canRead:"+file.canRead());
//public boolean canWriter():是否可写
System.out.println("canWriter:"+file.canWrite());
//public boolean exists():测试此抽象路径名表示的文件或目录是否存在
System.out.println("exites:"+file.exists());
//public boolean isHidden():是否是隐藏
System.out.println("isHidden:"+file.isHidden());
}
}public String getAbsolutePath()：获取抽象文件的绝对路径；
public String getPath()：获取相对路径的字符串；
public String getName()：返回由此抽象路径名表示的文件或目录的名称；
public long length()：返回由此抽象路径名表示的文件的长度；
public long lastModified()：文件最后一次被修改的时间(时间毫秒值)；
举例：
public class FileDemo3 {
@Test
public void demo() {
//表示一个当前项目下的a.txt
File file = new File("a.txt") ;
//public String getAbsolutePath():获取抽象文件的绝对路径
System.out.println(file.getAbsolutePath());//F:\eclipse-workspace\day16\a.txt
//public String getPath():获取相对路径的字符串
System.out.println(file.getPath());//a.txt
//public String getName()返回由此抽象路径名表示的文件或目录的名称
System.out.println(file.getName());
//public long length()返回由此抽象路径名表示的文件的长度。
System.out.println(file.length());
//public long lastModified():文件最后一次被修改的时间(时间毫秒值)
System.out.println(file.lastModified());//1526183014044
//知道了时间毫秒值,将之转换成我们知道的时间形式
Date d = new Date(1526183014044L) ;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(d) ;
System.out.println(str);
}
}public String[] list()：获取当前某个路径下的所有的文件夹以及文件名称的字符串数组；
public File[] listFiles()：获取当前某个路径下所有的文件夹以及文件的File数组；
举例：
public class FileDemo {
public static void main(String[] args) {
//表示e盘
File file = new File("e:\\") ;
//方式1::
String[] list = file.list() ;
for(String s:list) {
System.out.println(s);
}
System.out.println("--------------------------");
//方式2:
File[] fileArray = file.listFiles() ;
//防止他出现空指针异常
if(fileArray !=null) {
//遍历
for(File f:fileArray) {
System.out.println(f.getName());
}
}
}
}package org.westos.f;
import java.io.File;
/**
* 判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
*
* e盘下:图片文件
* 思路:
* 1)使用File对象表示e盘的根目录
* 2)File[] listFiles() ;String[] list() 获取当前盘符下所有的文件以及文件夹的File数组
* 3)对File数组对象进行非空判断,判断他是否为null,不是null,遍历
* 4)如果他是文件,并还有满足是否以.jpg结尾
* 满足就可以进行输出文件名称
*
*/
public class FileTest2 {
public static void main(String[] args) {
//封装e盘根目录
File file = new File("e:\\") ;
//获取当前盘下所有的文件夹以及文件的File数组
File[] fileArray = file.listFiles() ;
//非空判断
if(fileArray!=null) {
//遍历
for(File f :fileArray) {
//将每一个表示的文件/文件夹对象遍历出来
//判断是否是文件
if(f.isFile()) {
//满足文件
//并且以.jpg结尾的
if(f.getName().endsWith(".jpg")) {
//满足就输出
System.out.println(f.getName());
}
}
}
}
}
}使用匿名内部类的方式完成上述例题：
举例：
package org.westos.f;
import java.io.File;
import java.io.FilenameFilter;
/**
*
* 断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出此文件名称
*
* 使用方式:A:封装e盘,获取所有的文件以及文件夹的File数组(文件以及文件及的名称数组)
* 遍历的时候进行一系列判断进行条件过滤,麻烦
* B:当前获取到的时候就已经拿到.jpg文件等等....
*
*
* FilenameFilter:一个接口: 文件名称过滤器
* boolean accept(File dir, String name)测试指定文件是否应该包含在某一文件列表中。
* dir - 被找到的文件所在的目录;
* name - 文件的名称;
* 文件是否包含在文件列表中,取决于返回值,true;false表示不包含
*/
public class FileTest3 {
public static void main(String[] args) {
//封装e盘
File src = new File("e:\\");//表现形式
//采用文件名称过滤器:匿名内部类的方式
String[] strArray = src.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
//return false;
//首先封装File对象
/*File file = new File(dir, name) ;
//判断是否文件
boolean flag = file.isFile() ;
boolean flag2 = name.endsWith(".jpg") ;
return flag && flag2 ;*/
//一步走
return new File(dir, name).isFile() && name.endsWith(".jpg") ;
}
}) ;
//遍历字符串数组
for(String s: strArray) {
System.out.println(s);
}
}
}字节输入流OutputStream：
举例：public class FileOutputStreamDemo {
public static void main(String[] args) throws Exception {
//1)创建一个字节输出流对象
//OutputStream out = new OutputStream() ;
//FileOutputStream(String name)
//OutputStream out = new FileOutputStream("fos.txt") ; //抽象类多态
//创建对象做了几件事情
/**
* 1)构造了输出流对象 (系统创建对象)
* 2)指向了当前项目下输出fos.txt
*/
FileOutputStream fos = new FileOutputStream("fos.txt") ; //FileNotFoundException
//写数据
// 使用流对象给文件中写入数据
fos.write("hello".getBytes());
//关闭资源
/**
* 1)将文件和流对象不建立关系了 (fos对象不指向fos.txt)
* 2)及时释放掉流对象所占用的内存空间
*/
fos.close();
/**
* 如果关闭流对象了,那么就不能对流对象进行操作了
*/
//fos.write("java".getBytes());//java.io.IOException: Stream Closed :流已经关闭了
}
}public void write(int b)：一次写一个字节；
public void write(byte[] b)：一次写一个字节数组；
public void write(byte[] b, int off,int len)：一次写一部分字节数组；
举例：
public class FileOutputStreamDemo2 {
public static void main(String[] args) throws Exception {
//构造一个字节数出流对象
FileOutputStream fos = new FileOutputStream("fos2.txt") ;
//写数据
//一次一个字节
fos.write(97);
fos.write(98);
// public void write(int b):
//public void write(byte[] b) :一次写一个字节数组
byte[] bys = {97,98,99,100,101} ;
fos.write(bys);
//public void write(byte[] b, int off,int len):一次写一部分字节数组
fos.write(bys, 0, 2);
//关闭资源
fos.close();
}
}public FileOutputStream(File file, boolean append)：指定为true，末尾追加数据；
举例：
public class FileOutputStreamDemo {
public static void main(String[] args) throws Exception {
//1)创建字节文件输出流对象:FileOutputStream
//FileOutputStream fos = new FileOutputStream("fos3.txt") ;
FileOutputStream fos = new FileOutputStream("fos3.txt",true) ;
//2)写数据
for(int x = 0 ; x < 10 ; x ++) {
fos.write(("hello"+x).getBytes());
//写入换行符号
fos.write(("\r\n").getBytes()); // editplus工具
}
//3)释放资源
fos.close();
}
}字节输出流InputStream：
关于字节输入流读数据的方法：public abstract int read()：一次读取一个字节；
public int read(byte[] b)：一次读取一个字节数组 (读取实际的字节数)；
public class FileInputStreamDemo {
@Test
public void demo() throws Exception{
FileInputStream fis = new FileInputStream("fis.txt") ;
//最终版代码
int by = 0 ;
while((by=fis.read())!=-1) {
System.out.print((char)by);
}
//释放资源
fis.close();
}
}复制文本文件：
两个文件在同一个文件夹内：举例：
public class CopyFileDemo{
public static void main(String[] args) throws Exception {
//封装目的地文件和源文件
FileInputStream fis = new FileInputStream("a.txt") ;
FileOutputStream fos = new FileOutputStream("b.txt") ;
//进行读写操作
//一次读取一个字节
int by = 0 ;
while((by=fis.read())!=-1) {
//第一个字节,写个一个字节
fos.write(by);
}
System.out.println("------");
//一次读取一个字节数组
//释放资源
fis.close();
fos.close();
}
}举例：
public class CopyFileDemo2 {
public static void main(String[] args) throws Exception {
//封装目的地文件和源文件
FileInputStream fis = new FileInputStream("c:\\a.txt") ;
FileOutputStream fos = new FileOutputStream("d:\\b.txt") ;
//读写操作
int by = 0 ;
while((by=fis.read())!=-1) {
//不断写数据
fos.write(by);
}
//释放资源
fos.close();
fis.close();
}
}举例：
public class CopyImageDemo {
public static void main(String[] args) throws Exception {
//封装源文件和目的地文件
FileInputStream fis = new FileInputStream("高圆圆.jpg") ;
FileOutputStream fos = new FileOutputStream("mm.jpg") ;
//读写操作
//一次读取字节数组
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=fis.read(bys))!=-1) {
//写数据
fos.write(bys, 0, len);
}
//释放资源
fis.close();
fos.close();
}
}
1510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
