Java24：IO流

已于 2024-02-02 00:00:55 修改
阅读量218 收藏
点赞数
分类专栏： Java 文章标签： java
于 2022-05-13 01:52:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45754498/article/details/124722615
版权

1.File类

File 类提供了一些用于查看文件信息的方法

package com.qfedu.test4;

import java.io.File;
import java.io.IOException;

/**
 * 	java.io.File类
 * 	此类提供了一些用于获取文件信息的方法
 * 	比如 名称  大小 等等  
 * @author WHD
 *
 */
public class TestFile {
	public static void main(String[] args) throws IOException {
		File file = new File("a.txt");
		file.createNewFile(); // 创建一个新文件
		System.out.println("文件名" + file.getName());
		System.out.println("相对路径" + file.getPath());
		System.out.println("绝对路径" + file.getAbsolutePath());
		System.out.println("是否存在" + file.exists());
		System.out.println("是否是一个文件" + file.isFile());
		System.out.println("是否是一个文件夹" + file.isDirectory());
		System.out.println("文件大小" + file.length());
		System.out.println("删除文件" + file.delete());
		
		File dir = new File("A");
		dir.mkdir();
		System.out.println("是否是一个文件夹" + dir.isDirectory());
		
		
		File dir1 = new File("E/F/G");
		dir1.mkdirs();
		
		File f = new File("C:\\Users\\WHD\\Desktop\\2103.txt");
		f.createNewFile();
		
		
	}
}

2.字节流

2.1 InputStream ***read方法

字节流读取类父类，是一个抽象类，提供了各种read方法

2.1.1 FileInputStream

提供了用于读写字节的方法，可以一次读取一个字节，也可以读取一个字节数组

package com.qfedu.test5;

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

/**
 * 	InputStream
 * 	FileInputStream 字节读取(输入流)流类
 * 		read() 每次读取一个字节 返回值为读取的内容的ascii码值
 * 		
 * 		close() 关闭资源
 * 		available() 获取当前文件可读字节数  
 * 
 * 	构造方法
 * 		FileInputStream(File file)
 *		FileInputStream(String name)	
 * @author WHD
 *
 */
public class TestFileInputStream1 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("a.txt");
		int data = -1;
		while((data = fis.read()) != -1) {
			System.out.println((char)data);
		}
		
		fis.close(); // 关闭资源
	}
}


package com.qfedu.test5;

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

/**
 * 	使用字节流每次读取一个byte数组
 * 	read(byte [] datas) 每次读取指定长度的字节	返回值为读取的长度 读取的内容在byte数组
 * @author WHD
 *
 */
public class TestFileInputStream2 {
	public static void main(String[] args) {
		FileInputStream  fis = null;
		try {
			fis = new FileInputStream("b.txt");
			System.out.println(fis.available());
			byte [] datas = new byte[fis.available()];
			int dataCount = -1;
			while((dataCount = fis.read(datas)) != -1) {
//				System.out.println(dataCount);
				System.out.println(new String(datas, 0, dataCount));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}	
}

2.2 OutputStream***wirte方法

字节写入流父类，抽象类，提供了各种wirte方法

2.2.1 FileOutputStream

字节写入流类，可以一次写入一个字节，也可以一次写入一个字节数组

package com.qfedu.test6;

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

/**
 * 	OutputStream 父类 抽象类
 * 	FileOutputStream 
 * 	write(int chars);
 * 	write(byte [] datas);
 * 	close();
 * 	flush(); 将内存中的内容 刷新到硬盘中 字节流是直接操作硬盘的 
 * @author WHD
 *
 */
public class TestFileOutputStream {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("c.txt", true); // 第二个参数为是否追加 默认为false
		fos.write(98);
		fos.close();
	}
}


package com.qfedu.test6;

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

/**
 * 	每次写入一个字节数组
 * @author WHD
 *
 */
public class TestFileOutputStream2 {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("d.txt", true);
		String info = "hello world 世界你好";
		fos.write(info.getBytes());
		fos.write("你好".getBytes());
		fos.close();
	}
}

