IO（Input Output）技术

已于 2024-07-11 16:55:51 修改
阅读量111 收藏
点赞数 1
分类专栏： JavaSE基础 文章标签： java
于 2022-09-21 01:12:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiuCJ_20000/article/details/126964632
版权

IO（Input Output）技术

1 IO的概述

IO输入输出流。主要解决的是数据在不同设备(介质)之间的传输问题。IO的应用场景 非常广泛，比如文件上传与下载，还有资源的读写操作。

在java当中，数据除了在内存中保存。我们还可以将数据保存在文件中，那么我们需要使用一个类来描述文件，那么就是File类。

1.1 File类

File（java.io包）。File用来描述文件(目录)。我们要学习File。首先就需要学习File的 构造函数、api。

1.1.1 File的构造函数

描述File的构造函数主要是 3 个。

第一种： File(String path) 根据文件的路径(绝对路径 相对路径)去创建File对象。

//第一种创建对象的方法 传入的是描述文件的绝对路径
File file = new File("F:\\upload\\hello.txt");
System.out.println(file.exists()); //exists 判断文件是否存在 true 存在 false 不存在
//传入相对路径
File file1 = new File("test.txt");
System.out.println(file1.exists());

第二种：File(String parent,String child)。根据文件的父路径和文件名来构建File对象。

//第二种创建文件对象的方法
File file2 = new File("F:\\upload","demo1.txt");
System.out.println(file2.exists());

第三种：File(File parent,String child)。根据文件的父路径(File)和子路径来构建文件对象。

File f1 = new File("F:\\upload");
//参数1 文件对象 参数2 资源名称
File file3 = new File(f1,"demo1.txt");
System.out.println(file3.exists());

需要注意的是：关于文件的分隔符的问题。

在windows平台下面，我们描述文件使用到的分隔符是 \ \ (使用 / 也可以)。但是在linux操作系统里面我们使用文件分割符只能是/。这个时候会出现分隔符不兼容的 问题(windows平台开发的程序，在linux系统里面去运行)。

使用File.separator 描述分隔符的问题。

File file4 = new File("F:" + File.separator + "upload"+File.separator + "demo1.txt");
System.out.println(file4.exists());

1.1.2 File的常用的方法


1.1.2.1 创建和删除的方法

  • createNewFile() 创建文件的方法
public static void main(String[] args) throws IOException {
   File file = new File("F:\\upload\\Hello.java");
   if(!file.exists()){	//创建文件
   	boolean result = file.createNewFile();
       System.out.println("创建的结果是:" + result);
   }
}

这个方法的返回值是boolean类型的值。 创建文件的前提是文件不存在的情况下才

会创建。如果创建成功返回值为true。如果创建失败 返回值为false。

  • mkdir 创建文件目录(单级文件目录)

这个方法的返回值是bolean类型的值。true 创建成功。false 创建失败。

File file = new File("F:\\upload\\abc");
if(!file.exists()){    
    boolean flag = file.mkdir();   // make directory    				System.out.println(flag);
}
  • mkdirs 创建多级文件目录
File file = new File("F:\\upload\\a\\b\\c\\d");
if(!file.exists()){
	boolean flag = file.mkdirs(); //创建多级文件目录
	System.out.println(flag);
}
  • createNewFile()
