IO流

最新推荐文章于 2023-06-11 20:05:01 发布
最新推荐文章于 2023-06-11 20:05:01 发布
阅读量557 收藏 1
点赞数
分类专栏： java学习总结 文章标签： java io流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013479321/article/details/19845473
版权


IO流

1：File
  (1)File:由于数据在硬盘上最常见的方式，就是文件，所以文件本身有很多的属性，那么，java为了方便我们对文件进行操


  作，就提供了File类供我们使用。
File既可以表示文件，也可以表示文件夹(目录)。
  (2)构造方法：

File(String pathname)根据指定的路径创建File对象。
	File(String parent, String child)根据指定的父文件夹和子文件或者文件夹创建File对象
	File(File parent,String child)根据指定的父文件夹对象和子文件或者文件夹创建File对象。
	Example:
		// 方式1
		File file = new File("d:\\a.txt");
		File file2 = new File("d:\\aaa");

		// 方式2
		File file3 = new File("d:\\", "a.txt");
		File file4 = new File("d:\\", "aaa");

		// 方式3
		File file5 = new File("d:\\");
		File file6 = new File(file5, "a.txt");
		File file7 = new File(file5, "aaa");


创建功能
创建文件：public boolean createNewFile()如果指定文件不存在，就创建，如果存在，就不创建。
创建文件夹：public boolean mkdir() 创建指定目录，如果存在就创建
    public boolean mkdirs()创建指定目录，如果存在，就不创建，如果父目录不存在，他也会自动创建。
Example:

