File .节字.字符流 .异常等_file获取文字节-优快云博客

本文详细介绍了Java中File类的使用方法，包括创建、删除文件夹及文件，判断文件属性等。同时深入探讨了Java IO流的概念、分类及其具体应用，如字节流、字符流、缓冲流的操作步骤与技巧。

File~

三种构造方法：File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象

功能：创建与删除获取及判断功能。

代码演示

public class FileDemo {
	public static void main(String[] args) {
		//public boolean mkdir():如果目录不存在，就创建。否则，不创建。
		//需求：D盘下造一个文件夹test
		//File file = new File("D://test");
		//System.out.println(file.mkdir());
		
		System.out.println("----------");
		//public boolean mkdirs():如果目录不存在，就创建。否则，不创建。
		//即时父目录不存在，也可以连父目录一起创建。
		//File file = new File("D://aa//bb//a.txt");
		//System.out.println(file.mkdirs());
		
		
	}  创建功能注意点：你要造什么东西，就应该用对应的方法。

}

public class FileDemo2 {
	public static void main(String[] args) {
		//删除D://a.txt
		//File file = new File("D://a.txt");
		//System.out.println(file.delete());
		
		
		//删除D://test//a.txt
		//File file = new File("D://test//a.txt");
		//System.out.println(file.delete());
		
		//删除D://test,删除文件夹的时候只能删除空的文件夹
		File file = new File("D://test");
		System.out.println(file.delete());
		
	}删除注意点：Java程序的删除不走回收站以及如果目录内还有内容就不能删除。

判断功能~
public boolean isDirectory():是否是目录 public boolean isFile():是否是文件 public boolean exists():是否存在

public boolean canRead():是否可读 public boolean canWrite():是否可写 public boolean isHidden():是否隐藏

public class FileDemo4 {
	public static void main(String[] args) throws IOException {
		//创建一个文件
		File file = new File("a.txt");
		//创建一个文件
		//System.out.println(file.createNewFile());
		
		//  public String getAbsolutePath():获取绝对路径
		System.out.println(file.getAbsolutePath());//D:\workspace\十二天_File\a.txt
		
		//public String getPath():获取相对路径
		System.out.println(file.getPath());//a.txt
		
		//public String getName():获取名称
		System.out.println(file.getName());
	}

}     获取部分  代码

字节流及字节高效流~

图解IO流

字符输入流 Reader 字节输入流 InputStream(抽象类)

字符输出流 Writer 字节输出流 OutputStream（抽象类）

两个构造的区别？
   FileOutputStream(File file)
  FileOutputStream(String name)
  FileOutputStream fos = new FileOutputStream("fos.txt");
  请问上面这个操作做了哪几件事情？
   * 1.创建了一个文件输出流fos,指向文件a.txt
   * 2.创建了a.txt这个文件
       fos.write("helloworld".getBytes());

fos.close();关流

fos.write("java".getBytes());

FileOutputStream写数据的方法
write(byte[] b)
write(int b) ：一次写一个字节
write(byte[] b, int off, int len) ：一次写一个字节数组的一部分

字节输入流：
具体操作步骤：
* 字节输入流操作步骤：
* A:创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");

* B:调用方法读取数据
一次读取一个字节：read() -- 测试读取不到内容的时候的返回值（并且用循环改进）

* C:释放资源
fis.close

* 练习：
*   A:把a.txt的内容复制到b.txt中
*   C:把d:\\复制视频文件

* 数据源：
*   IODemo.java -- 读取数据 -- InputStream -- FileInputStream -- 一次读取一个字节
* 目的地：
*   Copy.java -- 写出数据 -- OutputStream -- FileOutputStream -- 一次写一个字节

字节输入流：
具体操作步骤：
* 字节输入流操作步骤：
* A:创建字节输入流对象
FileInputStream fis = new FileInputStream("a.txt");

* B:调用方法读取数据（一次读取一个字节数组，提升效率）
一次读取一个字节数组： public int read(byte[] b):返回实际读取长度,数据被读取到数组中。
-- 测试方法返回长度？根据String类的构造方法构造字符串
* C:释放资源
fis.close

public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		//读取a.txt中的文件
		//1.创建文件输入流
		FileInputStream fis = new FileInputStream("a.txt");
		
		//一次读取一个字节数组
/*		byte[] bys= new byte[4];
		System.out.println(fis.read(bys));//读取到的是字节数组的实际长度
		System.out.println(fis.read(bys));
		System.out.println(fis.read(bys));
		
		System.out.println(fis.read(bys));*/
		
		//创建一个字节数组，一般来说字节数组的长度都是1024或者1024的倍数
		byte[] bys= new byte[1024];
		int len;//实际读取到的长度
		while ((len=fis.read(bys))!=-1) {
			//只需要将实际读取到的长度转换为字符串就可以
			System.out.println(new String(bys, 0, len));
		}
		
		
		//3.关流
		fis.close();
	}

}