File file = new File("/test.txt");
if(!file.exists() || (file.exists() && file.isDirectory()){
	file.createNewFile();
}

  • renameTo(File file)

    • 如果是在同级目录下面操作文件，这个方法就是重命名
File file = new File("F:\\upload\\hello.txt");  //重命名
boolean result = file.renameTo(new File("F:\\upload\\hello1.txt"));
System.out.println(result);

​

  • 如果不是在同一个目录下面操作文件，这个方法就是剪切并重命名
File file = new File("F:\\upload\\hello1.txt");
boolean result = file.renameTo(new
File("F:\\upload\\jd\\cat.txt"));
System.out.println(result);
  • delete 删除文件(目录)
//删除文件
File file = new File("F:\\upload\\jd\\cat.txt");
boolean flag = file.delete();
System.out.println("删除的结果是:" + flag);

//删除目录 只能删除空目录，不能删除带有文件的目录
File file = new File("F:\\upload\\abc");
System.out.println(file.delete());

1.1.2.2 判断的方法
  • exists 判断文件(目录)是否存在
//第一种创建对象的方法 传入的是描述文件的绝对路径
File file = new File("F:\\upload\\demo1.txt");
System.out.println(file.exists()); 
//exists 判断文件是否存在 true 存在 false 不存在
  • isFile() 判断是否是文件
File file = new File("F:\\upload\\abc\\demo1.txt");
System.out.println(file.isFile());// true 就是文件 false 不是文件
  • isDirectory() 判断是否是文件目录
File file = new File("F:\\upload\\abc");
System.out.println(file.isDirectory());
  • canRead() 判断文件是否只读
File file = new File("F:\\upload\\abc\\demo1.txt");
System.out.println(file.canRead());
  • canWrite() 判断文件是否可写
File file = new File("F:\\upload\\abc\\demo1.txt");
System.out.println(file.canWrite());
  • isHidden() 判断文件是否是隐藏文件
File file = new File("F:\\upload\\abc\\demo1.txt");
System.out.println(file.isHidden());
  • isAbsolute() 判断文件的路径是否是绝对路径
File file = new File("F:\\upload\\abc\\demo1.txt");
System.out.println(file.isAbsolute());
1.1.2.3 获取的方法
  • getName() 获取文件的名称
public static void main(String[] args) {
	File file = new File("F:\\upload\\Hello.java");
	if(file.exists()){
		String name = file.getName();
        //不管文件存不存在 都会获取文件的名称。		
        System.out.println(name);
    }
}

注意：

getName方法获取文件的名称。不管文件存不存在，都会拿到文件的名称。所以我们在使用这个方法的时候，最好先判断一下文件是否存在，如果文件存在，再去获取文件的名称。

  • getParent() 获取文件的父级目录
File file = new File("F:\\upload\\Hello.java");
String parent = file.getParent();
System.out.println(parent);
  • getAbsolutePath() 获取文件的绝对路径
File file = new File("F:\\upload\\Hello.java");
String path = file.getAbsolutePath();
System.out.println(path);
  • lastModified() 获取文件最后的修改时间
public static void main(String[] args) {
    File file = new File("F:\\upload\\Hello.java");
    long modified = file.lastModified();
    System.out.println(modified);
    //将毫秒值转换成时间格式的数据
    Date date = new Date(modified);
    //SimpleDateFormat进行日期格式的转换
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //将date类型的数据转换成String类型的数据
    String dateTime = sdf.format(date);
    System.out.println(dateTime);
}
  • length 获取文件的长度
long length = file.length();
System.out.println(length);
1.1.2.4 与文件夹有关的方法
  • listRoots 获取当前计算机的盘符列表
File[] roots = File.listRoots();
for(File file : roots){
	System.out.println(file);
}
  • list 获取指定目录下面的文件和文件目录的所有名称
File file = new File("F:\\upload");
String[] list = file.list();
for(String str: list){
	System.out.println(str);
}
  • listFiles 获取指定目录下面的所有文件对象
File file = new File("F:\\upload");
File[] files = file.listFiles();
for(File f : files){
//获取文件(目录)的名称
	System.out.println(f.getName());
}

1.1.3 File相关的案例

  • 案例 1 需求：获取指定目录下面的所有java文件

方法 1 ：

public static void main(String[] args) {
	File file = new File("F:\\upload");  //获取指定目录下面的所有文件
    String[] list = file.list();
	for(String fileName : list){
		if(fileName.endsWith(".java")){	 //判断字符串以指定的内容结尾
			System.out.println(fileName);
        }
    }
}

方法 2 ：

第一步： 定义文件过滤器

//定义文件过滤器
public class FileFilter implements FilenameFilter {
     /**
    * 定义过滤的规则
    * @param dir 文件目录的File对象
    * @param name 文件名
    * @return
	*/
    @Override
    public boolean accept(File dir, String name) {
        return name.endsWith(".java");
        }
}

第二步： 使用文件过滤器

public static void main(String[] args) {
	File file = new File("F:\\upload");
	String[] list = file.list(new FileFilter());
	for(String fileName : list){
		System.out.println(fileName);
    }
}
  • 案例 2 将指定目录下面的文件归类输出
public static void main(String[] args) {
    File file = new File("F:\\upload");
    File[] files = file.listFiles();
    //遍历文件目录
    for(File f : files){
    	String fileName = f.getName();
    	if(f.isDirectory()){ //获取文件目录
    		System.out.println("文件目录:" + fileName);
    	}
    }
    //遍历图片信息
    for(File f : files){
    	String fileName = f.getName();
    	if(fileName.endsWith(".jpg")){
   			 System.out.println("图片:" + fileName);
   	 	}
	}
    //遍历txt文档
	for(File f : files){
		String fileName = f.getName();
		if(fileName.endsWith(".txt")){
			System.out.println("txt文件:" + fileName);
		}
	}
    //遍历java文件
	for(File f : files){
		String fileName = f.getName();
		if(fileName.endsWith(".java")){
			System.out.println("Java文件:" + fileName);
		}
    }
}
  • 案例 3 获取指定目录下面的所有文件夹
public class MyFilter implements FilenameFilter {
    @Override
	public boolean accept(File dir, String name) {
		File file = new File(dir,name);
		return file.isDirectory();   //获取文件目录
    }
}
public static void main(String[] args) {
	File file = new File("F:\\upload");
	File[] files = file.listFiles(new MyFilter());
	for(File f : files){
		System.out.println(f.getName());
    }
}

1.2 IO流

数据在硬盘和内存之间进行传输需要的流通道。IO流根据流向的划分可以分为输入流，输出流。我们也可以根据类型来划分，根据类型可以划分为字节流 字符流


1.2.1 字节流


1.2.1.1 字节输入流

InputStream 是所有字节输入流的基类(父类)，它是一个抽象类

FileInputStream 字节输入流，继承了InputStream

需求：读取txt文档里面的数据。

使用字节输入流读取文件的步骤：

  1. 构建文件对象
  2. 构建字节输入流
  3. 执行read操作，读取文件
  4. 关闭流通道，释放资源

第一种读取文件的方式： 循环读取每个字节，然后再强制转换成字符。

public class IODemo1 {
    public static void main(String[] args) throws Exception{
        //构建文件对象
        File file = new File("F:\\upload\\Demo.txt");
        //构建输入流对象
        InputStream in = new FileInputStream(file);
        int data = 0;
        //指定读操作。如果到达文件的末尾处，read的返回值就为-1
        while((data = in.read()) != -1){
            System.out.print((char)data);
        }
        //关闭资源
        in.close();
    }
}

注意：

1.循环读取字节，为什么返回值必须为-1才跳出循环操作。

在官方源码里面定义好了。

在这里插入图片描述

  1. 必须要记得关闭资源。因为如果不关闭资源 会导致内存空间得不到释放，最终会导致内存溢出的问题。

面试考点：

内存泄漏(memory leak)：

是指程序在申请内存后，无法释放已申请的内存空间，导致系统无法及时回收内存并且分配给其他进程使用。通常少次数的内存无法及时回收并不会到程序造成什么影响，但是如果在内存本身就比较少获取多次导致内存无法正常回收时，就会导致内存不够用，最终导致内存溢出。

内存溢出(out of memory)：

指程序申请内存时，没有足够的内存供申请者使用，导致数据无法正常存储到内存中。也就是说给你个int类型的存储数据大小的空间，但是却存储一个long类型的数据，这样就会导致内存溢出。

第二种读取文件的方式：

配合字节数组批量读取，提高读取文件的效率。

public class IODemo2 {
    public static void main(String[] args) throws Exception{
        //构建文件对象
        File file = new File("F:\\upload\\Demo.txt");
        //构建输入流对象
        InputStream in = new FileInputStream(file);
        byte[] bytes = new byte[1024];
        int data = 0; //实际读取字节的个数
        //配合字节数组进行读操作
        while((data = in.read(bytes)) != -1){
            String msg = new String(bytes,0,data);
            System.out.println(msg);
        }
        //关闭资源
        in.close();
    }
}
1.2.1.2 字节输出流

OutputStream是所有字节输出流的基类。它也是一个抽象类。

FileOutputStream 是OutputStream的子类。

需求：将指定的数据写入到指定文件中。

public class IODemo3 {
    public static void main(String[] args) throws Exception {
        //构建文件对象
        File file = new File("F:\\upload\\Demo.txt");
        //构建输出流对象(新写入的内容会覆盖掉后写入的内容)
        //OutputStream out = new FileOutputStream(file);
        //参数1 文件对象  参数2 是否追加新内容 true 追加 false 不追加，直接覆盖
        OutputStream out = new FileOutputStream(file,true);
        String msg = "hello,java....";
        //执行写操作
        out.write(msg.getBytes());
        //关闭资源
        out.close();
    }
}

案例：使用字节输入流和字节输出流实现图片的拷贝。

/**
 * 使用字节输入流和字节输出流实现图片的拷贝
 */
public class CopyImageDemo {
    public static void main(String[] args) throws Exception{
        //创建图片的源对象
        File file = new File("F:\\upload\\AudiA7.jpg");
        //构建字节输入流
        InputStream in = new FileInputStream(file);
        //创建输出的文件对象
        File newFile = new File("F:\\upload\\A7.jpg");
        //构建字节输出流对象
        OutputStream out = new FileOutputStream(newFile);
        //先读 再写
        byte[] bytes = new byte[1024];
        int data = 0;
        while((data = in.read(bytes)) != -1){//读操作
            out.write(bytes,0,data);//写操作
        }
        //关闭资源
        out.close();
        in.close();
    }
}
1.2.1.3 字节缓冲流

缓冲流java给我们提供的一个字节流，专门用来提高文件的读写效率。

BufferedInputStream 缓冲字节输入流，间接的继承了InputStream。

在这里插入图片描述

BufferedOutputStream 缓冲字节输出流，间接的继承了OutputStream。

在这里插入图片描述

缓冲字节输入流和缓冲字节输出流主要是通过减少文件的读写次数来提高文件的读写效率。为什么它们可以提高文件的读写效率呢，因为缓冲流的内部维护了一个缓冲区。缓冲区的内部其实维护了一个字节数组，默认字节数组的大小了8192.

我们使用缓冲区进行文件读写的时候，我们首先会把数据写到缓冲区里面，当缓冲区满了之后，然后刷新缓冲区(flush方法)。一般适用于文件内容比较多的场景。

1.2.1.3.1 使用缓冲流来进行数据的读取
/**
 * 使用缓冲流读取数据
 */
public class BufferedIODemo1 {
    public static void main(String[] args) throws Exception {
        File file = new File("F:\\upload\\Hello.java");
        InputStream in = new FileInputStream(file);
        //构建缓冲输入流
        BufferedInputStream bif = new BufferedInputStream(in);
        int data = 0;
        //执行读操作
        while((data = bif.read()) != -1){
            System.out.print((char)data);
        }
        //关闭资源
        bif.close();
        in.close();
    }
}
1.2.1.3.2 使用缓冲流来进行数据的写操作
/**
 * 使用缓冲流读取数据
 */
public class BufferedIODemo2 {
    public static void main(String[] args) throws Exception {
        File file = new File("F:\\upload\\Hello.java");
        OutputStream out = new FileOutputStream(file,true);
        //构建缓冲输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(out);
        String message = "hello,spring";
        //写操作
        bos.write(message.getBytes());
        //刷新缓冲区
        bos.flush(); 
        //关闭资源
        bos.close();
        out.close();
    }
}

练习：使用缓冲输入流和缓冲输出流实现文件的拷贝

/**
 * 使用缓冲流的方式读写文件
 */
public class IOTest {
	public static void main(String[] args) throws Exception{
		//构建字节流
		InputStream in = new FileInputStream(new File("F:\\upload\\AudiA7.jpg"));
		OutputStream out = new FileOutputStream(new
File("F:\\upload\\A8.jpg"));
		//根据字节流构建缓冲流
		BufferedInputStream bin = new BufferedInputStream(in);
		BufferedOutputStream bout = new BufferedOutputStream(out);
		int length = 0 ;
		//byte[] bytes = new byte[1024];
		while((length = bin.read()) != - 1 ){
			//bout.write(bytes,0,length);
			bout.write(length); 
        }
        //关闭流通道
        bout.close();
        bin.close();
        out.close();
        in.close();
    }
}

1.2.2 字符流

字符流主要是用来处理中文的。如果使用字节流进行中文数据读取的话，会出现中文乱码的问题。所以我们需要使用字符流来解决这个问题，字符流根据流向的划分，又可以划分为字符输入流、字符输出流。

1.2.2.1 字符输入流

Reader: 字符输入流的基类。是一个抽象类。

FileReader: 字符输入流，间接的继承了Reader这个类。

在这里插入图片描述

需求：使用字符输入流读取文件。

步骤：

  1. 构建目标文件对象

  2. 构建字符流通道

  3. 进行文件的读取操作

  4. 关闭流通道

  • 方案 1 按照字节一个个的读取
public class FileReaderDemo1 {
	public static void main(String[] args) throws Exception{
		//1.构建File对象
		File file = new File("F:\upload\Demo.txt");
		//2.创建字符输入流
		FileReader reader = new FileReader(file);
		int length = 0 ;
		//3.执行读操作
		while((length = reader.read()) != - 1 ){
			System.out.print((char) length);
        }
		//4.关闭资源	
		reader.close();
   	}
}
  • 方法 2 配合字符数组来批量读取
/**
 * 配合字符数组批量读取
 */
public class FileReaderDemo2 {
	public static void main(String[] args) throws Exception {
		//1.构建File对象
		File file = new File("F:\upload\Demo.txt");
		//2.创建字符输入流
		FileReader reader = new FileReader(file);
		int length = 0 ;
		char[] chars = new char[ 1024 ];
		//3.配合字符数组 批量读取文件
		while((length = reader.read(chars)) != - 1 ){
			System.out.println(new String(chars, 0 ,length));
		}
		//4.关闭资源
		reader.close();
    }
}
1.2.2.2 字符输出流

Writer： 字符输出流的基类 它是一个抽象类。

FileWriter: 字符输出流，间接的继承了Writer。

在这里插入图片描述

需求：使用字符输出流写文件。

步骤：

1.构建目标文件对象。

2.构建字符输出流通道。

3.进行文件的写出操作。

4.关闭资源。

/**
* 使用字符输出流写数据
*/
public class FileWriterDemo1 {
	public static void main(String[] args) throws Exception{
        //构建目标文件对象
        File file = new File("F:\\upload\\Demo.txt");
        //构建字符输出流通道 true 追加的内容不会将原来的内容覆盖
        FileWriter writer = new FileWriter(file,true);
        String message = "我爱学习数学";
        //执行写操作
        writer.write(message);
        //关闭资源
        writer.close();
    }
}
1.2.2.3 字符缓冲流
  • 缓冲字符输入流

在java中，sun公司通过BufferedReader这个类来描述缓冲字符输入流。 这个类直
接继承了Reader这个字符流的基类。

public class BufferedReader extends Reader{}

需求： 使用字符缓冲流来读取文件。

方法 1 ： 配合字符数组读取，或者单个单个字符读取。

/**
 * 使用缓冲字符输入流来读取文件
 */
public class BufferedFileReaderDemo1 {
	public static void main(String[] args) throws Exception {
		//构建目标文件对象
		File file = new File("F:\\upload\\Demo.txt");
		//构建字符输入流对象
		Reader reader = new FileReader(file);
		//构建缓冲字符输入流对象
		BufferedReader br = new BufferedReader(reader);
		int length = 0 ;
		char[] chars = new char[ 1024 ];
		//读取文件
        /*while((length = br.read()) != -1){
        	System.out.print((char)length);
        }*/
        while((length = br.read(chars)) != - 1 ){
            System.out.println(new String(chars, 0 ,length));
        }
        //关闭资源
        br.close();
        reader.close();
    }
}

方法 2 ： 为了提高读取效率，我们可以一行行读取。

readLine方法： 一行行的读取文件，方法的返回值为String。如果到达文件的末尾处，返回值为null。

在这里插入图片描述

public class BufferedFileReaderDemo2 {
	public static void main(String[] args) throws Exception {
        //构建目标文件对象
        File file = new File("F:\\upload\\Demo.txt");
        //构建字符输入流对象
        Reader reader = new FileReader(file);
        //构建缓冲字符输入流对象
        BufferedReader br = new BufferedReader(reader);
        //执行读取操作
        String content = null;
        //content 存储的是每次读取文件的行内容
        while((content = br.readLine()) != null){//readLine一行行读取
        	System.out.println(content);
        }
        //关闭资源
        br.close();
        reader.close();
    }
}
  • 缓冲字符输出流

在java中，sun公司通过BufferedWriter这个类来描述缓冲字符输出流。 这个类直接继承了Writer这个字符流的基类。

public class BufferedWriter extends Writer {}

需求： 使用字符缓冲输出流来写文件。

public class BufferedFileWriterDemo1 {
    public static void main(String[] args) throws Exception {
        File file = new File("F:\\upload\\Demo.txt");
        FileWriter writer = new FileWriter(file,true);
        //构建缓冲字符输出流
        BufferedWriter bw = new BufferedWriter(writer);
        String message = "我爱学习PHP";
        //执行换行输出
        bw.newLine();
        //执行写操作
        bw.write(message);
        //关闭资源
        bw.close();
        writer.close();
    }
}

1.2.3 序列化和反序列化

Java序列化：就是指把Java对象转换为字节序列的过程(将java对象以字节流的方式写入到文件中)。

Java反序列化：就是指把字节序列恢复为Java对象的过程(将字节流读取到程序中，并转换成java对象的过程)。

在java中，我们通过下面的几个类来实现对象的序列化的反序列化。

ObjectOutputStream: 对象写入到文件中 需要用到的一个类。使用这个类的时候，操作对象所属的类必须要实现Serializable接口，否则会出现异常。

public class ObjectOutputStream   
    extends OutputStream implements ObjectOutput, 				ObjectStreamConstants{}

ObjectInputStream:将对象从文件中读到程序中来使用的类。

public class ObjectInputStream    extends InputStream implements ObjectInput, ObjectStreamConstants{}

案例： 序列化和反序列化User对象。

public class User implements Serializable {    
    //序列化的版本号    
    private static final long serialVersionUID = -5194183731020781169L;   
    private String username;    
    private String password;    
    public String getUsername() {        
        return username;   
    }    
    public void setUsername(String username) {        
        this.username = username;   
    }    
    public String getPassword() {        
        return password;   
    }    
    public void setPassword(String password) {        
        this.password = password;   
    }    
    @Override    
    public String toString() {        
        return "User{" +               
            "username='" + username + '\'' +                
            ", password='" + password + '\'' +                
            '}';   
    }
}

/** 
 * 序列化和反序列化对象 
 */
public class UserDemo {    
    //序列化    
    @Test   //注解 修饰一个方法，标识当前方法是一个测试类    
    public void test01() throws Exception{       
        User user = new User();       
        user.setUsername("eric");        
        user.setPassword("admin");       
        //创建输出流对象        
        FileOutputStream out = new FileOutputStream(new File("F:\\upload\\user.txt"));        
        //构建序列化流(对象输出流)       
        ObjectOutputStream oos = new ObjectOutputStream(out);
        //进行对象的序列化        
        oos.writeObject(user);        
        //关闭资源        
        oos.close();        
        out.close();   
    }    
    //反序列化    
    @Test    
    public void test02() throws Exception{        
        //创建输入流对象        
        FileInputStream in = new FileInputStream(new File("F:\\upload\\user.txt"));        
        //构建反序列化流(对象输入流)        
        ObjectInputStream oin = new ObjectInputStream(in);        
        //执行读操作        
        User user = (User) oin.readObject();
        System.out.println(user);        
        //关闭资源        
        oin.close();        
        in.close();   
    }
}

上面使用的是Junit’单元测试。我们只需要在方法上面加上一个@Test注解即可。这个注解修饰的方法就是一个测试方法，功能和main方法一样。

简单了解junit里面的几个常用的注解：

public class TestDemo{    
    @Test    
    public void test03(){        
        System.out.println("test03方法执行了......");   
    }  
    
    @Before //标识在@Test方法之前执行    
    public void before(){        
        System.out.println("before方法执行了......");   
    }
    
    @After //标识在@Test方法之后执行    
    public void after(){        
        System.out.println("after方法执行了......");   
    }
}

问题： 在序列化和反序列化的时候，为什么我们必须要实现Serializable接口？(面试题)

凡是实现 Serializable 接口的类都有一个表示序列化版 本标识符的静态变量：private static final long serialVersionUID；

serialVersionUID 用来表明序列化的版本。它的值是一个静态常量，是 Java 运行时环境根据类的内部细节自动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。

简单来说，Java 的序列化机制是通过在运行时判断类 的 serialVersionUID 来验证版本一致性的。在进行反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地相应实体类的 serialVersionUID 进行比较，如果相同就 认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。(InvalidCastException)

1.2.4 二进制流

案例：将图片转换成二进制数据，再将二进制的数据转换成图片信息。

/** 
 * 将图片转换成二进制的数据 
 * 再将二进制的数据转换成图片 
 */
public class ImageIODemo1 {    
    static BASE64Encoder encoder = new sun.misc.BASE64Encoder();  
    static BASE64Decoder decoder = new sun.misc.BASE64Decoder();  
    public static void main(String[] args) throws Exception{      
        String message = getImageBinary();        
        System.out.println(message);        
        base64StringToImage(message);   
    }    
    //将图片转换成二进制数据    
    public static String getImageBinary() throws Exception{        
        File file = new File("F:\\upload\\A7.jpg");        
        BufferedImage bufferedImage = ImageIO.read(file);        
        //构建二进制输出流对象
        ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
        //将图片相关的数据写入到ByteArrayOutputStream中        
        ImageIO.write(bufferedImage, "jpg", baos);  //经测试转换的图片是格式这里就什么格式，否则会失真        
        byte[] bytes = baos.toByteArray();        
        return encoder.encodeBuffer(bytes).trim();   
    }    
    
    //再将二进制的数据转换成图片    
    public static void base64StringToImage(String message) throws Exception{        
        byte[] bytes1 = decoder.decodeBuffer(message);        
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes1); 
        BufferedImage bi1 = ImageIO.read(bais);        
        File w2 = new File("F:\\upload\\jd\\QQ.jpg");
        // 可以是jpg,png,gif格式        
        ImageIO.write(bi1, "jpg", w2);
        // 不管输出什么格式图片，此处不需改动   
    }
}