</pre><pre code_snippet_id="202948" snippet_file_name="blog_20140224_3_1479098" name="code" class="java">		public boolean delete()即可以删除文件，也可以删除文件夹，取决于使用的对象。
	Example:
		//删除文件
		File file = new File("a.txt");
		System.out.println("delete:" + file.delete()
		//删除文件夹
		File file2 = new File("aaa");
		System.out.println("delete:" + file2.delete());
		
	判断功能：
		boolean exists():判断file对象是否存在。
		boolean isFile():判断file对象是否是文件。
		boolean isDirectory():判断file对像是否是文件夹
		boolean isAbsolute()：判断file对象是否是绝对路径
		boolean canRead():判断file对象是否可读
		boolean canWrite():判断file对象是否可写
		boolean isHidden():判断服了对象是否隐藏
	Example:
		File file = new File("a.txt");


		System.out.println("exists:" + file.exists());// true
		System.out.println("isFile:" + file.isFile());// true
		System.out.println("isDirectory:" + file.isDirectory());// false
		System.out.println("isAbsolute:" + file.isAbsolute());// false
		System.out.println("canRead:" + file.canRead());// true
		System.out.println("canWrite:" + file.canWrite());// true
		System.out.println("isHidden:" + file.isHidden());// false
	获取功能：
		String getAbsolutepath():获取绝对路径
		String getPath()获取相对路径
		String getName():获取文件名称
		long length()文件大小，单位是字节
		long lastModified()上次修改时间的毫秒值
	Example 
		File file = new File("bbb\\ccc\\a.txt");


		System.out.println("getAbsolutePath:" + file.getAbsolutePath());
		System.out.println("getPath:" + file.getPath());
		System.out.println("getName:" + file.getName());
		System.out.println("length:" + file.length());
		System.out.println("lastModified:" + file.lastModified());


		Date d = new Date(file.lastModified());
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println(sdf.format(d));
  (3)成员方法
	获取功能：
		public static File[] listRoots():列出可用的系统根目录
		public String[] list():返回的是指定目录下所有文件或者文件夹的名称数组
	        public File[] listFiles():返回的是指定目录下所有文件或者文件夹对象数组
	Example:
		 File[] rootArray = File.listRoots();
		 for (File root : rootArray) {
		 System.out.println(root);
		 }


		// 创建对象
		File file = new File("d:\\");
		 String[] strArray = file.list();
		 for (String str : strArray) {
		 System.out.println(str);
		 }


		File[] fileArray = file.listFiles();
		for (File f : fileArray) {
			System.out.println(f.getName());
		}


Example；
 需求：获取指定目录下所有.mp4文件的名称。
  方式1


  思路：
  A:封装指定目录
  B:获取指定目录下所有文件或者文件夹File数组
  C:遍历File数组，获取得到每一个File对象
  D:判断该对象是否是否文件
  E:判断该对象的后缀名是否是.mp4,是否以.mp4结尾。 

import java.io.File;
public class FileTest {
	public static void main(String[] args) {
		// 封装指定目录
		File f = new File("d:\\");

		// 获取指定目录下所有文件或者文件夹File数组
		File[] fileArray = f.listFiles();

		// 遍历File数组，获取得到每一个File对象
		for (File file : fileArray) {
			// 判断该对象是否是否文件
			if (file.isFile()) {
				// 判断该对象的后缀名是否是.mp4,是否以.mp4结尾。
				String name = file.getName();
				if (name.endsWith(".mp4")) {
					System.out.println(name);
				}
			}
		}
方式2 
package cn.itcast_01;

import java.io.File;
import java.io.FilenameFilter;

/*
 * 获取指定目录下指定后缀的文件名称：
 * A:先获取指定目录下所有文件或者文件夹的File数组,然后再遍历的时候进行判断。满足条件的就输出该File的名称。
 * B:直接获取指定目录下满足条件的String(File)数组。然后遍历数组即可。
 * 
 * 文件名称过滤器：FilenameFilter
 * 		public String[] list(FilenameFilter filter)
 */
public class FileDemo {
	public static void main(String[] args) {
		// 封装目录
		File file = new File("d:\\");

		// 获取满足条件的数组
		String[] strArray = file.list(new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				// 判断是否是文件，是否是以.mp4结尾
				// System.out.println(dir + "---" + name);
				File file = new File(dir, name); // d:\我的文档
				boolean flag = file.isFile();
				boolean flag2 = name.endsWith(".mp4");
				return flag && flag2;
			}
		});

		// 遍历字符串数组
		for (String str : strArray) {
			System.out.println(str);
		}
	}
}
2:递归
(1)方法定义中调用方法本身的现象。
举例：老和尚给小和尚讲故事。
生活中举例：
老和尚给小和尚讲故事，故事是：从前有座山，山里有座庙，庙里有个老和尚
老和尚给小和尚讲故事，故事是：从前有座山，山里有座庙，庙里有个老和尚
老和尚给小和尚讲故事，故事是：从前有座山，山里有座庙，庙里有个老和尚
老和尚给小和尚讲故事，故事是：从前有座山，山里有座庙，庙里有个


老和尚
(2)递归的注意事项：
A:一定要有出口，否则死递归。
B:次数不能过多，否则内存溢出。


构造方法不能递归调用。
(3)案例：
A:递归求数列第二十项
/*
 * 用递归求下列数列的第二十项的值：
 * 1,1,2,4,7,13...
 */ 
public class DiGuiTest {
	public static void main(String[] args) {
		System.out.println(fun(20));
	}

	public static int fun(int n) {
		if (n == 1 || n == 2) {
			return 1;
		} else if (n == 3) {
			return 2;
		} else {
			return fun(n - 1) + fun(n - 2) + fun(n - 3);
		}
	}
}
B:递归遍历指定目录的文件绝对路径 

import java.io.File;

/*
 * 需求：在控制台输出D:\\sfc\\java 所有的java文件的绝对路径。
 * 
 * 思路：
 * 		A:封装目录 D:\\sfc\\java
 * 		B:获取该目录下的所有文件或者文件夹的File[]数组。
 * 		C:遍历File[]数组，获取到每一个File对象
 * 		D:判断该File对数是否是
 * 			目录：返回B。(递归)
 * 			不是目录：
 * 				判断是否java结尾。
 * 					是：输出路径。
 */
public class ShowFileName {
	public static void main(String[] args) {
		// 封装目录 D:\\sfc\\java
		File file = new File("D:\\sfc\\java");

		showFiles(file);
	}

	private static void showFiles(File file) {
		// 获取该目录下的所有文件或者文件夹的File[]数组。
		File[] fileArray = file.listFiles();

		// 遍历File[]数组，获取到每一个File对象
		for (File f : fileArray) {
			// 判断该File对数是否是目录
			if (f.isDirectory()) {
				showFiles(f);
			} else {
				// 文件
				if (f.getName().endsWith(".java")) {
					System.out.println(f.getAbsolutePath());
				}
			}
		}
	}
}
C:递归删除带内容的目录 
import java.io.File;

/*
 * 需求：删除指定的目录。(目录是带有目录或者文件的)
 * 思路：
 * 		A:封装目录
 *		B:获取该目录下的所有文件或者文件夹的File[]数组。
 * 		C:遍历File[]数组，获取到每一个File对象
 * 		D:判断该File对数是否是
 * 			目录：返回B。(递归)
 * 			不是目录：
 * 				删除文件
 */
public class DeleteFile {
	public static void main(String[] args) {
		File file = new File("test");
		deleteFiles(file);
	}

	private static void deleteFiles(File file) {
		File[] fileArray = file.listFiles();
		if (fileArray != null) {
			for (File f : fileArray) {
				if (f.isDirectory()) {
					deleteFiles(f);
				} else {
					System.out.println(f.getName() + "***" + f.delete());
				}
			}
			// 如果for循环结束，就表示目录下的文件被删除完毕。
			System.out.println(file.getName() + "***" + file.delete());
		}
	}
}
IO
(1)分类
字节流：
输入流：
InputStream
int read()
int read(byte[] bys)
FileInputStream
BufferedInputStream
输出流：
OutputStream
write(int by)
write(byte[] bys,int index,int len)
FileOutputStream
BufferedOutputStream


字符流：
输入流：
Reader
int read()
int read(char[] chs)
FileReader
BufferedReader
String readLine()
输出流：
Writer
write(int ch)
write(char[] chs,int index,int len)
FileWriter
BufferedWriter
write(String line)
void newLine()
(2)到底使用谁?
用记事本打开能读懂的，就用字符流。
否则，用字节流。
如果你根本就不知道，用字节流。

(3)FileWriter写入数据
步骤：
A:创建字符输出流对象
B:调用写入数据方法，并刷新缓冲区
C:释放资源


代码体现： 

FileWriter fw = new FileWriter("a.txt");

			fw.write("hello,io");
			fw.flush();

			fw.close();
问题?
A:创建字符输出流对象做了几件事情?
A:调用系统功能创建了文件
B:创建字符输出流对象 
C:把字符输出流对象指向创建的文件
B:写数据完毕后，为什么要刷新?
件数据底层单位是字节，而我们现在是字符，所以它不能直接把数据写入文件。 把字符输出存储到


缓冲区里面。
 
C:为什么要close()?
1:让流对象变成垃圾。
2：通知系统去释放和文件相关的资源
D:flush()和close()的区别?
flush():只刷新缓冲区，流对象还可以继续使用。
  close():先刷新缓冲区，再关闭流对象。流对象不可以继续被使用
E:怎么实现数据换行?
不同的操作系统，对换行符的要求不一样：
windows:\r\n
  linux:\n
  mac:\r
F:怎么实现数据追加写入?
构造的时候，用带两个参数的。
  public FileWriter(String fileName,boolean append)


(3)FileReader读取数据
步骤：
A:创建字符输入流对象
B:调用读取数据方法，并显示
C:释放资源


代码体现： 

<span style="white-space:pre">			</span>FileReader fr = new FileReader("a.txt");
			
			//方式1
			//一次读取一个字符
			int ch = 0;
			while((ch=fr.read())!=-1)
			{
				System.out.print((char)ch);
			}

			//方式2
			//一次读取一个字符数组
			char[] chs = new char[1024];
			int len = 0;
			while((len=fr.read(chs))!=-1)
			{
				System.out.print(new String(chs,0,len));
			}
(4)转换流
1:如果有字节流对象，为了使用字符流的功能，就必须使用转换流进行操作。
2:案例：
键盘录入数据 
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferddWriter bw = new BufferedWriter(new FileWriter("a.txt"));

		String line = null
		while((line=br.readLine())!=null)
		{
			if("over".equals(line))
			{
				break;
			}

			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();
把文本文件的数据通过流对象在控制台显示 

BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		BufferddWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

		String line = null
		while((line=br.readLine())!=null)
		{
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();
(5)打印流
1:打印流是写数据的。
2:特点：
A:可以写任意数据类型的数据
B:如果启动了自动刷新，能自动刷新，还会换行。println()
C:可以直接往文件写数据
注意：哪些流对象可以直接读写文件?
看构造方法，如果同时有String和File的构造参数，那么该流对象就可以读写文件。
3:用打印流改进复制文本文件的操作
数据源：
c:\\a.txt
目的地：
d:\\b.txt 

<span style="white-space:pre">		</span>BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
		PrintWriter pw = new PrintWriter(new FileWriter("d:\\b.txt"),true);

		String line = null;
		while((line=br.readLine())!=null)
		{
			pw.println(line);
		}

		pw.close();
		br.close();
(6)序列化流(理解)
1:序列化：把对象按照流一样的方式在网络中传输，或者存储到文本文件
   反序列化：把流数据还原成对象
2:如何实现序列化?
A:被序列化的对象所属的类必须实现序列化接口
B:用序列化流对象进行操作
3:序列化(对象)流对象
ObjectInputStream:
Object readObject()
ObjectOutputStream:
void writeObject(Object obj)
4:掌握：
A:看到类实现了序列化接口，就知道该类可以被序列化流对象操作
B:看到类实现了序列化接口，知道点击鼠标就可以解决黄色警告问题
4：Properties
(1)是Map体系一个集合类。
(2)特点：
A:可以把集合中的数据保存到文本文件，也可以把文本文件的数据加载到集合中。
B:该集合的键和值都是String类型
(3)特殊功能：
A:setProperty(String key,String value)
B:getProperty(String key)
 getProperty(String key,String defaultValue)
C:Set<String> stringPropertyNames()
(4)和IO流结合的方法：
A:list 通过打印流把数据保存到文件中
B:load 通过任意流把文本中的数据加载到集合中
C:store 通过任意流把数据保存到文件中
(5)案例：
查找文件中是否有键为lisi的，如果有，则修改其值为50


5：字符编码(理解)
(1)编码表：
就是字符和对应的数据组成的一张表。
(2)常见的编码表：
ASCII
ISO-8859-1
GBK
GB2310
GB18030
UTF-8
BIG5
(3)转换流中的编码问题
A:字符流 = 字节流+编码表
B:通过转换流写入数据，指定为UTF-8编码，并通过UTF-8编码读取。


()案例：
复制文本文件 9种方式体现
数据源：c:\\a.txt
目的地：d:\\b.txt
方式1 

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

public class CopyFile1 {
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileReader fr=new FileReader("c:\\a.txt");
	
	FileWriter fw=new FileWriter("d:\\b.txt");
	int ch=0;
	while((ch=fr.read())!=-1){
		fw.write(ch);
		fw.flush();
	}
	fw.close();
	fr.close();
	}
}
方式2 

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

public class CopyFile2{
	public static void main(String[] args) throws IOException {
		
	FileReader fr=new FileReader("d:\\a.txt");
	FileWriter fw=new FileWriter("e:\\b.txt");
	char[] chs=new char[1024];
	int len=0;
	while((len=fr.read(chs))!=-1){
		fw.write(chs, 0, len);
		
	}
	fw.close();
	fr.close();
方式3 

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

public class CopyFile3 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis=new FileInputStream("d:\\a.txt");
		FileOutputStream fos=new FileOutputStream("e:\\b.txt");
		int by=0;
		while((by = fis.read()) != -1) {
			fos.write(by);
		}
		fos.close();
		fis.close();
		
		
	}

}
方式4 用字节流--一次一个字节数组 

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


public class CopyFile4 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis=new FileInputStream("d:\\a.txt");
		FileOutputStream fos=new FileOutputStream("e:\\b.txt");
		byte[] bys=new byte[1024];
		int len=0;
		while((fis.read(bys))!=-1){
			fos.write(bys, 0, len);
		}
		fos.close();
		fis.close();
	}


}

