JavaSe——IO流_Part2

最新推荐文章于 2022-10-05 22:37:29 发布
最新推荐文章于 2022-10-05 22:37:29 发布
阅读量452 收藏
点赞数
分类专栏： JavaSe-刘意-2015版本
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AbstractAccount/article/details/44171889
版权

A.转换流

l  由于字节流操作中文不是特别方便，所以，java就提供了转换流。

l  字符流=字节流+编码表。

package com.core.io.demo;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Test {

	public static void main(String[] args) throws UnsupportedEncodingException {
		//String---byte
		String s = "你好";
		byte[] bs1 = s.getBytes();
		byte[] bs2 = s.getBytes("GBK");
		byte[] bs3 = s.getBytes("utf-8");
		System.out.println(Arrays.toString(bs1));//[-60, -29, -70, -61]
		System.out.println(Arrays.toString(bs2));//[-60, -29, -70, -61]
		System.out.println(Arrays.toString(bs3));//[-28, -67, -96, -27, -91, -67]
		
		//bye----String
		byte[] bs4 = {-60, -29, -70, -61};
		System.out.println(new String(bs4));//你好
		System.out.println(new String(bs4,"GBK"));//你好
		byte[] bs5 = {-28, -67, -96, -27, -91, -67};
		System.out.println(new String(bs5,"utf-8"));//你好
		System.out.println(new String(bs5));//浣犲ソ
		System.out.println(new String(bs4,"utf-8"));//???
	}

}


B.转换流OutputStreamWriter

package com.core.io.demo;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Test2 {
	// 转换流，OutputStreamWriter的使用
	public static void main(String[] args) throws UnsupportedEncodingException,
			IOException {
		// OutputStreamWriter(OutputStream out)
		// 创建使用默认字符编码的 OutputStreamWriter。
		// OutputStreamWriter(OutputStream out, Charset cs)
		// 创建使用给定字符集的 OutputStreamWriter。
		// OutputStreamWriter(OutputStream out, CharsetEncoder enc)
		// 创建使用给定字符集编码器的 OutputStreamWriter。
		// OutputStreamWriter(OutputStream out, String charsetName)
		// 创建使用指定字符集的 OutputStreamWriter。

		// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
		// "osw.txt"));// 默认使用GBK
		// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
		// "osw.txt"),"GBK");// 指定使用GBK
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
				"osw.txt"), "UTF-8");// 指定使用UTF-8

		osw.write("中国UTF-8");// 不需要getbytes了

		osw.close();
	}

}


C.转换流InputStreamWriter


package com.core.io.demo;

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

public class Test3 {
	// 转换流，InputStreamWriter的使用
	public static void main(String[] args) throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"osw-gbk.txt"));
		// 使用指定编码(gbk),读取数据

		// 一次读取一个字符
		int ch = 0;
		while ((ch = isr.read()) != -1) {
			System.out.print((char) ch);// 中国gbk
		}

		isr.close();

		InputStreamReader isr2 = new InputStreamReader(new FileInputStream(
				"osw-utf.txt"), "utf-8");// 使用指定字符集读取数据
		int ch2 = 0;
		while ((ch2 = isr2.read()) != -1) {
			System.out.print((char) ch2);// 中国UTF-8
		}
		// 关资源
		isr2.close();
	}

}


D.字符流的5种写数据的方式

l  OutputStreamWriter写数据方法

•    public void write(int c)

•    public void write(char[] cbuf)

•    public void write(char[] cbuf,int off,int len)

•    public void write(String str)

•    public void write(String str,int off,int len)

l  字符流操作要注意的问题

•    flush()的作用

•    flush()和close()的区别


package com.core.io.demo;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Test4 {
	// D.字符流的5种写数据的方式
	// l OutputStreamWriter写数据方法
	// • public void write(int c)
	// • public void write(char[] cbuf)
	// • public void write(char[] cbuf,int off,int len)
	// • public void write(String str)
	// • public void write(String str,int off,int len)
	// l 字符流操作要注意的问题
	// • flush()的作用
	// • flush()和close()的区别

	public static void main(String[] args) throws IOException {
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));
		//写一个字符
		osw.write(97);
		osw.write('a');
		
		//写一个字符数组
		char[] chs = {'b','c','d',102,103};
		osw.write(chs );
		
		//写一个换行
		osw.write("\n\r");
		//写一个字符数组的一部分
		osw.write(chs, 1, 2);
		
		//写一个字符串
		String str = "中国 China";
		osw.write(str);
		//写一个字符串的一部分
		osw.write(str,0,2);
		
		//刷新缓冲区
		osw.flush();
		osw.close();
		
