java基础-IO流

异常

异常：就是程序出现了不正常的情况
ArithmeticException:当出现异常的运算条件时，抛出此异常。
Throwable类是Java语言中所有错误或异常的超类。
Error是Throwable的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
Exception类及其子类是Throwable的一种形式，它指示了合理的应用程序想要捕获的条件。
RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类。
Exception分为运行期和编译期：
		运行期的异常：在编译器是不处理的，在程序运行时候出现了问题，需要我们回来修改代码。
		编译期的异常：在编译器就必须处理，否则程序不能通过编译，就更不能正常的执行。
异常的体系：
Throwable
	Error:严重问题，不需要处理。
	Exception
		RuntimeException:在编译器是不处理的，在程序运行时，需要我们回来修改代码。
		非RuntimeException:在编译期就必须处理，否则程序不能通过编译，就更不能正常的执行了。

JVM针对异常的默认处理方式

异常的默认处理方式
如果程序出现了问题，我们没有做任何的处理，最终JVM会做出默认的处理
处理方案：
A:把异常的名称，异常的原因，异常出现的位置等信息在控制台输出。
B:让程序停止执行

异常处理方案try_catch

异常处理：
方案1：try...catch...
格式：
try {
	可能出现异常的代码；
}catch(异常类名 变量名) {
		异常的处理代码；
}
执行流程：
程序从try开始执行，执行到那里出现了问题，就会跳转到catch里面
执行完毕后，程序还能继续往下执行。

编译时异常和运行时异常的区别

import java.test.ParseException
import java.text.SimpleDataFormat;
import java.util.Date;
/*
 *Java中的异常被分为两大类：编译时异常和运行时异常
 *所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常都是编译时异常。
 *编译时异常：Java程序必须显示处理，否则程序就会发生错误的一个提示，无法通过编译。
 *运行时异常：Java程序无需显示处理，也可以和编译时异常一样处理。
 */
 public class ExceptionDemo4 {
 	public static void main(String[] args) {
 		System.out.println("程序开始执行");
 		method();
 		System.out.println("程序结束执行");
 	} 		
 	//编译时异常ParseException
 	public static void method() {
 		try{
 			String s = "2088-08-08";
 			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 			Date d = sdf.parse(s);
 			System.out.println(d);
 		}catch(ParseException e) {
 			e.printStackTrace();
 		}
 	}
 	//运行时异常
 	public static void method2() {
 		try{
 			int a = 10;
 			int b = 0;
 			System.out.println(a/b);
 		}catch(ArithmeticException e) {
 			e.printStackTrace();
 		}
 	}
 }
 

异常处理方案throws

/*格式：
 *throws 异常类名
 *这个格式必须跟在方法的括号的后面。
 *注意：
 *编译异常时必须进行处理，两种处理方式：try...catch...或者throws
 *如果你采用throws这种方法，将来谁调用，还得进行处理。
 *运行时异常可以不用处理，出现问题后我们需要回来修改代码。
 */
 public class ExceptionDemo5 {
 	public static void main(String[] args) {
 		System.out.println("程序开始执行");
 		try {
 			method();
 		} catch(ParseException e){
 			e.printStackTrace();
 		}
 		method2();
 		System.out.println("程序结束执行")；
 	}
 	//编译时异常
 	public static void method() throws ParseException {
 		String s = "2088-08-08";
 		SimpleDataFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Date d = sdf.parse(s);
 		System.out.println(d);
 	}
 	//运行时异常
 	public static void method2() throws ArithmeticException {
 		int a = 10;
 		int b = 0;
 		System.out.println(a/b);
 	}
}

File类

File类的概述和构造方法