方式5用字符流--一次一个字 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFile5 {
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new FileReader("d:\\a.txt"));
		BufferedWriter bw=new BufferedWriter(new FileWriter("e:\\b.txt"));
		 int ch = 0;
		 while ((ch = br.read()) != -1) {
		 bw.write(ch);
		 bw.flush();
		 }
		 br.close();
	}

}
方式6 用字节流--一次一个字节数组 

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

import java.io.IOException;

public class CopyFile6 {
	public static void main(String[] args) throws IOException {
		BufferedInputStream bis=new BufferedInputStream(new  FileInputStream("d:\\a.txt"));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("e:\\b.txt"));
		byte[] bys = new byte[1024];
		int len = 0;
		while((len=bis.read(bys))!=-1)
		{
			bos.write(bys,0,len);
		}

		bos.close();
		bis.close();
}
	}
方式7 
import java.io.IOException;

public class CopyFile7 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("d:\\a.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\b.txt"));

		String line = null;
		while((line=br.readLine())!=null)
		{
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();

	}

}
方式8 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFile8 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("d:\\a.txt"));
		 BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\b.txt"));
		char[] chs=new char[1024];
		int len=0;
		while((len=br.read(chs))!=-1){
			bw.write(chs, 0, len);
			
		}
		br.close();
		bw.close();
