Java IO _字节流与字符流

最新推荐文章于 2022-12-04 10:00:28 发布
最新推荐文章于 2022-12-04 10:00:28 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： JavaSE编程 文章标签： java io import file exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanshileiai/article/details/6712008
版权

1.掌握流的概念

2.掌握字节流与字符流的作用

3.掌握文件的标准操作步骤

4.掌握字节与字符操作的区别

1、流的概念


程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。

2、字节流与字符流


内容操作就四个类：OutputStream、InputStream、writer、Rader

使用 File 类操作的时候一定要有路径的问题，注意分隔符

实际上四个操作类都是抽象类

IO操作属于资源操作，对于资源操作，操作的最后必须关闭，否则就有可能出现未知错误。

3.字节流


Byte 是字节，肯定使用字节流操作。所有的数基本都可以直接使用 byte 数组表示出来。

字节输出流： OutputStream 类


Clonseable： 表示可以关闭的操作，因为程序运行到最后肯定要关闭。

Fluashable： 表示刷新，清空内存中的数据。

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo01{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		OutputStream out = null ;	// 准备好一个输出的对象
		out = new FileOutputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		byte b[] = str.getBytes() ;			// 只能输出byte数组，所以将字符串变为byte数组
		out.write(b) ;						// 将内容输出，保存文件
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};

在操作的时候，如果文件本身不存在，则会为用户自动创建新文件。

在操作输出流的时候，也可以使用 write(int i) 的方法写出数据

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo02{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		OutputStream out = null ;	// 准备好一个输出的对象
		out = new FileOutputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		byte b[] = str.getBytes() ;			// 只能输出byte数组，所以将字符串变为byte数组
		for(int i=0;i<b.length;i++){		// 采用循环方式写入
			out.write(b[i]) ;	// 每次只写入一个内容
		}
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};

以上的操作中在写入数据之后，文件之前的内容已经不存在了，因为在IO操作中默认的情况是将其进行覆盖的，那么如果现在要想执行追加的功能，则必须设置追加的操作，找到FileOutputStream 类；


import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo03{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		OutputStream out = null ;	// 准备好一个输出的对象
		out = new FileOutputStream(f,true)  ;	// 此处表示在文件末尾追加内容
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		byte b[] = str.getBytes() ;			// 只能输出byte数组，所以将字符串变为byte数组
		for(int i=0;i<b.length;i++){		// 采用循环方式写入
			out.write(b[i]) ;	// 每次只写入一个内容
		}
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};

程序本身是可以追加内容了，但是没有换行，是直接在末尾追加的。

如果在文件操作中想换行的话，使用  “\r\n” 完成。

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo04{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		OutputStream out = null ;	// 准备好一个输出的对象
		out = new FileOutputStream(f,true)  ;	// 此处表示在文件末尾追加内容
		// 第3步、进行写操作
		String str = "\r\nHello World!!!" ;		// 准备一个字符串
		byte b[] = str.getBytes() ;			// 只能输出byte数组，所以将字符串变为byte数组
		for(int i=0;i<b.length;i++){		// 采用循环方式写入
			out.write(b[i]) ;	// 每次只写入一个内容
		}
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};
字节输入流：InputStream 


import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo01{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		InputStream input = null ;	// 准备好一个输入的对象
		input = new FileInputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		byte b[] = new byte[1024] ;		// 所有的内容都读到此数组之中
		input.read(b) ;		// 读取内容
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流
		System.out.println("内容为：" + new String(b)) ;	// 把byte数组变为字符串输出
	}
};
此时，内容确实已经读取进来了，但是可以发现存在问题。 

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo02{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		InputStream input = null ;	// 准备好一个输入的对象
		input = new FileInputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		byte b[] = new byte[1024] ;		// 所有的内容都读到此数组之中
		int len = input.read(b) ;		// 读取内容
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流\
		System.out.println("读入数据的长度：" + len) ;
		System.out.println("内容为：" + new String(b,0,len)) ;	// 把byte数组变为字符串输出
	}
};
 这个代码还存在问题，现在文件没有这么大，但是开辟了这么大的数组空间，这样肯定很浪费，能不能根据文件大小来开辟数组空间呢？

