2021-05-18

Java学习

day20

目录

1. File类
2. (递归)
3. IO流
   

1、File类

1.1、概述

• 它是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。
• 文件和目录是可以通过File封装成对象的对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。
• 它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

1.2、构造方法

• public Fie(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
• public Fie(String parent, String child)从父路径名字符串和子路径名字符串创建新的File实例。
• public Fie(File parent, String chid)从父抽象路径名和子路径名字符串创建新的Fie实例。

1.3、常用方法
1.3.1、获取功能的方法

• publc String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
• publc String getPath() 将此抽象路径名转换为路径名字符串
• publc String getName() 返回由此抽象路径名表示的文件或目录的名称
• public long length() 返回由File表示的文件的长度

1.3.2、判断功能的方法

• publc boolean isDirectory()测试此抽象路径名表示的File是否为目录
• publc boolean isFile()测试此抽象路径名表示的File是否为文件
• publc boolean exists()测试此抽象路径名表示的File是否存在

1.3.3、创建功能的方法

• publiC boolean CreateNewFile() 当且仅当具有该名称的文件尚不存在时，创建一个新的文件夹。
• public boolean mkdir() 创建由此抽象路径名命名的目录
• public boolean mkdirs() 创建田此抽象路径名命名的目录，包括任何必需但不存在的父目录。

1.3.4、删除功能的方法

• publiC boolean delete() 删除田此抽象路径名表示的文件或目录
• 例一:
  运行代码如下

package demo01;

import java.io.File;
import java.io.IOException;
/*
 * file类
 * 创建一个文件/文件夹
 * 删除一个文件/文件夹
 * 获取文件/文件夹
 * 判断文件/文件夹
 * 对文件进行遍历
 * 获取文件大小
 * 
 * file是一个与操作系统无关的类
 * 
 * 记住三个单词：
 * file ：文件
 * directory ：目录、文件夹
 * path ：路径
 * 
 * */
public class Demo01File {
	public static void main(String[] args) throws IOException {
        //路径分隔符
		String pathSeparator = File.pathSeparator;
		System.out.println(pathSeparator);  // win是分号;    linux是冒号：
		
		String separator = File.separator;
		System.out.println(separator);  // 文件名称分割符是\     linux是/root/home/
		//绝对路径C:\Users\..\..\..\..
		//相对路径../../
		
		//构造方法演示
		// show01();
		// show02(separator, separator);
		// show03();
		
		//常用方法演示
		// show04();
		// show05();
		// show06();
		// show07();
		// show08();
		// show09();
		// show10();
		// show11();
		   show12();
	}
	private static void show12() {
		File f1 = new File("D:\\Java\\20\\day20-code\\hello.java");
		boolean b1 = f1.delete();//直接从硬盘删除  可以删文件，也可以删文件夹
		System.out.println(b1);
		
		File f2 = new File("Java\\1\\11\\111");//相对路径；会自动补齐D:\\Java\\1\\11\\111\\
		boolean b2 = f2.delete();
		System.out.println(b2);
	}
	private static void show11() {
		File f1 = new File("D:\\Java\\20\\day20-code\\hello.java");//这里的hello.java是一个文件夹
		boolean b1 = f1.mkdir();//只能创建一个文件夹
		System.out.println(b1);
		
		File f2 = new File("D:\\Java\\1\\11\\111\\hello.java");//这里的hello.java是一个文件夹
		boolean b2 = f2.mkdirs();//递归创建文件夹
		System.out.println(b2);
		
	}
	private static void show10() throws IOException {
		File f1 = new File("D:\\Java\\20\\day20-code\\hello.java");
		boolean b1 = f1.createNewFile();//只能创建文件
		System.out.println(b1);
		
		//第二次执行的时候返回false。因为文件已经存在
		File f2 = new File("D:\\Java\\20\\day20-code\\新建文件夹");
		boolean b2 = f2.createNewFile();//只能创建文件
		System.out.println(b2);
		
	}
	private static void show09() {
		File f1 = new File("D:\\Java\\20\\day20-code");
		if(f1.exists()) {//返回true，进入if语句
		System.out.println(f1.isDirectory());
		System.out.println(f1.isFile());//不存在
		}
		System.out.println("===================");
		
		File f2 = new File("D:\\Java\\20\\day20-code\\classfive");
		if(f2.exists()) {//不存在返回false，所以不会进入if语句
		System.out.println(f2.isDirectory());
		System.out.println(f2.isFile());
		}
		System.out.println("===================");
		
		File f3 = new File("D:\\Java\\20\\day20-code\\.classpath");
		if(f3.exists()) {
		System.out.println(f3.isDirectory());
		System.out.println(f3.isFile());//存在
		}
	}
	private static void show08() {
		File f1 = new File("D:\\Java\\20\\day20-code");
		System.out.println(f1.exists());//文件存在
		
		File f2 = new File("D:\\Java\\20\\day20-code\\classfive");
		System.out.println(f2.exists());//不存在
		
		File f3 = new File("D:\\Java\\20\\day20-code\\.classpath");
		System.out.println(f3.exists());
		
		File f4 = new File("D:\\Java\\20\\day20-code\\hello.java");
		System.out.println(f4.exists());
	}
	private static void show07() {
		File f1 = new File("D:\\Java\\20\\day20-code");
		System.out.println(f1.length());//文件存在，大小为0
		
		File f2 = new File("D:\\Java\\20\\day20-code\\classfive");
		System.out.println(f2.length());//文件不存在，大小为0
		
		File f3 = new File("D:\\Java\\20\\day20-code\\.classpath");
		System.out.println(f3.length());//最后为文件的情况，且文件存在，打印文件大小
		
		File f4 = new File("D:\\Java\\20\\day20-code\\hello.java");
		System.out.println(f4.length());//最后为文件的情况，且文件存在，打印文件大小
	}
	private static void show06() {
		File f1 = new File("D:\\Java\\20\\day20-code\\hello.java");
		File f2 = new File("D:\\Java\\20\\day20-code");
		//获取的是构造方法传递路径结尾部分
		System.out.println(f1.getName());
		System.out.println(f2.getName());
	}
	private static void show05() {
		File f1 = new File("D:\\Java\\20\\day20-code\\hello.java");
		File f2 = new File("a.txt");
		
		String path1 = f1.getPath();
		System.out.println(path1);
		System.out.println(f2.getPath());
		
		System.out.println(f1);
		System.out.println(f1.toString());
	}
	private static void show04() {
		File f1 = new File("D:\\Java\\text\\hello.java");
		String absolutepath1=f1.getAbsolutePath();
		System.out.println(absolutepath1);
		
		File f2 = new File("hello.java");//相对路径
		//创建的时候，是放在项目路径下面
		String absolutepath2=f2.getAbsolutePath();
		System.out.println(absolutepath2);//获取绝对路径
	}
	private static void show03() {
		File parent = new File("D:\\Java\\text");
		File f1 = new File(parent,"hello.java");
		System.out.println(f1);
	}

	private static void show02(String parent,String child) //第二种：两个字符串拼接
	{
		File f1 = new File(parent,child);
		System.out.println(f1);
		
	}
	private static void show01() {
		File f1 = new File("D:\\Java\\text");
		System.out.println(f1);
		
		//仅仅是创建了file这样的
		File f2 = new File("D:\\Java\\text\\a.text");
		System.out.println(f2);
		
		File f3 = new File("b.txt");
		System.out.println(f3);
		
	}

}

运行结果:

2、递归

2.1、概述

• 递归:指在当前方法内调用自己的这种现象。
• 递归的分类:递归分为两种，直接递归和间接递归。

1. 直接递归称为方法自身调用自己。
2. 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

• 注意事项:

1. 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
2. 在递归中虽然有限定条件，但是递归次数不能太多，否则也会发生栈内存溢出。
3. 构造方法，禁止递归。

3、IO 流

3.1、什么是I0
生活中，你肯定经历过这样的场象。当你编辑个文本文件， 忘记了crnia，可能文件就日日编何了，当你电脑上插入一个U盘，可以把个视频。 拷贝到你的电脑硬盘里，那么数据都是在哪些设备上的呢?键盘、内存、硬盘，外接设备等等。
我们把这种数据的传输，可以看做是种数据的流动，按照流动的方向，以内存为基准，分为输入input和输出output，即流向内存是输入流，流出内存的输出流。
Java中/O操作主要是指使用java.i0包下的内容，进行输入，输出操作。输入也叫做读取数据，输出也叫做作写出数据。

3.2、 IO的分类
根据数据的流向分为:输入流和输出流。

• 输入流: 把数据从其他设备上读取到内有中的流。(读取数据)
• 输出流: 把教据从内存中写出到其他设备上的流。(写出数据)

格局数据的类型分为:字节流和字符流。

• 宁节流:以字节为单位，读与数据的流。
• 字符流:以字符为单位，读写数据的流。

3.3、IO流的使用场景

• 如果操作的是纯文本文件，优先使用字符流。
• 如果操作的是图片、视频、音频等二进制文件。优先使用字节流。
• 如果不确定文件类型，优先使用字节流。字节流是万能的流。

3.4、字节流
字节流抽象基类

• InputStream：这个抽象类是表示字节输入流的所有类的超类
• OutputStream：这个抽象类是表示字节输出流的所有类的超类
• 子类名特点：子类名称都是以其父类名作为子类名的后缀。

字节输出流

• FieOutputStream(String name)：创建文件输出流以指定的名称写入文件。

• 例二
  运行代码如下:

package demo02;

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

/*
 * 构造方法的使用：
 * 1.创建了一个FileOutputStream 对象
 * 2.根据构造方法中传递的文件/文件路径，创建一个空文件夹
 * 3.会把FileOutputStream 对象指向创建的文件

 * 写入过程：
 * java程序 --> jvm(java虚拟机) --> os（系统操作上） --> 会调用对应的驱动 --> 把数据写入文件
*/
public class Demo02OutputStream {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("a.txt");
		
		//调用write方法，将数据写入文件中
		//fos.write(97);
		//fos.write(98);
		//fos.write(99);
		//释放资源
		
		//fos.write(49);
		//fos.write(48);
		//fos.write(48);
		//现在文件中就是100
		
		//byte[] bytes = {65,66,67,68};//出现ABCD
		//byte[] bytes = {-65,-66,-67,-68};//会被当成中文来解释
		byte[] bytes = {65,66,67,68,69,70};
		fos.write(bytes,2,3);
		fos.close();
	}

}

tip:2020080605006