介绍的了Java中常见的输入输出流
前言
文件 文件
内存 程序 内存
键盘 控制台
I/O的层次
在整个java.io中,最重要的就是五大类和一个接口,这五大类分别是File,Reader,Writer,InputStream,OutStream和接口Serializable
各个类主要作用:
1:File(文件管理):主要是处理文件的,不参与文件流的输入与输出,比如创建文件,删除文件,确定文件名,确定路径等.
2:Reader(文件格式操作):抽象类,基于字符的输入操作
3:Writer(文件格式操作):抽象类,基于字符的输出操作
4:InputStream(二进制格式操作):抽象类,基于字节的输入操作,拥有所有输入流的特征
5:OutputStream(二进制格式操作):抽象类,基于字节的输出操作,拥有所有输出流的特征
文件:
相关记录或放在一起的数据的集合
如何访问文件属性:
JAVA API java.io.File
一、File类
| 方法名称 | 说明 |
| boolean exists( ) | 判断文件或目录是否存在 |
| boolean isFile( ) | 判断是否是文件 |
| boolean isDirectory( ) | 判断是否是目录 |
| String getPath( ) | 返回此对象表示的文件的相对路径名 |
| String getAbsolutePath( ) | 返回此对象表示的文件的绝对路径名 |
| String getName( ) | 返回此对象表示的文件或目录的名称 |
| boolean delete( ) | 删除此对象指定的文件或目录 |
| boolean createNewFile( ) | 创建名称的空文件，不创建文件夹 |
| long length() | 返回文件的长度，单位为字节, 如果文件不存在，则返回 0L |
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
//创建File的对象
File file1=new File("F:\\newdemo.txt");
//查询api里面file类里面的方法对文件属性进行操作
boolean result=file1.exists();
System.out.println("文件存在: "+result);
//获取路径
String path=file1.getPath();
System.out.println("file1对象指向的文件路径是:"+path);
//获取绝对路径
String path1=file1.getAbsolutePath();
System.out.println("file1对象指向的文件绝对路径是:"+path1);
//创建新的空文件
File file2=new File("test.txt");
File file3=new File("F:\\a");
File file4=new File("F:\\mm\\fds\\asd");
try {
boolean result2=file2.createNewFile();
boolean result3=file3.mkdir();
System.out.println("file2对象指向的文件创建成功 "+result2);//已经创建成功不能在创建
System.out.println("file3对象创建的是否为目录: "+file3.isDirectory());//判断是否是目录
System.out.println("file3对象创建的目录成功: "+result3);
//mkdirs
boolean result4=file4.mkdirs();
System.out.println("file4对象创建的目录成功: "+result4);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("file2对象创建的文件相对路径为: "+file2.getPath());
System.out.println("file2对象创建的文件绝对路径为: "+file2.getAbsolutePath());
//删除指定的文件
System.out.println("file2对象创建的文件删除成功: "+file2.delete());
System.out.println("file3对象创建的文件删除成功: "+file3.delete());
file4.delete();
//获取文件的长度
long changDU=file1.length();
System.out.println("file1对象创建的文件长度为: "+changDU);
}
}运行结果:
文件存在: true
file1对象指向的文件路径是:F:\newdemo.txt
file1对象指向的文件绝对路径是:F:\newdemo.txt
file2对象指向的文件创建成功 true
file3对象创建的是否为目录: true
file3对象创建的目录成功: true
file4对象创建的目录成功: true
file2对象创建的文件相对路径为: test.txt
file2对象创建的文件绝对路径为: F:\Java课程\java高级特性\Demo0705输入输出流\test.txt
file2对象创建的文件删除成功: true
file3对象创建的文件删除成功: true
file1对象创建的文件长度为: 25
二、输入/输出流与数据源
按照流向区分:输出流---OutputStream和Writer作为基类
输入流---inputStream和Reader作业基类
输入和输出是按照计算机内存来说的
按照处理数据单元划分:字节流:字节流输入流InputStream基类
字节输出流OutputStream基类
字符流:字符输入流Reader基类
字符输出流Write基类
字节流是8位通用的字节流,字符流是16位的Unico字符流
InputStream类
void close();
int read();//从输入流中读取下一个字节
int read(byte[] b);//从输入流中输入一定的字节,并将其存储在缓冲区数组b中
int read(byte[] b,int off,int len);
FileInputStream(InputStream子类)
常用构造方法:
FileInputStream(File file)
FileInputStream(String name)
ObjectInputStream(InputStream子类)//ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
代码如下（示例）：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class FileInputStreamDemo {
public static void main(String[] args) {
//创建File的对象
File file=new File("F:\\newdemo.txt");
FileInputStream fis = null;
//读取数据流
try {
fis=new FileInputStream(file);//因为InputStream是一个抽象类,抽象类不能实例化,所以其子类创建对
/* int num1=fis.read();
char ch1=(char)num1;
System.out.println(ch1);
int num2=fis.read();
char ch2=(char)num2;
System.out.println(ch2);*/
int num;
while((num=fis.read())!=-1){//注意,不能在下面写fis.read()方法
char ch = (char)num;
System.out.print(ch);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fis.close();//关闭文件流
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
OutputStream类
OutputStream类常用方法
void write(int c)
void write(byte[] buf)
void write(byte[] b,int off,int len)
void close()
void flush()：强制把缓冲区的数据写到输出流中
FileOutputStream(OutputStream子类)
常用的构造方法
FileOutputStream (File file)
FileOutputStream(String name)
FileOutputStream(String name,boolean append)
注意:OutputStream在创建对象时如果文件中没有该文件,会自动创建一个文件
代码如下（示例）：
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class FileOutputStreamDemo01 {
public static void main(String[] args) {
//创建OutputStream类对象指向FileOutputStream类对象
OutputStream os=null;
try {
/*
* 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* 如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
*/
os=new FileOutputStream("F:\\newdemo.txt",true);
//将数据写入到自定义的文件中
os.write(65);//返回的是空值,不需要变量接受
System.out.println("数据传入完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}Reader类
InpoutStreamReader(Reader子类),可以按照指定编码格式读取数据
构造方法:
InpoutStreamReader(InputStream is)
InpoutStreamReader(InputStream is ,String charset name)
FileReader类(InputStreamReader的子类)
构造方法:
FileReader(File file)
FileReader(String fileName)//在给定情况下创建一个新的FileReader
BufferedReader类(Reader子类)
这个类可以高效率的一行一行的读取数据
readLine()方法:一行一行读取数据
Writer类
OutputStreamWriter(Writer子类)
构造方法:
OutputStreamWriter(OutputStream os)
OutputStreamWriter(OutputStream out, String charsetName) //创建使用指定的字符集
FileWriter类(OutputStreamWriter子类)
构造方法:
FileWriter(File file)
FileWriter(File file,boolean append)//根据给定的File对象构造一个FileWriter对象
BufferedWriter(Writer的子类)
构造方法:
BufferedWriter(Writer w)
DateInputStream和DateOutputStream文件读写二进制文件
DateInputStream和DataOutputStream是FilterInputStream和FilterOutputStream的子类
//可以实现文件的复制,采用边输入边输入的模式
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.DataInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DateOutputStreamAndDateIntputStreamDemo {
public static void main(String[] args) {
// 边读取边操作
DataInputStream dis=null;
DataOutputStream dos=null;
try {
dis=new DataInputStream(new FileInputStream("F://lol图片.webp"));
dos=new DataOutputStream(new FileOutputStream("F://copflol图片.webp"));
int num;
while((num=dis.read())!=-1){//读取输入流
dos.write(num);//将指定字节写入基础输出流
}
System.out.println("读写成功!");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
dis.close();
dos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
序列化流和反序列化流
序列化指的是将对象的状态写入特定流中的工程:
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo01 {
/**
* 实现对象的序列化
*/
public static void main(String[] args) {
ObjectOutputStream ois=null;
try {
ois=new ObjectOutputStream(new FileOutputStream("F://demo.txt"));
Student stu=new Student("小明",18);
ois.writeObject(stu);
System.out.println("对象写入完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
反序列化就是从特定的流中获取数据重新构建对象的过程:
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
/*
* 实现特定的流到重新构建数据形成新的对象
* 反序列化
*/
public class ObjectInputStreamDemo01 {
public static void main(String[] args) {
try {
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("F://demo.txt"));
Object object=ois.readObject();
Student stu=(Student)object;
System.out.println(stu.getAge());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