//		aabcdfg
//
//		cd中国 China中国
	}

}


E.字符流的2种读数据的方式

1.一次读一个字符
2.一次读一个字符数组 

package com.core.io.demo;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test5 {
	// 字符流读取数据的两种方式
	public static void main(String[] args) throws IOException {
		// A.一次读取一个字符
		InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"file.java"));
		int ch = 0;
		while ((ch = isr.read()) != -1) {
			System.out.print((char) ch);
		}

		isr.close();
		// B.一次读取一个字符数组
		
		System.out.println("-----------------");
		InputStreamReader isr2 = new InputStreamReader(new FileInputStream(
				"file.java"));

		char[] chs = new char[1024];
		int len = 0;
		while((len = isr2.read(chs))!=-1){
			System.out.print(new String(chs,0,len));
		}
		
		isr2.close();
		
	}

}

F.字符流文件复制

package com.core.io.demo;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class Test6 {
	// 字符流文件复制的两种方式
	public static void main(String[] args) throws IOException {
		// A.一次读取一个字符
		InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"file.java"),"UTF-8");
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("fileA.java"),"UTF-8");
		int ch = 0;
		while ((ch = isr.read()) != -1) {
			osw.write(ch);
		}

		isr.close();
		osw.close();
		// B.一次读取一个字符数组
		
		System.out.println("-----------------");
		InputStreamReader isr2 = new InputStreamReader(new FileInputStream(
				"file.java"),"UTF-8");
		OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("fileB.java"),"UTF-8");
		char[] chs = new char[1024];
		int len = 0;
		while((len = isr2.read(chs))!=-1){
			osw2.write(chs, 0, len);
		}
		
		isr2.close();
		osw2.close();
		
	}

}


G.转换流的简化书写，FileReader&FileWriter

转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化我们书写，转换流提供了对应的子类。
FileWriter
FileReader 

package com.core.io.demo2;

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

public class Test {

	public static void main(String[] args) throws IOException {
		// FileReader & FileWriter
		FileReader fr = new FileReader("file.java");
		FileWriter fw = new FileWriter("fileA.java");
		// 方法1：一次读写一个字符
		int ch;
		while ((ch = fr.read()) != -1) {
			fw.write(ch);
		}

		fr.close();
		fw.close();
		
		// 方法2：一次读写一个字符数组
		FileReader fr2 = new FileReader("file.java");
		FileWriter fw2 = new FileWriter("fileB.java");
		int len =0;
		char[] chs = new char[1024];
		while((len = fr2.read(chs))!=-1){
			fw2.write(chs, 0, len);
		}

		fr2.close();
		fw2.close();
	}

}


H.字符缓冲输出流BufferedWriter & 字符缓冲输入流BufferedReader

特殊用法

BufferedWriter

-newLine()

BufferedReader

-readLine()

使用字符缓存流复制数据的3种方式

package com.core.io.demo2;

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

public class Test2 {
	// 使用字符缓存流复制数据3种方式
	public static void main(String[] args) throws IOException {
		method1();
		method2();
		method3();
	}

	// 使用字符缓存流的特殊方法读取数据
	private static void method3() throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("file.java"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("fileE.java"));

		String line = null;
		while((line = br.readLine())!=null){
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		
		// 关资源
		br.close();
		bw.close();
	}

	// 一次读写一个字符数组
	private static void method2() throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("file.java"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("fileD.java"));

		int len = 0;
		char[] chs = new char[1024];
		while ((len = br.read(chs)) != -1) {
			bw.write(chs, 0, len);
			bw.flush();
		}
		// 关资源
		br.close();
		bw.close();

	}

	// 一次读写一个字符
	private static void method1() throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("file.java"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("fileC.java"));

		int ch = 0;
		while ((ch = br.read()) != -1) {
			bw.write(ch);
		}
		// 关资源
		br.close();
		bw.close();
	}

}