3.字符流

3.1 Reader

字符读取流父类，抽象类。提供了各种read方法。

3.1.1 InputStreamReader

此类提供各种read方法，可以一次读取一个字符，也可以一次读取一个char数组，还支持指定读取的编码格式

package com.qfedu.test1;

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

/**
 * 	Reader类抽象类父类
 * 	InputStreamReader子类
 * 	字符读取流：
 * 	read 每次读取一个字符 返回值为读取的内容
 * 	read(char [] datas) 每次读取一个字符数组  返回值是读取的长度 内容在char数组
 * 	
 * 	close 关闭资源
 * @author WHD
 *
 */
public class TestInputStreamReader1 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("a.txt");
		InputStreamReader isr = new InputStreamReader(fis);
		int data = -1;
		
		while((data = isr.read()) != -1){
			System.out.println((char)data);
		}
		
		
		// 关闭的顺序 先用后关
		isr.close();
		fis.close();
		
	}
}

package com.qfedu.test1;

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

/**
 * 	每次读取一个字符数组
 * @author WHD
 *
 */
public class TestInputStreamReader2 {
	public static void main(String[] args) throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
		char [] chars = new char[5];
		int readCount = 0;
		while((readCount = isr.read(chars)) != -1) {
//			System.out.println(readCount);
			System.out.println(chars);
			System.out.println(new String(chars, 0, readCount));
			System.out.println("========================");	
		}
		// 关闭资源
		isr.close();	
	}
}


package com.qfedu.test1;

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

/**
 * 	使用InputStreamReader构造方法指定编码格式 解决乱码问题
 * 
 * 	乱码产生的原因：
 * 		编码和解码方式不统一 将会产生乱码
 * 	解决方案：
 * 		让编码和解码使用一种编码格式就可以了
 * 	
 * 	UTF-8（Unicode编码格式、万国码）：支持中文及其他国家的语言
 * 	GBK（国标扩展板）：支持大部分的中文简体和繁体
 * 	GB2312（国标2312）：支持大部分的中文简体
 * 	ISO-8859-1（最原始的编码格式）：用于处理字符串内容乱码
 * 	ANSI（在不同的操作系统表示不同的编码格式）：在中文Win10 表示 GBK
 * @author WHD
 *
 */
public class TestInputStreamReader3 {
	public static void main(String[] args) throws IOException {
		System.getProperties().list(System.out);
		
		
		InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\Users\\WHD\\Desktop\\2103.txt"),"utf-8");
		int data = -1;
		while(( data = isr.read()) != -1) {
			System.out.println((char)data);
		}
		
		// 关闭资源
		isr.close();
	}
}
3.1.1.1 FileReader

FileReader 此类只能按照本地平台默认的编码格式来读取 不能指定编码

package com.qfedu.test2;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 	Reader
 * 	InputStreamReader
 * 	FileReader 此类只能按照本地平台默认的编码格式来读取 不能指定编码
 * 	
 * @author WHD
 *
 */
public class TestFileReader {
	public static void main(String[] args) throws IOException {
		FileReader reader = new FileReader("a.txt");
		int data = -1;
		while((data = reader.read() )!= -1){
			System.out.println((char)data);
		}
		reader.close();
	}
}



package com.qfedu.test2;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * 	使用FileReader每次读取一个字符数组
 * @author WHD
 *
 */
public class TestFileReader2 {
	public static void main(String[] args) throws IOException {
		FileReader reader = new FileReader("a.txt");
		char [] chs = new char[5];
		int dataCount = -1;
		while((dataCount = reader.read(chs)) != -1) {
			System.out.println(new String(chs,0,dataCount));
		}
		
		reader.close();
		
	}
}

3.1.2 BufferedReader