package cokm.edu_04;

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

public class CopyMp4 {
	public static void main(String[] args) throws IOException {
		//一次读写一个字节数组
		//1.封装数据源和目的地
		FileInputStream fis = new FileInputStream("D://b.mp4");
		FileOutputStream fos = new FileOutputStream("e.mp4");
		
		//一次读写一个字节数组
		byte[] bys =  new byte[1024];
		int len;
		while ((len=fis.read(bys))!=-1) {
			//读取多少就给fos中写多少数据
			fos.write(bys, 0, len);
		}

		//释放资源
		fos.close();
		fis.close();
	}

}

字节缓冲区流（也叫高效流）~

BufferedInputStream(read() 一次读取一个字节, public int read(byte[] b):返回实际读取长度,数据被读取到数组中。)

BufferedOutputStream（write(byte[] b)）
低级流: 基本的流，可以直接操作文件。高级流：是操作基本流的流。

BufferedReader:字符缓冲输入流： BufferedWriter:字符缓冲输出流

BufferedReader(Reader in) BufferedWriter(Writer out)

public String readLine():包含该行内容的字符串，特殊方法：public void newLine():会根据系统来确定写入不同的换行符

不包含任何行终止符，如果已到达流末尾，

则返回 null

public class BufferedReaderDemo {
	public static void main(String[] args) throws IOException {
		/**
		 * 需求：使用高效字符输入流读取f.txt文件
		 * 1.创建高效字符输入流对象，指向f.txt
		 * 2.一次读取一行，readLine()
		 * 3.关流
		 */
		//1.创建高效字符输入流对象，指向f.txt
		//BufferedReader(Reader in) 
		BufferedReader br = new BufferedReader(new FileReader("f.txt"));
		
		
		//2.一次读取一行，readLine(),当读取文件末尾的时候返回null
/*		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		System.out.println(br.readLine());
		
		
		System.out.println(br.readLine());
		System.out.println(br.readLine());*/
		
		//使用循环改进
		String line;
		while ((line= br.readLine())!=null) {
			System.out.println(line);
		}
		
		//3.关流
		br.close();
		
		
	}

}

public class BufferedWriterDemo2 {
	public static void main(String[] args) throws IOException {
		//使用高效字符输出流写入10个helloworld,每写一个换一行
		/**
		 * 1.创建字符高效输出流，并指向一个txt文件
		 * 2.调用里面写数据的方法，给文件中写入数据
		 * 3.调用换行的方法，给写入的数据换行
		 * 4.刷新换新区
		 * 5.关流
		 */
		//1.创建字符高效输出流，并指向一个txt文件
		BufferedWriter bw = new BufferedWriter(new FileWriter("f.txt"));
		
		//2.调用里面写数据的方法，给文件中写入数据
		for (int i = 0; i < 10; i++) {
			//给文件中写入helloworld
			bw.write("helloworld");
			//写入换行符
			bw.newLine();
			//刷新缓冲区
			bw.flush();
		}
		
		//关流
		bw.close();
		
	}

}

编码问题

String中的编码和解码问题。
*
* 编码：
* 把我们能够看懂的字符转换为看不懂的数据
* 解码：
* 把我们看不懂的数据转换为看得懂的字符

public byte[] getBytes(String charsetName) 按照给定的编码方式，编码字节数组（gbk,utf-8）
String(byte[] bytes, String charsetName) 按照给定的编码方式解码字符数组

   String s = "中国好";
  byte[] bytes = s.getBytes("utf-8");
  System.out.println(Arrays.toString(bytes));

  //String(byte[] bytes, String charsetName)
  System.out.println(new String(bytes,"gbk"));

注意：有什么编码就用什么解码

异常：
   *   编译时期异常：程序运行之前
   *   运行时期异常：成运行起来之后
   *
   *体系结构：
   * Throwable：
   *   Error：错误
   *   Exception：异常
   *     非RuntimeException：
   *    RuntimeException：

异常演示：除数不能为0

ublic class ExceptionDemo2 {
	public static void main(String[] args) {
		System.out.println("start");
		int a = 10;
		int b = 0;
		System.out.println(a/b);//java.lang.ArithmeticException: / by zero
		System.out.println("end");
	}

}

Exception in thread "main" start
java.lang.ArithmeticException: / by zero

异常的处理方式：A:try...catch...finally
B:throws

