JAVA（IO流1）

最新推荐文章于 2024-03-05 14:57:45 发布

Taiiiii

最新推荐文章于 2024-03-05 14:57:45 发布

阅读量348

点赞数

本文链接：https://blog.csdn.net/Taiiiii/article/details/108460437

版权

JAVA 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

异常

异常：就是程序出现了不正常的情况。

异常的体系的介绍：
Throwable 类是 Java 语言中所有错误或异常的超类。
Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
也就是说针对程序发生了Error的情况，Java程序本身是无能为力的，比如说：硬件层面的问题，内存不足等。
所以，针对Error的问题我们不处理。
Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
也就是说针对程序发生了Exception的情况，是我们需要处理的问题。
Exception的分类：
运行期的异常（RunTimeException）：在编译期是不处理的，在程序运行时候出现了问题，需要我们回来修改代码。
编译期的异常（非RunTimeException）：在编译期就必须处理，否则程序不能通过编译，就更不能正常的执行了。

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

处理方案：
A:把异常的名称，异常的原因，异常出现的位置等信息在控制台输出
B:让程序停止执行

异常处理方案try_catch

try…catch的格式和执行流程为

格式：
try {
可能出现异常的代码;
}catch(异常类名变量名) {
异常的处理代码;
}

执行流程：
程序从try开始执行，执行到哪里出现了问题，就会跳转到catch里面执行。
执行完毕后，程序还能继续往下执行。

try…catch处理方式&JVM的默认处理方式有什么不同:
try…cathc处理方式的特点, 产生了问题, 是自己将问题处理掉, 不影响后续代码的运行.
JVM默认处理方式是将程序终止, 并将异常信息打印在控制台.

两种异常

Java中的异常被分为两大类：编译时异常和运行时异常。
所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常都是编译时异常
编译时异常：Java程序必须显示处理，否则程序就会发生错误的一个提示，无法通过编译
运行时异常：Java程序无需显示处理，也可以和编译时异常一样处理
在这里插入图片描述

public class ExceptionDemo4 {
	public static void main(String[] args) {
		System.out.println("程序开始执行");
		//method();
		method2();
		System.out.println("程序结束执行");
	}
	
	//编译时异常ParseException
	public static void method() {
		try{
			//String s = "2088-08-08";
			String s = "abcd";
			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";
		SimpleDateFormat 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);
	}
	
}

throw/throws就是一个甩手掌柜，它只会把异常一层层地往上抛，直到有人去处理它。而try…catch就是那个劳苦工人，负责获取相应的异常并对它进行处理。

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(String pathname)
		File f1 = new File("d:\\aa\\b.txt");
		
		//File(String parent, String child)
		File f2 = new File("d:\\aa","b.txt");
		
		//File(File parent, String child)
		File f3 = new File("d:\\aa");
		File f4 = new File(f3,"b.txt");
		
		//上面的f1,f2,f4其实做的是同样的事情，就是把d:\\aa\\b.txt转换为了一个File对象
	}
}

File类的功能

创建功能

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());
		
		//需求2：我要在d盘目录下创建一个目录bb
		File f2 = new File("d:\\bb");
		System.out.println("mkdir:"+f2.mkdir());
		System.out.println("-----------------");
		
		//需求3：我要在d盘目录下创建一个多级目录cc\\dd
//		File f3 = new File("d:\\cc\\dd");
//		System.out.println("mkdir:"+f3.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:\\ee");
		File f5 = new File("d:\\ee\\f.txt");
		System.out.println("mkdir:"+f4.mkdir());
		System.out.println("createNewFile:"+f5.createNewFile());
	}
}

删除功能

路径的问题：
绝对路径：是以盘符开始的路径。d:\aa\b.txt
相对路径：不以盘符开始。相对于当前的项目而言

删除功能
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.createNewFile());
		//
		// //需求2：我要创建一个目录bb
		// File f2 = new File("bb");
		// System.out.println("mkdir:"+f2.mkdir());
		// System.out.println("-----------------");
		//
		// //需求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.out.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 f3 = new File("cc");
		System.out.println("delete:"+f3.delete());
		//思路：先删除d.txt这个文件，再删除cc这个目录
	}
}

判断获取功能

判断功能
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写数据

字节流&字符流的抽象父类

字节流：
InputStream 字节输入流
OutputStream 字节输出流
字符流：
Reader 字符输入流
Writer 字符输出流

字节流写出数据

字节流写数据
OutputStream:此抽象类是表示输出字节流的所有类的超类
FileOutputStream:文件输出流是用于将数据写入 File

构造方法：
FileOutputStream(String name):创建一个向具有指定名称的文件中写入数据的输出文件流。

字节流写数据的步骤：
A:创建字节输出流对象
B:调用写数据的方法
C:释放资源

