java IO

最新推荐文章于 2023-06-06 18:01:13 发布
最新推荐文章于 2023-06-06 18:01:13 发布
阅读量140 收藏
点赞数
分类专栏： Java基础部分 文章标签： io 流 数据源
原创不易，仅限学习参考，转载请注明出处！更多资讯请移步【公众号：Java那些事儿】
本文链接：https://blog.csdn.net/qq_40414738/article/details/82154941
版权

目录

IO技术

1、基本概念

1.1、数据源

1.2、流的概念

1.3、四大IO抽象类

2、流

2.1、文件字节流

2.1.1、输入流（FileInputStream）

2.1.2、输出流（FileOutputStream）

2.1.3、拷贝

2.2、文件字符流

2.2.1、输入流（FileReader）

2.2.2、输出流

2.2.3

2.3、缓冲字节流

2.3.1、输入流（BufferedInputStream）

2.3.2、输出流（BufferedOutputStream）

2.4、缓冲字符流

2.4.1、输入流（BufferedReader）

2.4.2、输出流（BufferedWriter）

2.5、转换流

2.5.1、输入流（InputStreamReader）

2.5.2、输出流（OutputStreamWriter）

3、转码

3.1、乱码

3.1.1、编码和解码不同

3.1.2、长度丢失

IO技术

  • 1、基本概念

  • 1.1、数据源

data source. 提供原始数据的原始媒介。常见的：数据库、文件、其他程序、内存、网络连接、IO设备。数据源就像水箱，流就像水管中流着的水流，程序就是我们最终的用户。 流是一个抽象、动态的概念，是一连串连续动态的数据集合。

  • 1.2、流的概念

文件流:从一端流动到另一端，即从java内存流动到存储介质中。存储介质包括:硬盘文件、数据库与网络等节点(数据源)。记住:一切以java内存为中心。

  • 1.3、四大IO抽象类

      InputStream/OutputStream和Reader/writer类是所有IO流类的抽象父类，我们有必要简单了解一下这个四个抽象类的作用。然后，通过它们具体的子类熟悉相关的用法。

·InputStream

      此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。 数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类 。

      继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节(8 bit)。

      常用方法：

      int read()：读取一个字节的数据，并将字节的值作为int类型返回(0-255之间的一个值)。如果未读出字节则返回-1(返回值为-1表示读取结束)。

      void close()：关闭输入流对象，释放相关系统资源。

· OutputStream

      此抽象类是表示字节输出流的所有类的父类。输出流接收输出字节并将这些字节发送到某个目的地。

      常用方法：

      void write(int n)：向目的地中写入一个字节。

      void close()：关闭输出流对象，释放相关系统资源。

· Reader

      Reader用于读取的字符流抽象类，数据单位为字符。

      int read(): 读取一个字符的数据，并将字符的值作为int类型返回(0-65535之间的一个值，即Unicode值)。如果未读出字符则返回-1(返回值为-1表示读取结束)。

      void close() ： 关闭流对象，释放相关系统资源。

· Writer

      Writer用于写入的字符流抽象类，数据单位为字符。

      void write(int n)： 向输出流中写入一个字符。

      void close() ： 关闭输出流对象，释放相关系统资源。

  • 2、流

  • 2.1、文件字节流

  • 2.1.1、输入流（FileInputStream）

 *  单字节读取:
 * 
 * 输入流  InputStream 
 *     此抽象类是表示字节输入流的所有类的超类。
 *     read() 每次读入一个字节数据,返回读入的数据的int值
 * 
 * 每次都是读入一个字节的数据,效率慢
 * 
 * 批量读取:
 * 
 * 输入流  InputStream 
 *     解决每次只读入一个字节的问题  read()
 *  使用 int read(byte[] b) 
 *  从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。 
 *  读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。 

