IO流详解

最新推荐文章于 2024-04-26 16:26:34 发布
最新推荐文章于 2024-04-26 16:26:34 发布
阅读量3.8k 收藏 35
点赞数 8
分类专栏： # java进阶 文章标签： windows java c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tower_SHR/article/details/120398933
版权

文章目录

IO流

IO流分类

  • 以内存为参照物
    - 往内存中去，输入流，读
    - 从内存中出，输出流，写
  • 读取方式不同
    - 按照字节读取数据，一次读取一个字节byte，相当于8个二进制位。这类流的读取方式是万能的，什么类型的文件都可以读取：文本文件、图片、声音文件、视频
    - 按照字符读取数据，一次读取一个字符，这种流是为了方便读取普通文本而存在的。这种流不能读取图片、声音、视频等文件，只能读取纯文本文件【word文档不可以，因为word有格式】

例：txt文件的内容：o中国o
【在Windows系统中：字母占一个字节、汉字占两个字节】 按照字节流读取：第一次：读取“o”；第二次：读取“中”字符的一半；第三次：读取“中”字符的另外一半。 按照字符流读取：第一次：读取“o”；第二次读取字符“中”。

  • 四大家族：以“Stream”结尾的都是字节流；以“reader”“writer”结尾的都是字符流

  • 所有的流都实现了Java.io.Closeable接口，都有close()方法。流毕竟是一个管道，联通内存与硬盘，用完之后一定要关闭。

    • InputStream 字节输入流
    • OutputStream 字节输出流
    • Reader 字符输入流
    • Writer 字符输出流

  • 所有的输出流都是可刷新的，都有flush()方法。实现了java.io.Flushable接口。输出流在最终输出之后，一定记得flush()刷新，这个刷新表示管道当中剩余的数据强行输出完（清空管道），刷新的作用就是清空管道。
    在这里插入图片描述在这里插入图片描述

FileInputStream

输入流框架

在这里插入图片描述

package Advance.io;

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

/**
 * java.io.FileInputStream：
 * 		文件字节输入流，万能
 * 		构建输入流框架
 * */