如果要想知道文件大小，直接使用File 类即可。

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo03{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		InputStream input = null ;	// 准备好一个输入的对象
		input = new FileInputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		byte b[] = new byte[(int)f.length()] ;		// 数组大小由文件决定
		int len = input.read(b) ;		// 读取内容
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流\
		System.out.println("读入数据的长度：" + len) ;
		System.out.println("内容为：" + new String(b)) ;	// 把byte数组变为字符串输出
	}
};
以上直接使用 byte 数组的方式完成的。

现在使用 public abstract int read() throws IOException 读取内容。

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo04{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		InputStream input = null ;	// 准备好一个输入的对象
		input = new FileInputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		byte b[] = new byte[(int)f.length()] ;		// 数组大小由文件决定
		for(int i=0;i<b.length;i++){
			b[i] = (byte)input.read() ;		// 读取内容
		}
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流\
		System.out.println("内容为：" + new String(b)) ;	// 把byte数组变为字符串输出
	}
};
以上的操作，只适合于知道输入流大小的时候，如果现在不知道大小呢？ 
import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo05{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		InputStream input = null ;	// 准备好一个输入的对象
		input = new FileInputStream(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		byte b[] = new byte[1024] ;		// 数组大小由文件决定
		int len = 0 ; 
		int temp = 0 ;			// 接收每一个读取进来的数据
		while((temp=input.read())!=-1){
			// 表示还有内容，文件没有读完
			b[len] = (byte)temp ;
			len++ ;
		}
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流\
		System.out.println("内容为：" + new String(b,0,len)) ;	// 把byte数组变为字符串输出
	}
};
当不知道读取内容有多在的时候，就只能以读取的数据是否为-1为读完的标志。
4.字符流

字符输出流



字符流的操作比字节流操作好在一点， 就是可以直接输出字符串了。不用再像之前那样进行转换操作了。

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo01{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Writer out = null ;	// 准备好一个输出的对象
		out = new FileWriter(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		out.write(str) ;						// 将内容输出，保存文件
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};

使用字符流默认请况下依然是覆盖已有的文件，如果要想追加的话，则直接在FileWrite 上增加一个可追加的标记即可。

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo02{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Writer out = null ;	// 准备好一个输出的对象
		out = new FileWriter(f,true)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "\r\nLIXINGHUA\r\nHello World!!!" ;		// 准备一个字符串
		out.write(str) ;						// 将内容输出，保存文件
		// 第4步、关闭输出流
		out.close() ;						// 关闭输出流
	}
};
字符输入流：Reader


以字符数组的形式读取出数据。

import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo01{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Reader input = null ;	// 准备好一个输入的对象
		input = new FileReader(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		char c[] = new char[1024] ;		// 所有的内容都读到此数组之中
		int len = input.read(c) ;		// 读取内容
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流
		System.out.println("内容为：" + new String(c,0,len)) ;	// 把字符数组变为字符串输出
	}
};

也可以使用循环的方式，通过文件是否讲到底的形式读取。

import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo02{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Reader input = null ;	// 准备好一个输入的对象
		input = new FileReader(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行读操作
		char c[] = new char[1024] ;		// 所有的内容都读到此数组之中
		int temp = 0 ;	// 接收每一个内容
		int len = 0 ;		// 读取内容
		while((temp=input.read())!=-1){
			// 如果不是-1就表示还有内容，可以继续读取
			c[len] = (char)temp ;
			len++ ;
		}
		// 第4步、关闭输出流
		input.close() ;						// 关闭输出流
		System.out.println("内容为：" + new String(c,0,len)) ;	// 把字符数组变为字符串输出
	}
};
5.字节流与字符流的区别

字节流和字符流使用是非常相似的，那么除了操作代码的不同之外，还有那些不同呢?

