File和字节流

File类

1.File类:
文件和目录路径名的抽象表示

2.绝对路径:
带盘符的路径.
相对路径:
相对其他文件或目录的一个路径叫相对路径.

如果当前文件或目录相对其他盘符的的文件或目录来说,此时相对路径==绝对路径.

如果当前文件或目录相对当前所有在的盘符的文件或目录来说,此时相对路径!=绝对路径.

根路径:相当当前项目的路径.

3.file类常用方法:

public static void main(String[] args) {
		//获得文件对象
		File f1=new File("aa\\a.txt");
		System.out.println("文件名:"+f1.getName());
		System.out.println("绝对路径:"+f1.getAbsolutePath());
		System.out.println("相对路径:"+f1.getPath());
		System.out.println("是否可读:"+f1.canRead());
		System.out.println("是否可写:"+f1.canWrite());
		System.out.println("是否隐藏:"+f1.isHidden());
		System.out.println("文件的长度:"+f1.length());
		//得到文件最后一次修改时间
		Long time1=f1.lastModified();
		//创建格式化对象
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		//用格式化对象将时间进行格式化成指定格式的字符串
		String time2=sdf.format(new Date(time1));
		
		System.out.println("最后一次修改时间:"+time2);
	}

	public static void main(String[] args) throws IOException {
		//获得文件对象
		File f1=new File("cc\\bb\\b.txt");
		
		//获得当前文件对象父目录
		File parentFile=f1.getParentFile();
		//判断父目录是否存在
		if (parentFile.exists()) {//父目录存在
			System.out.println("父目录存在");
		} else {//父目录不存在
			//创建一级目录
			//parentFile.mkdir();
			//创建多级目录
			parentFile.mkdirs();
			System.out.println("父目录创建成功");
			
		}
		
		//判断当前文件是否存在
		if (f1.exists()) {//文件存在
			System.out.println("文件存在");
		} else {//文件不存在
			//创建文件
			f1.createNewFile();
			System.out.println("文件创建成功");
		}
	}

	public static void main(String[] args) throws IOException {
		//获得目录对象
		File f1=new File("cc");
		
		//判断当前目录是否存在
		if (f1.exists()) {//当前目录存在
			//获得当前目录所有子文件或子目录的字符串形式
			String[] childFiles=f1.list();
			//遍历子文件或子目录
			for (String child : childFiles) {
				//判断子文件或子目录是否以.txt结尾
				if (child.endsWith(".txt")) {
					System.out.println(child);
				}
			}
			
		} else {
			System.out.println("当前目录不存在");
		}
	}

4.递归:方法自身调用自身.
4.1:可以将原问题拆分成若干子问题,子问题的解决方法与原问题的解决方法一样.
4.2:原问题的解决依赖于所有子问题的解决.
4.3:递归一定要有出口.

eg:/**
 * 2.获得指定目录下所有以.txt结尾的文件(子文件,孙子文件,子子孙孙)
 * @author sx
 * @version 2020年3月16日
 */
public class FileTest4 {

	public static void main(String[] args) throws IOException {
		//获得目录对象
		File f1=new File("cc");
		if (f1.exists()) {
			//调用递归方法
			digun(f1);
		} else {
			System.out.println("目录不存在");
		}
	}
	
	/**
	 * 判断当前目录的子文件是否以.txt结尾
	 * @param f
	 */
	public static void digun(File f) {
		//获得当前目录的子文件或子目录
		File[] files=f.listFiles();
		//遍历所有子文件和子目录
		for (File f2 : files) {
			if (f2.isDirectory()) {//当前遍历的是子目录
				digun(f2);//调用自身
			}else{//当前遍历的是子文件
				if (f2.getName().endsWith(".txt")) {
					System.out.println(f2.getName());
				}
			}
		}
	}
}

5.过滤器:将需要数据留下来,不需要数据过滤掉.

/**
 * 自定义文件过滤器类
 * @author sx
 * @version 2020年3月16日
 */
public class MyFilter implements FilenameFilter{
	/**
	 * 过滤方法
	 * @param dir 要过滤文件对象
	 * @param name要过滤文件名
	 */
	@Override
	public boolean accept(File dir, String name) {
		if (name.endsWith(".txt")) {
			return true;
		} else {
			return false;
		}
	}
}

public static void main(String[] args) throws IOException {
		//获得目录对象
		File f1=new File("cc");
		
		//判断当前目录是否存在
		if (f1.exists()) {//存在
			//创建一个过滤器对象
			FilenameFilter mf=new MyFilter();
			//用过滤器获得当前目录下满足条件以.txt结尾子文件
			String[] files=f1.list(mf);
			//遍历输出
			for (String f2 : files) {
				System.out.println(f2);
			}
		} else {
			System.out.println("目录不存在");
		}
}

字节流

1.IO流:将数据从一个地方传输另一个地方.

2.流的分类:

2.1:按输出方向分:以程序为参数物.
输入流:将文件中数据读取到程序中.
注意:如果文件不存在,输入流会抛异常(报错).
输出流:将程序中数据写入到文件中.
注意:如果文件不存在,先创建文件,再向文件中写入数据.

2.2:按单元分:bit(位),byte,kb,mb,g,t,p
字节流:以字节为单元传输的流.
作用:用来传输部分文本文件,图片,视频,二进制文件.
字符流:以字符为单元传输的流.
作用:用来传输文本文件.

2.3:按功能分:
节点流:原始流.
处理流:封装了原始流.
注意:所有处理流都用了装饰者模型.

3.装饰者模式:将原有类的对象进行封装,使其功能更强大.
4.基本字节流(原始字节流)

