本章内容

1，file类

2，递归

3，IO流

4，字符流，字符缓冲区

5，装饰者模式

6，字节流，字节流缓冲区

7，转换流

8，其他流

9，编码问题

一、file类

用来将文件或者文件夹封装成对象
方便对文件与文件夹的属性信息进行操作
FILe能新建，删除，重命名文件与目录，但file不能访问文件内容

File(String pathname)
可以把一个存在或者不存在的文件（文件目录）封装成一个对象

File(String parent, String child)

File(File parent, String child)

判断：
   * exists() 判断文件或者文件夹是否存在
   * isDirectory() 判断文件对象是不是一个文件夹
   * isFile() 判断文件对象是不是一个文件
   * isAbsolute() 判断当前路径是不是绝对路径
   * isHidden() 判断文件是否隐藏

   获取类方法
   * getAbsolutePath() 获取文件的绝对路径，返回路径字符串
   * getAbsoluteFile() 获取文件的绝对路径，返回File对象
   * getParentFile() 获取当前路径的父路径，以File对象的形式返回父路径
   * getParent() 获取当前路径的父路径，以字符串形式返回父路径
   * getPath() 获取当前路径
   * getName() 获取当前文件或文件夹名称
   * lastModified() 获取文件最后修改时间
   * length() 获取文件长度
   * getTotalSpace() 获取分区总大小
   * renameTo(File newFile) 给文件改名字

* list() 以字符串形式返回当前路径下的所有文件和文件夹
* listFiles() 以File对象的形式返回当前路径下的所有文件和文件夹

package Test1;

import java.io.File;
import java.io.IOException;
import java.util.Date;

import org.junit.Test;

public class Demo {
	/*
	 * File(String pathname)
	 * 可以把一个存在或者不存在的文件（文件目录）封装成一个对象
	 * 
	 * File(String parent, String child)
	 
	 *File(File parent, String child)
	 */
	@Test
	public  void testConstructor(){
		// /斜杠 \反斜杠
		File f1 = new File("E:/practice/b.txt");//绝对路径
		File f2 = new File("E:/xxxx");
		
		File f3 = new File("E:/practice","b.txt");
		File parent = new File("E:/practice");
		File f4 = new File(parent,"b.txt");
		
	}
	/*
	 * 创建和删除文件:
	 * 
	 * CreateNewFile() 指定的文件不存在，就创建文件返回true，否则false
	 * mkdir() 创建单级文件夹
	 * mkdirs() 创建多级文件夹
	 * 
	 * delete() 删除单个文件或者多个文件夹
	 */
	
	@Test
	public void testCreateAndDelete() throws IOException{
		File f = new File("F:/pp");
		boolean flag = f.createNewFile();
		System.out.println(flag);
//		boolean mkidir = f.mkdirs();
//		System.out.println(mkidir);
//		boolean delete = f.delete();
//		System.out.println(delete);
	}
	/*
	 * 判断
	 * exists() 判断文件或者文件夹是否存在
	 * isDirectoery()判断文件对象是不是文件
	 * isFile() 判断文件对象是不是一个文件
	 * isAbsolute();
	 * isHidden();
	 * 
	 * 
	 */
	@Test
	public void testPanduan(){
		 File f1 = new File("F:/pp");
//		 boolean exists = f1.exists();
//		System.out.println(exists);
//		boolean directory = f1.isDirectory();
//		System.out.println(directory);
//		 boolean file = f1.isFile();
//		 System.out.println(file);
		 boolean file = f1.isAbsolute();
		 boolean hidden = f1.isHidden();
		 System.out.println(file);
	}
	/*
	 * 获取类方法
	 * getAbsoluteFile()   获取文件的绝对路径， 返回Flle对象
	 * getAbsolutePath() 获取文件的绝对路径，返回路径字符串
	 * getParentFile() 获取当前路径的父路径，以File对象的形式返回路径
	 * getPath() 获取当前路径
	 * getName() 获取当前文件夹或文件的名称
	 * lastModified() 获取文件最后修改时间
	 * length() 获取文件的长度
	 * getTotalSpace() 获取文件占用磁盘的大小,分区的大小
	 */
	@Test
	public void  testGet(){
		File f1 = new File("F:/pp");
		File f2 = new File("F:/xcc");
		File absoluteFile = f1.getAbsoluteFile();
		String absolutePath = f1.getAbsolutePath();
		File parentFile = f1.getParentFile();
		String path = f1.getPath();
		String name = f1.getName();
		long lastModified = f2.lastModified();
		long length = f1.length();
		long totalSpace = f2.getTotalSpace();
		boolean renameTo = f1.renameTo(f2);
		System.out.println(renameTo);
		
		Date d = new Date(lastModified);
		System.out.println(d.toLocaleString());
		System.err.println(totalSpace);
		
	}
	