I .复制文本文件的5种方式案例(字符流)

FileWriter & FileReader:  一次读一个字符、一个读一个字符数组

BufferedWriter & BufferedReader : 一次读一个字符、一个读一个字符数组、特殊的方法(newLine()、readLine())


J.复制图片的4种方式案例(字节流)

FileOutputStream & FileInputStream: 一次读一个字符、一个读一个字符数组

BufferedOutputStream & BufferedInputStream:一次读一个字符、一个读一个字符数组


K.文件和集合ArrayList

package com.core.io.demo2;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class Test3 {
	// ArrayList存进文件
	// 文件取出来存到ArrayList
	public static void main(String[] args) throws IOException {
		ArrayList<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");
		list.add("android");
		
		FileWriter fw = new FileWriter("list.txt");
		BufferedWriter bw = new BufferedWriter(fw);
		for (String str : list) {
			bw.write(str);
			bw.newLine();
			bw.flush();
		}
		bw.close();
		System.out.println("-----------");
		
		BufferedReader br = new BufferedReader(new FileReader("list.txt"));
		ArrayList<String> list2 = new ArrayList<String>();
		String line = null;
		while((line= br.readLine())!=null){
			list2.add(line);
		}
		br.close();
		for (String str : list2) {
			System.out.println(str);
		}
	}


}

L.复制单级文件夹案例

package com.core.io.demo2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Arrays;

public class Test4 {
	public static void main(String[] args) throws IOException {
		// 复制单机文件夹
		// E:\temp\a----》E:\temp\b
		// method1();
		// 复制单级目录指定后缀名并修改后缀名
		System.out.println("over...");
		method2();
	}

	private static void method2() throws IOException {
		File srcFile = new File("e:\\temp\\a");
		File desFile = new File("e:\\temp\\c");
		if (!desFile.exists()) {
			desFile.mkdir();
		}
		File[] listFiles = srcFile.listFiles(new FilenameFilter() {

			@Override
			public boolean accept(File dir, String name) {
				return new File(dir, name).isFile() && name.endsWith(".java");
			}
		});

		System.out.println(Arrays.toString(listFiles));
		for (File file : listFiles) {
			String name = file.getName();
			File newFile = new File(desFile, name);
			copyFile2(file, newFile);
			String newName = name.replace(".java", ".jad");
			File newNameFile = new File(desFile, newName);
			newFile.renameTo(newNameFile);
		}
	}

	private static void copyFile2(File file, File newFile) throws IOException {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				file));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(newFile));
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}
		bos.close();
		bis.close();
		
		
	}

	private static void method1() throws IOException {
		File srcFile = new File("e:\\temp\\a");
		File[] listFiles = srcFile.listFiles();

		File desFile = new File("e:\\temp\\b");
		if (!desFile.exists()) {
			desFile.mkdir();
		}

		for (File file : listFiles) {
			String name = file.getName();
			File newFile = new File(desFile, name);
			copyFile(file, newFile);
		}
	}

	private static void copyFile(File srcFile, File newFile) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader(srcFile));
		BufferedWriter bw = new BufferedWriter(new FileWriter(newFile));

		if (!newFile.exists()) {
			newFile.createNewFile();
		}
		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		bw.close();
		br.close();
	}

}


M.复制多级文件夹案例

package com.core.io.demo2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Arrays;

public class Test5 {
	public static void main(String[] args) throws IOException {
		// 复制多级文件
		File srcFile = new File("e:\\temp\\a");
		File desFile = new File("e:\\temp\\b");
		if (!desFile.exists()) {
			desFile.mkdir();
		}
		copyFolder(srcFile, desFile);
		System.out.println("over...");

	}

	private static void copyFolder(File srcFile, File desFile)
			throws IOException {
		if (srcFile.isDirectory()) {
			File newFloder = new File(desFile, srcFile.getName());
			newFloder.mkdir();
			File[] listFiles = srcFile.listFiles();
			for (File file : listFiles) {
				copyFolder(file, newFloder);
			}

		} else {
			String name = srcFile.getName();
			System.out.println("复制文件：" + name);
			File newFile = new File(desFile, name);
			copyFile(srcFile, newFile);
		}
	}