import java.io.File
/*
 *File:文件和目录路径名的抽象表示形式
 *也就是说文件和目录是可以通过File封装
 *目录：其实就是文件夹
 *File构造方法：
 *File(String pathname):通过将给定路径名字符串转换为抽象路径名来创建一个新File实例。
 *File(String parent,String child):根据parent路径名字符串和child路径名字符串创建一个新File实例。
 *File(File parent, String child):根据parent抽象路径名和child路径名字符串创建一个新File实例
 */
 public class FileDemo {
 	public static void main(String[] args) {
 		File f1 = new File("d:\\aa\\b.txt");

		File f2 = new File("d:\\aa","b.txt");
		
		File f3 = new File("d:\\aa");
		File f4 = new File("f3","b.txt");
 	}

File类的创建功能

import java.io.File;
import java.io.IOException;
/*
 *创建功能
 *public boolean createNewFile();创建文件
 *如果文件不存在，创建文件并返回true
 *如果文件存在，创建文件失败并返回false.
 *public boolean mkdir();创建目录
 *如果目录不存在，创建目录并返回true
 *如果目录存在，创建目录失败并返回false
 *public boolean mkdirs();创建多级目录
 */
 public class FileDemo {
 	public static void main(String[] args) throws IOException {
 		//需求1：d盘目录下创建一个文件a.txt
 		File f1 = new File("d:\\a.txt");
 		System.out.println("createNewFile:" + f1.createNewFile());
 		//d盘目录下创建一个目录bb
 		File f2 = new File("d:\\bb");
 		System.out.println("mkdir:"+f2.mkdir());
 		//一步一步的实现
 		File f3 = new File("d:\\cc");
 		File f4 = new File("d:\\cc\dd");
 		System.out.println("mkdir:" + f3.mkdir());
 		System.out.println("mkdir:" + f4.mkdir());
		//一步操作
		File f3 = new File("d:\\cc\\dd");
		System.out.println("mkdirs:" + f3.mkdirs());
		//需求4：我要在d盘目录下创建一个文件ee\\f.txt
		File f4 = new File("d:\\");
		File f5 = new File("d:\\ee\\f.txt");
		System.out.println("mkdir:" + f4.mkdir());
		System.out.println("createNewFile:"+f5.createNewFile());
	}
}

File类的删除功能

import java.io.File;
import java.io.IOException;
/*
 *删除功能
 *public boolean delete():删除文件和目录
 *路径的问题;
 *绝对路径：是以盘符开始的路径
 *相对路径：不以盘符开始，相对于项目而言
 *
 *如果一个中有内容（目录，文件），就不能直接删除
 */
public class FileDemo {
	public static void main(String[] args) throws IOException {
		//需求1：我要创建一个文件a.txt
		File f1 = new File("a.txt");
		System.out.println("createNewFile:"+f1.creatNewFile());
		//需求2：我要创建一个目录bb
		File f2 = new File("bb");
		System.out.println(mkdir:)+f2.mkdir());
		//需求3：我要创建一个文件cc\\d.txt
		File f3 = new File("cc");
		File f4 = new File("cc\\d.txt");
		System.out.println("mkdir:" + f3.mkdir());
		System.out.println("createNewFile:"+f4.createNewFile());
		System.ou.println("--------")

		//public boolean delete():删除文件和目录
		//需求1：我要删除a.txt这个文件
		File f1 = new File("a.txt");
		System.out.println("delete:" + f1.delete());
		//需求2：我要删除bb这个目录
		File f2 = new File("bb");
		System.out.println("delete:" + f2.delete());
		System.out.println("--------");
		//需求3：我要删除cc这个目录

File类的判断和获取功能

/*
 *判断功能
 *public boolean isDirectory():判断是否是目录
 *public boolean isFile():判断是否是文件
 *public boolean exists():判断是否
 *辅助功能
 *public String getAbsolutePath():获取绝对路径
 *public String getPath():获取相对路径
 *public String getName():获取名称
 */
public class FileDemo {
	public static void main(String[] args) {
		//创建File对象
		File f = new File("aaa\\bbb.txt");
		//判断功能
		System.out.println("isDirectory:" + f.isDirectory());
		System.out.println("isFile:" + f.isFile());
		System.out.println("exists:"+f.exists());
		System.out.println("---------");

		//获取功能
		System.out.println("getAbsolutePath:"+f.getAbsolutePath());
		System.out.println("getPath:"+f.getPath());
		System.out.println("getName:"+f.getName());
	}
}

IO流

IO流的概述和分类

读数据-----输入流
写数据-----输出流
字符流数据通过windows系统自带的记事本软件打开可以读懂里面内容的。

FileOutputStream写数据

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
/*
 *字节流：
 *InputStream 字节输入流
 *OutputSteam 字节输出流
 *字符流：
 *Reader    字符输入流
 *Writer    字符输出流
 *
 *字节流写数据
 *OutputStream:此抽象类是表示输出字节流的所有类的超类
 *FileOutputStream:文件输出流是用于将数据写入File
 *构造方法：FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流
 */
public class  FileOutputStreamDemo {
	public static void main(String[] args) throws FileNotFoundException {
		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("a.txt");
		/*
		 *创建字节输出流对象做了这样的三件事情
		 *A:调用系统功能创建了文件
		 *B:创建字节输出流对象
		 *C:让fos这个对象指向a.txt这个文件
		 */
		//write(int b)
		fos.write(65);
		fos.write(66);
		
		fos.close();
	}
}

FileOutputStream写数据的三种方式

字节流写数据的三种方式
构造方法：
fileOutputStream(String name)
FileOutputStream(File file)
public void write(int b):一次写一个字节
public void write(byte[] b):一次写一个字节数组
public void write(byte[] b, int off, int len):一次写一个字节数组的一部分

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
/*
 *字节流写数据的步骤
 *A:创建字节输出流对象
 *B:调用写数据的方法
 *C:释放资源
 */
public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws FileNotFoundException {
		//创建字节输出流对象
		//FileOutputStream(String name)
		FileOutputStream fos = new FileOutputStream("b.txt");
		//FileOutputStream fos = new FileOutputStream(new File("b.txt"));
	
	//public void write(int b):一次写一个字节
	fos.write(65);
	//public void write(byte[] b):一次写一个字节数组
	byte[] bys = {65,66,67,68,69};
	fos.write(bys);
	//String -- byte[]
	//String类中有一个方法：public byte[] getByte()
	//byte[] bys = "ABCDEE".getBytes();
	fos.write(bys);
	fos.write("ABCDE".getBytes());
	//public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
	fos.write("ABCDE".getBytes(),0,3);
	//删除资源
	fos.close();
	}
}

FileOutputStream如何实现换行和追加写数据

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 *如何实现数据的换行？
 *不同的操作系统，针对换行的符号识别是不一样的。
 *windows:\r\n
 *linux:\n
 *mac:\r
 */
public class FileOutputStreamDemo3 {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		FileOutputStream fos = new FileOutStream("c.txt");
		//调用写数据的方法
		for(int x=0; x<10;x++) {
			for.write("hello".getByte());
			//输入换行符号
			fos.write("\r\n".getBytes());
		}
		//释放资源
		fos.close();
	}
}