	/*
	 * List() 以字符串形式返回当前路径下的所有 文件和文件夹
	 *  ListFiles 以File对象的形式返回当前路径下的所有文件和文件夹
	 *  
	 * 
	 */
	@Test
	public void testList(){
		File f = new File("F:/K/A");
		String[] list = f.list();
		for(String str : list){
			System.out.println(str);
		}
		System.out.println();
		System.out.println();
		
		File[] listFiles = f.listFiles();
		for(File file : listFiles){
			System.out.println(file.getName());
		}
		System.out.println();
		System.out.println(listFiles.length);
	}
	
	
}

2，递归

为了求一个数值，不断的调用本身。。具体内容前面有，这里就不赘述了

例一：递归

package Digui;

public class Demo {
	public static void main(String[] args) {
		int result = jiecheng(5);
		System.out.println(result);
	}
	public static int jiecheng(int n){
		if(n == 1){
			return 1;
		}
		else{
			return n*jiecheng(n-1);
		}
	}
}

再来一个用递归算法思想来完成文件夹的遍历与批量删除

package Digui;

import java.io.File;

public class Demo2 {
	public static void main(String[] args) {
//		//列出一个文件夹下所有子文件夹以及子文件
//		File file = new File("E://Desktop//chapter12//src//com//jp");
//		showList(file);
		//删除一个目录的过程是如何进行的？
		File file = new File("G://a");
		remove(file);
	}
	 private static void remove(File file) {
		 if(file.isDirectory()){
			 File[] listFiles = file.listFiles();
			 for( File f   : listFiles ){
			 if(f.isFile()){
				 f.delete();
			 }else if(f.isDirectory()){
				 remove(f);
			 }
			 }
		 }
		 file.delete();
	}

	//* isDirectory() 判断文件对象是不是一个文件夹
	 // isFile()   判断文件对象是不是一个文件
	/*private static void showList(File file) {
		 if(file.isDirectory()){
			 File[] listFiles = file.listFiles();//以File对象的形式返回当前路径下的所有文件和文件夹
			 for(File f : listFiles){
				 if(f.isFile()){
					 System.err.println("文件: " + f.getName() );
				 }else if(f.isDirectory()){
					 //这里是正在循环的f的文件对象
				showList(f);//这里用的就是递归
				 }
			 }
		 }
		 System.out.println("文件夹： " + file.getName());
	}*/
}

3.IO流

IO流用来处理设备之间的数据传输
java对对数据的操作是通过流（系统资源）的方式
java用于操作流的对象都在java.io包中
流按操作数据分为两种：字节流，和字符流
流按流向分为：输入流（读），输出流（写）

java --IO流

带Stream后缀的都是字节

带另一种的就是字符流。下面的图为老师上课讲的图，方便看点

java --IO流

4.字符流-创建文件

创建流对象，建立数据存放文件

–FileWriter fw =new FIleWriter(“a.txt”);

调用流对象的写入方法，将数据写入流

–fw.write(“aafsa”);

-关闭流资源，并将流中的数据清空到文件中。

–fw.close();

package Writer;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
	public static void main(String[] args) throws IOException {
		File file = new File("a.txt");
		FileWriter fw = new FileWriter(file);
//		fw.write(97);
//		fw.flush();//刷新
//		fw.close();//关闭流，自带刷新功能
		int i = 100;
		System.out.println((char)i);
	}
}