	private static void copyFile(File srcFile, File desFile) throws IOException {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
				srcFile));
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream(desFile));
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}
		bos.close();
		bis.close();
	}

}

N.LineNumberReader

package com.core.io.demo3;

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

public class Test {

	public static void main(String[] args) throws IOException {
		//LineNumberReader
		//是bufferedReader的子类
		LineNumberReader lnr = new LineNumberReader(new FileReader("file.java"));
		String line = null;
		while((line = lnr.readLine())!=null){
			int lineNumber = lnr.getLineNumber();
			System.out.println(lineNumber+":"+line);
		}
		lnr.close();
	}

}


         IO流

                   |--字节流

                            |--字节输入流

                                     InputStream

                                               intread():一次读取一个字节

                                               intread(byte[] bys):一次读取一个字节数组

                                    

                                               |--FileInputStream

                                               |--BufferedInputStream

                            |--字节输出流

                                     OutputStream

                                               voidwrite(int by):一次写一个字节

                                               voidwrite(byte[] bys,int index,int len):一次写一个字节数组的一部分

                                              

                                               |--FileOutputStream

                                               |--BufferedOutputStream

                   |--字符流

                            |--字符输入流

                                     Reader

                                               intread():一次读取一个字符

                                               intread(char[] chs):一次读取一个字符数组

                                              

                                               |--InputStreamReader

                                                        |--FileReader

                                               |--BufferedReader

                                                        StringreadLine():一次读取一个字符串

                            |--字符输出流

                                     Writer

                                               voidwrite(int ch):一次写一个字符

                                               voidwrite(char[] chs,int index,int len):一次写一个字符数组的一部分

                                              

                                               |--OutputStreamWriter

                                                        |--FileWriter

                                               |--BufferedWriter

                                                        voidnewLine():写一个换行符

                                                       

                                                        voidwrite(String line):一次写一个字符串













