JAVA中IO流（二）

旧城等待， 2023-06-13 15:29 102阅读 0赞

### 文章目录 ###

*  1. 流 Stream
 *   *  1.1 IO流
 *  2. 字节流
 *   *  2.1 FileInputStream : 字节输入流
     *  2.2 FileOutputStream：字符输出流
 *  3. 字符流
 *   *  3.1 FileReader 字符输入流
     *  3.2 FileWriter 字符输出流
     *  3.3 字符缓冲流
 *  4. 数据流
 *   *  4.1 字节流与字符流区别：
 *  5. 读取图片到目录下
 *  6. 文件系统
 *  7. ※ 对象流
 *   *  7.1 什么是java序列化，如何实现java序列化？

# 1. 流 Stream #

*  **网络中，不同计算机之间，软件之间，传输的字节码数据信息**。

## 1.1 IO流 ##

*  **方向来看**：  
    输入流：由文件源向本地系统传输数据信息，叫做输入流。  
    输出流：由本地系统向目标系统传输数据信息，叫做输出流。
 *  **读取数据**： ***read***
 *  **写出数据**：***write***
 *  数据方向看：
 *  **字节流** **字符流** **对象流** **数据流** **缓冲流** **打印流**  
    ————————————————————

# 2. 字节流 #

*  字节流:万能流 ★★★★★ io流中的重点
 *  字节输入流  
    InputStream 流向:输入流 操作单元:字节流 功能:节点流  
    此抽象类是表示字节输入流的所有类的超类。 不能实例化  
    public class FileInputStream  
    extends InputStream  
    从文件系统中的某个文件中获得输入字节  
    read() 每次从输入流中读入一个字节的内容,想要读入多个 手动一个字节一个字节读入  
    int read(byte\[\] b) 一个字节数组一个字节数组读入

--------------------

## 2.1 FileInputStream : 字节输入流 ##

*  FileInputStream
 *  从文件系统中的某个文件中获得输入字节。

public class FileInputStreamDemo {
        
    
    	public static void main(String[] args) throws Exception {
        
    		File file = new File("D://tt//a.java");
    		FileInputStream inputStream = new FileInputStream(file);
    //		int read = inputStream.read();// 读取单一字节。
    //		int read2 = inputStream.read();
    //		System.out.println(read+" "+read2);
    		int length = (int)file.length();
    //		for(int i=0;i<length;i++){
        
    //			System.out.print((char)inputStream.read()+" ");
    //		}
    		
    		System.out.println("\n*********************************");
    		// 读取到byte数组中。
    //		byte[] bytes = new byte[length];
    //		inputStream.read(bytes);// 读取数组
    //		for(byte b : bytes){
        
    //			System.out.print((char)b+" ");
    //		}
    		
    		System.out.println("***********************************");
    		 //读取到byte数组中。
    		byte[] bytes = new byte[length];
    		inputStream.read(bytes,0,3);// 读取数组
    		for(byte b : bytes){
        
    			System.out.print((char)b+" ");
    		}
    		// 关闭流。
    		inputStream.close();
    
    	}
    
    }

## 2.2 FileOutputStream：字符输出流 ##

--------------------

public class FileOutputStreamDmo {
        
    
    	public static void main(String[] args) throws Exception {
        
    		String string = "hello";
    		FileOutputStream out = new FileOutputStream(new File("D://tt//b.java"));
    //		out.write(string.getBytes());
    		out.write(string.getBytes(), 0, 2);
    		
    		out.flush();// 缓冲
    		out.close();// 关闭流
    
    	}
    
    }

# 3. 字符流 #

*  字符流的类通常以reader和writer结尾
 *  字符输入流：  
    常见的字符输入流有：  
    Reader  
    InputStreamReader  
    FileReader  
    BufferedReader

--------------------

## 3.1 FileReader 字符输入流 ##

--------------------

public class FileReaderDemo {
        
    
    	public static void main(String[] args) throws Exception {
        
    		char a = 0;
    		File file = new File("D://tt//a.txt");
    		int len = (int)file.length();
    		char[] chars = new char[len];
    		FileReader in = new FileReader(file);
    //		while((a=(char)in.read())!=0){
        
    //			System.out.print(a);
    //		}
    		
    		for(int i=0;i<len;i++){
        
    			in.read(chars);
    		}
    		System.out.println(chars.toString());
    		
    		in.close();
    		
    		
    
    	}
    
    }

————————————————————————

## 3.2 FileWriter 字符输出流 ##

--------------------

public class FileWriteDemo {
        
    
    	public static void main(String[] args) throws Exception {
        
    		String str = "中国";
    		FileWriter out = new FileWriter(new File("D://tt//a.txt"));
    		out.write(str);
    		out.append("人民真幸福");
    		out.flush();
    		out.close();
    	}
    
    }

————————————————————————————

## 3.3 字符缓冲流 ##

--------------------