带有缓冲区的字符读取流，提供了独有的读取整行的方法readLine()

package com.qfedu.test2;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestBufferedReader {
	public static void main(String[] args) throws IOException {
		BufferedReader  br = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
		String line = null;
		while((line = br.readLine()) != null) {
			System.out.println(line);
		}
		// 关闭资源
		br.close();
	}
}

3.2 Writer

字符写入流父类，抽象类，提供了各种write方法

3.2.1 OutputStreamWriter

字符写入流，可以一次写入一个字符，也可以一次写入一个char数组，可以指定写入的编码格式

package com.qfedu.test3;

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

/**
 * 	Writer抽象类父类
 * 	OutputStreamWriter 子类
 * 	write(String str);
 * 
 * 	OutputStreamWriter 可以指定写入的编码格式
 * @author WHD
 *
 */
public class TestOutputStreamWriter {
	public static void main(String[] args) throws IOException {
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt",true));
		osw.write(98);
		osw.write("hello world");
		osw.write("世界你好".toCharArray());
		osw.flush(); // 字符流相当于有一个缓冲区 不是直接操作硬盘的
		osw.close();
	}
}


package com.qfedu.test3;

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

/**
 * 	Writer抽象类父类
 * 	OutputStreamWriter 子类
 * 	write(String str);
 * 
 * 	OutputStreamWriter 可以指定写入的编码格式
 * @author WHD
 *
 */
public class TestOutputStreamWriter2 {
	public static void main(String[] args) throws IOException {
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("c.txt",true),"gbk");
		osw.write(98);
		osw.write("hello world");
		osw.write("世界你好".toCharArray());
		osw.flush(); // 字符流相当于有一个缓冲区 不是直接操作硬盘的
		osw.close();
	}
}
3.2.1.1 FileWriter

​ FileWriter不能指定编码格式写入

package com.qfedu.test3;

import java.io.FileWriter;
import java.io.IOException;

/**
 * 	Writer
 * 	OutputStreamWriter
 * 	FileWriter不能指定编码格式写入
 * @author WHD
 *
 */
public class TestFileWriter {
	public static void main(String[] args) throws IOException {
		FileWriter fw = new FileWriter("d.txt", true); 
		fw.write("hello world");
		fw.flush();
		fw.close();
	}
}

3.2.2 BufferedWriter

此类提供的有换行的方法 newLine()

package com.qfedu.test3;

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

/**
 * 	Writer
 * 	BufferedWriter 
 * 	此类提供的有换行的方法  newLine()
 * @author WHD
 *
 */
public class TestBufferedWriter {
	public static void main(String[] args) throws IOException {
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("e.txt")));
		bw.write("hello world1\n");
		bw.write("hello world2\n");
		bw.newLine();
		bw.write("世界你好");
		bw.flush();
	}
}

4.数据流

4.1 DataInputStream读取二进制文件

4.2 DataOutputStream写入二进制文件

读 DataInputStream

写 DataOutputStream

package com.qfedu.test4;

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

/**
 * 	读取二进制文件
 * 	读  DataInputStream
 * 	写  DataOutputStream
 * @author WHD
 *
 */
public class TestDataStream {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("C:\\Users\\WHD\\Desktop\\zs.jpg");
		DataInputStream dis = new DataInputStream(fis);
		byte [] datas = new byte[fis.available()];
		System.out.println(dis.read(datas));
		// System.out.println(new String(datas,0,datas.length)); 因为图片是二进制文件 所以不要打印
		
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("copyzs.jpg"));
		dos.write(datas);
		
		// 关闭资源 
		
		dos.close();
		dis.close();
		fis.close();
	
	}
}

5.对象流

5.1 序列化和反序列化

序列化：将对象写入到二进制文件中

反序列化：将存有对象的二进制文件读取为对象

注意：可以被序列化的对象所属的类必须实现Serializable接口，此接口是一个空接口，仅仅作为一个标识，表示此接口的实现类可以被序列化。