简化第一个：
* try{
* 可能出现异常的代码
* }catch(异常类名变量名) {
* 针对异常的代码处理

public class ExceptionDemo3 {
	public static void main(String[] args) {
		System.out.println("start");
		int a= 10;
		int b = 0;
		try{
			//可能出现异常的代码
			System.out.println(a/b);//当除数为0的时候会抛出ArithmeticException这个异常
									//接着程序会拿着这个异常和catch里面的异常类已经对比					
		}catch(ArithmeticException e){
			//当程序抛出ArithmeticException这个异常之后给出的具体的处理方法
			System.out.println("你的除数不能为0");
		}
		System.out.println("end");
	}

}

多个异常的处理：A:针对每一个出现问题的地方写一个try...catch语句
B:针对多个异常，采用一个try，多个catch的情况。
try...catch...catch...

注意点：如果异常间有子父关系，父类必须再后

代码演示

public class ExceptionDemo4 {
	public static void main(String[] args) {
		//多个异常处理的第一种解决方案
		//A：给每一个可能出现异常的代码全部加上try..catch..
/*		try{
			System.out.println(10/0);
		}catch(ArithmeticException e){
			System.out.println("除数不能为0");
		}
		
		int[] arr = {1,2,3};
		try{
			System.out.println(arr[3]);//抛出IndexOutOfBoundsException这个异常
		}catch(IndexOutOfBoundsException e){
			System.out.println("数组越界了");
		}*/
		
		
		//B:针对多个异常，采用一个try，多个catch的情况。
		//当存在多个catch情况下，如果异常类之间存在子父关系，那么父类应该放到最后
		int[] arr = {1,2,3};
		try{
			//System.out.println(arr[3]);//抛出IndexOutOfBoundsException
			//System.out.println(10/0);//抛出ArithmeticException
			arr = null;
			System.out.println(arr[2]);//抛出空指针异常NullpointerException
		}catch(IndexOutOfBoundsException e){//Exception e = new IndexOutOfBoundsException();
			System.out.println("数组越界了");
		}catch(ArithmeticException e){
			System.out.println("除数不能为0");
		}catch(Exception e){//当前面的异常类都没有匹配到之后，会自动匹配这个异常
			System.out.println("出现了其他异常");
		}
		
		
	}

}

throws:(演示文件未找到异常，除数为0异常)
	 * 		用在方法声明后面，跟的是异常类名
	 * 		可以跟多个异常类名，用,号隔开
	 * 		表示抛出异常，由该方法的调用者来处理
	 * 		throws表示出现异常的一种可能，并不一定会发生这些异常
 */
public class ExceptionDemo7 {
	public static void main(String[] args){
		method();
		//method2();//将这个异常交给了调用者去进行处理
				 //1.可以继续往上throws，将异常继续向上进行抛出了
		         //2.自己try..catch...,相当与自己处理了这个异常
		try{
			method2();
		}catch(FileNotFoundException e){
			System.out.println("文件未找到");
		}
		/**
		 * 我们以后遇到异常是抛还是抓呢？
		 * 答：原则上能抛就抛，等到已经抛到了程序最底层的时候，最好就不要抛了，自己抓取。
		 */
		
	}

	private static void method2() throws FileNotFoundException {
		//此时会抛出一个编译时期的异常，
		//我们必须在方法上进行声明，如果不声明的话，会一直编译报错
		FileInputStream fis = new FileInputStream("D://a.txt");
	}

	private static void method() throws ArithmeticException {
		//在方法声明上声明这个方法可能出现的异常，不代表这个异常一定会出现
		//此时仅仅是告诉我的调用者我的这个方法可能会出现异常，并不做具体的处理，交给
		//调用者自己去处理这个异常
		//此时抛出的 出数为0的异常，属于运行时期异常
		System.out.println(10/5);
	}

}

hrow和throws的区别？
* throws:
*   用在方法声明后面，跟的是异常类名
*   可以跟多个异常类名，用逗号隔开
*   表示抛出异常，由该方法的调用者来处理
*   throws表示出现异常的一种可能性，并不一定会发生这些异常
*
* throw:
*   用在方法体内，跟的是异常对象名
*   只能抛出一个异常对象名
*   表示抛出异常，由方法体内的语句处理
*   throw则是抛出了异常，执行throw则一定抛出了某种异常？

public class ThrowDemo {
	public static void main(String[] args) {
		method();
		try {
			method2();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

	private static void method2() throws FileNotFoundException{
		try{
			FileInputStream fis = new FileInputStream("D://a.txt");
		}catch(FileNotFoundException e){
			//当遇见这个异常之后，直接抛出(这就是我给出的处理方法)
			//如果【抛出的是编译时期异常的话，必须在方法声明上给予声明
			throw new FileNotFoundException();
		}

	}

	private static void method() throws ArithmeticException{
		int a = 10;
		int b = 2;
		if (b==0) {
			//在这里抛出的是运行时期异常，抛出这个异常的同时，可以在方法声明上给予声明，也可以不声明
			throw new ArithmeticException();
		}else {
			System.out.println(a/b);
		}
	}
	
	

}