写入异常的处理

package Writer;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo2 {
	public static void main(String[] args) {
		FileWriter fw = null;
		try {
			File file = new File("xx:/a.txt");
			fw = new FileWriter(file,true);
			fw.write(97);
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fw != null){
					fw.close();
				}
			} catch (IOException e) {
				//保存到日志
				throw new RuntimeException("流关闭出门啦！！赶紧来处理");
			}
		}
	}
}

字符流-读取文件

建立一个流对象，和指定的文件数据关联
–FileReader fr = new FileReader(“01.txt”);
创建一个临时存放数据的数组。
–char[] ch = new char[1024];
调用流对象的读取方法将流中的数据读入到数组。
–fr.read(ch);

\r\n代表回车键

读的第一个例子：

package Reader;

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("a.txt");
//		int read1 = fr.read();
//		System.out.println(read1);
//		int read2 = fr.read();
//		System.out.println(read2);
//		int read3 = fr.read();
//		System.out.println(read3);
		int len = 0;
		while((len = fr.read()) != -1){
			//   \r\n代表回车键
			System.out.println(len);
		}
		fr.close();
	}
}

自定义缓冲区：

package Reader;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo2 {
		public static void main(String[] args) throws IOException {
			FileReader fr = new FileReader(new File("a.txt"));
			//临时缓冲区
			char[] c = new char[10];
//			int len1 = fr.read(c);//将数据读取到一个字符数组中
//			System.out.println("长度:" + len1 + "---读取的内容是:" + new String(c));
//			int len2 = fr.read(c);
//			System.out.println("长度:" + len2 + "---读取的内容是:" + new String(c));
//			int len3 = fr.read(c);
//			System.out.println("长度:" + len3 + "---读取的内容是:" + new String(c));
		
			int len = 0;
			while((len= fr.read(c)) != -1){
				System.out.println(new  String(c, 0, len));
			}
	}
}

字符流练习：比较正规的

package Example;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDoc1 {
	public static void main(String[] args){
		FileReader fr = null;
		FileWriter fw = null;
		try {
			//源文件
			File sourceFile = new File("F://a.txt");
			
			//目标文件
			File targetFile = new File("D://copy.doxc");
			
			//建立读取流的通道
			fr = new FileReader(sourceFile);
			
			//建立写入流通道
			fw = new FileWriter(targetFile);
			//建立临时缓冲区，以提高效率
			char[] c = new char[1024];
			//记录读取的字符个数
			int len = 0;
			
			while((len = fr.read(c)) != -1){
				fw.write(c, 0, len);
				fw.flush();//刷新
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fr != null){
					fr.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("读取流关闭出问题啦");
			}
			try {
				if(fw != null){
					fw.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("写入流关闭出问题啦");
			}
		}
	}
}

字符流–缓冲区
缓冲区提高了对数据的读写效率
对应类：
—BufferedWriter
—BufferedReader
缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强

package Buffer;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferDemo2 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = null;
		BufferedWriter  bw = null;
		try {
			br = new BufferedReader(new FileReader(new File("F://a.txt")));
			bw = new BufferedWriter(new FileWriter(new File("D://nihao.txt")));
			String line = null;
			while((line = br.readLine()) != null){
				bw.write(line);
				bw.newLine();//换行
				bw.flush();//刷新
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(br != null){
				br.close();
			}
			if(bw != null){
				bw.close();
			}
		}
		
	}
}

5，装饰者设计模式

对原有类进行了功能增强
它与继承有什么不同？
继承：被增强的对象固定
被增强的内容也是固定的
装饰者模式;被增强的对象是可以切换的
被增强的内容是固定的
动态代理（AOP） :被增强的对象可以切换
被增强的内容也是可以切换的

6,字节流

FileInputStream

FileOutputStream

复制一个mv到别的盘