通过一个代码来验证字符流使用到了缓存。

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo05{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		OutputStream out = null ;	// 准备好一个输出的对象
		out = new FileOutputStream(f)  ;	// 实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		byte b[] = str.getBytes() ;			// 只能输出byte数组，所以将字符串变为byte数组
		out.write(b) ;		// 写入数据
		// 第4步、关闭输出流
		// out.close() ;						// 关闭输出流
	}
};
在使用字节流操作中，即使没有关闭，最终也是可以输出的。 

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo03{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Writer out = null ;	// 准备好一个输出的对象
		out = new FileWriter(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		out.write(str) ;						// 将内容输出，保存文件
		// 第4步、关闭输出流
		// out.close() ;						// 此时，没有关闭
	}
};

以上的操作，没有输出任何内容出来，也就是说，所有的内容现在都是保存在了缓冲区中，而如果执行关闭的时候会强制性的刷新缓冲区，所以可以把内容输出。

如果现在假设，没有关闭的话，也可以手式强制性调用刷新方法。

public abstract void flush()throws IOException

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo04{
	public static void main(String args[]) throws Exception{	// 异常抛出，不处理
		// 第1步、使用File类找到一个文件
		File f= new File("d:" + File.separator + "test.txt") ;	// 声明File对象
		// 第2步、通过子类实例化父类对象
		Writer out = null ;	// 准备好一个输出的对象
		out = new FileWriter(f)  ;	// 通过对象多态性，进行实例化
		// 第3步、进行写操作
		String str = "Hello World!!!" ;		// 准备一个字符串
		out.write(str) ;						// 将内容输出，保存文件
		// 第4步、关闭输出流
		out.flush() ;	// 强制性清空缓冲区中的内容
		// out.close() ;						// 此时，没有关闭
	}
};
问题：

开发中是使用字节流好还是字符流好。

在所有的硬盘上保存文件或是进行传输的时候都是以字节的方式进行的，包括图片也是按字节完成，而字符是只有在内存中才会形成的，所以使用字节的操作是最多的。

6.操作范例


操作的时候要求可以按照如下的格式进行：

java Copy 源文件 目标文件

如果要采用以上的格式，则肯定要使用初始化参数的形式，输入两个路径，所以此时就必须输入参数的个数进行验证，判断其是否为 2

是使用字符流还是使用字节流呢？ 肯定使用字节流，因为万一拷贝的是一个图片的。

要完成拷贝程序，两种方式可以采用：

实现一：将源文件中的内容全部读取进来，之后一次性写入到目标文件

实现二：边读边写的方式

很明显，使用第二种方式

import java.io.* ;
public class Copy{
	public static void main(String args[]){
		if(args.length!=2){		// 判断是否是两个参数
			System.out.println("输入的参数不正确。") ;
			System.out.println("例：java Copy 源文件路径 目标文件路径") ;
			System.exit(1) ;	// 系统退出
		}
		File f1 = new File(args[0]) ;	// 源文件的File对象
		File f2 = new File(args[1]) ;	// 目标文件的File对象
		if(!f1.exists()){
			System.out.println("源文件不存在！") ;
			System.exit(1) ;
		}
		InputStream input = null ;		// 准备好输入流对象，读取源文件
		OutputStream out = null ;		// 准备好输出流对象，写入目标文件
		try{
			input = new FileInputStream(f1) ;
		}catch(FileNotFoundException e){
			e.printStackTrace() ;
		}
		try{
			out = new FileOutputStream(f2) ;
		}catch(FileNotFoundException e){
			e.printStackTrace() ;
		}
		if(input!=null && out!=null){	// 判断输入或输出是否准备好
			int temp = 0 ;	
			try{
				while((temp=input.read())!=-1){	// 开始拷贝
					out.write(temp) ;	// 边读边写
				}
				System.out.println("拷贝完成！") ;
			}catch(IOException e){
				e.printStackTrace() ;
				System.out.println("拷贝失败！") ;
			}
			try{
				input.close() ;		// 关闭
				out.close() ;		// 关闭
			}catch(IOException e){
				e.printStackTrace() ;
			}
		}
	}	
}
总结：