public class FileInputStreamTest01 {
	public static void main(String[] args)  {
		//创建字节输入流对象
			//文件路径：E:\Javatest 里面有一个temp.txt文档
			//编译器会自动把 \ 变成 \\ ，因为java中 \ 表示转义
		
			//FileInputStream fis = new FileInputStream("E:\\Javatest\\temp.txt");  //处理异常
			
			/*  //处理异常
			try {
				FileInputStream fis = new FileInputStream("E:\\Javatest\\temp.txt");
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
			
			//关闭流：无论程序执行如何，最后程序都需要关闭——finally
			//将创建的流放到try，catch语句块外面
			FileInputStream fis  = null;
			try { 
				 fis = new FileInputStream("E:\\Javatest\\temp.txt");
				 
				 //读取信息
				 int readData = fis.read();	  //该方法是读取到的字节  读取到的字节本身 a的ASCII码
				 System.out.println(readData);		//读取该文档的第一个字节
				 
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {	//处理读取信息时的异常
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally {
				//finally语句块可以确保流一定关闭
				if(fis!=null) {   //关闭流的前提是：流不为空  ：避免空指针异常
					try {
						fis.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
			}
		}
	}
}

相对路径

  • 相对路径是从当前所在位置开始作为起点开始找。
  • 编译器的默认当前路径：工程Project是当前的根
    在这里插入图片描述在这里插入图片描述

读取过程详解

在这里插入图片描述

package Advance.io;

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

public class FileInputStreamTest03 {
	public static void main(String[] args) {
		//创建字节流
		//处理异常
		//关闭流
		FileInputStream fis =null;
		try {
			//设置相对路径 ：相对路径是从当前所在位置开始作为起点开始找
			//编译器的默认当前路径：工程Project是当前的根
			
			 fis = new FileInputStream("src/source/temp.txt");
			 
			 //读取信息: 采用byte数组 一次读取多个字节 最多读取数组.length个字节
			/*
			 * byte[] bytes = new byte[4];		//一次最多读取4个字节
			 *  int readCount = fis.read(bytes);   //读取到的字节数量，不是字节本身
			 System.out.println("第一次读取到的字节数——"+readCount);		//4
			 //此时内存的byte数组里面存有数据，转为String类型
			 //String(bytes);
			 System.out.println(new String(bytes));		//abcd
			 
			 readCount = fis.read(bytes);
			 System.out.println("第二次读取到的字节数——"+readCount);		//2
			 System.out.println(new String(bytes));		//efcd
			 //程序期望输出整个文件内容
			//byte数组转String，从下标0开始，到下标readCount结束
			 System.out.println(new String(bytes,0,readCount));		
			 
			 readCount = fis.read(bytes);
			 System.out.println("第三次读取到的字节数——"+readCount);		//-1
			 System.out.println(new String(bytes,0,readCount));		//没有内容
			 */
			 
			 //读取信息: 采用byte数组 一次读取多个字节 最多读取数组.length个字节
			 byte[] bytes = new byte[4];		//一次最多读取4个字节
			 int readCount =0;
			 while((readCount =fis.read(bytes))!=-1) {
				 System.out.print(new String(bytes,0,readCount));
			 }
			 
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(fis !=null) {		//流不为空，避免空指针异常
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
}

在这里插入图片描述

available()

  • int available(); 返回流当中剩余没有读到的字节数量
  • 当数据没有读取的时候，调用该方法，获得的是总字节数量，那么在建立byte数组时，可以设置数组长度来匹配文件字节数。但是这种方法不适合大的文件，因为byte数组不能太大。
package Advance.io;

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

/*
 * FileInputStream其他的常用方法
 * 		int available();   返回流当中剩余没有读到的字节数量
 * 		long skip(long n)； 跳过几个字节不读
 * 
 * */
public class FileInputStreamTest04 {
	public static void main(String[] args) {
		//创建流
		//处理异常
		//关闭流
		FileInputStream fis =null;
		try {
			fis = new FileInputStream("src/source/temp.txt");
			
			System.out.println("总字节数——"+fis.available());
			//读取信息 
			//读取一个字节
			int readByte = fis.read();
			//剩余多少字节
			System.out.println("剩下字节数——"+fis.available());
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(fis!=null) {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

skip(long n)

  • long skip(long n)； 跳过几个字节不读

FileOutputStream

  • 文件字节输出流，负责写数据

输入流框架

在这里插入图片描述

  • 在文件中写入字符串时，使用到字符串转byte方法：getBytes()；
    在这里插入图片描述
  • 在java编译器相对路径写入信息时，如果指定的文件不存在，系统会先新建一个文件，再进行写入。当写在根目录下时，发现目录栏没有新建该文件，此时刷新一下就可以。
    在这里插入图片描述

FileReader

  • 文件字符输入流：只能读取普通文本
  • 读取文本时，比较方便、快捷
  • FileReader使用的是char数组
package Advance.io;

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

public class FileReaderTest01 {
	public static void main(String[] args) {
		//创建字符流
		FileReader fr = null;
			try {
				fr= new FileReader("src/source/tempChar.txt");
				//读取信息
				char[] c = new char[4];	//一次读取4个字符
				int readCount =0;
				while((readCount=fr.read(c))!=-1) {
					//下面两行代码，输出结果一致。笔者没有弄懂
					//按理来说，如果最后一个数组存入的数据不满数组的长度，那么readCount 到之后的数组
					//之内存储的应该是上一次数组存储的元素
					//那么，输出c时，上一次的数组元素依旧会输出；但是输出从0到readcount的长度的数组则不会
					//但是这两行代码输出结果一样
					System.out.print(c);
					//System.out.print(new String(c,0,readCount));
				}
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}	finally {
				//关闭流
				if(fr !=null) {
					try {
						fr.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
	}
}

FileWriter

  • 字符输出流
    - 在FileOutputStream中，写信息时，需要进行String转换为byte类型，再将byte数组写进去。而在FileWriter中的writer方法可以直接接收字符串，方便程序的写入
    在这里插入图片描述

文件复制

  • 文件复制原理:想让文件从D盘移到C盘，需要利用内存作中介，内存一边从D盘读取，一边从C盘写出。
    在这里插入图片描述

FileInputStream 、FileOutputStream

在这里插入图片描述

package Advance.io;

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

//使用FileInputStream和FlieOutputStream完成文件的拷贝
	//拷贝的过程是一边读，一边写
public class Copy01 {
	public static void main(String[] args) {
		//创建流
		FileInputStream fis = null;
		FileOutputStream fos =null;
		
		//处理异常
		try {
			fis = new FileInputStream("H:\\temp.txt");
			fos= new FileOutputStream("E:\\temp.txt");
			
			//核心：边读边写
			byte[] bytes =new byte[1024*1024];	//1mb  一次最多拷贝1MB
			int readCount = 0;
			while((readCount=fis.read(bytes))!=-1) {
				fos.write(bytes,0,readCount);
			}
			
			//刷新
			fos.flush();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			//分开处理异常
			//一起处理，当一个异常，会影响另外一个关闭
			if(fis!=null) {
				try {
					fis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(fos!=null) {
				try {
					fos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
		}
	}
	}
}

FileReader 、FileWriter

package Advance.io;

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

/*
 * 使用FileReader、FileWriter进行拷贝
 * */
public class Copy02 {
	public static void main(String[] args) {
		//建立
		FileReader fr = null;
		FileWriter fw = null;
		
		try {
			fr =new FileReader("H:\\tempChar.txt");
			fw= new FileWriter("E:\\tempChar.txt");
			
			//复制
			int readCount =0;
			char[] c = new char[1024*512];		//char是两个字节 1MB
			while((readCount =fr.read(c))!=-1 ){
				fw.write(c,0,readCount);
			}
			//刷新
			fw.flush();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(fr!=null) {
				try {
					fr.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(fw!=null) {
				try {
					fw.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}	
	}
}

缓冲流

BufferedReader

  • 带有缓冲区的字符输入流
  • 使用这个流的时候不需要自定义char数组、byte数组。自带缓冲
  • 由于Buffered构造方法需要传入一个reader类型的参数，所以在创建Buffered时候，需要创建一个reader类型的参数，传入是参数对应的流属于结点流。当需要Buffered处理非Reader类型的数据时，需要采用格式转换，转换为reader类型的数据，再传入Buffered。
  • BufferReader优点：
    • 读取一行文字：readLine()；
      在这里插入图片描述在这里插入图片描述
package Advance.io;

import java.io.*;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.InputStreamReader;

public class BufferedReaderTest01 {
	public static void main(String[] args) throws Exception {
		
		FileReader reader =new FileReader("src/Advance/io/Copy02.java");
		//当一个流的构造方法需要一个流，那么传入的这个流称为节点流
		//外部负责包装的流：包装流、处理流
		//FileReader：节点流   ； BufferedReader ：处理流。
		BufferedReader br = new BufferedReader(reader);
		
		//读取信息
		//使用readLine 读取一行信息
		String s =null;
		while((s=br.readLine())!=null) {
			System.out.println(s);
		}
		
		
		//关闭流
		//对应包装流来说，只需要关闭最外层的流就可以，里面的结点流会自动关闭
		br.close();
	
		System.out.println("===============================");
		//BUfferReader需要传入一个Reader类型的参数
		//当需要传入的数据属于字节流时，需要使用转换
		FileInputStream fis = new FileInputStream("src/Advance/io/Copy01.java");
		//转换类型
		InputStreamReader isr= new InputStreamReader(fis);
		BufferedReader bfr = new BufferedReader(isr);
		
		//读取信息......
		
		bfr.close();
	}
}

数据专属流

DataOutputStream

  • 这个流可以将数据连同数据类型一并写入文件。该文件不是普通文档，使用记事本打不开。
    在这里插入图片描述

DataInputDtream

  • DataOutputStream写入的文件，只能使用DataInputDtream读取，并且读取的时候需要提前知道写入的顺序。读的顺序需要和写的顺序一致，才能正常的取出数据。加密!!
  • 在这里插入图片描述

标准输出流

在这里插入图片描述

日志框架log 输出方向

package Advance.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStreamTest01 {
	public static void main(String[] args) throws Exception {
		PrintStream ps =System.out;
		ps.print("hello world!");
		
		//标准输出流不需要手动关闭
		
		/**
		 * System类使用过的方法
		 * System.gc();		运行垃圾回收器。
		 *	System.currentTimeMillis()		 返回以毫秒为单位的当前时间。
		 *	System.exit(status);		终止当前正在运行的 Java 虚拟机。
		 *	System.arraycopy(src, srcPos, dest, destPos, length);	 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
		 * 
		 * */
		
		//标准输出流更改输出方向
		//标准输出流不再指向控制台，指向log文件
		PrintStream printStream = new PrintStream(new FileOutputStream("log"));
		//修改输出方向，输出方向修改为log文件
		System.setOut(printStream);			//重新分配“标准”输出流。
		System.out.println("hello world");
		System.out.println("hello java");
		
	}
}

File

  • File ：文件和目录路径名的抽象表达形式。
  • 一个File可能对应的是目录，也可能对应的是文件
  • File类和四大家族没有关系，所以File类不能完成文件的读和写
  • File常用方法：
    • File(String pathname） 构造方法： 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
    • boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
    • String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
    • String getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
    • File getParentFile() 返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
    • String getName() 返回由此抽象路径名表示的文件或目录的名称。
    • File[] listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
import java.io.File;

public class FileTest01 {
	public static void main(String[] args) throws Exception{
		//创建一个File对象
		File f1 = new File("E:\\Javatest\\file");
		
		//判断指定file是否存在
		System.out.println(f1.exists());
		
		//如果指定file不存在，
		if(!f1.exists()) {
				//以文件的形式创建出来
			//f1.createNewFile();
				//以目录形式创建出来
			f1.mkdir();
		}
		
		File f2 = new File("h:\\file");
		//获取文件的父路径
		String parentPath = f2.getParent();
		System.out.println(parentPath);
		
		//获取绝对路径
		System.out.println("获取的绝对路径——"+f2.getParentFile().getAbsolutePath());
		//获得文件名
		System.out.println("文件名"+f1.getName());
		
		//判断file是否是一个目录
		System.out.println(f1.isDirectory());
		
		//判断file是否是一个文件
		System.out.println(f1.isFile());
		
		//获得文件最后一次修改时间
		long haomiao = f1.lastModified();		//毫秒是从1970年到现在的总时间
			//转换日期
		Date time = new Date(haomiao);
			//日期格式话
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
		String strtime = sdf.format(time);
		System.out.println(strtime);
		
		//获取文件大小
		System.out.println(f1.length());
		
		//获取当前目录下的所有子文件
		File[] files = f1.listFiles();
		for(File f :files) {
			System.out.println(f);
		}
	}
}

目录拷贝

在这里插入图片描述

package homework;

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

/**
 * 将E:\Javatest文件夹的东西拷贝到H盘
 * 		FileInputStream 
 * 		FileOutputDtream
 *		File
 * */

public class FileCopy {
	public static void main(String[] args) {
		//拷贝源
		File srcFile = new File("E:\\Javatest\\file");
		//拷贝目标
		File desFile = new File("H:\\");	
		//调用方法拷贝
		copyDir(srcFile,desFile);
	}
	
	
	/**
	 * 拷贝目录方法
	 * @param srcFile ：拷贝源
	 * @param desFile	：拷贝目标
	 */
	private static void copyDir(File srcFile, File desFile) {
			//递归停止条件：如果是文件的话，递归结束
		if(srcFile.isFile()) {
			//确定是文件，进行拷贝：但是拷贝时是递归到了最后一层，将文件拷贝到其他盘时
			//也需要建立对应的路径
			//建立完路径之后，相当于在目的准备好了房子 ，下一步就是搬文件
						//FileInputStream FileOutputStream
						FileInputStream fs =null;
						FileOutputStream fos =null;
						try {
							fs =new FileInputStream(srcFile);
							//System.out.println("========"+desFile.getAbsolutePath()+srcFile.getAbsolutePath().substring(12));
							fos= new FileOutputStream(desFile.getAbsolutePath()+srcFile.getAbsolutePath().substring(12));
							
							//拷贝
							int readCount =0;
							byte[] bytes = new byte[1024*1024];
							while((readCount=fs.read(bytes))!=-1) {
								fos.write(bytes,0,readCount);
							}
							
							//刷新
							fos.flush();
						} catch (FileNotFoundException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}finally {
							if(fs!=null) {
								try {
									fs.close();
								} catch (IOException e) {
									// TODO Auto-generated catch block
									e.printStackTrace();
								}
							}
							if(fos!=null) {
								try {
									fos.close();
								} catch (IOException e) {
									// TODO Auto-generated catch block
									e.printStackTrace();
								}
							}
						}
						
			return;
		}
		//获取源下面的子目录
		File[] srcFiles = srcFile.listFiles();
		//System.out.println(srcFiles.length);
		
		
		for(File f : srcFiles) {	//取出源文件夹中的子文件			
								//如果File是文件夹的话，在目标目录新建对应目录
								if(f.isDirectory()) {
									//System.out.println("获取文件的绝对路径——"+f.getAbsoluteFile());
									//	E:\Javatest\file\a		源目录
									//	H:\file							目标目录
									//实际上，拷贝就是将目标文件夹放到目标地，那么拷贝完成后
									//新的拷贝后的路径，就是目标地+目标文件
									String srcDir = f.getAbsolutePath();
									//System.out.println(srcDir.substring(12));		//file\a  截取字符
									String desDir =desFile.getAbsolutePath()+srcDir.substring(12);
									System.out.println(desDir);
									
									//新建
									File newFile = new File(desDir);
									if(!newFile.exists()) {
										newFile.mkdirs();
									}
								}
			
			//递归
			copyDir(f,desFile);
		}
	}
}

对象流 ObjectOutputStream ObjectInputStream

  • 对象的序列化 反序列化 。
  • 参与序列化和反序列化的对象必须实现Serializable接口。否则出现NotSerializableException异常。Serializable接口只是一个标志接口，这个接口没有代码，起到了标识作用，java虚拟机看到这个类实现了这个接口之后，会为该类自动生成一个序列化版本号。
    在这里插入图片描述在这里插入图片描述
package Advance.io.bean;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectOutputStreamTest02 {
	public static void main(String[] args) throws Exception{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/source/students"));
		//反序列化 读
		Object obj = ois.readObject();
		
		//反序列化一个学生对象，调用学生对象的toString方法
		System.out.println(obj);
		
		ois.close();
	}
}
  • 当存储多个对象反序列话、序列话时，可以使用集合。
  • 当对于对象的某个属性，不希望它序列化、反序列化时，添加transient关键字
    在这里插入图片描述在这里插入图片描述
  • 在序列化一次之后【字节码文件】，再次对代码进行修改【生成新的字节码文件】，反序列化会出现异常——序列化版本号的作用！
    • 优点： java语言中进行类的区分时，先根据类名进行区分，如果类名一样，再依靠序列化版本号进行区分。——不同的开发人员编写的类名一致时、内容不同时，这时序列化版本号就发挥作用了，对于java虚拟机来说，当两个类都实现了Serialiable接口后，就具备了默认的版本号，两个同名类的版本号不一致，就可以区分出来。
    • 缺陷：自动化生成版本号，一旦代码确定生成版本号，不可更改。一旦修改，必定会重新编译，此时生成全新的序列化版本号，java虚拟机会认为是一个全新的类。
    • 最终建议：序列化版本号手写赋值，不建议自动生成
      在这里插入图片描述

IO、Properties

  • Io文件的读和写；Properties是一个map集合，Key和Value都是String类型，key重复时，会异常报错；不要写中文。
  • 当value对应的是类的路径是，采用点，而不是反斜杠。
  • 无需更改代码就可以获得动态信息。在编程时，经常更改的数据，可以单独写到一个文档中，使用程序动态读取，将来只需要更改这个文件的内容，java代码不需要更改，不需要重写编译，服务器也不需要重启，就可以拿到动态信息。类似于以上机制的文件被称为配置文件。
配置文件的格式为：
	key=value
	key=value
	这种配置文件被称为属性配置文件。
java中规范要求：属性配置文件建议以properties结尾，非强制要求。
在属性配置文件中，key重复时，会异常报错；使用“#”进行注释

在这里插入图片描述

今天论文也要改
关注
  • 8
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
面试官：请讲一讲IO流核心模块与基本原理是什么？
程序媛小琬的博客
08-20 980
前言 一、IO流与系统 IO技术在JDK中算是极其复杂的模块，其复杂的一个关键原因就是IO操作和系统内核的关联性，另外网络编程，文件管理都依赖IO技术，而且都是编程的难点，想要整体理解IO流，先从Linux操作系统开始。 Linux空间隔离 Linux使用是区分用户的，这个是基础常识，其底层也区分用户和内核两个模块： User space：用户空间 Kernel space：内核空间 常识用户空间的权限相对内核空间操作权限弱很多，这就涉及到用户与内核两个模块间的交互，此时部署在服务上的应用如果需要请求系
IO流——IO流概述
shengshanlaolin_的博客
10-20 254
IO流概述
java学习——IO流
最新发布
m0_73245690的博客
04-26 904
FileInputStream:文件输入流BufferedInputStream:缓冲字节输入流ObjectInputStream:对象字节输入流（类的继承关系）通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定通过使用文件描述符fdObj创建一个FileInputStream，该文件描述符表示到文件系统中的某个实际文件的现有连接。
IO流
qq_40318250的博客
07-25 86
目录： IO流 IO流概述及其分类 A:IO流概述 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中 java.io B:IO流分类 a:按照数据流向 站在内存角度 输入流 读入数据 输出流 写出数据 b:按照数据类型 字节流 可以读写任何类型的文件 比如音频 视频 文本文件 字符流 只能读写文本文件 什么...
IO流(概念,作用及体系结构)
tianhumanong的博客
04-17 3275
1. IO流的概念与作用 1.1 IO流是什么 I（Input）输入，O（Out）输出 1.2 IO流的作用 数据在各个设备之间的传输，是通过流的方式完成的 1.3 IO流分类 根据流动方向的不同，流分为输入流和输出流（相对于内存，输入和输出） 根据流的格式不同，流分为字节流和字符流 程序中的输入和输出都是以流的形式保存的，流中保存的实际上全是字节文件。 所有文件的存储都是字节（byte）来存储，在磁盘上保留的并不是文件的字符，而是先把字符编码成字节，再存储这些字节到硬..
Java中IO流详解
08-30
Java中IO流详解 Java中IO流详解是指Java语言中负责输入输出操作的类库，主要包括字节流和字符流两大类。下面将详细介绍Java中IO流的知识点。 一、IO解决的问题 IO流解决了设备之间的数据传输问题，例如硬盘和...
C#IO流详解
07-14
io流详解
java IO流详解
11-14
文档是关于JAVA常用IO流的学习笔记，可以用于参考，学习。
io流详解代码
05-17
这是第二部分的io流详解内容。包含图片和代码，还有视频。不方便传！
JavaSE文件IO流详解.pptx
06-08
JavaSE文件IO流详解
Java IO流详尽解析
键盘上舞动的青春
12-03 2234
流的概念和作用 学习Java IO，不得不提到的就是Java IO流。 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 IO流的分类        根据处理数据类型的不同分为：字符流和字节流        根据数据流向不同分为：输入流和输出流 字符流和字节
（Java笔记）IO流的六类16种流方式
张松的博客
04-26 3105
IO流的四大类16种流方式
Io流总结
a690439559的博客
06-13 112
IO 一串流动的数据 从数据源流动至目的地 以程序为中心 分类 流向 输入流 输出流 操作单元 字节流 字符流 功能 节点流(数据直接从数据源到目的地) 功能流(经过包装) close()方法需要后接入的先关闭 字节流(万能流) 字节...
IO流实例详解
吉祥龙龙的博客
04-02 1972
IO流一、IO流简介01.流的概念和作用流是一组有顺序的，有起点和终点的字节集合，是对数据传输的的总称或抽象。即数据在两设备之间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。02.Io流的分类根据处理数据类型的不同分为：字符流和字节流 字符流的由来：因为数据编码的不同，而有了对字符进行高效操作的对象。本质其实就是基于字节流读取时，去查了指定的码表。字...
什么是io流操作
xixisir的博客
04-08 999
IO流操作 一.什么是io流操作？ IO流操作中的读写操作不是我们平时所说读写看，而是将数据加载到硬盘中，我们叫IO流的写操作，即输入流，将硬盘加载出来，叫做IO流的读操作，即输出流。 流分类： IO流的分类 根据数据流动（站在内存的角度上来说分为不同的方向 输入流 输出流 根据数据的类型 字节流 字符流 二.python操作IO流 open函数即可 open函数主要的目的是打开一个本地的文件 ...
Java IO流学习总结一：输入输出流
weixin_34198881的博客
01-09 3965
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/54292148 本文出自【赵彦军的博客】 Java流类图结构： 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。...
（8）IO流技术
zl_StepByStep的博客
03-24 748
1.IO是什么意思？data source是什么意思？ IO：Input Output data source：数据流。   2.字节流和字符流有什么区别？输入流输出流有什么区别？     字节流和字符流是流的一种划分，按照处理流的数据单位进行的划分。两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入是使用InputStream；在字符流中输出主要是...
java io流详解
07-28
Java的IO流是用于处理输入和输出的机制。它提供了一种方便的方式来读取和写入数据，包括文件、网络连接和其他数据源。 Java的IO流分为输入流和输出流。输入流用于从数据源中读取数据，输出流用于将数据写入目标位置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值