package FileInputStream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis =null;
		FileOutputStream fos = null;
		try {
			File sourceFile = new File("D://123.mp4");
			File targetFile = new File("G://xcc.mp4");
			fis = new FileInputStream(sourceFile);
			fos = new FileOutputStream(targetFile);
			byte[] b = new byte[1024];
			int len = 0;
			while((len = fis.read(b)) != -1){
				fos.write(b, 0, len);
				fos.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fis != null){
				try{
					fis.close();
				}catch(IOException e){
					throw new RuntimeException("关闭读取流出问题");
				}
			}
			if(fos != null){
				try{
					fos.close();
				}catch(IOException e){
					throw new RuntimeException("关闭写入流出问题");
				}
			}
			
		}
		
	}

}

字节流—-缓冲区

BufferedInputStream
BufferedOutputStream

package Test1;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedDemo3 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = null;
		FileOutputStream fos  =null;
		BufferedInputStream bis  = null;
		BufferedOutputStream  bos = null;
		try {
			fis = new FileInputStream("E://Desktop//大二  上学期//123.mp4");
			fos = new FileOutputStream("d://copy1.mp4");
			bis = new BufferedInputStream(fis);
			bos = new BufferedOutputStream(fos);
			
			byte[] b = new byte[1024];
			
			int len = 0;
			
			while((len = bis.read(b)) != -1) {
				bos.write(b, 0, len);
				bos.flush();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch (IOException e){
			e.printStackTrace();
		}finally {
			try {
				if(fis != null){
					fis.close();
				}
			} catch (IOException e) {
					throw new RuntimeException("出问题啦");
			}
			
			try {
				if(fos != null){
					fos.close();
				}
			} catch (IOException e) {
					throw new RuntimeException("出问题啦");
			}
			try {
				if(bis != null){
					bis.close();
				}
			} catch (IOException e) {
					throw new RuntimeException("出问题啦");
			}
			try {
				if(bos != null){
					bos.close();
				}
			} catch  (IOException e) {
					throw new RuntimeException("出问题啦");
			}
		}
		
	}
}

7，转换流

InputStreamReader , OutputStreamWriter
转换流的由来

–字符流与字节流之间的桥梁
–方便了字符流与字节流之间的操作

转换流的应用
-字节流中的数据都是字符时，转换字符流的操作更高效
GBK读中文的码表

package Trans;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class TransDemo {
	public static void main(String[] args) throws IOException {

		//FileInputStream fis = new FileInputStream("E://xx.txt");

		// 需要转换吗？
		//InputStreamReader isr = new InputStreamReader(fis, "gbk");
		
		FileReader fr = new FileReader("G://xx.txt");
		// 需要提高效率吗？
		BufferedReader br = new BufferedReader(fr);

		FileOutputStream fos = new FileOutputStream("F://yy.txt");

		OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");

		BufferedWriter bw = new BufferedWriter(osw);

		String line = null;

		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.flush();
		}

		fr.close();
		br.close();
		fos.close();
		osw.close();
		bw.close();
	}
}

8，标准输入输出流

System.in 和 System.out分别代表了系统标准的输入和输出设备
默认输入设备是键盘，输出设备是显示器
System.in 的类型是 InputStream
System.out 的类型是 PrintStream，其实OutoutStream 的子类
通过System 类的seth，setOut方法对默认设备进行改变。
Public static void setln(InputStream in)
public static void setOut(PrintStream out)

package SYs;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

public class SystemDemo {
	public static void main(String[] args) throws IOException {
		InputStream in = System.in;
//		int read = in.read();
//		System.out.println(read);
//		int read1 = in.read();
//		System.out.println(read1);//  13 \r
//		int read2 = in.read();
//		System.out.println(read2);//   10\n
//		int len = 0;
//		while((len = in.read()) != -1){
//			System.out.println(len);
//		}
		InputStreamReader isr = new InputStreamReader(in);
		BufferedReader br = new BufferedReader(isr);
		
		PrintStream out = System.out;
		OutputStreamWriter osw = new OutputStreamWriter(out);
		
		BufferedWriter bw = new BufferedWriter(osw);
		
		String line = null;
		while((line = br.readLine())  != null ){
			//System.out.println(line);
			if("over".equals(line)){
				break;
			}
			bw.write(line.toUpperCase());//大写
			bw.newLine();//换行
			bw.flush();//刷新
		}
		in.close();
		isr.close();
		br.close();
		out.close();
		osw.close();
		bw.close();
		
		
	}
}