1、掌握流的概念

2、掌握字节流和字符流操作文件的基本步骤

本章是以文件为例，实际上以后的所有操作都可以通过此段代码完成

3、字节流和字符流的区别

字节流：使用和到了缓冲区

4、边读、边写的方式在日后的开发中非常有用处。



中国风2012
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaIO实例_字节流_字符流_缓冲流_转换流IODemo
12-16
在Java中，IO流分为两大类：字节流和字符流，每种流又有输入流和输出流之分，分别用于数据的读取和写入。 1. **字节流**： - 字节流处理的是8位的字节数据，是最基本的流类型。Java中的`InputStream`和`...
Java IO 文件操作 笔记+作业
zxcsjf的博客
07-03 538
Java IO 各种输入输出流
java编程基础总结——27.IO流
m0_58679504的博客
08-14 270
java字节流、字符流、装饰流、数据流、转换流、对象流
Java 文件与IO操作大全
通往IT大道的专栏
07-31 975
文件
java和jsp中out.print和out.write的方法
小康小白的博客
05-12 3058
java java中有这个方法：print(Object)，没有这个方法：write(Object) 但是却有这个方法：write(String) 从javaAPI，可以发现。 out.print()方法，可以输出一个java对象； out.write()方法，只能输入一个字符串。 jsp jsp中的out对象是JspWriter类型的． 而JspWriter继承了java.io.Writer . write方法是在在父类Writer中定义的， print方法是在子类JspWriter中定义的． 重载的p
java out.write网页_Servlet 中，out.print()与out.write()的区别
weixin_29304713的博客
02-13 739
最近刚学习了Ajax，其中有通过$.getJSON的实现方式由于前后端传递值的时候会通过流的方式进行传递，这就不得不涉及到这方面的知识了PrintWrite out=response.getWrite;而流输出的时候有两种方法out.write()和out.print()out.write()是字节输出流的方法out.print()是字符输出流的方法一、区别1.print方法是子类JspWrite...
Java IO流常用字节字符流原理解析
08-19
Java IO流中的字节流和字符流是两个基本的流类型，字节流用于对文件、网络等进行读写操作，而字符流用于对文本文件、网络等进行读写操作。了解Java IO流的原理和实现，可以帮助我们更好地使用Java IO流来进行文件、...
ByteIO_java_字节流_
10-04
Java的`java.io`包提供了大量预定义的字节流类，例如`FileInputStream`和`FileOutputStream`用于文件操作，`SocketInputStream`和`SocketOutputStream`则涉及网络通信。 在`ByteIO.java`文件中，我们可以预期看到...
Java_IO.rar_IO流 java_java io流
09-21
在Java中，IO流可以分为两类：字节流（处理单个字节）和字符流（处理Unicode字符）。此外，它们又可以分为四大类：输入流（用于读取数据）、输出流（用于写入数据）、节点流（与特定数据源或目的地关联）和过滤流...
详解Java中字符流与字节流的区别
09-02
根据处理的数据单位，Java提供了两种主要类型的流：字符流和字节流。这两种流在处理数据时有显著的区别，尤其是在处理文本数据和二进制数据时。 1. 什么是流 流在Java中是一个抽象概念，它描述了数据如何从一个地方...
Java中的out.write()和out.print()的区别
liaowenxiong的博客
02-12 1382
out 就是 PrintWriter 对象。 out.print() 有处理空值，如果传入的字符串为 null，则会转换为"null"字符串，print() 后续还是调用的 write() 方法，write() 传入的字符串不能为空。这个可以通过 PrintWriter 的源码中看到： public void print(String s) { if (s == null) { s = "null"; } write(s); } ...
out.print() 和 out.write()详细用法
weixin_42098099的博客
01-11 3万+
out.print()和out.write()都可以用在jsp中做输出, 有部分区别如下: out.print() 会将所有类型的数据转换为字符串, 包括null值, 并输出 int a = 10; String b = null out.print(&amp;quot;abc&amp;amp;lt;hr&amp;amp;gt;&amp;quot;); //abc&amp;amp;lt;hr&amp;amp;gt;(html解析后为分割线) out.print
Java中关于最简单的输入输出字节流操作
jjb_584520的博客
11-01 1512
Java中关于文件的读入和写出
JAVA中的IO流
六弦织乐的博客
08-03 360
从内容上分： 字节流（Stream）和字符流（Reader/Writer） 从流向上分： 输入流和输出流 节点流： 直接操作文件，构造方法(File file/String filepath); 包括：InputStream、OutputStream、Reader、Writer 字节流：可读写任意文件； 字节输入流：InputStream(in.read(byte[])) 字节
Java输入输出流详解
热门推荐
Java菜鸟
06-09 9万+
通过数据流、序列化和文件系统提供系统输入和输出。 Java把这些不同来源和目标的数据都统一抽象为数据流。Java语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简洁，因为你往往需要包装许多不同的对象。 在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流。 1.1、Java流
java基础教程--IO
song_lf的博客
06-08 304
java.io.File 类  代表文件，文件夹   new File() 只是在内存堆创建对象，并不是在磁盘上创建文件夹、文件   创建文件，文件夹有相应的方法   文件系统操作：查看文件、文件夹的属性 、创建文件夹、文件   列文件夹目录，删除文件夹、文件    RandomAccessFile随即访问文件，可以在任何位置开始读写文件   什么是文件：文件是byte by b
Java实验七
最新发布
m0_69383623的博客
12-04 2780
1、判断E盘指定目录下是否有后缀名为.jpg的文件，如果有就输出此文件名称。分别使用字节流和字节缓冲流的两种读取方式实现对图片文件的复制操作并比较两种方式在复制时间上的效率。编写一个程序，分别使用转换流、字符流和缓冲字符流拷贝一个文本文件。要求： • 分别使用InputStreamReader、OutputStreamWriter类和FileReader、FileWriter类用两种方式（字符和字符数组）进行拷贝。 • 使用BufferedReader、BufferedWriter类的特殊方法进行拷贝
Java程序设计实验五 输入输出流
萌新程序猿的博客
01-02 1779
Java程序设计实验五 输入输出流 实验内容： 1. 实验方案：创建一个文件，向其中写入字符并保存读取，完成实验任务。 2. 实验步骤：创建一个“song.txt”文件并向其中添加初始信息，用字节流和字符流，向文件中添加歌曲信息，并选择打开文件检验是否有遗漏，不断调试直至试验结束。 3. 设计思路： 创建一个主类，在主类中完成文件的创建以及是否选择写入和读取，通过文件字节输入流将文件中的信息显示在命令行中，再次通过文件字节/字符输出流将定义的信息存入文件中，并且通过文件字符输入流再次显示在命令行中。
java初学笔记09-IO流
chenyao的博客~
04-20 152
IO流java.io.File类的使用IO原理及流的分类文件流缓冲流转换流标准输入/输出流打印流(了解)数据流(了解)对象流 ---- 涉及序列化、反序列化随机存取文件流 java.io.File类的使用 java.io.File类: 文件和目录路径名的抽象表示形式, 与平台无关 File 能新建、删除、重命名文件和目录, 但File不能访问文件内容本身。如果需要访问文件内容本身, 则需要使用输入/ 输出流。 File对象可以作为参数传递给流的构造函数 File类的常见构造方法: public File
Java IO理解：字节流与字符流解析
3. **字节流与字符流的区别**：字节流处理的是原始的二进制数据，适用于任何类型的数据，如图片、音频、视频等。字符流则基于字符编码，如UTF-8，主要处理文本数据。字符流内部通常会用到字节流，通过字符编码解码来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值