public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		FileOutputStream fos = new FileOutputStream("a.txt");
		/*
		 * 创建字节输出流对象做了这样的三件事情：
		 * A:调用系统功能创建了文件
		 * B:创建字节输出流对象
		 * C:让fos这个对象指向a.txt这个文件
		 */
		
		//write(int b) 
		fos.write(65);
		fos.write(66);
		
		//最后我们还要做一个事情
		//close() 关闭此文件输出流并释放与此流有关的所有系统资源。
		fos.close();
	}
}

FileOutputStream写数据的三种方式

写出数据的三个方法:

public void write(int b):一次写一个字节
public void write(byte[] b):一次写一个字节数组
public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
String类中的方法
byte[] getBytes() 将字符串转换为字节数组

public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		//FileOutputStream(String name) 
		FileOutputStream fos = new FileOutputStream("b.txt");
		//new File(name)
//		FileOutputStream fos = new FileOutputStream(new File("b.txt"));
		
		//FileOutputStream(File file) 
//		File file = new File("b.txt");
//		FileOutputStream fos = new FileOutputStream(file);
//		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[] getBytes()
//		byte[] bys = "ABCDE".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如何实现换行和追加写数据

换行：
不同的操作系统，针对换行的符号识别是不一样的。
windows:\r\n
linux:\n
mac:\r

public class FileOutputStreamDemo3 {
	public static void main(String[] args) throws IOException {
		//创建字节输出流对象
		//FileOutputStream fos = new FileOutputStream("c.txt");
		//FileOutputStream(String name, boolean append) 
		//如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处
		FileOutputStream fos = new FileOutputStream("c.txt",true);
		
		//调用写数据的方法
		for(int x=0; x<10; x++) {
			fos.write("hello".getBytes());
			//加入换行符号
			fos.write("\r\n".getBytes());
		}
		
		//释放资源
		fos.close();
	}
}

FileOutputStream写数据加入异常处理

try…catch.finally

格式:
try{
可能发生问题的代码
}catch(){
处理异常代码
}finally{
一定会被执行的代码. // 通常用于释放资源, 做善后的动作
}

public class FileOutputStreamDemo4 {
	public static void main(String[] args) {
		FileOutputStream fos = null;
		try{
			//FileOutputStream fos = new FileOutputStream("d.txt");
//			fos = new FileOutputStream("z:\\d.txt");
			fos = new FileOutputStream("d.txt");
			fos.write("hello".getBytes());
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			if(fos!=null) {
				//释放资源
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

FileInputStream读数据方式

方式1一次读取一个字节

字节流读数据的步骤：
A:创建字节输入流对象
B:调用读数据的方法
C:释放资源

public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("a.txt");
		int by;
		// 用by不断的记录读取到的每一个数据
		while((by=fis.read())!=-1) {
			System.out.print((char)by);
		}
		//释放资源
		fis.close();
	}
}

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

public int read(byte[] b):
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
返回值是读入缓冲区的字节总数，也就是实际的读取个数
如果因为已经到达文件末尾而没有更多的数据，则返回 -1。

public class FileInputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		//创建字节输入流对象
		FileInputStream fis = new FileInputStream("b.txt");
		byte[] bys = new byte[1024]; //1024或者1024的整数倍
		int len;
		//将数据读取到数组中, 并用len记录读取到的有效字节个数
		while((len=fis.read(bys))!=-1) {
			System.out.print(new String(bys,0,len));
		}
		//释放资源
		fis.close();
	}
}

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

需求：拷贝文本文件
分析：
第一步: 创建输入输出流对象关联数据源和数据目的
第二步: 定义字节数组,为了提高效率
第三步: 将数据通过while循环不断读取到字节数组中
第四步: 将数据从字节数组中取出并写出
第五步: 释放资源

public class CopyTxtTest {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("d:\\窗里窗外.txt");
		//封装目的地
		FileOutputStream fos = new FileOutputStream("林青霞.txt");
		
		//读写数据
		//方式1:一次读取一个字节
//		int by;
//		while((by=fis.read())!=-1) {
//			fos.write(by);
//		}
		
		//方式2:一次读取一个字节数组
		byte[] bys = new byte[1024];
		int len;
		while((len=fis.read(bys))!=-1) {
			fos.write(bys, 0, len);
		}
		
		//释放资源
		fos.close();
		fis.close();
	}
}

字节流练习之复制图片

public class CopyJpgTest {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		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();
	}
}

Taiiiii

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA（IO流1）

文章目录异常JVM针对异常的默认处理方式异常处理方案try_catch两种异常throws处理异常使用的格式&注意事项File类File类的构造方法File类的功能创建功能删除功能判断获取功能IO(字节流)IO流分类FileOutputStream写数据字节流&字符流的抽象父类字节流写出数据FileOutputStream写数据的三种方式FileOutputStream如何实现换行和追加写数据FileOutputStream写数据加入异常处理try..catch.finallyFile
复制链接

扫一扫