一、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网别的相干文章!