JavaIo案例

1、常用的文件操作

方式一：根据路径构建一个 File 对象：

//方式 1
@Test
public void create1(){
    String filePath = "D:\\file1.txt";
    File file = new File(filePath);
    try {
        file.createNewFile();
        System.out.println("创建文件 1 成功");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

方式二：根据父目录文件+子路径构建：

//方式 2
@Test
public void create2(){
    File parentFile = new File("D:\\");
    String fileNane = "file2.txt";
    File file = new File(parentFile, fileNane);
    try {
        file.createNewFile();
        System.out.println("文件 2 创建成功");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

方式三：根据父目录+子路径构建：

//方式三
@Test
public void create3(){
    String parentPath = "d:\\";
    String filePath = "file3.txt";
    File file = new File(parentPath, filePath);
    try {
        file.createNewFile();
        System.out.println("文件 3 创建成功");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

2、获取文件的相关信息

image
    Serializable是java中实现对象序列化与反序列化的方式之一，使用方式非常简单，只要在在类声明时实现Serializable接口就可以。
    Comparable是个排序接口，若一个类实现了该接口，那么该类的数组和列表就可以通过Collections.sort或Arrays.sort进行自动排序。
    gbk编码： 中文占用两个字节，英文占用一个字节
    utf-8编码：中文占用三个字节，英文占用一个字节
    常见的 File 相关方法： getName()/getAbsolutePath/getParent/length/exists/isFile/isDirectory

//获取文件信息
@Test
public void Info(){
    //先创建文件对象
    File file = new File("D:\\file1.txt");
    //调用相应方法，得到对应信息
    System.out.println("文件名称："+file.getName());
    System.out.println("文件绝对路径："+file.getAbsolutePath());
    System.out.println("文件父目录："+file.getParent());
    System.out.println("文件大小(字节)："+file.length());
    System.out.println("文件是否存在："+file.exists());
    System.out.println("是否是文件："+file.isFile());
    System.out.println("是否是目录："+file.isDirectory());
}

3、目录的操作

    创建一级目录：mkdir，创建多级目录：mkdirs ，delete 删除空目录或者文件：

@Test
//删除文件
public void fileDelete() {
    String filePath = "D:\\file1.txt";
    File file = new File(filePath);
    if (file.exists()) {
        if (file.delete()) {
            System.out.println(filePath + "删除成功");
        } else {
            System.out.println(filePath + "删除失败");
        }
        ;
    } else {
        System.out.println("文件不存在");
    }
}

//删除目录
@Test
public void fileDeleteD() {
    String filePath = "D:\\file1.txt";
    File file = new File(filePath);
    if (file.exists()) {
        if (file.delete()) {
            System.out.println(filePath + "删除成功");
        } else {
            System.out.println(filePath + "删除失败");
        }
        ;
    } else {
        System.out.println("目录不存在");
    }
}

//判断目录是否存在，不存在就创建
@Test
public void fileDeleteD1() {
    String dirPath = "D:\\test\\dir1.txt";
    File file = new File(dirPath);
    if (file.exists()) {
        System.out.println(dirPath + "该目录已经存在");
    } else {
        if (file.mkdirs()) {
            System.out.println("创建成功");
        } else {
            System.out.println("创建失败");
        }
        ;
    }
}

4、IO 流原理及流的分类

1、I=input，O=output，用于处理数据传输，读写文件、网络通信
2、Java 程序中，输入输出以流的形式进行
3、java.io 包下

流的分类：
    按操作数据单位不同可以分为：字节流（8bit）、字符流(字符，对应字节按照编码确定)
    效率：字符流更好，字节流的存在是为了更好的处理二进制文件，音视频
    按流向不同可以分为：输入流、输出流
    按流的角色不同分为：节点流、处理流
image
    在java中InputStream是字节输入流，用来将文件中的数据读取到java程序中。InputStream是所有字节输入流的顶层父类，是一个抽象类。如果要用，需要使用子类。最常用的子类：FileInputStream。

public abstract class InputStream implements Closeable {
	private static final int MAX_SKIP_BUFFER_SIZE = 2048;
	public InputStream() {
	}
	public abstract int read() throws IOException;
	public int read(byte[] var1) throws IOException {
	return this.read(var1, 0, var1.length);
}

下面是idea生成的类图：
image

    OutputStream抽象类，此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。

public abstract class OutputStream implements Closeable, Flushable {
	public OutputStream() {
	}
}

void close()
关闭此输出流并释放与此流有关的所有系统资源。

void flush()
刷新此输出流并强制写出所有缓冲的输出字节。

void write(byte[] b)
将 b.length 个字节从指定的 byte 数组写入此输出流。

void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

abstract void write(int b)
将指定的字节写入此输出流。
image

    Java.io.Writer类是用于写入字符流的抽象类。而且Writer类是Java IO中所有Writer的基类。它的子类如:BufferedWriter和PrintWriter等

public abstract class Writer implements Appendable, Closeable, Flushable{
}

image

    Reader是Java的IO库提供的另一个输入流接口。和InputStream的区别是，InputStream是一个字节流，即以byte为单位读取，而Reader是一个字符流，即以char为单位读取。

public abstract class Reader implements Readable, Closeable {
}

image

前面四个都是抽象类，想要使用必须实现其具体方法

5、Scanner 与 Println

1、基本键盘输入：

import org.testng.annotations.Test;
import java.util.Scanner;
public class scanPrintTest {
	public static void main(String[] args) {
		//创建 Scanner 对象，接受从控制台输入
		Scanner input = new Scanner(System.in);
		//接受 String 类型
		String str = input.next();
		//输出结果
		System.out.println(str);
		System.out.println("hello world");
	}
}

2、常见键盘输入类型：

import java.util.Scanner;
public class scanTest {
	public static void main(String[] args) {
		Scanner input =new Scanner(System.in);
		//double 类型的数据
		System.out.print("请输入一个 double 类型的数:");
		double d = input.nextDouble();
		System.out.println(d);
		//int 类型的数据
		System.out.print("请输入一个 int 类型的数:");
		int i = input.nextInt();
		System.out.println(i);
		//字符串类型的数据
		System.out.print("请输入一个 string 类型的数:");
		String s = input.next();
		System.out.println(s);
	}
}

6、InputStream

常见的子类：

FileInputStream:文件输入流
BufferedStream：缓冲字节输入流
ObjectedStream：对象字节输入流

public class fileInputStream {
	public static void main(String[] args) {
	}

	@Test
	public void fileIn1() {
		String filePath = "D:\\testfile.txt";
		int readData;
		FileInputStream fileInputStream = null;
		try {
			//创建 FileInputStream 对象，用于读取文件
			fileInputStream = new FileInputStream(filePath);
			while ((readData = fileInputStream.read()) != -1) {
				System.out.println((char) readData);
			}
			;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//关闭文件流
			try {
				fileInputStream.close();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
	}

	@Test
	public void fileIn2() {
		String filePath = "D:\\testfile.txt";
		int readData;
		int readlength = 0;
		//字节数组
		byte[] buf = new byte[8];
		FileInputStream fileInputStream = null;
		try {
			//创建 FileInputStream 对象，用于读取文件
			fileInputStream = new FileInputStream(filePath);
			while ((readlength = fileInputStream.read(buf)) != -1) {
				System.out.println(new String(buf, 0, readlength));
			}
			;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//关闭文件流
			try {
				fileInputStream.close();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
	}

	@Test
	public void fileIn3() {
		String filePath = "D:\\testfile.txt";
		int readData;
		int readlength = 0;
		//字节数组
		byte[] buf = new byte[8];
		FileInputStream fileInputStream = null;
		try {
			//创建 FileInputStream 对象，用于读取文件
			fileInputStream = new FileInputStream(filePath);
			while ((readlength = fileInputStream.read(buf)) != -1) {
				System.out.println(new String(buf, 0, readlength));
			}
			;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			//关闭文件流
			try {
				fileInputStream.close();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
	}
}

7、OutputStream

1、FileOutputStream：

例子：使用 FileOutputStream 在文件夹中写入“hello world”，如果文件不存在，会创建文件

public class outputStream {
	public static void main(String[] args) {
	}

	//使用 FileOutputStream 将数据写到文件中
	//如果文件不存在，则创建文件
	@Test
	public void writeFile() {
		String filePath = "d:\\fileout.txt";
		//创建对象
		FileOutputStream fileOutputStream = null;
		try {
			fileOutputStream = new FileOutputStream(filePath);
		//1、写入一个字节
		//fileOutputStream.write('H');
		//2、写入一个字符串
		//String str = "hello socket";
		//str.getBytes()将字符串转换成字节数组
		//fileOutputStream.write(str.getBytes());
		//3、写入字符串
			String str = "hello lst";
			fileOutputStream.write(str.getBytes(), 0, str.length());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fileOutputStream.close();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
	}
}

8、文件复制

public class copyPic {
	//file 读和写实现复制文件
	public static void main(String[] args) throws Exception {
		//创建 file 对象
		File f = new File("d:\\test.jpg");
		//判断文件是否存在
		if (f.exists()) {
			System.out.println("test.jpg 存在，可以复制");
		} else {
			f.createNewFile();
			System.out.println("test.jpg 不存在，新建成功，可以复制");
		}
		//创建 FileInputStream 对象
		FileInputStream inp = new FileInputStream(f);
		//创建 FileOutputStream 对象
		//判断 demo 目录是否存在
		File f1 = new File("d:\\demo");
		if (f1.isDirectory()) {
			FileOutputStream out = new FileOutputStream("e:\\demo\\" + f.getName());
			byte bytes[] = new byte[1024];
			int temp = 0; //边读边写
			while ((temp = inp.read(bytes)) != -1) { //读
				out.write(bytes, 0, temp); //写
			}
			//结束
			inp.close();
			out.close();
			System.out.println("文件拷贝成功！");
		} else {
			//新建 demo 目录
			f1.mkdir();
			System.out.println("demo 目录不存在，已经新建成功，继续复制");
			FileOutputStream out = new FileOutputStream("d:\\demo\\" + f.getName());
			byte bytes[] = new byte[1024];
			int temp = 0; //边读边写
			while ((temp = inp.read(bytes)) != -1) { //读
				out.write(bytes, 0, temp); //写
			}
			//结束
			inp.close();
			out.close();
			System.out.println("文件拷贝成功！");
		}
	}
}
posted @   charIotte  阅读(53)  评论(0)  编辑  收藏  举报
相关博文：
· 进程与线程的区别
· 网络字节序与主机字节序的转换函数实践
· JavaIO流理解
· java 常用的文件操作以及I/O流
· JavaIO流
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