4.1:字节输入流:InputStream->FileInputStream
4.1.1:一个字节一个字节的读取

eg:public static void main(String[] args) throws IOException{
		//声明一个流对象
		FileInputStream fis=null;
		try {
			//1.创建流对象
			fis=new FileInputStream("bb\\b.txt"); 
			/*2.用流来读取文件中内容,一个字节一个字节的读取,*/
			//返回的是读取的内容,先读取一次
			int content=fis.read();
			//接着读
			while (content!=-1) {
				//将读取的字节内容转换为字符输出
				System.out.print((char)content);
				//接着读
				content=fis.read();
			}
			System.out.println("读取完毕!");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			//3.关流
			if (fis!=null) {
				fis.close();
			}
		}
	}

4.1.2:按字节数组的读取

eg:public static void main(String[] args) throws IOException {
		//声明流对象
		FileInputStream fis=null;
		
		try {
			//1.创建流对象
			fis=new FileInputStream("bb\\b.txt");
			/*2.用流对象读取内容*/
			//准备一个数组
			byte[] b=new byte[5];
			//先读取一次,返回的是读取的长度,读取的内容存在数组中.
			int len=fis.read(b);
			//接着读
			while (len!=-1) {
				System.out.println("读取的长度:"+len);
				//先将读取的内容转换为String类型再输出
				String s1=new String(b, 0, len);
				System.out.println(s1);
				//接着读
				len=fis.read(b);
			}
			System.out.println("读取完毕");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关闭对象
			if (fis!=null) {
				fis.close();
			}
		}
	}

4.2:字节输出流:OutputStream->FileOutputStream

eg:public static void main(String[] args) throws IOException {
		//声明流对象
		FileOutputStream fos=null;
		
		try {
			//1.创建流对象,第二个参数是否向文件末尾追加内容
			fos=new FileOutputStream("bb\\c.txt",true);
			/*2.用流对象向文件中写入内容*/
			fos.write("Hello Java".getBytes());
			fos.write("Hello Stream".getBytes());
			fos.write("我是千锋人".getBytes());
			System.out.println("写入完毕");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (fos!=null) {
				fos.close();
			}
		}
	}

4.3:文件的拷贝

eg:public static void main(String[] args) throws IOException {
		//声明流对象
		FileInputStream fis=null;
		FileOutputStream fos=null;
		
		try {
			//1.创建输入流和输出流对象
			fis=new FileInputStream("C:\\Users\\sx\\Desktop\\image\\4.jpg");
			fos=new FileOutputStream("bb\\a.jpg");
			/*用流边读取边写入*/
			//准备一个数组
			byte[] b=new byte[1024];
			//先读取一次,返回读取的长度,读取的内容存到数组中
			int len=fis.read(b);
			//判断,接着读
			while (len!=-1) {
				//将读取的内容写入到文件中
				fos.write(b, 0, len);
				//接着读
				len=fis.read(b);
			}
			System.out.println("图片拷贝成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (fis!=null) {
				fis.close();
			}
			if (fos!=null) {
				fos.close();
			}
		}
	}

5.字节缓冲流:处理流封装原始字节流
5.1:字节缓冲输入流:FilterInputStream->BufferedInputStream

eg:public static void main(String[] args) throws IOException {
		//声明流对象
		BufferedInputStream bis=null;
		
		try {
			//1.创建流对象
			bis=new BufferedInputStream(new FileInputStream("aa\\a1.txt"));
			/*2.用流对象调用方法读取文件中内容*/
			//准备一个数组
			byte[] b=new byte[10];
			//先读取一次,返回的是读取的长度,读取的内容存在数组中
			int len=bis.read(b);
			//接着读
			while (len!=-1) {
				//将读取的内容转换为String,再输出
				String s1=new String(b, 0, len);
				System.out.println(s1);
				//接着读取
				len=bis.read(b);
			}
			System.out.println("读取完毕!");
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (bis!=null) {
				bis.close();
			}
		}
	}

5.2:字节缓冲输出流:FilterOutputStream->BufferedOutputStream

eg:public static void main(String[] args) throws IOException {
		//声明流对象
		BufferedOutputStream bos=null;
		
		try {
			//1.创建流对象,可以向文件中追加内容
			bos=new BufferedOutputStream(new FileOutputStream("aa\\a1.txt",true));
			/*2.用流对象向文件中写入内容*/
			bos.write("今天好像没有太阳".getBytes());
			//刷新缓冲区
			bos.flush();
			bos.write("elephent".getBytes());
			//刷新缓冲区
			bos.flush();
			System.out.println("写入成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (bos!=null) {
				bos.close();
			}
		}
	}

5.3:字节缓冲流的拷贝

eg:public static void main(String[] args) throws IOException {
		//声明流对象
		BufferedInputStream bis=null;
		BufferedOutputStream bos=null;
		
		try {
			//1.创建流对象
			bis=new BufferedInputStream(new FileInputStream("C:\\Users\\sx\\Desktop\\image\\b.jpg"));
			bos=new BufferedOutputStream(new FileOutputStream("aa\\a2.jpg"));
			/*2.用对象来边读取边写入*/
			//准备一个数组
			byte[] b=new byte[1024];
			//声明一个变量存读取的长度
			int len;
			while ((len=bis.read(b))!=-1) {
				//将读取的内容写入到文件中
				bos.write(b, 0, len);
				//刷新缓存
				bos.flush();
			}
			System.out.println("拷贝成功");
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			//3.关流
			if (bis!=null) {
				bis.close();
			}
			if (bos!=null) {
				bos.close();
			}
		}
	}