方式9 

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyFile9 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("d:\\a.txt"));
		 BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\b.txt"));
		 int by=0;
			while((by = br.read()) != -1) {
				bw.write(by);
			}
			
		br.close();
		bw.close();
}
}
4：复制图片 4种方式体现
数据源：c:\\a.jpg
目的地：d:\\b.jpg 

<span style="white-space:pre">	</span>public class CopyImage {
	public static void main(String[] args) throws IOException {
		// method1();
		method2();
	}

	// 用字节流--一次一个字节数组
	private static void method2() throws IOException {
		// 封装数据源和目的地
		FileInputStream fis = new FileInputStream("mn.jpg");
		FileOutputStream fos = new FileOutputStream("d:\\mn.jpg", true);

		// 读写
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			fos.write(bys, 0, len);
		}

		// 释放资源
		fos.close();
		fis.close();
	}
// 用字符流--一次一个字符 
<span style="white-space:pre">		</span>private static void method1() throws IOException {
		// 封装数据源和目的地
		FileReader fr = new FileReader("mn.jpg");
		FileWriter fw = new FileWriter("d:\\mn.jpg");

		// 基本读写
		int ch = 0;
		while ((ch = fr.read()) != -1) {
			fw.write(ch);
			// fw.flush();
		}

		// 释放资源
		fw.close();
		fr.close();
	}

}
//用字符流--一次一个字节 

