一、IO：上传下载，写入写出
流: 一连串活动的数据，以先入先出的体式格局举行活动，管道，以递次为中间、递次与收集|文件|服务器|数组..（相干课程引荐：java视频教程）
分类
1)依据流向:
输入流；输出流
2)操纵单位分:
字撙节 (万能流):任何内容都可以转为字节,可以传输文本,图片,音频；字符流 :只能操纵纯文本数据
3)依据功用:
节点流 : 包裹泉源,完成基础功用；功用流 : 对节点流加强机能,进步效力
4)各个分类之间是相辅相成的
字撙节
(1)字节输入流 : InputStream 此笼统类是示意字节输入流的一切类的超类；FileInputStream 从文件体系中的某个文件中取得输入字节
//字撙节输入 InputStream
//导包 导包快捷键: ctrl+shift+o
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo01 {
public static void main(String[] args) throws IOException {
//FileInputStream(String name)
经由历程翻开一个到现实文件的连接来建立一个 FileInputStream，该文件经由历程文件体系中的途径名 name 指定
//FileInputStream(File file)
经由历程翻开一个到现实文件的连接来建立一个 FileInputStream，
该文件经由历程文件体系中的 File 对象 file 指定
InputStream is=new FileInputStream(new File("D:/test.txt"));//建立D盘符的根目次下的文件
System.out.println(is);
//体式格局1： int read() 读入数据 一个字节一个字节读入
/*int num=is.read();
System.out.println((char)num);
num=is.read();
System.out.println((char)num);
System.out.println((char)(is.read()));*/
//体式格局2：运用轮回,轮回读入，可以简化代码,反复代码只写一次,但照样一个字节一个字节的读入
/*int num=-1;
while((num=is.read())!=-1){
System.out.println((char)num);
}*/
//体式格局3：int read(byte[] b) 一个字节数组一个字节数组的读入
//返回值: 返回读入到字节数组中数据的个数,没有读到返回-1
byte[] car=new byte[1];
//int len=is.read(car);
int len=-1;
while((len=is.read(car))!=-1){
System.out.println(new String(car,0,len));
}
//封闭
is.close();
}
}
(2)字节输出流： OutputStream 此笼统类是示意输出字撙节的一切类的超类；FileOutputStream 文件输出流是用于将数据写入 File 的输出流
//字节输出流 OutputStream
//导包 导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo02 {
public static void main(String[] args) {
//FileOutputStream(String name)建立一个向具有指定称号的文件中写入数据的输出文件流
//FileOutputStream(String name,boolean append)
建立一个向具有指定 name 的文件中写入数据的输出文件流
//FileOutputStream(File file,boolean append)
建立一个向指定 File 对象示意的文件中写入数据的文件输出流
//boolean append 返回值：true追加,false不追加(默许false)
OutputStream os=null;
//try...catch(){} 捕获非常，处置惩罚非常
try {
//1.挑选流
os=new FileOutputStream("D:/hhh.txt",hhtrue);
//文件不存在,体系会自动帮我们建立,但文件夹不会
//2.预备数据
String str="要好好进修，天天向上...";
byte[] c和=str.getBytes();
//3.写出 void write(byte[] b)
os.write(ch);
//4.刷出
os.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
//5.封闭
try {//预防空指针非常
if(os!=null){
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符流
只能操纵纯文本
1)节点流:
(1)字符输入流：Reader 读取字符流的笼统类；FileReader 用来读取字符文件的便利类
//字符输入流 Reader
//导包 导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo03 {
public static void main(String[] args) {
//FileReader(String fileName)
Reader rd=null;
try {
//1.挑选流
rd=new FileReader("D:/hehe.txt");//建立D盘符的根目次下的文件
//2.读入
//要领1：int read() 读取单个字符。
/*System.out.println((char)rd.read());
System.out.println((char)rd.read());
System.out.println((char)rd.read());
System.out.println((char)rd.read());*/
int len=-1; //存储读到的数据 假如为-1,证实已达到末端
//要领2:
/*while(-1!=(len=rd.read())){
System.out.println((char)len);
}*/
//要领3：int read(char[] cbuf) 将字符读入数组。
char[] car=new char[1024];
while((len=rd.read(car))!=-1){
System.out.println(new String(car,0,len));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally{
if(rd!=null){
try {
//封闭功用
rd.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
(2)字符输出流: Writer 写入字符流的笼统类；FileWriter 用来写入字符文件的便利类
//字符输出流：Writer
//导包 导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class CharDemo02 {
public static void main(String[] args) {
//FileWriter(File file) //默许不追加
//FileWriter(File file, boolean append)
//FileWriter(String file)
//FileWriter(String file, boolean append)
Writer rt=null;
try {
//1.挑选流
rt=new FileWriter("D:/houhou.txt",true);
//2.写出
/* void write(char[] cbuf) 写入字符数组
void write(char[] cbuf, int off, int len) 写入字符数组的某一部份
void write(int c) 写入单个字符
void write(String str) 写入字符串
void write(String str, int off, int len) 写入字符串的某一部份
*/
rt.write(97);
rt.write("\r\n"); //换行
rt.write("你真悦目!!!!");
rt.write("\r\n");
rt.write("你真悦目!!!!",2,2);
rt.write("\r\n");
char[] ch={'a','b','c','d','e'};
rt.write(ch);
rt.write("\r\n");
rt.write(ch,2,3);
//3.刷出
rt.flush();
} catch (IOException e) {
e.printStackTrace();
} finally{
//4.封闭
if(null!=rt){
try {
rt.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
功用流
缓冲流: 加强功用，进步机能，加速读写效力
1）字撙节：
BufferedInputStream 字节输入流缓冲流
BufferedOutputStream 字节输出流缓冲流
没有新增要领，可以发作多态运用
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class BufferedInputStream01 {
public static void main(String[] args) throws IOException {
//1.挑选流
//BufferedInputStream(InputStream in)
InputStream is=new BufferedInputStream(new FileInputStream("D:/hehe.txt"));
OutputStream os=new BufferedOutputStream(new FileOutputStream("E:/hengheng.txt") );
//2.读写
byte[] car=new byte[1024];
int len=-1;
while((len=is.read(car))!=-1){
os.write(car,0,len);
}
//3.刷出
os.flush();
//4.封闭
os.close();
is.close();
}
}
2）字符流:
BufferedReader 字符输入流缓冲流
新增要领: String readLine() 读取一个文本行
BufferedWriter 字符输出流缓冲流
新增要领: void newLine() 写入一个行分隔符
//导包
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedReader02 {
public static void main(String[] args) throws IOException {
//1.挑选流 导包快捷键: ctrl+shift+o
BufferedReader br=new BufferedReader(new FileReader("D:/hehe.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("D:/ccc.txt"));
//2.读写
String msg=null;
while((msg=br.readLine())!=null){
bw.write(msg);
bw.newLine();
}
//3.刷出
bw.flush();
//4.封闭
bw.close();
br.close();
}
}
Data流(字节节点流)
Data流(字节节点流)：
读写基础数据范例+String范例数据，是字撙节功用流的一种
DataInputStream 新增要领: readXxx()
DataOutputStream 新增要领: writeXxx()
存在新增要领不能发作多态，先写出再写入
可以遇到的非常：EOFException 文件有,内容读入不到,必需读入的是写出的源文件
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Data01 {
public static void main(String[] args) throws IOException {
//挪用要领
write("D:/data.txt");
read("D:/data1.txt");
}
//读入
public static void read(String path) throws IOException{
//1.输入流 数据范例+数据
DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
//2.读入
int i=in.readInt();
boolean b=in.readBoolean();
String s=in.readUTF();
System.out.println(i+"-->"+b+"-->"+s);
//3.封闭
in.close();
}
//写出
public static void write(String path) throws IOException{
//1.输出流
DataOutputStream out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
//2.预备数据
int i=101;
boolean f=false;
String s="哈哈";
//3.写出 写出和读入的递次要保持一致
out.writeInt(i);
out.writeBoolean(f);
out.writeUTF(s);
//4.刷出
out.flush();
//5.封闭
out.close();
}
}
对象流
Object 保留数据范例+数据
字节的功用流:当想要传输|读写对象范例数据的时刻,可以运用一个对象流
序列化: 把对象范例的数据转化为可存储|可传输的状况的历程
ObjectInputStream() 反序列化输入流 新增要领: readObject()
ObjectOutputStream() 序列化输出流 新增要领: writeObject()
注重:
1)先序列化后反序列化
2)序列化反序列读写递次一致
3)不是一切的类都能序列化 java.io.Serializable 空接口
4)不是一切的属性都须要序列化 transient
5)static内容不会被序列化
6)假如父类完成Serializable接口,子类中可以序列化一切内容
假如子类完成Serializable接口,然则父类没有完成,子类只能序列化子类独占的内容
//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;
public class ObjectDemo02 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
write("D:/object.txt");
read("D:/object.txt");
}
//反序列化输入
public static void read(String path) throws IOException, ClassNotFoundException{
//1.输入流
ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
//2.读入
Object p= is.readObject();
int[] arr= (int[]) is.readObject();
if(p instanceof Person){
Person person=(Person)p;
System.out.println(person.getName());
}
System.out.println(p);
System.out.println(Arrays.toString(arr));
//3,封闭
is.close();
}
//序列化输出
public static void write(String path) throws IOException{
//1.输出对象信息
ObjectOutputStream os=new ObjectOutputStream(new BufferedOutputStream(new
FileOutputStream(path)));
//2.预备数据
Person p=new Person("aaa",18);
int[] arr={1,2,3,4};
//3.输出
os.writeObject(p);
os.writeObject(arr);
//4.刷出
os.flush();
//5.封闭
os.close();
}
}
//接口
class Person implements Serializable{
private String name;
private static int age;
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
二、File 类
File 类：文件和目次途径名的笼统示意情势
供应的功用：操纵文件外部的才能,不能操纵文件内部的内容
可以定义实在存在的途径|文件,不在的也可以定义,所以笼统表现情势
组织器： File(File parent, String child) 依据 parent 笼统途径名和 child 途径名字符串建立一个新 File 实例
File(String pathname) 经由历程将给定途径名字符串转换为笼统途径名来建立一个新 File 实例
File(String parent, String child) 依据 parent 途径名字符串和 child 途径名字符串建立一个新 File 实例
本文来自java入门教程栏目，迎接进修！
以上就是java中的IO流怎样分类的细致内容，更多请关注ki4网别的相干文章！