FileOutputStream写数据加入异常处理

import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileOutputStreamDemo4 {
	public static void main (String[] args) {
		FileOutputStream fos = null;
		try{
			fos.write("hello".getBytes());
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			if(fos != null) {
				try {
					fos.close();
				} catch{IOException e}{
					e.printStackTrace();
				}
			}
		}
	}
}

FileInputStream读数据方式1一次读取一个字节

import java.io.IOException;
/*
 *字节流读数据：InputStream
 *FileInputStream 从文件系统中的某个文件中获得输入字节
 *构造方法：FileInputStream(String name)
 *字节流读数据的步骤：
 *A:创建字节输入流对象
 *B:调用读数据方法
 *C:释放资源
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节输入对象
		FileInputStream fis = new FileInputStream("s.txt");
		//调用读数据方法
		//public int read():读取一个字节的数据
		int by = fis.read();
		System.out.println(by);
		System.out.println((char)by);
		fis.close();
		
		int by;
		while((by = fis.read()) != -1) {
			System.out.print((char)by);
		}
		fis.close();
	}
}

FileInputStream读数据方式2一次读取一个字节数组

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
 *字节流读数据：
 *方式1：一次读取一个字节
 *方式2：一次读取一个字节数组
 *public int read(byte[] b):从此输入流中将最多b.length 个字节的数据读入一个byte数组中
 */
 public class FileInputStreamDemo2 {
 	public static void main(String[] args) throws IOException {
 		//创建字节输入流对象
 		FileInputStream fis = new FileInputStream("b.txt");
 		//调用读取数据的方法
 		//定义一个数组
 		byte[] bys = new byte[5];
 		//第一次读取
 		int len = fis.read(bys);
 		System.out.println(len);
 		//byte[] -- String
 		//String(byte[] bytes)
 		//String(byte[] bytes, int offset,int length)
 		System.out.println(new String(bys));
 		/*
 		byte[] bys = new byte[5];
 		int len = fis.read(bys);
 		while(len != -1) {
 			System.out.print(new String(bys,0,len));
 			len = fis.read(bys);
 		}
 		//最终新版本
 		byte[] bys = new byte[1024];
 		int len;
 		while((len=fis.read(bys)) != -1) {
 			System.out.print(new String(bys,0,len));
 		}
 		//释放资源
 		fis.close();
 	}
 }

字节流练习之复制文本文件

import java.io.FileInputStream;
import java.io.FileNotFoundException;
/*
 *把d:\\xxx.txt内容复制到项目目录下yyy.txt中
 *文件复制，其实就是从一个文件中读数据，然后把数据写到另一个文件中
 *数据源：
 *d:\\xxx.txt --- 读数据 --- InputStream ---FileInputStream
 *目的地：
 *yyy.txt --- 写数据 --- OutputStream --- FileOutStream
 */
public class CopyTxtText {
	public static void main(String[] args) throws FileNotFoundException {
	//封装数据源
	FileInputStream fis = new FileInputStream("d:\\xxx.txt");
	//封装目的地
	FileOutputStream fos = new FileOutputStream("yyy.txt");
	//读取数据
	//方式1：一次读取一个字节
	int by;
	while((by=fis.read())!=-1) {
		fos.write(by);
	}
	//方式2：一次读取一个字节数组
	byte[] bys = new byte[];
	int len;
	while((len = fis.read(bys))!=-1) {
		fos.write(bys,0,len);
	}
	//释放资源
	fos.close();
	fis.close();
	}
}

字节流练习之复制图片

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
/*
 *把d:\\mn.jpg内容复制到当前项目目录下的mn.jpg中
 *数据源：
 *d:\\mn.jpg---读数据---FileInputStream
 *目的地：
 *mn.jpg---写数据---FileOutputStream
 */
 public class CopyJpgTest {
 	public static void main(String[] args)throws FileNotFoundException {
 		//封装数据源
 		FileInputStream fis = new FileInputStream("d:\\mn.jpg");
 		//封装目的地
 		FileOutputStream fos = new FileOutputStream("mn.jpg");
 		//读写数据
 		//方式1：一次读取一个字节，一次写一个字节
 		//方式2：一次读取一个字节数组，一次写一个字节数组的一部分
 		byte[] bys = new byte[1024];
 		int len;
 		while((len=fis.read(bys))!=-1) {
 			fos.write(bys,0,len);
 		}
 		//释放资源
 		fos.close();
 		fis.close();
 	}
 }