eBinary() throws Exception{
File file = new File(“F:\upload\A7.jpg”);
BufferedImage bufferedImage = ImageIO.read(file);
//构建二进制输出流对象
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//将图片相关的数据写入到ByteArrayOutputStream中
ImageIO.write(bufferedImage, “jpg”, baos); //经测试转换的图片是格式这里就什么格式，否则会失真
byte[] bytes = baos.toByteArray();
return encoder.encodeBuffer(bytes).trim();
}

//再将二进制的数据转换成图片    
public static void base64StringToImage(String message) throws Exception{        
    byte[] bytes1 = decoder.decodeBuffer(message);        
    ByteArrayInputStream bais = new ByteArrayInputStream(bytes1); 
    BufferedImage bi1 = ImageIO.read(bais);        
    File w2 = new File("F:\\upload\\jd\\QQ.jpg");
    // 可以是jpg,png,gif格式        
    ImageIO.write(bi1, "jpg", w2);
    // 不管输出什么格式图片，此处不需改动   
}

}
王维诗里的代码i
关注
专栏目录
java output_Java中Input和Output操作
weixin_31043555的博客
02-20 1946
一． Input和Output1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream(包括Input和Out stream)都包括两种类型：1.1 以字节为导向的stream以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：1) input　s...
java中的Io(input与output)操作总结(四)
09-05
Java中的IO操作主要涉及到输入（Input）和输出（Output）数据到不同的源和目标，如文件、网络连接、内存缓冲区等。在本篇总结中，我们将深入探讨几个额外的重要概念：Serializable序列化、DataOutputStream和...
Linux 基础IO（Input与output）学习
weixin_59215611的博客
04-05 839
基础IO（Input与output）学习
java.io.IOException: Input/output error
dy105936的博客
01-13 2881
java.io.IOException: Input/output error
FPGA静态时序分析——IO口时序（Input Delay /output Delay）
basn168的博客
12-06 1858
感谢原文作者：屋檐下的龙卷风 链接地址：https://www.cnblogs.com/linjie-swust/archive/2012/03/01/FPGA.html 本文PDF版本下载： http://files.cnblogs.com/linjie-swust/FPGA%E4%B8%ADIO%E6%97%B6%E5%BA%8F%E7%BA%A6%E6%9D%9F%E5%88%86%E6%9E%90.pdf 1.1 概述 　　在高速系统中FPGA时序约束不止包括内部时钟约束，还应包括完整的IO时序约
linux input/output error
热门推荐
SoldierJazz的专栏
01-21 3万+
在操作linux系统的时候有时候会遇到这个错误提示，那么首先要确定之前有没有操作过分区表，修改过磁盘配置等。尤其在虚拟机环境下改动后直接操作都会出现这个错误，此时尝试以下方法： 1. reboot  2. 确定报错的挂载目录对应的分区，通过 df -Th查看。  然后修复模式进入系统，执行： e2fsck -a /dev/sdb4 (sdb4 为假设的问题分区) 有其他出错情形与方法，可
javaIO流，input,output 文件输入与输出
weixin_51426897的博客
02-17 4449
目标： input，output，在java中主要操作数据的输入输出，数据的流动，可以通过学习输入输出的方法把一段数据从内存里放到硬盘上永久的存起来，也可以从硬盘上读取一个文件加载到内存。 1.能够通过File类对文件熟练操作（熟练） 2.理解相对路径和绝对路径的区别（了解） 3.掌握常见的字节输入输出和字符输入输出（熟练） 4.了解序列化和反序列化（熟悉） File类（文件类）： 是java中的文件/文件夹的抽象表示形式，一个File类的对象，在java中就表示一个文件或文件夹。...
LUA io.input,io.output,io.write,io.read之间的关系
zhuoyuetec的专栏
02-13 5829
io.write(content)//输出内容，可以是字符串，函数，表达式等，不能使nil,例如 io.write("sin(30)=",math.sin(3.14/6)); 如果不设置io.output，io.write会输出到控制台 做如下设置 page=[[               An HTML Page               LUA          
java.lang.NoClassDefFoundError: org/apache/commons/io/output/UnsynchronizedByteArrayOutputStream
我的博客
08-30 1万+
把commons-io和log4j-api的版本升级到下面版本。：版本在5.1.0的时候导出EXECL会出错，报加载不到当前类。把poi的版本降低到5.0.0即可解决。
vivado VIO （virtual input output）虚拟IO的使用
我的blog屋
08-31 8450
转自：https://blog.csdn.net/wordwarwordwar/article/details/77150930 一般情况下ILA和VIO都是用在chipscope上使用，VIO可以作为在chipscope时模拟IO。 譬如： 在使用chipscope时需要使用按键出发，但是没有设计按键或者板子不再身边，所以需要模拟按键输入还有其他信号的输出。 参数配置，配置输入探针数量和输出探针数量。分别可以设置0-2
服务器 Input/output error 问题解决
w36680130的博客
12-12 4048
服务器 Input/output error 问题解决
java中的Io(input与output)操作总结(三)
09-05
在Java中，Input/Output（IO）操作是程序与外部世界交互的基础。本文主要关注Scanner类和PrintWriter类的使用，它们分别用于输入和输出。 Scanner类是Java中处理输入的常用工具，尤其在读取控制台输入时非常方便。...
JAVA IO-（FileBuffered的InputOutputStream的基本操作）
10-17
总结，Java中的FileBuffered的InputOutputStream结合了基础的文件流和缓冲技术，为开发者提供了高效、易用的文件读写方案。理解并熟练掌握这些基本操作，对于编写高性能的Java IO程序至关重要。
java中的Io(input与output)操作总结(二)
09-05
Java中的IO操作主要涉及到输入（Input）和输出（Output）数据到不同的存储媒介，如硬盘、内存、网络等。在Java中，文件操作是通过`java.io.File`类来实现的。这一节我们将深入探讨文件操作的相关知识点。 首先，...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1443
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 915
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 655
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JavaSE——认识异常
最新发布
wx2023_10_15的博客
10-12 943
本文主要是正在学习异常的总结，主要讲了异常的概念、体系结构、分类、处理以及捕获，还有自定义异常类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值