public class InputStreamDemo02 {
	public static void main(String[] args) {
		// 1.建立联系,只是联系
		File file = new File("d:/haha.txt");
		// 2.选择流 字节流输入
		InputStream in = null;
		try {
			in = new FileInputStream(file);
			//3.操作
			byte[] bt = new byte[3];
			while (in.read(bt) != -1) {
				System.out.println(new String(bt));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (in != null) {
				try {
					// 4.关闭
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

		}
	}
}

  • 2.1.2、输出流（FileOutputStream）

* 03.单字节写入:
 * 输出流  OutputStream 
 * 每次值输出一个数据  write(int) 
 * 每次只输出一个,不符合需求
 * 输入流  InputStream 
 * 
 * 04.批量写入:
 *     解决一次能够输出多个数据  write(byte[])
 * 注意:
 *             1.如果目标文件不存在,会自动为你创建
 *             2.如果目标文件夹不存在,不会为你自动创建,会抛异常找不到路径
 *             3.每次运行输出的内容会进行覆盖,如果想要追加,可以设置第二个参数,如果是true则追加,如果是false是覆盖,默认false

public class OutputStreamDemo03_04 {
	public static void main(String[] args) {
		// 1.建立联系
		File file = new File("D:/haha.txt");
		// 2.选择流 文件输出流
		OutputStream out = null;
		try {
			// 以追加形式写出文件 必须为true 否则会覆盖
			out = new FileOutputStream(file, true);
			// 3.操作
			String str = "王杰是真屌\r\n";
			// 字符转数组
			byte[] bt = str.getBytes();
			out.write(bt);
			// 强制刷出
			out.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//4.关闭
			try {
				if(out!=null){
					out.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

  • 2.1.3、拷贝

 * 文件拷贝
 * 		1.创建联系--源头,目的地
 * 		2.选择流--InputStream  OutputStream
 * 		3.读入,写出
 * 			while(len=is.read(car)!=-1){
 * 				os.write(car,0,len);
 * 			}
 * 		4.强制刷出
 * 		5.关闭管道
 */
public class CopyFile05 {

	public static void main(String[] args) {
		// File srcfile = new File("D:/haha.txt");
		// File destfile = new File("D:/hehe.txt");
		// FileUtil06.copyFile(srcfile, destfile);

		// 1.创建联系--数据源,目的地
		File srcfile = new File("D:/haha.txt");
		File destfile = new File("D:/hehe.txt");
		// 2.选择流--文件输入输出流

		InputStream is = null;
		OutputStream os = null;

		try {
			is = new FileInputStream(srcfile);
			os = new FileOutputStream(destfile);
			// 3.操作--读入
			byte[] bt = new byte[128];
			int len = 0;
			while ((len = is.read(bt)) != -1) {
				// 3.操作--写出
				os.write(bt, 0, len);
			}
			// 4.强制刷出
			os.flush();
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 5.先打开的后关闭
			try {
				if (os != null) {
					os.close();
				}
				if (is != null) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}
import java.io.*;

/*
 * 文件拷贝工具类
 */
public class FileUtil06 {
	/**
	 * @param srcfile
	 *            数据源字符串
	 * @param destfile
	 *            目的地字符串
	 */
	public static void copyFile(String srcfile, String destfile) {
		copyFile(srcfile, destfile);
	}

	/**
	 * @param srcfile
	 *            数据源对象
	 * @param destfile
	 *            目的地对象
	 */
	public static void copyFile(File srcfile, File destfile) {
		// 2.选择流
		InputStream is = null;
		OutputStream os = null;
		try {
			is = new FileInputStream(srcfile);
			os = new FileOutputStream(destfile, true);
			// 3.操作 读入
			// 字节数组
			byte[] car = new byte[1024];
			int len = 0; // 长度
			while ((len = is.read(car)) != -1) {
				os.write(car, 0, len);
			}
			// 4.刷出
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 5.先打开的后关闭
			try {
				if (os != null) {
					os.close();
				}
				if (is != null) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

  • 2.2、文件字符流

  • 2.2.1、输入流（FileReader）

/*
 * 字符输入流读入...
 */
public class ReaderDemo08 {
	public static void main(String[] args) {
		File file = new File("src/char.txt");
		Reader rd =null;
		try {
			rd= new FileReader(file);
			char[] ch = new char[1024];
			int len = 0;
			while((len=rd.read(ch))!=-1){
				System.out.println(new String(ch,0,len));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if (rd!=null) {
					rd.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

  • 2.2.2、输出流

* 使用字符输出流写出...
 *  byte[]  getBytes(String charsetName) 
            使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 
    void    getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
            将字符从此字符串复制到目标字符数组。

public class WriterDemo09 {
	public static void main(String[] args) {
		File file = new File("src/char.txt");
		Writer wt = null;
		try {
			wt=new FileWriter(file,true);
			String str = "qwertyuiio";
			//wt.write(str);
			char car[]=new char[1024];
			str.getChars(0, str.length(), car, 0);
			wt.write(car,0,str.length());
			wt.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//5.关闭
			try {
				if(wt!=null){
					wt.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

  • 2.2.3、拷贝

/*
 * 使用字符流做文件拷贝...
 */
public class CopyDemo10 {
	public static void main(String[] args) {
		//1.建立联系
		File src=new File("src/char.txt"); //数据源
		File dest=new File("src/copy.txt");  //目标
		//2.选择流
		Reader rd=null;
		Writer wr=null;
		try {
			rd=new FileReader(src);
			wr=new FileWriter(dest);
			//3.操作
			char[] car=new char[1024];
			int len=0;
			while((len=rd.read(car))!=-1){
				wr.write(car,0,len);
			}
			//强制刷出
			wr.flush();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			try {
				wr.close();
				rd.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//4.关闭
		
		
	}
}

  • 2.3、缓冲字节流

  • 2.3.1、输入流（BufferedInputStream）

  • 2.3.2、输出流（BufferedOutputStream）

     输入:BufferedInputStream
     输出:BufferedOutputStream
     没有新增方法,可以多态调用
     使用和InputSteam一样

public class BufferedI_OCopyDemo11 {
	public static void main(String[] args) {
		File src = new File("src/char.txt");
		File dest = new File("src/copy.txt");
		
		InputStream is = null;
		OutputStream os = null;
		try {
			is = new BufferedInputStream(new FileInputStream(src));
			os = new BufferedOutputStream(new FileOutputStream(dest));
			int len=0;
			byte bt[]=new byte[1024];
			while((len=is.read(bt))!=-1){
				os.write(bt, 0, len);
			}
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(os!=null){
					os.close();
				}
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

  • 2.4、缓冲字符流

  • 2.4.1、输入流（BufferedReader）

  • 2.4.2、输出流（BufferedWriter）

 字符缓冲流:
         输入:BufferedReader
              新增:
                  readLine()读取一行,返回读取到的字符串,否则返回false
                  newLine()写入一个行分隔符
          输出:BufferedWriter
      有新增方法,多态调用对子类新增方法不可见.

public class BufferedR_WCopyDemo12 {
	public static void main(String[] args) {
		// 1,建立联系
		File src = new File("src/copy.txt");
		File dest = new File("src/newchar.txt");
		// 2.流
		BufferedReader is = null;
		BufferedWriter os = null;
		try {
			is = new BufferedReader(new FileReader(src));
			os = new BufferedWriter(new FileWriter(dest, true));
			// 3.操作
			int len = 0;
			// 新增方法
			// String mes=null;
			// os.newLine();
			// while((mes=is.readLine())!=null){
			// os.write(mes);
			// }
			char[] by = new char[1024];
			while ((len = is.read(by)) != -1) {
				os.write(by, 0, len);
			}
			// 4.强制刷出
			os.flush();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				// 关闭
				if (os != null) {
					os.close();
				}
				if (is != null) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

  • 2.5、转换流

  • 2.5.1、输入流（InputStreamReader）

  • 2.5.2、输出流（OutputStreamWriter）

 * 字符转换流:（字节流转成字符流）
 *     InputStreamReader(InputStream,charset)---Reader
 *     OutputStreamWriter(OutputStream,charset)---Writer

public class ConvertCopyDemo14 {
	public static void main(String[] args) {
		// 建立联系
		File src = new File("src/newchar.txt");
		File dest = new File("src/copy.txt");
		// 选择流
		BufferedReader rd = null;
		BufferedWriter wt = null;
		try {
			rd = new BufferedReader(new InputStreamReader(
					new BufferedInputStream(new FileInputStream(src)), "utf-8"));
			wt = new BufferedWriter(new OutputStreamWriter(
					new BufferedOutputStream(new FileOutputStream(dest)),
					"utf-8"));
			// 操作
			String msg = null;
			while ((msg = rd.readLine()) != null) {
				wt.write(msg);
			}
			//wt.write(rd.readLine());
			// 强制刷出
			wt.flush();
		} catch (UnsupportedEncodingException | FileNotFoundException e) {
			System.out.println("456465");
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (rd != null) {
					rd.close();
				}
				if (wt != null) {
					wt.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

  • 3、转码

  • 3.1、乱码

  • 3.1.1、编码和解码不同

  • 3.1.2、长度丢失

public class ConvertDemo13 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		// 编码
		String s = "中国";
		// 解码
		byte[] bt = s.getBytes();
		System.out.println(new String(bt));// 默认以工作空间的编码格式为准
		System.out.println(new String(bt, "gbk"));// 默认以工作空间的编码格式为准
		/*
		 * ISO8859-1 1个字节 UTF-8 3个字节 gbk 2个字节 gb2312 2个字节
		 */
		System.out.println(s.getBytes("ISO8859-1").length);
		System.out.println(s.getBytes("UTF-8").length);
		System.out.println(s.getBytes("gbk").length);
		System.out.println(s.getBytes("gb2312").length);

		// 长度丢失
		System.out.println(new String(bt, 0, 4));
	}
}

 

一只蚊子啊
关注
专栏目录
Java IO - 分类
Liarboy
09-20 2466
IO：输入/输出（Input/Output）流：是一个种抽象的概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输。IO中的流就相当与我们日常生活中的管道,我们通过管道来把水引到用户,通过管道把石油输送到大罐.同样,我们利用流来从硬盘的文件中读数据到你的程序中,利用流来写数据到硬盘的文件IO流就是用来处理设备间数据传输问题的常见的应用：文件复制；文件上传；文件下载。
JAVA IO模型
RenTouZhuNao的博客
01-23 1998
JAVA IO模型常见的IO模型有：阻塞IO模型、非阻塞IO模型、多路复用IO模型、信号驱动IO模型、异步IO模型。
java 图片的上传总结
虫逗蚊子的博客
09-19 615
jsp中上传图片，整理别人的文章，自己测试后又加入了其他方法 需求:前台选择图片，页面显示上传后的图片地址 代码一(方法1): form 提交,获取不了返回值，会刷新页面                              图片：                                     代码一(方法2):ajaxUploadI
Java IO详解
liwangcuihua的博客
06-06 7474
IO即Input和Output，即输入和输出。这里的输入和输出都是相对于内存来说的。
Java IO RandomAccessFile
WYSCODER的博客
03-15 4625
Java IO RandomAccessFile详解~~~
Java io流文件读取和写入
lxwfly的博客
07-10 7242
Java io 流操作demo类 1.读取操作 /** *@author lxw *@date 2020/6/24 *@desc 获取文件输入流，这里读入内存中 *@param [fileName] *@return byte[] **/ public byte[] readPdfFile(String fileName) throws Exception{ InputStream in = null;
Java IO流学习总结一：输入输出流
热门推荐
赵彦军
01-09 6万+
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构：流的概念和作用流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直
Java IO体系架构图
david's Blog
09-15 4387
Java的核心库java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。
Java IO流关闭顺序
u014644574的博客
11-28 2481
总结：包装流的关闭其实是引用关闭，是调用被包装流的关闭方法。不论关闭包装流或者被包装流都可以。也就是以下代码只关闭fos.close();就可以了。 如果你不放心，先关闭包装流fos.close()，再关闭被包装流fos.close(); public static void main(String[] args) throws IOException { FileOutputStream fos = new FileOutputStream("d:\\a.txt"); .
Java IO 流操作详解
BXA
05-27 1944
Java IO流提供了一种可以对数据进行输入输出的机制。可以把它比作是一条河流从源头流向目标地，由源文件输入到程序再由程序输出到目标文件。IO即Input/Output顾名思义就是数据的输入输出，在Java中指的是java.io包中的类库，提供了一系列操作数据输入与输出的类和接口。Java NIO（New IO）是JDK1.4引入的新的IO API，能够以更高效的方式进行文件、网络读写等各种I/O操作。
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
java-io-guide:Java中的Java IO（输入和输出流）指南
04-29
这是Java中文件处理的完整指南。 本指南的源代码在我们的本地开发环境中经过了很好的测试，并使用了静态代码分析器工具SonatLint ， PMD等对代码进行了分析。本指南的源代码无缺陷，并使用JDK 8进行编译和执行。 ...
JavaIO总结
05-08
有关Java输入输出流的总结有关Java输入输出流的总结有关Java输入输出流的总结
Java IO与NIO：深入理解与实践指南
最新发布
10-29
Java IO和NIO提供了两种不同的I/O处理方式，各有优势和适用场景。IO适用于简单的I/O操作，而NIO则适合于需要高性能和高并发的应用。了解这两种I/O处理方式的区别和特点，可以帮助开发者根据具体的应用需求选择合适的...
java IO教程，java IO教程，java IO教程
04-07
java IO教程，java IO教程，java IO教程，java IO教程java IO教程java IO教程java IO教程java IO教程，java IO教程java IO教程java IO教程java IO教程java IO教程，java IO教程，java IO教程，java IO教程，java IO...
container，Collection接口，Iterator接口，list接口，set接口
一只蚊子学Java
08-26 556
目录 1. 容器(container) 容器 概念 使用数组手写简单容器 泛型<> 为什么需要泛型 泛型的好处 2. Collection接口 collection遍历 List接口 ArrayList ArrayList存储对象 LinkedList Vector与Stack 三者比较 Set接口 HashSet T...
数组及选择，冒泡排序（动态演示图）
一只蚊子学Java
08-24 485
一维数组 * 数组 * 相同类型数据的有序集合 * * 数组:存储多个数据 * 变量:一个数据 * * 注意: * 1.数组是定长的 * 2.数组中数据类型是统一的 * 3.数组是有序的,每个数据都有一个下标值(索引),索引都是唯一的 * 3.数组是一个对象 * * 数组的索引|下标 * 下标从0开始,最后...
map接口
一只蚊子学Java
08-28 450
目录 1. Comparable类 1.1 重写compareTo 1.2 内部比较器 2. Map接口 2.1 HashMap实现类 2.1.1 遍历 2.1.2 练习:统计单词出现的次数 2.2 TreeMap实现类 2.3 HashTable实现类 2.3.1 Properties 3. Collections工具类 3.1 定义 3.2 方法 4. IO 4....
反射，枚举
一只蚊子学Java
08-31 325
目录 1. io 1.1 字节数组流 1.1.1 输入流 1.1.2 输出流 1.1.3 拷贝 1.2 数据流 1.2.1 输入流 1.2.2 输出流 1.2.3 拷贝 1.3 对象流 1.3.1 序列化输出流 1.3.2 反序列化输入流 2. 反射(reflection) 2.1 获取对象 2.2 获取构造器 2.3 获取属性(字段) 2.4获取方法 2.5...
Java IO流试题与解析
"此资源主要涵盖了Java IO相关的习题，包括选择题，涉及到了不同类型的流在读写操作中的应用，以及File类的一些基本操作。" Java IO是Java平台中的核心部分，它允许程序进行输入输出操作。在Java中，IO流被设计用来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值