java基础知识整理——IO（五）

「爱情、让人受尽委屈。」 2022-10-27 14:59 196阅读 0赞

### java基础知识整理 IO（五） ###

*   *   *  1.字节流
         *  2.字符流
     *  3.对象序列化和反序列化

1.File类

*  文件：文件可认为是相关记录或放在一起的数据的集合。
 *  在java中，使用java.io.File类对文件进行操作。
 *  在windows中，目录分隔符为 ‘\\’。
 *  在Linux中，目录分隔符为’/’。

2.绝对路径和相对路径

*  绝对路径：是从盘符开始的路径。
 *  相对路径：是从当前路径开始的路径。
 *  在程序中, …\\\\表示当前路径的上一级，…\\\\…\\\\表示上两级，以此类推。（…是两点，不知道写出来为什么是三个点。）

3.例子

import java.io.File;
    import java.io.IOException;
    
    public class FileDemo {
        
    	public static void main(String[] args) {
        
    // 1.文件的定义形式有以下四种，适用于不同场景。		
    		File file1 = new File("E:\\javaReStudy\\imooc\\test.txt");
    //		File file1 = new File("E:\\javaReStudy", "imooc\\test.txt");
    //		File file1 = new File("E:\\javaReStudy");
    //		File file2 = new File(file1, "imooc\\test.txt");
    		System.out.println("是否为目录：" + file1.isDirectory());
    		System.out.println("是否为文件：" + file1.isFile());
    		
    		File file2 = new File("E:\\javaReStudy\\imooc\\kk");
    		if(!file2.exists()) {
        
    			file2.mkdir(); 
    //2.mkdir()创建目录成功的依据是前的目录都已经存在，即E：\\javaReStudy\\imooc。
    //  mkdirs()创建多级目录，即不管前面的目录存不存在，都能成功创建。
    		}
    		
    		File file3 = new File("E:\\javaReStudy\\imooc\\kk\\dd.txt");
    		if(!file3.exists()) {
        
    			try {
        
    				file3.createNewFile();
    			} catch (IOException e) {
        
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }

### 1.字节流 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70]  
1.1 FileInputStream：从文件系统中的某个文件中获得输入字节，或用于读取诸如图像数据之类的原始字节流。

例子：

//从文件中读取数据；
    public class FileInputDemo {
        
    
    	public static void main(String[] args) {
        
    		try {
        
    			FileInputStream fis = new FileInputStream("E://javaReStudy//imooc//test.txt");
    //FileInputStream当调用read()方法时，每次取一个字节，结束标识符是-1。
    //FileInputStream当调用read(byte[] b) 或者 read(byte[] b,int off, int len)，每次取n个字节。
    			//1.read()
    //			int n = 0;
    //			while((n = fis.read()) != -1) {
        
    //				System.out.print((char)n);
    //			}
    			//2.read(byte[] b) read(byte[] b, int off, int len);
    			byte[] bytes = new byte[100];
    			fis.read(bytes);
    			System.out.println(new String(bytes));
    			fis.close();
    		} catch (FileNotFoundException e) {
        
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch (IOException e) {
        
    			// TODO: handle exception
    			e.printStackTrace();
    		}
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70 1]

1.2 FileOutputStream

//向文件中写入数据
    public class FileOutputDemo {
        
    
    	public static void main(String[] args) {
        
    		// TODO Auto-generated method stub
    		try {
        
    			FileOutputStream fos = new FileOutputStream("E://javaReStudy//imooc//test.txt",true); //true表示文件末尾追加。
    			fos.write('a');
    			fos.close();
    		} catch (FileNotFoundException e) {
        
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}catch(IOException e) {
        
    			e.printStackTrace();
    		}
    	}
    
    }

2.3 BufferedInputStream 和 BufferedOutputStream 可以加快文件内容的读取速度。  
原理：预先创建一个大小固定的缓存容器，将流中的数据读入容器中，每当容器数据填满或者流中数据读取完毕时，则进行操作，释放CPU的处理时间。BufferedOutputStream的两个方法，flush()方法是当缓冲区未满的时候，手动清空缓冲区，即把内容写入文件中，而当缓冲区满时会触发write()方法自动写入。

用法是将FileInputStream和FileOutputStream对象分别作为参数传入对应的构造方法中。

FileOutputStream fos=new FileOutputStream("imooc.txt");
    	BufferedOutputStream bos=new BufferedOutputStream(fos);
    	FileInputStream fis=new FileInputStream("imooc.txt");
    	BufferedInputStream bis=new BufferedInputStream(fis);
    	bos.write(50);
    	bos.write('a');
    	bos.flush();
    	System.out.println(bis.read());
    	System.out.println((char)bis.read());
    	fos.close();
    	bos.close();
    	fis.close();
    	bis.close();

### 2.字符流 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70 3]  
字符流与字节流的区别：字符流虽然以字节流为基础创建的，但是字节流可以支持声音，视频，图片，文本等所有文件类型，而字符流只支持文本文件。

2.1 字节字符转换流

在网络传输的是字节流，但是到了客户端显示的是字符流，这时候就需要有字节字符转换流。  
这两个类分别是：InputStreamReader 和 OutputStreamWriter。

InputStreamReader的构造方法有：

<table> 
 <thead> 
  <tr> 
   <th>构造方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>InputStreamReader(InputStream in)</td> 
   <td>使用默认编码创建字符输入流</td> 
  </tr> 
  <tr> 
   <td>InputStreamReader(InputStream in, Charset cs)</td> 
   <td>使用指定的编码格式创建字符输入流</td> 
  </tr> 
  <tr> 
   <td>InputStreamReader(InputStream in, CharsetDecoder dec)</td> 
   <td>使用指定的编码器创建字符输入流</td> 
  </tr> 
  <tr> 
   <td>InputStreamReader(InputStream in, String CharsetName)</td> 
   <td>使用指定的编码格式的名称创建字符输入流</td> 
  </tr> 
 </tbody> 
</table>

OutputStreamWriter和InputStreamReader相似就不写了。

应用：

FileInputStream fis = new FileInputStream("ddd.txt"）;
    	InputStreamReader isr = nw InputStreamReader(fis);
    	int n = 0;
    	char[] cbuf = new char[10];
    	while((n = isr.read(cbuf)) != -1){
        
    		String s =  new String(cbuf);
    		System.out.println(s);
    	}
    	fis.close();
    	isr.close();

FileInputStream fis = new FileInputStream("ddd.txt"）;
    	InputStreamReader isr = nw InputStreamReader(fis);
    	FileOutputStream fos = new FileOutputStream("kkk.txt");
    	OutputStreamWriter osw = new OutputStreamWriter(fos);
    	int n = 0;
    	char[] cbuf = new char[10];
    	while((n = isr.read(cbuf)) != -1){
        
    		//String s =  new String(cbuf);
    		//System.out.println(s);
    		osw.write(cbuf,0,n);
    		osw.flush(); //调用close()的时候也会执行flush()操作的。
    	}
    	fis.close();
    	fos.close();
    	isr.close();
    	osw.close();

## 3.对象序列化和反序列化 ##

步骤：

*  创建一个类，继承Serializable接口
 *  创建对象
 *  将对象写入文件
 *  从文件读取对象信息

例：

public class Goods implements Serializable{
        
    	private String goodsId;
    	private String goodsName;
    	private double price;
    	public Goods(){
        
    	}
    	public Goods(String goodsId,String goodsName,double price){
        
    		this.goodsId=goodsId;
    		this.goodsName=goodsName;
    		this.price=price;
    	}
    	public String getGoodsId() {
        
    		return goodsId;
    	}
    	public void setGoodsId(String goodsId) {
        
    		this.goodsId = goodsId;
    	}
    	public String getGoodsName() {
        
    		return goodsName;
    	}
    	public void setGoodsName(String goodsName) {
        
    		this.goodsName = goodsName;
    	}
    	public double getPrice() {
        
    		return price;
    	}
    	public void setPrice(double price) {
        
    		this.price = price;
    	}
    	@Override
    	public String toString() {
        
    		return "商品信息 [编号：" + goodsId + ", 名称：" + goodsName 
    				+ ", 价格：" + price + "]";
    	}
    	
    }

public class GoodsTest {
        
    
    	public static void main(String[] args) {
        
    		// 定义Goods类的对象
    		Goods goods1 = new Goods("gd001", "电脑", 3000);
    		try {
        
    			FileOutputStream fos = new FileOutputStream("ddd.txt");
    			ObjectOutputStream oos = new ObjectOutputStream(fos);
    			FileInputStream fis = new FileInputStream("ddd.txt");
    			ObjectInputStream ois = new ObjectInputStream(fis);
    			// 将Goods对象信息写入文件
    			oos.writeObject(goods1);
    			oos.writeBoolean(true);//写入一个boolean值。
    			oos.flush();
    			// 读对象信息
    			try {
        
    				Goods goods = (Goods) ois.readObject();
    				System.out.println(goods);
    			} catch (ClassNotFoundException e) {
        
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			//读取的时候也要跟写入一样的顺序，即先读对象，再读boolean值。
    			System.out.println(ois.readBoolean());
    
    			fos.close();
    			oos.close();
    			fis.close();
    			ois.close();
    		} catch (FileNotFoundException e) {
        
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
        
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70]: /images/20221024/a5543c2c3fd64663af2e780108245933.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70 1]: /images/20221024/7dbf4bb10044416b80b183f542046c7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70 2]: /images/20221024/8aadfdd4f34a4a87a59f5d30b8c74971.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzk1MjczNg_size_16_color_FFFFFF_t_70 3]: /images/20221024/ccb469f245144cf48dbcacb2b9f8f360.png