<span style="white-space:pre">		</span>FileInputStream fis=new FileInputStream("mn.jpg");
		FileOutputStream fos=new FileOutputStream("d:\\mn.jpg");
		int by=0;
		while((by = fis.read()) != -1) {
			fos.write(by);
		}
		fos.close();
		fis.close();
用字符流--一次一个字符数组 
private static void method3() throws IOException {
FileReader fr=new FileReader("d:\\a.txt");
	FileWriter fw=new FileWriter("e:\\b.txt");
	char[] chs=new char[1024];
	int len=0;
	while((len=fr.read(chs))!=-1){
		fw.write(chs, 0, len);
		
	}
	fw.close();
	fr.close();

}


5：复制单级文件夹 

public class CopyFolder {
	public static void main(String[] args) throws IOException {
		// 封装d:\\java这个目录
		File srcFile = new File("d:\\java");

		// 获取该目录所有满足条件的File[]数组。
		File[] fileArray = srcFile.listFiles(new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				return new File(dir, name).isFile() && name.endsWith(".java");
			}
		});
		
		//判断是否存在目的地目录，如果没有，就创建。
		File destFile = new File("d:\\jad");
		if(!destFile.exists()){
			destFile.mkdir();
		}

		// 遍历File[]数组，获取到每一个File。
		for (File file : fileArray) {
			// file	--	d:\\java\\Constant.java	--	数据源
			//最终的结果：	d:\\jad\\Constant.jad	--	目的地
			String name = file.getName(); //Constant.java
			String newName = name.replace(".java", ".jad");//Constant.jad
			File newFile = new File(destFile,newName);//d:\\jad\\Constant.jad
			
			//复制文件
			BufferedReader br = new BufferedReader(new FileReader(file));
			BufferedWriter bw = new BufferedWriter(new FileWriter(newFile));
			
			String line = null;
			while((line=br.readLine())!=null){
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
			
			bw.close();
			br.close();
		}
	}
}