8、其他流

打印流
—printWriter 与 printStream
可以直接操作输入流文件
序列流
—SequenceInputStream
对多个流进行合并
对象流
— ObjectInputStream与ObjectOutputStream
被操作的对象需要Serializable（标记接口）

打印流

package Pint;

import java.io.IOException;
import java.io.PrintStream;

import org.junit.Test;

public class PrintDemo {
	@Test
	public void testPrintDemo()  throws IOException{
	PrintStream ps = new PrintStream("preawer.txt");
	ps.print(91);
	ps.println();
	ps.flush();
	ps.close();
	}
	@Test
	public void testPrintWriter(){
		//字节流   ctrl + t  查看代码的结构
		PrintStream out = System.out;
//		PrintWriter pw = new PrintWriter(out);
//		pw.print('a');
//		pw.flush();
//		pw.close();
		out.print("aaa");
	}
}

对象流

package com.jp.obj;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import org.junit.Test;

public class ObjDemo {
	
	@Test
	public void testObjectInputStream() throws IOException, ClassNotFoundException{
		ObjectInputStream in = new ObjectInputStream(new FileInputStream("zs.txt"));
		//对象的反序列化
		Object readObject = in.readObject();
		Person p = (Person)readObject;
		System.out.println(p.getName());
		in.close();
	}
	
	@Test
	public void testObjectOutputStream() throws IOException{
		//对象的写出流，写入到磁盘上
		ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream("zs.txt"));
		
		//对象序列化过程
		out.writeObject(new Person("zs", 20));
		out.flush();
		out.close();
	}
}

9、常见码表

编码变的由来：

计算机智能识别二进制数据，早期由来是电信号，为了方便应用计算机，让它可以识别各个国家的文字，就将各个国家的文字用数学来表示，并一一对应，形成一张表，这就是编码表

常见的编码表如下

java --IO流

编码: 字符串—–字节数组
解码：字节数组—字符串
转换流的编码应用
可以将字符按指定编码格式存储
可以对文本数据按指定编码格式来解读
指定编码表的动作由构造器来完成

package Example;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyDoc1 {
	public static void main(String[] args){
		FileReader fr = null;
		FileWriter fw = null;
		try {
			//源文件
			File sourceFile = new File("F://a.txt");
			
			//目标文件
			File targetFile = new File("D://copy.doxc");
			
			//建立读取流的通道
			fr = new FileReader(sourceFile);
			
			//建立写入流通道
			fw = new FileWriter(targetFile);
			//建立临时缓冲区，以提高效率
			char[] c = new char[1024];
			//记录读取的字符个数
			int len = 0;
			
			while((len = fr.read(c)) != -1){
				fw.write(c, 0, len);
				fw.flush();//刷新
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fr != null){
					fr.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("读取流关闭出问题啦");
			}
			try {
				if(fw != null){
					fw.close();
				}
			} catch (IOException e) {
				throw new RuntimeException("写入流关闭出问题啦");
			}
		}
	}
}

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/114802.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...

java –IO流

本章内容

一、file类

2，递归

3.IO流

4.字符流-创建文件

5，装饰者设计模式

6,字节流

字节流—-缓冲区

7，转换流

8，标准输入输出流

8、其他流

打印流

对象流

9、常见码表

编码变的由来：

发表回复

java –IO流

本章内容

一、file类

2，递归

3.IO流

4.字符流-创建文件

5，装饰者设计模式

6,字节流

字节流—-缓冲区

7，转换流

8，标准输入输出流

8、其他流

打印流

对象流

9、常见码表

编码变的由来：

相关推荐

安卓7.1精简版下载_asm字节码

cmd查看防火墙状态_win7防火墙关闭不了

RapeLay（电车之狼R）的结局介绍 (隐藏结局攻略)

电平转换芯片_电平转换芯片无方向

java定时任务之quartz

面试题的基本总结回顾（以以往面试过的问题做基本总结）[通俗易懂]

发表回复