AbstractAccount
关注
专栏目录
Java入门基础
阿杰同学的博客
08-29 269
Java入门基础 一：java概述： 　　1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 　　1994年将Oak语言更名为Java； 　　Java的三种技术架构: 　　JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； 　　JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基
JavaSE-IO流总结
三省的博客
11-02 261
1. File 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的 File常用方法： win系统的路径分隔符\要用转义为\\ 常用字段： // 路径结束的标志 static String pathSeparator // 目录与目录之间的分隔符 static String separator 常用构造： // 通过将给定的路径名字符串转.
JAVASE_IO流
天才来源于积累
03-29 575
IO流是用来处理设备之间的数据传输java对数据的操作都是通过流的方式java把处理流的对象都存放在IO包中流按操作数据分为两种：字节流和字符流（字符在生活中用的比较多，因此把字节流从字节流中独立出来(字符流中存在编码表)）字符流基于字节流，读出来的字节数组对应的编码查询转换后就成了一个个码值显示成文字流按流向分：输入流和输出流IO的常用基类：字节流的抽象基类：InputStream，OutpuS
JavaSE之IO流
wnxiaobear的博客
05-21 215
大家好，这是我的第一篇博客，目前在校学习，喜欢做一些笔记，只不过一开始用的是语雀来进行记录笔记的，这是我在学习java的过程中所积累的笔记，希望能够帮助到大家，如有错误，欢迎请大佬指出。 一.File类 1.File的构造方法 File file = new File(“文件路径名”); 2.文件的基本操作（文件的一些属性） boolean = file.createNewFile(“文件的路径名”); 文件如果不存自动创建一个新文件，若存在则返回true； Boolean = file.exists();
JavaSE（六）:IO流
水滴的博客
04-09 268
一、概序    Java IO：通过数据流、序列化和文件系统提供系统输入和输出，即Java 输入输出系统。    流：数据流，从中读到数据，往里面写入数据。流是数据流向的媒介。二、类型数据流的方向不同可以分为：输入流和输出流。数据单位不同可以分为：字节流和字符流。实现功能不同可以分为：节点流和处理流。  Jdk提供的流继承了四大类：InputStream(字节输入流)，OutputStream（字...
JavaSe基础XX18——IO流_6
雨一直下
09-10 3329
*48-IO流(打印流-PrintStream)
黑马就业班（01.JavaSE Java语言基础\13.JDBC）——part1：JDBC基础
LKJgdut的博客
01-05 348
今日内容 1. JDBC基本概念 2. 快速入门 3. 对JDBC中各个接口和类详解 1、JDBC基本介绍   概念：Java DataBase Connectivity Java 数据库连接， Java语言操作数据库（我们之前使用SQL操作数据库，而这里我们使用java操作数据库。既使用java代码对数据块进行增删改查等操作）   JDBC本质：其实是官方（sun公司）定义的一套操作所有...
黑马程序员-JAVA基础学习日志——通篇大总结及学习方法思想
无码骑兵的博客
09-07 5603
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   Java基础知识总结          回首是为了更好向前，天空没有翅膀的痕迹，而我已飞过，人总是这样，害怕回首，又时常回首，看看走过的路是直是弯，踩下的脚印是深是浅，回首昨天的风雨，眺望远方的灿烂。几多感慨，几多愁，放下包袱，轻装前行... 写代码： 1，明确需求。我要做什么？
Java基础总结
houbinbin123456的博客
12-18 282
Java基础知识总结（超级经典） Java基础知识总结（超级经典） 写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。 学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 —————————————————————————————————————————————————————— 一
JavaSE基础：IO流
qq_43265673的博客
07-27 367
基础流（节点流） FileInputStream FileOutputStream FileReader FileWriter 包装流（处理流） BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter ObjectInputStream ObjectOutputStream 其他小流 打印流 标准输入输出流 File类的特点和使用
Javase基础——IO流
涛涛的个人博客
07-15 716
Javase基础——IO流
JavaSE中IO流简介
labixiaoxin868的专栏
12-09 227
JavaSE中IO（Input Output）流          作用： IO流用来处理设备之间的数据传输                    Java对数据的操作是通过流的方式                    Java用于操作流的对象都在IO包中                    流按操作数据分为两种：字节流和字符流                    流按流向分...
JavaSE——IO流总结
Demon_and_Angle_的博客
08-14 272
用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出。
「JavaSE」- IO流
WangJinDL的博客
04-24 498
IO File类 1、File类的使用 java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关 File 能新建、删除、重命名文件和目录，但File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 File对象可以作为参数传递给流的构造器 2、常用构造器 public
JavaSE-19 【IO流】
Allure泽宇的博客
07-23 523
IO流的基本使用
JavaSe——IO流_Part1
AbstractAccount的专栏
03-09 387
A.递归 l  递归 •    方法定义中调用方法本身的现象 l  递归注意实现 •    要有出口，否则就是死递归 •    次数不能太多，否则就内存溢出 •    构造方法不能递归使用 案例1：阶乘 package com.core.io.demo; import java.util.Scanner; public class Test { p
Java基础-IO流
h2linlin的博客
12-27 147
IO流本身是用来做文件输入输出的。 一、File类 1.File类简介 File类是java.io包下用来操作文件和目录的类。File类可以新建、删除文件和目录，但是不能访问文件内容本身，如果需要访问文件内容本身，则需要使用IO流。 2.File类常用的构造方法 File没有无参的构造方法。操作每一个文件/文件夹都要对应一个对象。 1)File(String pa...
Java SE（九）之 IO流（字节流，字符流，缓冲流）
最新发布
ji_meng的博客
10-05 890
I表示intput，把硬盘文件中的数据读入到内存的过程，称之输入，负责读；O表示output，把内存中的数据写出到硬盘文件的过程，称之输出，负责写。File：它是文件和目录路径名的抽象表示文件和目录是可以通过File封装成对象的；File类的对象代表操作系统的文件，File封装了对文件进行：删除、获取信息、创建文件或文件夹等操作。但是不能读写文件内容；对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已（可以存在或不存在）将来是要通过具体的操作把这个路径的内容转换为具体存在的。
Java SE IO流异常处理与File类详解
Java标准版（JavaSE）中的I/O流是Java编程中不可或缺的部分，主要用于处理数据的输入与输出。在本文档中，我们重点总结了Java中I/O流的异常处理以及File类的相关知识。 首先，异常处理在Java中是通过`Throwable`类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值