s翱翔c
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的IO流
12-22
一、 什么是IO流 一般情况下是按照当前程序使用的内存为参照物来考虑数据的走向问题。 以文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取数据到内存 input 看视频，缓冲 使用缓冲可以让用户体验提高，相对...
java IO流
热门推荐
D大调奏鸣曲_第七序章_de博客
11-11 7万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
io流
qq_40977337的博客
05-09 3025
IO流 java.io包 1.什么是流？ io流就是java中运输数据的一种载体 它能够把数据从一个地方运输到另一个地方 2.流的分类 a 根据流运输数据的方向<以内存为参考物> 输入流 输出流 b 根据数据传输时转换的类型 字节流 byte 字符流 char ...
Java io流 详解
m0_68987535的博客
06-11 3989
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
IO流的分类
小白学编程
05-11 1万+
IO流的分类可以分为以下三种： 第一种：输入流和输出流 按照流的流向来分，可以分为输入流和输出流。输入，输出都是从程序运行所在内存的角度来划分的。 输入流：只能从中读取数据，而不能向其写入数据，由InputStream和Reader作为基类。 输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为基类 第二种：字节流和字符流 字节流和字符流的用法几乎完全一样，区...
java IO流详细笔记
07-12
Java IO流详解
IO流中关闭和刷新的区别
01-20
IO流中关闭和刷新的区别 因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中，但是关闭的流对象，是无法继续写出数据的，如果我们既想写出数据，又想继续使用流，就需要使用flush方法了 flush ： 刷新...
Java IO流 文件传输基础
09-02
主要介绍了Java IO流 文件传输基础的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下
IO流的思维导图
05-28
本人是初学者，在老师的指导下，将自身对Java中IO流的理解做成以下思维导图
IO流pdf宝典
07-21
JAVAIO流总结宝典，分享给大家，总结较为全面
IO流自用模板
12-17
IO流自用模板,平时工作遇到IO流,我都是套用我这个基础模板
IO流（二）
12-22
1.IO流 1.1 文件操作字符输出流 FileWriter文件操作输出字符流 Constructor 构造方法 FileWriter(File file); 根据File类对象创建对应文件的文件操作输出字符流 FileWriter(String pathName); 根据String类型文件...
java IO流文件的读写具体实例
09-04
主要介绍了java IO流文件的读写具体实例，有需要的朋友可以参考一下
IO流学习总结
01-26
本文档为本人学习 java IO流期间的学习总结笔记，希望对新学习的朋友有所帮助和参考价值。本人java 开发时间不是太长，可能存在不完善或不对之处，欢迎指正！
IO流的主要流
07-12
IO流的主要流
IO流工具组件
08-02
IO流工具组件 1 1 1 1 1 1
java基础之IO流
06-18
java基础之IO流，基础简介知识，帮助你了解java的io技术
map集合以及IO流
06-13
map集合的特性和它的遍历方式 还有一个根据Set特性的一个排序 以及IO流 字节流和字符流实现代码
Android io流
最新发布
08-30
Android中的IO流指的是输入输出流，用于读取和写入数据。在Android开发中，常用的IO流有FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等。 FileInputStream和FileOutputStream用于读取和写入...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值