被transient修饰的属性不能被序列化。

序列化ID

用于判断读取出来的对象 是所属于哪个类的实例 相当于一个唯一表示

可以自动生成默认的1L

也可以随机生成

也可以不写 因为JVM会自动帮我们添加一个

package com.qfedu.test5;

import java.io.Serializable;
/**
 * 	Serializable接口没有方法 只相当于一个标识 标识此类的实现类可以被序列化
 * 	序列化ID 
 *	用于判断读取出来的对象 是所属于哪个类的实例  相当于一个唯一表示
 *	可以自动生成默认的1L
 *	也可以随机生成 
 *	也可以不写  因为JVM会自动帮我们添加一个
 * @author WHD
 *
 */
public class Student implements Serializable{
	private  static final long serialVersionUID = 1656714578162247302L;
	private int age;
	private String name;
	private transient String address; // 被transient修饰的属性  不能被序列化
	
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Student() {
	}
	public Student(int age, String name) {
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + ", address=" + address + "]";
	}
}



package com.qfedu.test5;

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

/**
 * 	ObjectInputStream 读取对象流
 * 	ObjectOutputStream 写入对象流
 * @author WHD
 *
 */
public class TestObjectStream {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("stu.txt"));
		Student zhaosi = new Student(20,"赵四");
		zhaosi.setAddress("象牙山");
		Student guangkun = new Student(20,"广坤");
		guangkun.setAddress("铁岭的");
		Student dana = new Student(20,"大拿");
		dana.setAddress("东北的");
		oos.writeObject(zhaosi);
		oos.writeObject(guangkun);
		oos.writeObject(dana);
		oos.flush();
		
		
		FileInputStream fis = new FileInputStream("stu.txt");
		ObjectInputStream ois = new ObjectInputStream(fis);
		
		while(fis.available() > 0) {
			Object obj1 = ois.readObject();
			if(obj1 instanceof Student) {
				Student s = (Student) obj1;
				System.out.println(s);
			}
		}
		
		
		