public class BufferedReaderDemo {
        
    
    	public static void main(String[] args) throws Exception {
        
    		BufferedReader br = new BufferedReader(new FileReader(new File("D://tt//a.txt")));
    		BufferedWriter bw = new BufferedWriter(new FileWriter(new File("D://tt//aa.txt")));
    		String str = null;
    	
    		// 边读编写。
    		while((str=br.readLine())!=null){
        
    			bw.write(str);
    		}
    		bw.flush();
    		bw.close();
    		br.close();
    
    	}
    
    }

--------------------

![在这里插入图片描述][20191118093445387.png]

--------------------

# 4. 数据流 #

## 4.1 字节流与字符流区别： ##

*  字节流用于操作文件数据，网络传输等场景，而字符流适用于与字符串，中文有关的内容处理，因为Writer/Reader两个抽象类对字符的支持比较好。
 *  字符输出流写数据时是先将数据写入缓冲区，待字符输出流关闭后再写入到文件中，而字节输出流是直接写入到文件中

--------------------

public class DataStream {
        
    
    	public static void main(String[] args) throws Exception {
        
    		DataOutputStream out = new DataOutputStream(new FileOutputStream(new File("D://tt//c.txt")));
    		out.writeInt(100);
    		out.writeBoolean(true);
    		out.writeChar('a');
    		out.writeUTF("hello");
    		out.flush();
    		out.close();
    		
    		DataInputStream in = new DataInputStream(new FileInputStream(new File("D://tt//c.txt")));
    		System.out.println(in.readInt());
    		System.out.println(in.readBoolean());
    		System.out.println(in.readChar());
    		System.out.println(in.readUTF());
    		in.close();
    
    	}
    
    }

--------------------

# 5. 读取图片到目录下 #

--------------------

举例：读取图片到pm目录下!

public class Demo {
        
    
    	public static void main(String[] args) {
        
    		FileInputStream in = null;
    		FileOutputStream out = null;
    		File file = new File("D://tt//mp.jpg");
    		int length = (int)file.length();
    		String name = file.getName();
    		File outFile = new File("D://work//bigdataday22io//src//pm//"+name);
    		
    		byte[] bytes = new byte[length];
    		try {
        
    		    in = new FileInputStream(file);
    			in.read(bytes);
    			out = new FileOutputStream(outFile);
    			out.write(bytes);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    		}finally{
        
    			try {
        
    				out.flush();
    				out.close();
    				in.close();
    			} catch (Exception e) {
        
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    
    	}
    
    }

--------------------

# 6. 文件系统 #

--------------------

public class FileDemo {
        
    
    	public static void main(String[] args) throws IOException, Throwable {
        
    		File file = new File("D://tt//a.java");
    		file.createNewFile();// 创建文件。
    		System.out.println(file.exists());// 文件是否存在
    		System.out.println(file.getName());
    		System.out.println(file.getAbsolutePath());
    		System.out.println(file.getParent());
    		System.out.println(file.getPath());
    		System.out.println(file.getCanonicalPath());
    		System.out.println(file.lastModified());
    		System.out.println(file.length());
    	
    		// 创建目录
    		File file2 = new File("D://tt//aa");
    		file2.renameTo(new File("D://tt//aba"));
    		
    		// 获取目录下所有的文件。
    		File file3 = new File("D://tt");// URI 相对路径。统一资源标识符
    		File[] listFiles = file3.listFiles();
    		for(File file4 : listFiles){
        
    			System.out.println(file4.getName());
    		}
    		
    		
    
    	}
    
    }

--------------------

# 7. ※ 对象流 #

--------------------

*  序列化： 将对象转换成字节的过程叫做序列化。
 *  反序列化：将字节转换成对象的过程叫做反序列化。

--------------------

## 7.1 什么是java序列化，如何实现java序列化？ ##

--------------------

*  序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。  
    可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。  
    序列化是为了解决在对对象流进行读写操作时所引发的问题。
 *  **序列化的实现**：将需要被序列化的类实现Serializable接口，  
    该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，  
    然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，  
    使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

**Serializable 序列化接口**。

*  **序列化：将java中的对象，通过Serializable接口，转换成字节码数据的方式**。
 *  **序列化：把对象转换为字节序列的过程称为对象的序列化**。  
    **反序列化：把字节序列恢复为对象的过程称为对象的反序列化**。

--------------------

public class ObjectStreamDemo {
        
    
    	public static void main(String[] args) throws Exception, Exception {
        
    		Student student = new Student("dahuang",13);
    		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File("D://tt//object.txt")));
    		out.writeObject(student);
    		out.flush();
    		out.close();
    		
    		ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File("D://tt//object.txt")));
    		Object readObject = in.readObject();
    		Student stu1 = (Student)readObject;
    		System.out.println(stu1.name);
    		in.close();
    
    	}
    
    }
    
    class Student implements Serializable{
        
    	public String name;
    	public int age;
    	public Student() {
        
    		super();
    	}
    	public Student(String name, int age) {
        
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	
    	
    	
    }

--------------------

链接: [link][].

***可翻阅上一张JAVA中IO流（一）参考！！！***

[20191118093445387.png]: https://img-blog.csdnimg.cn/20191118093445387.png
[link]: https://mp.csdn.net/mdeditor/103116778#