//		Object obj1 = ois.readObject();
//		if(obj1 instanceof Student) {
//			Student s = (Student) obj1;
//			System.out.println(s);
//		}
//		
//		
//		Object obj2 = ois.readObject();
//		if(obj2 instanceof Student) {
//			Student s = (Student) obj2;
//			System.out.println(s);
//		}
//		
//		Object obj3 = ois.readObject();
//		if(obj3 instanceof Student) {
//			Student s = (Student) obj3;
//			System.out.println(s);
//		}
//		
		ois.close();
		oos.close();		
	}
}
Bruce6379
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 静态成员函数和lambda表达式的一些探索
MQLCSDN的博客
02-04 1441
故事的开始，从牛客网一道题目说起。 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。 例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。 题目怎么求解暂且不表，现在visual studio 2017中写好代码，如下： bool mCmp(const string& s1, const string &...
java多线程并发去调用一个类的静态方法安全性探讨
热门推荐
weibin_6388的专栏
02-26 2万+
这篇文章主要讲多线程对静态方法访问的数据安全性 总结如下： 1，java在执行静态方法时，会在内存中拷贝一份，如果静态方法所在的类里面没有静态的变量，那么线程访问就是安全的，比如在javaee中服务器必然会多线程的处理请求此时如果设计全局需要调用的静态方法，可用此种设计。 2，java在执行静态方法时，如果使用静态变量，同事类的设计时使用到了静态数据，最好在调用函数时使用synchr
多线程调用类的静态方法
最新发布
watermelonmelon_的博客
06-14 440
多线程之间互相影响的情况
java 多线程&内置类与静态内置类——50
爱的叹息的专栏
06-09 165
关键字synchronized的知识点还涉及内置类的使用 包括普通内部类和静态内部类
极简Java五：IO流
06-18
在本篇文章中，我们将深入探讨Java中的IO流，包括其概念、分类、用途以及如何在实际工作中有效地运用它们。 首先，我们需要理解什么是流。在计算机科学中，流是数据的有序传输，它可以从一个源（如文件或网络连接）...
Java基础篇：IO流.pdf
05-19
该文档主要整理了Java IO流的相关信息，主要包括IO流的按照不同维度的分类、节点流、处理流、输入输出流的处理过程、抽象基类的使用等细节内容
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
java基础之IO流
06-18
java基础之IO流，基础简介知识，帮助你了解java的io技术
Java多线程与静态方法
stephen830
04-26 1160
Java多线程与静态方法 在多线程中使用静态方法会发生什么事？也就是说多线程访问同一个类的static静态方法会发生什么事？是否会发生线程安全问题？   public class Test { public static void operation(){ // ... do something } }  事实证明只要在静态函数中没有处理多线程共享...
再说说单例模式和多线程（静态内部类实现）
oppoppoppo的专栏
11-26 793
静态内部类： package thread.singleton; public class StaticInnerClassSingleton { private static class Singleton{ private static Singleton singleton = new Singleton(); } public Singleton getInstance(){
【Java】线程安全的单例模式----静态内部类
大船
03-18 8310
单例模式作为一种常见的设计模式，在程序中非常常见，主要是为了保证一个类只有一个唯一的对象。从简单的“饿汉式”、“懒汉式”→利用 synchronized 和 复杂的“双重校验DCL模式”，是一个考虑线程安全的过程。后来有一篇文章上说“双重校验DCL模式”其实并不是线程安全的，我没看懂他说的原因（原文在此），但后来发现了另一种实现线程安全的单例模式，静态内部类方式，代码如下：public class
从头认识多线程-2.23 静态内部类的同步机制跟普通类相同
raylee2007的专栏
05-18 1824
这一章节主要讨论静态内部类的同步机制跟普通类相同。1.当同步方法的时候package com.ray.deepintothread.ch02.topic_23; /** * * @author RayLee * */ public class SynchOfStaticInnerClass { static class InnerClass { private static in
单例模式静态内部类为何线程安全
chuixue24的博客
04-26 7823
虚拟机会保证一个类的类构造器<clinit>()在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的类构造器<clinit>()，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。特别需要注意的是，在这种情形下，其他线程虽然会被阻塞，但如果执行<clinit>()方法的那条线程退出后，...
单例模式静态内部类实现线程安全。
Vincent
06-07 5414
静态内部类 线程安全 单例模式
设计模式：单例模式（静态内部类）
qq_41477034的博客
12-29 320
单例模式（静态内部类） JVM装载部类不会实例化外部类对象，装载内部类时候才会实例化外部类对象 三步： 1.构造器私有化 2.创建私有静态内部类，在静态内部类中创建私有静态对象实例 3.对外提供共有方法（以供外部调用），返回对象实例 代码示例和解释 /** * 单例模式：静态内部类实现（推荐使用） * 1.构造器私有化 * 2.创建私有静态内部类，在静态内部类中创建私有静态对象实...
Java多线程 单例模式静态内部类&枚举写法
Java持续实践
09-06 462
文章目录静态内部类(推荐使用)枚举 (推荐实际生产使用) 静态内部类(推荐使用) 如下为静态内部类的写法: package com.thread.jmm; /** * 类名称:Singleton1 * 类描述: 静态内部类(推荐使用) * * @author: https://javaweixin6.blog.csdn.net/ * 创建时间:2020/9/6 19:26 * Version 1.0 */ public class Singleton7 { /** *
韩顺平Java笔记：IO流详解与实战应用
本资源是一份关于Java学习的笔记，主要关注于IO流部分，作者韩顺平分享了他在观看课程过程中对Java与数据库操作的理解和心得。笔记涵盖了Java IO流的基本概念、分类以及实际应用。 首先，IO流是Java中处理数据输入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值