澳门网络娱乐游戏平台-澳门电子游戏娱乐网址-官方直营

澳门官网唯一授权入口Java IO流详尽解析

十、流

1      IO(三)No20

流的定义和效劳

学习Java IO,一定要涉及的便是JavaIO流。

流是黄金年代组有各类的,有源点和尖峰的字节集结,是对数据传输的总称或抽象。即数据在两配备间的传导称为流,流的本色是多少传输,依据数据传输个性将流抽象为各品种,方便更加直观的进行数据操作。

10.1 缓冲流

1.1    Properties 属性集

IO流的分类

       依据拍卖数据类型的两样分为:字符流和字节流

       依据数量流向分化分为:输入流和出口流

        10.1.1 概述

                缓冲流是对4个主导的FileXxx流的增长,所以也是4个流,遵照数据类型进行归类

                        字节缓冲流:BufferedInputStream,BufferedOutputStream

                        字符缓冲流:BufferedReader,BufferedWriter

                     缓冲流的基本原理,是在创制流对象时,会创立二个平放的暗中同意大小的缓冲区数组,通过缓冲区读写,减弱系统IO次数,进而坚实读写的效用。 

字符流和字节流

字符流的案由: 因为数据编码的不等,而有了对字符举办飞速操作的流对象。本质实际上正是依照字节流读取时,去查了点名的码表。字节流和字符流的界别:

(1)读写单位分歧:字节流以字节(8bit)为单位,字符流以字符为单位,依据码表映射字符,一回或然读两个字节。

(2)管理指标不相同:字节流能管理全数类型的数码(如图片、avi等),而字符流只好处理字符类型的多少。

(3)字节流在操作的时候作者是不会用到缓冲区的,是文本自身的第一手操作的;而字符流在操作的时候下后是会用到缓冲区的,是由此缓冲区来操作文件,大家就要下边验证那或多或少。

结论:优先采取字节流。首先因为硬盘上的具备文件都是以字节的样式开展传输大概封存的,包蕴图片等剧情。不过字符只是在内部存款和储蓄器中才会产生的,所以在付出中,字节流使用大范围。

         10.1.2 字节缓冲流 构造方法:

                    构造方法

 

  • public BufferedInputStream(InputStream in卡塔尔 :创制一个新的缓冲输入流。 

  • public BufferedOutputStream(OutputStream out卡塔尔国: 创设二个新的缓冲输出流。

Properties属性集,首要用以操作配置属性,

输入流和出口流

对输入流只可以张开读操作,对输出流只可以進展写操作,程序中供给基于待传输数据的不等特点而利用不相同的流。

         10.1.3 字符缓冲流

                架构方法

 

  • public BufferedReader(Reader inState of Qatar :成立贰个 新的缓冲输入流。 

  • public BufferedWriter(Writer out卡塔尔国: 创设叁个新的缓冲输出流。

                特有艺术:

                字符缓冲流的骨干措施与日常字符流动调查用格局雷同,不再演说, 大家来看它们具备的故意方法。

 

  • BufferedReader:public String readLine(卡塔尔(قطر‎: 读生龙活虎行文字。 

  • BufferedWriter:public void newLine(卡塔尔(قطر‎: 写一行行分隔符,由系统质量定义符号。

是以键值没有错办法来保存属性,並且都以String类型

Java流操作有关的类或接口:

顶级赌场官方直营网 1

 

 

10.2 转换流

一连自Hashtable类,所以是三个Map集合,具备Map接口中的全部办法,可是在保存和读取数据的时候不建议使用put和get方法,因为有极大可能会现身十分,提议选择Properties中有意识的点子实行数量的储存

Java流类图结构:

 

 顶级赌场官方直营网 2

 

 

        10.2.1 字符编码和字符集

                

字符编码

微Computer中存款和储蓄的新闻都以用二进制数表示的,而作者辈在显示屏上来看的数字、塞尔维亚语、标点符号、汉字等字符是二进制数调换之后的结果。根据某种法规,将字符存款和储蓄到Computer中,称为编码 。反之,将储存在微处理机中的二进制数依照某种准则深入分析显示出来,称为解码 。举例说,依据A准绳存款和储蓄,相通服从A准则拆解深入分析,那么就会展现正确的公文f符号。反之,依照A法则存款和储蓄,再依照B准绳拆解解析,就能够以致乱码现象。

字符编码Character Encoding : 就是黄金时代套自然语言的字符与二进制数之间的应和准绳。

字符集

字符集 Charset:是四个系统帮忙的具有字符的集结,包蕴各个国家家文字、标点符号、图形符号、数字等。

Computer要正确的囤积和识别各个字符集符号,供给开展字符编码,大器晚成套字符集必然至稀少风姿洒脱套字符编码。清汤寡水字符集有ASCII字符集、GBK字符集、Unicode字符集等。 data-src="img/1_charset.jpg">顶级赌场官方直营网 3

足见,当钦点了编码,它所对应的字符集本来就钦命了,所以编码才是大家最后要关心的。

ASCII字符集
ASCII(American Standard Code for Information Interchange,美利坚合众国音信调换规范代码)是依据拉丁字母的豆蔻年华套Computer编码系统,用于突显现代日语,首要不外乎调整字符(回车键、退格、换行键等)和可彰显字符(英文大小写字符、阿拉伯数字和西方文字符号)。
主干的ASCII字符集,使用7位(bits)表示一个字符,共128字符。ASCII的增加字符集使用8位(bits)表示贰个字符,共256字符,方便支持澳洲常用字符。
ISO-8859-1字符集
拉丁码表,外号Latin-1,用于显示亚洲选择的言语,包蕴荷兰王国、嗹(lián卡塔尔国国、德文、意大利共和国语、德文等。
ISO-5559-1行使单字节编码,宽容ASCII编码。
GBxxx字符集
GB便是国家标准的情致,是为了显得中文而规划的黄金时代套字符集。
GB2312:简体粤语码表。贰个稍差于127的字符的意思与原来相像。但七个超越127的字符连在联合具名时,就象征五当中华夏儿女民共和国字,那样大意可以结合了带有7000三个简体汉字,别的数学符号、加拉加斯The Republic of Greece的字母、罗马尼亚语的假名们都编进去了,连在ASCII里原来就有的数字、标点、字母都统统重新编了多个字节长的编码,那正是常说的"全角"字符,而原本在127号以下的那么些就叫"半角"字符了。
GBK:最常用的国语码表。是在GB2312规范根底上的扩大标准,使用了双字节编码方案,共收音和录音了21003个汉字,完全相称GB2312规范,同期扶植繁体汉字乃至日韩汉字等。
GB18030:最新的汉语码表。收录汉字702四十一个,选择多字节编码,每一个字能够由1个、2个或4个字节组成。扶助中中原人民共和国境内少数民族的文字,同有的时候候帮忙繁体汉字以至日韩汉字等。
Unicode字符集
Unicode编码系统为发挥跋扈语言的轻便字符而规划,是产业界的生龙活虎种标准,也称为统意气风发码、规范万国码。
它最多使用4个字节的数字来表明各个字母、符号,只怕文字。有三种编码方案,UTF-8、UTF-16和UTF-32。最为常用的UTF-8编码。
UTF-8编码,能够用来表示Unicode标准中此外字符,它是电子邮件、网页及其余存款和储蓄或传递文字的施用中,优用的编码。互连网工程职业小组(IETF)要求具有网络球协会议都一定要援助UTF-8编码。所以,我们付出Web应用,也要使用UTF-8编码。它使用一至七个字节为各类字符编码,编码法则:
1三十个US-ASCII字符,只需一个字节编码。
拉丁文等字符,供给叁个字节编码。
相当多常用字(含中文),使用三个字节编码。
任何极少使用的Unicode支持字符,使用四字节编码。

 

常用方法:

Java IO流对象

        10.2.2 现身的主题材料

                在IDEA中,使用FileReader 读取项目中的文本文件。由于IDEA的安装,都以默许的UTF-8编码,所以未有别的难点。可是,当读取Windows系统中创制的文书文件时,由于Windows系统的私下认可是GBK编码,就能够现出乱码。

public class ReaderDemo { public static void main(String[] args) throws IOException { FileReader fileReader = new FileReader("E:\File_GBK.txt"); int read; while ((read = fileReader.read()) != -1卡塔尔(قطر‎ { System.out.print((charState of Qatarread卡塔尔(قطر‎; } file里德r.close(卡塔尔国; } } 输出结果: ���

 

 

 

12

 

 

 

 

 

1

public class ReaderDemo {

2

    public static void main(String[] args) throws IOException {

3

        FileReader fileReader = new FileReader("E:\File_GBK.txt");

4

        int read;

5

        while ((read = fileReader.read()) != -1) {

6

            System.out.print((char)read);

7

        }

8

        fileReader.close();

9

    }

10

}

11

输出结果:

12

���

 

 

1、添加、获取

1.   输入字节流InputStream

         10.2.3 InputStreamReader类

转换流java.io.InputStreamReader,是Reader的子类,是从字节流到字符流的桥梁。它读取字节,并利用钦赐的字符集将其解码为字符。它的字符集能够由名称内定,也足以担负平台的私下认可字符集。

GBK : 叁个汉字对应2个字节

Utf-8 : 五当中国字对应3个字节

结构方法

InputStreamReader(InputStream in) > data-wiz-span="data-wiz-span">: 创立一个运用暗中认可字符集的字符流。

InputStreamReader(InputStream in, String charsetName) > data-wiz-span="data-wiz-span">: 成立几个点名字符集的字符流。

 

setProperty(String key,String value卡塔尔国:添加键值对

概念和结构表达:

从输入字节流的世袭图能够看来:

InputStream 是持有的输入字节流的父类,它是多个抽象类。

ByteArrayInputStream、StringBufferInputStream、FileInputStream 是二种基本的媒质流,它们各自从Byte 数组、StringBuffer、和本土文件中读取数据。PipedInputStream 是从与别的线程共用的管道中读取数据,与Piped 相关的文化后续单独介绍。

ObjectInputStream 和具有FilterInputStream的子类都以装饰流(装饰器情势的不可多得)。意思是FileInputStream类能够透过一个String路线名创制多少个指标,FileInputStream(String name卡塔尔国。而DataInputStream必得装饰一个类才干回来三个指标,DataInputStream(InputStream in卡塔尔国。如下图示:

顶级赌场官方直营网 4

 

           10.2.4 OutputStreamWriter 类

转换流java.io.OutputStreamWriter ,是Writer的子类,是从字符流到字节流的大桥。使用钦赐的字符集讲字符编码为字节。它的字符集能够由名称钦点,也得以担当平台的暗中同意字符集。

结构方法

OutputStreamWriter(OutputStream in) > data-wiz-span="data-wiz-span">: 成立叁个接受暗中同意字符集的字符流。

OutputStreamWriter(OutputStream in, String charsetName) > data-wiz-span="data-wiz-span">: 创制二个钦点字符集的字符流。

    

                   

getProperty(String key卡塔尔(قطر‎:通过键获取值《getProperty(Stringkey)

实例操作演示:

【案例 】读取文件内容

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  * 读文件内容 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        InputStream in=new FileInputStream(f);  
  11.        byte[] b=new byte[1024];  
  12.        in.read(b);  
  13.        in.close();  
  14.        System.out.println(new String(b));  
  15.     }  
  16. }  

 

注意:该示例中由于b字节数COO度为1024,假诺文件极小,则会有大气填充空格。大家能够接收in.read(b卡塔尔;的重回值来设计程序,如下案例:

【案例】读取文件内容

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  * 读文件内容 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        InputStream in=new FileInputStream(f);  
  11.        byte[] b=new byte[1024];  
  12.        int len=in.read(b);  
  13.        in.close();  
  14.        System.out.println("读入长度为:"+len卡塔尔(قطر‎;  
  15.        System.out.println(new String(b,0,len));  
  16.     }  
  17. }  

 

注意:阅览地点的例证能够见到,大家先行申请了二个点名大小的上空,然则一时那么些空间大概太小,一时候只怕太大,我们须求规范的大小,那样节约空间,那么大家能够这么做:

【案例】读取文件内容

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  * 读文件内容,节省空间 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        InputStream in=new FileInputStream(f);  
  11.        byte[] b=new byte[(int)f.length()];  
  12.        in.read(b);  
  13.        System.out.println("文件长度为:"+f.length(卡塔尔State of Qatar;  
  14.        in.close();  
  15.        System.out.println(new String(b));  
  16.     }  
  17. }  

【案例】逐字节读

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  * 读文件内容,节省空间 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        InputStream in=new FileInputStream(f);  
  11.        byte[] b=new byte[(int)f.length()];  
  12.        for (int i = 0; i < b.length; i++) {  
  13.            b[i]=(byte)in.read();  
  14.        }  
  15.        in.close();  
  16.        System.out.println(new String(b));  
  17.     }  
  18. }  

 

注意:上边的多少个例证都是在驾驭文书的内容多大,然后才进行的,临时候我们不亮堂文书有多大,这种情景下,大家要求判别是或不是独到文件的最后。

【案例】字节流读取文件

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  *读文件 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        InputStream in=new FileInputStream(f);  
  11.        byte[] b=new byte[1024];  
  12.        int count =0;  
  13.        int temp=0;  
  14.        while((temp=in.read())!=(-1)){  
  15.            b[count++]=(byte)temp;  
  16.        }  
  17.        in.close();  
  18.        System.out.println(new String(b));  
  19.     }  
  20. }  

 

留神:当读到文件末尾的时候会重临-1.好端端情况下是不会回来-1的。

【案例】DataInputStream类

 

[java] view plain copy

 

  1. import java.io.DataInputStream;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.IOException;  
  5.    
  6. public class DataOutputStreamDemo{  
  7.    public static void main(String[] args) throws IOException{  
  8.        File file = new File("d:" + File.separator +"hello.txt");  
  9.        DataInputStream input = new DataInputStream(new FileInputStream(file));  
  10.        char[] ch = new char[10];  
  11.        int count = 0;  
  12.        char temp;  
  13.        while((temp = input.readChar()) != 'C'){  
  14.            ch[count++] = temp;  
  15.        }  
  16.        System.out.println(ch);  
  17.     }  
  18. }  

 

【案例】PushBackInputStream回落流操作

 

[java] view plain copy

 

  1. import java.io.ByteArrayInputStream;  
  2. import java.io.IOException;  
  3. import java.io.PushbackInputStream;  
  4.    
  5. /** 
  6.  * 回降流操作 
  7.  * */  
  8. public class PushBackInputStreamDemo{  
  9.     public static void main(String[] args) throwsIOException{  
  10.        String str = "hello,rollenholt";  
  11.        PushbackInputStream push = null;  
  12.        ByteArrayInputStream bat = null;  
  13.        bat = new ByteArrayInputStream(str.getBytes());  
  14.        push = new PushbackInputStream(bat);  
  15.        int temp = 0;  
  16.        while((temp = push.read()) != -1){  
  17.            if(temp == ','){  
  18.                 push.unread(temp);  
  19.                 temp = push.read();  
  20.                 System.out.print("(回退" +(char) temp + ") ");  
  21.            }else{  
  22.                 System.out.print((char) temp);  
  23.            }  
  24.        }  
  25.     }  
  26. }  

                调换流驾驭图解

顶级赌场官方直营网 5

 

getProperty(Stringkey,StringdefaultValue)》假使键不设有重回暗中认可值

2.   输出字节流OutputStream

10.3 系列化流

2、保存、加载(配合IO流使用)

概念和布局表明:

IO 中输出字节流的后续图可以预知上图,能够看见:

OutputStream 是享有的出口字节流的父类,它是多少个抽象类。

ByteArrayOutputStream、FileOutputStream是二种基本的媒质流,它们各自向Byte 数组、和当半夏件中写入数据。PipedOutputStream 是向与别的线程共用的管道中写入数据,

ObjectOutputStream 和全体FilterOutputStream的子类都以装饰流。具体育赛事例跟InputStream是呼应的。

        10.3.1 概述

Java 提供了风度翩翩种对象序列化的建制。用多个字节体系能够象征一个指标,该字节体系富含该对象的数据对象的类型对象中存储的数据等消息。字节种类写出到文件今后,相当于文件中原原本本保存了叁个指标的新闻。

适逢其时相反,该字节类别仍为能够从文件中读取回来,重构对象,对它进行反系列化对象的数据对象的类型和`对象中存储的数据`音信,都得以用来在内部存款和储蓄器中创造对象。看图通晓系列化:

data-src="img/3_xuliehua.jpg">顶级赌场官方直营网 6

store(卡塔尔(قطر‎:将数据通过输出流写到钦点文件中

实例操作演示:

【案例】向文件中写入字符串

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  * 向文件中写入字符串 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        OutputStream out =new FileOutputStream(f);  
  11.        String str="Hello World";  
  12.        byte[] b=str.getBytes();  
  13.        out.write(b);  
  14.        out.close();  
  15.     }  
  16. }  

 

你也能够叁个字节贰个字节的写入文件:

【案例】逐字节写入文件

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  * 向文件中叁个字节多少个字节的写入字符串 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        OutputStream out =new FileOutputStream(f);  
  11.        String str="Hello World!!";  
  12.        byte[] b=str.getBytes();  
  13.        for (int i = 0; i < b.length; i++) {  
  14.            out.write(b[i]);  
  15.        }  
  16.        out.close();  
  17.     }  
  18. }  

【案例】向文件中扩展新剧情

 

[java] view plain copy

 

  1. /** 
  2.  * 字节流 
  3.  * 向文件中加进新剧情: 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        OutputStream out =new FileOutputStream(f,true卡塔尔国;//true代表追加方式,不然为隐瞒  
  11.        String str="Rollen";  
  12.        //String str="rnRollen"; 能够换行  
  13.        byte[] b=str.getBytes();  
  14.        for (int i = 0; i < b.length; i++) {  
  15.            out.write(b[i]);  
  16.        }  
  17.        out.close();  
  18.     }  
  19. }  

 

【案例】复制文件

 

[java] view plain copy

 

  1. /** 
  2.  * 文件的复制 
  3.  * */  
  4. import java.io.*;  
  5. class hello{  
  6.    public static void main(String[] args) throws IOException {  
  7.        if(args.length!=2){  
  8.            System.out.println("命令行参数输入有误,请检查"卡塔尔(قطر‎;  
  9.            System.exit(1);  
  10.        }  
  11.        File file1=new File(args[0]);  
  12.        File file2=new File(args[1]);  
  13.           
  14.        if(!file1.exists()){  
  15.            System.out.println("被复制的公文不设有"State of Qatar;  
  16.            System.exit(1);  
  17.        }  
  18.        InputStream input=new FileInputStream(file1);  
  19.        OutputStream output=new FileOutputStream(file2);  
  20.        if((input!=null)&&(output!=null)){  
  21.            int temp=0;  
  22.            while((temp=input.read())!=(-1)){  
  23.                 output.write(temp);  
  24.            }  
  25.        }  
  26.        input.close();  
  27.        output.close();  
  28.     }  
  29. }  

 

【案例】使用内部存款和储蓄器操作流将叁个大写字母转化为小写字母

 

[java] view plain copy

 

  1. /** 
  2.  * 使用内存操作流将贰个大写字母转变为小写字母 
  3.  * *澳门官网唯一授权入口Java IO流详尽解析。/  
  4. import java.io.*;  
  5. class hello{  
  6.    public static void main(String[] args) throws IOException {  
  7.        String str="ROLLENHOLT";  
  8.        ByteArrayInputStream input=new ByteArrayInputStream(str.getBytes());  
  9.        ByteArrayOutputStream output=new ByteArrayOutputStream();  
  10.        int temp=0;  
  11.        while((temp=input.read())!=-1){  
  12.            char ch=(char)temp;  
  13.            output.write(Character.toLowerCase(ch));  
  14.        }  
  15.        String outStr=output.toString();  
  16.        input.close();  
  17.        output.close();  
  18.        System.out.println(outStr);  
  19.     }  
  20. }  

 

【案例】验证管道流:进程间通讯

 

[java] view plain copy

 

  1. /** 
  2.  * 验证管道流 
  3.  * */  
  4. import java.io.*;  
  5.    
  6. /** 
  7.  * 消息发送类 
  8.  * */  
  9. class Send implements Runnable{  
  10.    private PipedOutputStream out=null;  
  11.    public Send() {  
  12.        out=new PipedOutputStream();  
  13.     }  
  14.    public PipedOutputStream getOut(){  
  15.        return this.out;  
  16.     }  
  17.    public void run(){  
  18.        String message="hello , Rollen";  
  19.        try{  
  20.            out.write(message.getBytes());  
  21.        }catch (Exception e) {  
  22.            e.printStackTrace();  
  23.        }try{  
  24.            out.close();  
  25.        }catch (Exception e) {  
  26.            e.printStackTrace();  
  27.        }  
  28.     }  
  29. }  
  30.    
  31. /** 
  32.  * 选拔音信类 
  33.  * */  
  34. class Recive implements Runnable{  
  35.    private PipedInputStream input=null;  
  36.    public Recive(){  
  37.        this.input=new PipedInputStream();  
  38.     }  
  39.    public PipedInputStream getInput(){  
  40.        return this.input;  
  41.     }  
  42.    public void run(){  
  43.        byte[] b=new byte[1000];  
  44.        int len=0;  
  45.        try{  
  46.            len=this.input.read(b);  
  47.        }catch (Exception e) {  
  48.            e.printStackTrace();  
  49.        }try{  
  50.            input.close();  
  51.        }catch (Exception e) {  
  52.            e.printStackTrace();  
  53.        }  
  54.        System.out.println("接收的内容为 "+(new String(b,0,lenState of Qatar卡塔尔卡塔尔;  
  55.     }  
  56. }  
  57. /** 
  58.  * 测试类 
  59.  * */  
  60. class hello{  
  61.    public static void main(String[] args) throws IOException {  
  62.        Send send=new Send();  
  63.        Recive recive=new Recive();  
  64.         try{  
  65. //管道连接  
  66.            send.getOut().connect(recive.getInput());  
  67.        }catch (Exception e) {  
  68.            e.printStackTrace();  
  69.        }  
  70.        new Thread(send).start();  
  71.        new Thread(recive).start();  
  72.     }  
  73. }  

【案例】DataOutputStream类示例

 

[java] view plain copy

 

  1. import java.io.DataOutputStream;  
  2. import java.io.File;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. public class DataOutputStreamDemo{  
  6.    public static void main(String[] args) throws IOException{  
  7.        File file = new File("d:" + File.separator +"hello.txt");  
  8.        char[] ch = { 'A', 'B', 'C' };  
  9.        DataOutputStream out = null;  
  10.        out = new DataOutputStream(new FileOutputStream(file));  
  11.        for(char temp : ch){  
  12.            out.writeChar(temp);  
  13.        }  
  14.        out.close();  
  15.     }  
  16. }  

 

【案例】ZipOutputStream类

先看一下ZipOutputStream类的接轨关系

java.lang.Object

  java.io.OutputStream

      java.io.FilterOutputStream

          java.util.zip.DeflaterOutputStream

              java.util.zip.ZipOutputStream

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.util.zip.ZipEntry;  
  7. import java.util.zip.ZipOutputStream;  
  8.    
  9. public class ZipOutputStreamDemo1{  
  10.    public static void main(String[] args) throws IOException{  
  11.        File file = new File("d:" + File.separator +"hello.txt");  
  12.        File zipFile = new File("d:" + File.separator +"hello.zip");  
  13.        InputStream input = new FileInputStream(file);  
  14.        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(  
  15.                 zipFile));  
  16.        zipOut.putNextEntry(new ZipEntry(file.getName()));  
  17.        // 设置注释  
  18.        zipOut.setComment("hello");  
  19.        int temp = 0;  
  20.        while((temp = input.read()) != -1){  
  21.            zipOut.write(temp);  
  22.        }  
  23.        input.close();  
  24.        zipOut.close();  
  25.     }  
  26. }  

 

【案例】ZipOutputStream类压缩八个公文

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.util.zip.ZipEntry;  
  7. import java.util.zip.ZipOutputStream;  
  8.    
  9. /** 
  10.  * 一回性压缩三个文件 
  11.  * */  
  12. public class ZipOutputStreamDemo2{  
  13.    public static void main(String[] args) throws IOException{  
  14.        // 要被压缩的文件夹  
  15.        File file = new File("d:" + File.separator +"temp");  
  16.        File zipFile = new File("d:" + File.separator + "zipFile.zip");  
  17.        InputStream input = null;  
  18.        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(  
  19.                 zipFile));  
  20.        zipOut.setComment("hello");  
  21.        if(file.isDirectory()){  
  22.            File[] files = file.listFiles();  
  23.            for(int i = 0; i < files.length; ++i){  
  24.                 input = newFileInputStream(files[i]);  
  25.                 zipOut.putNextEntry(newZipEntry(file.getName()  
  26.                         + File.separator +files[i].getName()));  
  27.                int temp = 0;  
  28.                 while((temp = input.read()) !=-1){  
  29.                     zipOut.write(temp);  
  30.                 }  
  31.                 input.close();  
  32.            }  
  33.        }  
  34.        zipOut.close();  
  35.     }  
  36. }  

 

【案例】ZipFile类展示

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.IOException;  
  3. import java.util.zip.ZipFile;  
  4.    
  5. /** 
  6.  *ZipFile演示 
  7.  * */  
  8. public class ZipFileDemo{  
  9.    public static void main(String[] args) throws IOException{  
  10.        File file = new File("d:" + File.separator +"hello.zip");  
  11.        ZipFile zipFile = new ZipFile(file);  
  12.        System.out.println("压缩文件的名号为:" + zipFile.getName(卡塔尔(قطر‎卡塔尔;  
  13.     }  
  14. }  

 

【案例】解压缩文件(压缩文件中独有贰个文本的情事)

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.OutputStream;  
  6. import java.util.zip.ZipEntry;  
  7. import java.util.zip.ZipFile;  
  8.    
  9. /** 
  10.  * 解压缩文件(压缩文件中独有三个文件的场所) 
  11.  * */  
  12. public class ZipFileDemo2{  
  13.    public static void main(String[] args) throws IOException{  
  14.        File file = new File("d:" + File.separator +"hello.zip");  
  15.        File outFile = new File("d:" + File.separator +"unZipFile.txt");  
  16.        ZipFile zipFile = new ZipFile(file);  
  17.        ZipEntry entry =zipFile.getEntry("hello.txt");  
  18.        InputStream input = zipFile.getInputStream(entry);  
  19.        OutputStream output = new FileOutputStream(outFile);  
  20.        int temp = 0;  
  21.        while((temp = input.read()) != -1){  
  22.            output.write(temp);  
  23.        }  
  24.        input.close();  
  25.        output.close();  
  26.     }  
  27. }  

 

【案例】ZipInputStream类解压缩三个压缩文件中带有三个文件的情状

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.OutputStream;  
  7. import java.util.zip.ZipEntry;  
  8. import java.util.zip.ZipFile;  
  9. import java.util.zip.ZipInputStream;  
  10.    
  11. /** 
  12.  * 解压缩一个压缩文件中蕴涵三个文件的情形 
  13.  * */  
  14. public class ZipFileDemo3{  
  15.    public static void main(String[] args) throws IOException{  
  16.         File file = new File("d:" +File.separator + "zipFile.zip");  
  17.        File outFile = null;  
  18.        ZipFile zipFile = new ZipFile(file);  
  19.        ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));  
  20.        ZipEntry entry = null;  
  21.         InputStream input = null;  
  22.        OutputStream output = null;  
  23.        while((entry = zipInput.getNextEntry()) != null){  
  24.            System.out.println("解压缩" + entry.getName() + "文件");  
  25.            outFile = new File("d:" + File.separator + entry.getName());  
  26.            if(!outFile.getParentFile().exists()){  
  27.                outFile.getParentFile().mkdir();  
  28.            }  
  29.            if(!outFile.exists()){  
  30.                 outFile.createNewFile();  
  31.            }  
  32.            input = zipFile.getInputStream(entry);  
  33.            output = new FileOutputStream(outFile);  
  34.            int temp = 0;  
  35.            while((temp = input.read()) != -1){  
  36.                 output.write(temp);  
  37.            }  
  38.            input.close();  
  39.            output.close();  
  40.        }  
  41.     }  
  42. }  

 

10.3.2 ObjectOutputStream类和ObjectInputStream类         布局方法

  •  

    public ObjectOutputStream(OutputStream out) data-wiz-span="data-wiz-span">: 创设三个内定OutputStream的ObjectOutputStream。

     

  • public ObjectInputStream(InputStream in) data-wiz-span="data-wiz-span">:

    始建二个点名InputStream的ObjectInputStream。

            Notes:

                

1.五个对象要想种类化,必得满意两个规范化:

该类必需贯彻java.io.Serializable 接口,Serializable 是叁个符号接口,不兑现此接口的类将不会使任何动静系列化或反系列化,会抛出NotSerializableException

2.此类的拥有属性必需是可类别化的。要是有一个本性无需可体系化的,则该属性必需评释是刹那态的,使用transient 关键字修饰。

public class Employee implements java.io.Serializable { public String name; public String address; public transient int age; // transient弹指态修饰成员,不会被类别化 public void addressCheck(卡塔尔(قطر‎ { System.out.println("Address check : " + name + " -- " + addressState of Qatar; } }

 

 

 

8

 

 

 

 

 

1

public class Employee implements java.io.Serializable {

2

    public String name;

3

    public String address;

4

    public transient int age; // transient瞬态修饰成员,不会被序列化

5

    public void addressCheck() {

6

      System.out.println("Address  check : " + name + " -- " + address);

7

    }

8

}

 

 

 

                    写出指标方法:

> > data-wiz-span="data-wiz-span">public final void writeObject (Object obj) > > data-wiz-span="data-wiz-span">` > > data-wiz-span="data-wiz-span"> : 将钦定的指标写出。

public final Object readObject () > > data-wiz-span="data-wiz-span">` > > data-wiz-span="data-wiz-span"> : 读取四个指标。

 

public static void main(String[] args卡塔尔国 throws IOException, ClassNotFoundException { Student s1 = new Student(卡塔尔; s1.setName("zhangsan"卡塔尔; s1.setAge(14卡塔尔(قطر‎; s1.setDefault1(9999卡塔尔国; ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Student"卡塔尔卡塔尔(قطر‎; oos.writeObject(s1State of Qatar; oos.close(卡塔尔国; System.out.println("已经被种类化"卡塔尔国; // 反类别化 FileInputStream fis = new FileInputStream("Student.txt"卡塔尔(قطر‎; ObjectInputStream ois = new ObjectInputStream(fisState of Qatar; // 读取八个对象 Student stu = (Student卡塔尔ois.readObject(卡塔尔; ois.close(卡塔尔; fis.close(State of Qatar; System.out.println("stu = "

  • stu.getName(卡塔尔国卡塔尔(قطر‎; System.out.println("stu = " + stu.getAge(State of QatarState of Qatar; System.out.println("stu = " + stu.getDefault1(卡塔尔State of Qatar; } // 先类别化 再反连串化

 

 

 

27

 

 

 

 

 

1

    public static void main(String[] args) throws IOException, ClassNotFoundException {

2

        Student s1 = new Student();

3

        s1.setName("zhangsan");

4

        s1.setAge(14);

5

        s1.setDefault1(9999);

6

7

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Student"));

8

9

        oos.writeObject(s1);

10

11

        oos.close();

12

        System.out.println("已经被序列化");

13

14

        // 反序列化

15

        FileInputStream fis = new FileInputStream("Student.txt");

16

        ObjectInputStream ois = new ObjectInputStream(fis);

17

        // 读取一个对象

18

        Student stu  = (Student) ois.readObject();

19

        ois.close();

20

        fis.close();

21

22

        System.out.println("stu = " + stu.getName());

23

        System.out.println("stu = " + stu.getAge());

24

        System.out.println("stu = " + stu.getDefault1());

25

    }

26

27

// 先序列化 再反序列化

 

 

        反类别化的时候注意:

    

对于JVM能够反连串化对象,它必需是力所能致找到class文件的类。假设找不到此类的class文件,则抛出八个 ClassNotFoundException 异常。

反体系化操作2

别的,当JVM反类别化对象时,能找到class文件,可是class文件在种类化对象之后发出了纠正,那么反种类化操作也会停业,抛出一个InvalidClassException异常。发生那几个这么些的缘由如下:

该类的行列版本号与从流中读取的类描述符的版本号不协作
该类包括未确定的数据类型
该类未有可访谈的无参数布局方法

Serializable 接口给必要体系化的类,提供了二个队列版本号。serialVersionUID 该版本号的意在证实连串化的靶子和对应类是还是不是版本相配。

public class Student implements Serializable { private String name; private int age; private transient int default1; public Student() { } public Student(String name, int age, int default1) { this.name = name; this.age = age; this.default1 = default1; } public void addressCheck() { System.out.println("Address check :" + name + "---" + 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; } public int getDefault1() { return default1; } public void setDefault1(int default1) { this.default1 = default1; } }

 

 

 

42

 

 

 

 

 

1

public class Student implements Serializable {

2

    private String name;

3

    private int age;

4

    private transient int default1;

5

6

    public Student() {

7

    }

8

9

    public Student(String name, int age, int default1) {

10

        this.name = name;

11

        this.age = age;

12

        this.default1 = default1;

13

    }

14

15

    public void addressCheck() {

16

        System.out.println("Address check :" + name + "---" + age);

17

    }

18

19

    public String getName() {

20

        return name;

21

    }

22

23

    public void setName(String name) {

24

        this.name = name;

25

    }

26

27

    public int getAge() {

28

        return age;

29

    }

30

31

    public void setAge(int age) {

32

        this.age = age;

33

    }

34

35

    public int getDefault1() {

36

        return default1;

37

    }

38

39

    public void setDefault1(int default1) {

40

        this.default1 = default1;

41

    }

42

}

 

 

 

 

store(OutputStreamout,Stringcomments)

3.字节流的输入与输出的应和图示

顶级赌场官方直营网 7

 

 

图暗绛雾灰的为机要的照管部分,郎窑红的豆蔻梢头部分正是不对应部分。铅灰的虚线部分代表这个流平时要映衬使用。从地点的图中得以观察Java IO 中的字节流是然则对称的。历史学上讲“存在及合理”,现在大家看看那么些字节流中不太对称的多少个类吧!

10.4 打印流

store(Writerwriter,Stringcomments卡塔尔国参数二:代表注释

4.多少个奇特的输入流类深入分析

10.4.1 概述

        平常大家在调控台打字与印刷输出,是调用print方法和println形式成功的,那五个点子都源于于java.io.PrintStream类,该类能够有扶植地打字与印刷种种数据类型的值,是生机勃勃种便利的输出方式。

load(State of Qatar:通过输入流读取钦命文件中的数据

LineNumberInputStream

重在变成从流中读取数据时,会获得相应的行号,至于什么日期分行、在哪里分行是由改类主动分明的,并不是在原有中有与此相类似贰个行号。在输出部分没有相应的片段,大家全然能够温和树立一个LineNumberOutputStream,在开始时期写入时会有贰个准绳的行号,现在每便境遇换行时会在下意气风发行增加多少个行号,看起来也是足以的。好像更不入流了。

10.4.2 PrintStream类

 

load(InputStreaminStream)load(Readerreader)

PushbackInputStream

其意义是翻开末了三个字节,不顺心就放入缓冲区。重要用在编写翻译器的语法、词法深入分析部分。输出部分的BufferedOutputStream 差不离实现相符的效应。

StringBufferInputStream

现已被Deprecated,自己就不应有出未来InputStream部分,首要归因于String 应该归属字符流的限量。已经被废弃了,当然输出部分也并未有供给须要它了!还允许它存在只是为着维持版本的向下包容而已。

布局方法

  • `public PrintStream(String fileName) `: 使用钦定的文本名创立二个新的打字与印刷流。

3、遍历数据

SequenceInputStream

能够以为是三个工具类,将五个也许八个输入流当成一个输入流依次读取。完全可以从IO 包中去除,还完全不影响IO 包的构造,却让其更“纯洁”――纯洁的Decorator 方式。

【案例】将五个文件文件合併为其它四个文书文件

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.OutputStream;  
  7. import java.io.SequenceInputStream;  
  8.    
  9. /** 
  10.  * 将七个文本文件合併为此外一个文本文件 
  11.  * */  
  12. public class SequenceInputStreamDemo{  
  13.     public static voidmain(String[] args) throws IOException{  
  14.         File file1 = newFile("d:" + File.separator + "hello1.txt");  
  15.         File file2 = newFile("d:" + File.separator + "hello2.txt");  
  16.         File file3 = newFile("d:" + File.separator + "hello.txt");  
  17.         InputStream input1 =new FileInputStream(file1);  
  18.         InputStream input2 =new FileInputStream(file2);  
  19.         OutputStream output =new FileOutputStream(file3);  
  20.         // 合并流  
  21.         SequenceInputStreamsis = new SequenceInputStream(input1, input2);  
  22.         int temp = 0;  
  23.         while((temp =sis.read()) != -1){  
  24.            output.write(temp);  
  25.         }  
  26.         input1.close();  
  27.         input2.close();  
  28.         output.close();  
  29.         sis.close();  
  30.     }  
  31. }  
  32.    

10.4.3 改动打字与印刷流向

public static void main(String[] args卡塔尔(قطر‎ throws IOException { // 调用系统的打字与印刷流,调节台直接出口97 System.out.println(97卡塔尔(قطر‎; // 创造打字与印刷流,内定文件的称谓 PrintStream ps = new PrintStream("ps.txt"卡塔尔; // 设置系统的打字与印刷流流向,输出到ps.txt System.setOut(ps卡塔尔(قطر‎; // 调用系统的打字与印刷流,ps.txt中输出97 System.out.println(97卡塔尔; }

 

 

 

12

 

 

 

 

 

1

    public static void main(String[] args) throws IOException {

2

// 调用系统的打印流,控制台直接输出97

3

        System.out.println(97);

4

      

5

// 创建打印流,指定文件的名称

6

        PrintStream ps = new PrintStream("ps.txt");

7

      

8

      // 设置系统的打印流流向,输出到ps.txt

9

        System.setOut(ps);

10

      // 调用系统的打印流,ps.txt中输出97

11

        System.out.println(97);

12

    }

 

 

 

list(State of Qatar:将汇集中的全体数据输出到钦命的流中(常常用于调节和测验)

PrintStream

也得以认为是一个扶持理工程师具。首要能够向其它输出流,可能FileInputStream 写入数据,自个儿内部落实照旧带缓冲的。本质上是对其余流的总结应用的三个工具而已。一样可以踢出IO 包!System.err和System.out 就是PrintStream 的实例!

 

【案例】使用PrintStream进行输出

 

[java] view plain copy

 

  1. /** 
  2.  * 使用PrintStream举办输出 
  3.  * */  
  4. import java.io.*;  
  5.    
  6. class hello {  
  7.    public static void main(String[] args) throws IOException {  
  8.        PrintStream print = new PrintStream(new FileOutputStream(newFile("d:"  
  9.                 + File.separator +"hello.txt")));  
  10.        print.println(true);  
  11.        print.println("Rollen");  
  12.        print.close();  
  13.     }  
  14. }  

 

【案例】使用PrintStream举行格式化输出

 

[java] view plain copy

 

  1. /** 
  2.  * 使用PrintStream举办输出 
  3.  * 并举行格式化 
  4.  * */  
  5. import java.io.*;  
  6. class hello {  
  7.    public static void main(String[] args) throws IOException {  
  8.        PrintStream print = new PrintStream(new FileOutputStream(newFile("d:"  
  9.                 + File.separator +"hello.txt")));  
  10.        String name="Rollen";  
  11.        int age=20;  
  12.        print.printf("姓名:%s. 年龄:%d.",name,age);  
  13. 顶级赌场官方直营网,       print.close();  
  14.     }  
  15. }  

 

【案例】使用OutputStream向荧屏上输出内容

 

[java] view plain copy

 

  1. /** 
  2.  * 使用OutputStream向荧屏上输出内容 
  3.  * */  
  4. import java.io.*;  
  5. class hello {  
  6.    public static void main(String[] args) throws IOException {  
  7.        OutputStream out=System.out;  
  8.        try{  
  9.            out.write("hello".getBytes());  
  10.        }catch (Exception e) {  
  11.            e.printStackTrace();  
  12.        }  
  13.        try{  
  14.            out.close();  
  15.        }catch (Exception e) {  
  16.            e.printStackTrace();  
  17.        }  
  18.     }  
  19. }  

 

【案例】输入输出重定向

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.FileOutputStream;  
  4. import java.io.PrintStream;  
  5.    
  6. /** 
  7.  * 为System.out.println(卡塔尔(قطر‎重定向输出 
  8.  * */  
  9. public class systemDemo{  
  10.    public static void main(String[] args){  
  11.        // 此刻一贯出口到显示屏  
  12.        System.out.println("hello");  
  13.        File file = new File("d:" + File.separator +"hello.txt");  
  14.        try{  
  15.            System.setOut(new PrintStream(new FileOutputStream(file)));  
  16.        }catch(FileNotFoundException e){  
  17.            e.printStackTrace();  
  18.        }  
  19.        System.out.println("那个内容在文件中本领收看啊!"State of Qatar;  
  20.     }  
  21. }  

 

【案例】使用System.err重定向

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileNotFoundException;  
  3. import java.io.FileOutputStream;  
  4. import java.io.PrintStream;  
  5.    
  6. /** 
  7.  *System.err重定向这一个事例也提示我们得以行使这种措施保存不当音讯 
  8.  * */  
  9. public class systemErr{  
  10.    public static void main(String[] args){  
  11.        File file = new File("d:" + File.separator +"hello.txt");  
  12.        System.err.println("那些在支配台出口"卡塔尔国;  
  13.        try{  
  14.            System.setErr(new PrintStream(new FileOutputStream(file)));  
  15.        }catch(FileNotFoundException e){  
  16.            e.printStackTrace();  
  17.        }  
  18.        System.err.println("那个在文件中技巧收看啊!"卡塔尔;  
  19.     }  
  20. }  

 

【案例】System.in重定向

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileNotFoundException;  
  4. import java.io.IOException;  
  5. /** 
  6.  *System.in重定向 
  7.  * */  
  8. public class systemIn{  
  9.    public static void main(String[] args){  
  10.        File file = new File("d:" + File.separator +"hello.txt");  
  11.        if(!file.exists()){  
  12.            return;  
  13.        }else{  
  14.            try{  
  15.                 System.setIn(newFileInputStream(file));  
  16.            }catch(FileNotFoundException e){  
  17.                 e.printStackTrace();  
  18.            }  
  19.            byte[] bytes = new byte[1024];  
  20.            int len = 0;  
  21.            try{  
  22.                 len = System.in.read(bytes);  
  23.            }catch(IOException e){  
  24.                 e.printStackTrace();  
  25.            }  
  26.            System.out.println("读入的剧情为:" + new String(bytes, 0, len卡塔尔(قطر‎卡塔尔国;  
  27.        }  
  28.     }  
  29. }  

10.5 属性集

list(PrintStreamout)list(PrintWriterout)

5.字符输入流Reader

10.5.1 概述

java.util.Properties 继承于Hashtable ,来代表三个贯彻始终的性质集。它应用键值布局存款和储蓄数据,各样键及其对应值都以三个字符串。该类也被众多Java类使用,例如获取系统性子时,System.getProperties data-wiz-span="data-wiz-span"> 方法正是回去一个Properties data-wiz-span="data-wiz-span">对象。

stringPropertyNames(卡塔尔国:获取群集中键的汇合(键的连串是String类型)

概念和评释:

在地点的持续关系图中得以观望:

Reader 是具备的输入字符流的父类,它是三个抽象类。

CharReader、StringReader是两种基本的媒质流,它们各自将Char 数组、String中读取数据。PipedReader 是从与别的线程共用的管道中读取数据。

BufferedReader 很显明便是一个装饰器,它和其子类担任装饰别的Reader 对象。

Filter里德r 是具备自定义具体装饰流的父类,其子类PushbackReader 对Reader 对象开展装修,会追加一个行号。

InputStreamReader 是三个三回九转字节流和字符流的桥梁,它将字节流调换为字符流。FileReader能够说是叁个高达此作用、常用的工具类,在其源代码中映珍视帘使用了将FileInputStream 调换为Reader 的主意。大家能够从那一个类中获得一定的本事。Reader 中各类类的用项和动用格局基本和InputStream 中的类应用同生龙活虎。后边会有Reader 与InputStream 的呼应关系。

10.5.2 Properties类

 

实例操作演示:

【案例】从文件中读取内容

 

[java] view plain copy

 

  1. /** 
  2.  * 字符流 
  3.  * 从文件中读出内容 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        char[] ch=new char[100];  
  11.        Reader read=new FileReader(f);  
  12.        int count=read.read(ch);  
  13.        read.close();  
  14.        System.out.println("读入的长度为:"+count卡塔尔国;  
  15.        System.out.println("内容为"+new String(ch,0,count));  
  16.     }  
  17. }  

 

只顾:当然最佳应用循环读取的办法,因为大家一时候不知晓文书到底有多大。

【案例】以巡回方式从文件中读取内容

 

[java] view plain copy

 

  1. /** 
  2.  * 字符流 
  3.  * 从文件中读出内容 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        char[] ch=new char[100];  
  11.        Reader read=new FileReader(f);  
  12.        int temp=0;  
  13.        int count=0;  
  14.        while((temp=read.read())!=(-1)){  
  15.            ch[count++]=(char)temp;  
  16.        }  
  17.        read.close();  
  18.        System.out.println("内容为"+new String(ch,0,count));  
  19.     }  
  20. }  

 

【案例】BufferedReader的小例子

瞩目:BufferedReader只可以负责字符流的缓冲区,因为每七个国语必要占用多个字节,所以必要将System.in这么些字节输入流变为字符输入流,接受:

BufferedReader buf = new BufferedReader(newInputStreamReader(System.in));

上边是一个实例:

 

[java] view plain copy

 

  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStreamReader;  
  4.    
  5. /**澳门官网唯一授权入口, 
  6.  * 使用缓冲区从键盘上读入内容 
  7.  * */  
  8. public class BufferedReaderDemo{  
  9.    public static void main(String[] args){  
  10.        BufferedReader buf = new BufferedReader(  
  11.                 newInputStreamReader(System.in));  
  12.        String str = null;  
  13.        System.out.println("请输入内容"卡塔尔;  
  14.        try{  
  15.            str = buf.readLine();  
  16.        }catch(IOException e){  
  17.            e.printStackTrace();  
  18.        }  
  19.        System.out.println("你输入的源委是:" + str卡塔尔;  
  20.     }  
  21. }  

 

【案例】Scanner类实例

 

[java] view plain copy

 

  1. import java.util.Scanner;  
  2. /** 
  3.  *Scanner的小例子,从键盘读数据 
  4.  * */  
  5. public class ScannerDemo{  
  6.     publicstatic void main(String[] args){  
  7.        Scanner sca = new Scanner(System.in);  
  8.        // 读叁个卡尺头  
  9.        int temp = sca.nextInt();  
  10.        System.out.println(temp);  
  11.        //读取浮点数  
  12.        float flo=sca.nextFloat();  
  13.        System.out.println(flo);  
  14.         //读取字符  
  15.        //...等等的,都以有的太底子的,就不师范了。  
  16.     }  
  17. }  

 

【案例】Scanner类从文件中读出内容

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileNotFoundException;  
  3. import java.util.Scanner;  
  4.    
  5. /** 
  6.  *Scanner的小例子,从文件中读内容 
  7.  * */  
  8. public class ScannerDemo{  
  9.    public static void main(String[] args){  
  10.    
  11.        File file = new File("d:" + File.separator +"hello.txt");  
  12.        Scanner sca = null;  
  13.        try{  
  14.            sca = new Scanner(file);  
  15.        }catch(FileNotFoundException e){  
  16.            e.printStackTrace();  
  17.        }  
  18.        String str = sca.next();  
  19.        System.out.println("从文件中读取的内容是:" + str卡塔尔国;  
  20.     }  
  21. }  

 

构造方法

  • public Properties() :成立一个空的质量列表。

  • ### 基本的寄存方法

    • public Object setProperty(String key, String value) : 保存生龙活虎对质量。

    • public String getProperty(String key) :使用此属性列表中钦点的键研究属性值。

    • public Set<String> stringPropertyNames() :全体键的称号的聚合。

 

1.1.1  示例程序

6.字符输出流Writer

与流相关的措施

  • `public void load(InputStream inStream)`: 从字节输入流中读取键值对。

参数中行使了字节输入流,通过流对象,能够提到到某文件上,那样就能够加载文本中的数据了。文本数据格式:

public static void main(String[] args卡塔尔(قطر‎ throws FileNotFoundException { // 创制属性集对象 Properties pro = new Properties(卡塔尔国; // 加载文本中国国投息到属性集 pro.load(new FileInputStream("read.txt"卡塔尔卡塔尔(قطر‎; // 遍历集结併打字与印刷 Set<String> strings = pro.stringPropertyNames(卡塔尔国; for (String key : strings State of Qatar { System.out.println(key+" -- "+pro.getProperty(key卡塔尔国卡塔尔(قطر‎; } } 结果: filename=a.txt length=209385038 location=D:a.txt tips; 文本中的数据,必须是键值对格局,能够使用空格、等号、冒号等标记分隔

 

 

 

18

 

 

 

 

 

1

    public static void main(String[] args) throws FileNotFoundException {

2

        // 创建属性集对象

3

        Properties pro = new Properties();

4

        // 加载文本中信息到属性集

5

        pro.load(new FileInputStream("read.txt"));

6

        // 遍历集合并打印

7

        Set<String> strings = pro.stringPropertyNames();

8

        for (String key : strings ) {

9

          System.out.println(key+" -- "+pro.getProperty(key));

10

        }

11

     }

12

结果:

13

filename=a.txt

14

length=209385038

15

location=D:a.txt

16

17

tips;

18

    文本中的数据,必须是键值对形式,可以使用空格、等号、冒号等符号分隔

 

 

 

概念和认证:

在上头的关系图中能够看来:

Writer 是怀有的出口字符流的父类,它是一个抽象类。

CharArrayWriter、StringWriter 是三种为主的介质媒质流,它们分别向Char 数组、String 中写入数据。

PipedWriter 是向与此外线程共用的管道中写入数据,

BufferedWriter 是四个装饰器为Writer 提供缓冲作用。

PrintWriter 和PrintStream 特别相近,功用和使用也非凡相符。

OutputStreamWriter 是OutputStream 到Writer 转变的大桥,它的子类FileWriter 其实正是三个得以完毕此成效的具体类(具体能够商量风华正茂SourceCode)。功效和接收和OutputStream 特别相仿,后边会有它们的对应图。

10.6 Path接口和Files类

publicclass Demo {

实例操作演示:

【案例】向文件中写入数据

 

[java] view plain copy

 

  1. /** 
  2.  * 字符流 
  3.  * 写入数据 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) throws IOException {  
  8.        String fileName="D:"+File.separator+"hello.txt";  
  9.        File f=new File(fileName);  
  10.        Writer out =new FileWriter(f);  
  11.        String str="hello";  
  12.        out.write(str);  
  13.        out.close();  
  14.     }  
  15. }  

 

留心:那一个事例上事情未发生前的事例没怎么分别,只是你能够直接输入字符串,而无需您将字符串转变为字节数组。当您假设想问文件中追加内容的时候,能够应用将地点的评释out的哪后生可畏行换为:

Writer out =new FileWriter(f,true);

诸有此类,当你运转程序的时候,会意识文件内容变为:hellohello假若想在文件中换行的话,供给利用“rn”比如将str变为String str="rnhello";那样文件扩大的str的剧情就能够换行了。

10.6.1 概述

  • java.nio.file.Paths :是一个类,该类通过转移路线字符串重返七个Path
  • java.nio.file.Path:是三个接口,表示系统有关的文件路线,用于在文件系统中固定文件的指标,能够代表File类。

  • `java.nio.file.Files`:是三个工具类,富含对文本、目录举办操作的静态方法。

public static void main(String[] args)throws IOException {

7.字符流的输入与出口的应和

顶级赌场官方直营网 8

 

 

10.6.2 便捷的公文操作

Paths类 使用Paths,获取Path对象,代码演示如下: Path path = 帕特hs.get("D:\a.txt"卡塔尔国; Files类 - 删除文件 public static void main(String[] args) throws IOException { // 获取Path Path path = Paths.get("D:\a.txt"卡塔尔(قطر‎; // 删除文件 Files.delete(path卡塔尔国; } - 文件复制 public static void main(String[] args) throws IOException { // 获取Path Path src = Paths.get("D:\src.txt"); Path target = Paths.get("D:\target.txt"); //REPLACE_EXISTING:文件存在,就替换 Files.copy(src, target,StandardCopyOption.REPLACE_EXISTING卡塔尔(قطر‎; } - 逐行读取文件 public static void main(String[] args) throws IOException { // 获取path Path src = Paths.get("D:\read.txt"); // 创设字符流 BufferedReader reader = Files.newBufferedReader(src,StandardCharsets.UTF_8卡塔尔国; // 读取字符 String line ; while((line = reader.readLine(State of Qatar卡塔尔 != null卡塔尔{ System.out.println(line卡塔尔国; } // 释放能源 reader.close(卡塔尔(قطر‎; }

 

 

 

x

 

 

 

 

 

1

Paths类

2

3

使用Paths,获取Path对象,代码演示如下:

4

5

    Path path = Paths.get("D:\a.txt");

6

7

Files类

8

9

- 删除文件

10

11

    public static void main(String[] args) throws IOException {

12

      // 获取Path

13

        Path path = Paths.get("D:\a.txt");

14

      // 删除文件

15

        Files.delete(path);

16

    }

17

18

- 文件复制

19

20

    public static void main(String[] args) throws IOException {

21

      // 获取Path

22

      Path src = Paths.get("D:\src.txt");

23

      Path target = Paths.get("D:\target.txt");

24

    

25

        //REPLACE_EXISTING:文件存在,就替换

26

        Files.copy(src, target,StandardCopyOption.REPLACE_EXISTING);

27

    }

28

29

- 逐行读取文件

30

31

    public static void main(String[] args) throws IOException {

32

      // 获取path

33

     Path src = Paths.get("D:\read.txt");

34

      // 创建字符流

35

        BufferedReader reader = Files.newBufferedReader(src,StandardCharsets.UTF_8);

36

      // 读取字符

37

        String line ;

38

        while((line = reader.readLine()) != null){

39

            System.out.println(line);

40

        }

41

      // 释放资源

42

        reader.close();

43

    }

44

45

46

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

<wiz_tmp_tag id="wiz-table-range-border" contenteditable="false" style="display: none;">

 

 

 

 

发源为知笔记(Wiz卡塔尔国

Properties prop = newProperties();

8.字符流与字节流调换

/*

调换流的特征:

(1)其是字符流和字节流之间的大桥

(2)可对读取到的字节数据通过钦定编码转换来字符

(3)可对读取到的字符数据通过钦定编码转变到字节

* Properties类继承于Hashtable类,所以能够采纳put方法增添键值对,

什么时候使用调换流?

当字节和字符之间有调换动作时;

流操作的数量须求编码或解码时。

* 不过Properties类中的数据必要应当都以String类型,使用put方法重回恐怕会出标题

具体的靶子浮现:

InputStreamReader:字节到字符的大桥

OutputStreamWriter:字符到字节的大桥

那五个流对象是字符体系中的成员,它们有转移职能,自己又是字符流,所以在结构的时候必要传入字节流对象进来。

* 官方建议使用setProperty(卡塔尔(قطر‎方法增多键值对

字节流和字符流转变实例:

【案例】将字节输出流转化为字符输出流

 

[java] view plain copy

 

  1. /** 
  2.  * 将字节输出流转变为字符输出流 
  3.  * */  
  4. import java.io.*;  
  5. class hello{  
  6.    public static void main(String[] args) throws IOException {  
  7.        String fileName= "d:"+File.separator+"hello.txt";  
  8.        File file=new File(fileName);  
  9.        Writer out=new OutputStreamWriter(new FileOutputStream(file));  
  10.        out.write("hello");  
  11.        out.close();  
  12.     }  
  13. }  

 

【案例】将字节输入流转变为字符输入流

 

[java] view plain copy

 

  1. /** 
  2.  * 将字节输入流变为字符输入流 
  3.  * */  
  4. import java.io.*;  
  5. class hello{  
  6.    public static void main(String[] args) throws IOException {  
  7.        String fileName= "d:"+File.separator+"hello.txt";  
  8.        File file=new File(fileName);  
  9.        Reader read=new InputStreamReader(new FileInputStream(file));  
  10.        char[] b=new char[100];  
  11.        int len=read.read(b);  
  12.        System.out.println(new String(b,0,len));  
  13.        read.close();  
  14.     }  
  15. }  

 

*/

9.File类

File类是对文件系统汉语件以致文件夹进行李包裹装的对象,能够通过对象的动脑来操作文件和文书夹。 File类保存文件或目录的各样元数据新闻,包罗文件名、文件长度、最终纠正时间、是不是可读、获取当前文件的路线名,判定内定文件是还是不是存在、拿到当前目录中的文件列表,创造、删除文件和目录等方法。 

【案例 】创造八个文件

 

[java] view plain copy

 

  1. import java.io.*;  
  2. class hello{  
  3.    public static void main(String[] args) {  
  4.        File f=new File("D:\hello.txt");  
  5.        try{  
  6.            f.createNewFile();  
  7.        }catch (Exception e) {  
  8.            e.printStackTrace();  
  9.        }  
  10.     }  
  11. }  

 

【案例2】File类的多个常量

 

[java] view plain copy

 

  1. import java.io.*;  
  2. class hello{  
  3.    public static void main(String[] args) {  
  4.        System.out.println(File.separator);  
  5.        System.out.println(File.pathSeparator);  
  6.     }  
  7. }  

 

此处多说几句:有个别同学只怕认为,我一贯在windows下选拔扩充私分不行吧?当然是足以的。可是在linux下就不是了。所以,要想使得大家的代码跨平台,越发完善,所以,大家都选用那八个常量吧,其实也多写不了几行。

【案例3】File类中的常量改写案例1的代码:

 

[java] view plain copy

 

  1. import java.io.*;  
  2. class hello{  
  3.    public static void main(String[] args) {  
  4.        String fileName="D:"+File.separator+"hello.txt";  
  5.        File f=new File(fileName);  
  6.        try{  
  7.            f.createNewFile();  
  8.        }catch (Exception e) {  
  9.            e.printStackTrace();  
  10.        }  
  11.     }  
  12. }  

 

【案例4】删除叁个文本(或许文件夹)

 

[java] view plain copy

 

  1. import java.io.*;  
  2. class hello{  
  3.    public static void main(String[] args) {  
  4.        String fileName="D:"+File.separator+"hello.txt";  
  5.        File f=new File(fileName);  
  6.        if(f.exists()){  
  7.            f.delete();  
  8.        }else{  
  9.            System.out.println("文件不设有"卡塔尔国;  
  10.        }  
  11.           
  12.     }  
  13. }  

 

【案例5】创立一个文本夹

 

[java] view plain copy

 

  1. /** 
  2.  * 创立贰个文书夹 
  3.  * */  
  4. import java.io.*;  
  5. class hello{  
  6.    public static void main(String[] args) {  
  7.        String fileName="D:"+File.separator+"hello";  
  8.        File f=new File(fileName);  
  9.        f.mkdir();  
  10.     }  
  11. }  

 

【案例6】列出目录下的保有文件

 

[java] view plain copy

 

  1. /** 
  2.  * 使用list列出钦赐目录的整整文本 
  3.  * */  
  4. import java.io.*;  
  5. class hello{  
  6.    public static void main(String[] args) {  
  7.        String fileName="D:"+File.separator;  
  8.        File f=new File(fileName);  
  9.        String[] str=f.list();  
  10.        for (int i = 0; i < str.length; i++) {  
  11.            System.out.println(str[i]);  
  12.        }  
  13.     }  
  14. }  

 

注意使用list再次回到的是String数组,。况且列出的不是完全路径,假如想列出完整路线的话,需求接收listFiles.它回到的是File的数组。

【案例7】列出钦点目录的满贯文书(饱含隐敝文件):

 

[java] view plain copy

 

  1. /** 
  2.  * 使用listFiles列出钦定目录的方方面面文书 
  3.  * listFiles输出的是生龙活虎体化路径 
  4.  * */  
  5. import java.io.*;  
  6. class hello{  
  7.    public static void main(String[] args) {  
  8.        String fileName="D:"+File.separator;  
  9.        File f=new File(fileName);  
  10.        File[] str=f.listFiles();  
  11.        for (int i = 0; i < str.length; i++) {  
  12.            System.out.println(str[i]);  
  13.        }  
  14.     }  
  15. }  

 

【案例8】剖断三个内定的路径是或不是为目录

 

[java] view plain copy

 

  1. /** 
  2.  * 使用isDirectory推断一个点名的门道是不是为目录 
  3.  * */  
  4. import java.io.*;  
  5. class hello{  
  6.    public static void main(String[] args) {  
  7.        String fileName="D:"+File.separator;  
  8.        File f=new File(fileName);  
  9.        if(f.isDirectory()){  
  10.            System.out.println("YES");  
  11.        }else{  
  12.            System.out.println("NO");  
  13.        }  
  14.     }  
  15. }  

 

【案例9】递归找寻钦定目录的全部内容,富含文件和文件夹

 

[java] view plain copy

 

  1. * 列出钦命目录的全部内容  
  2.  * */  
  3. import java.io.*;  
  4. class hello{  
  5.    public static void main(String[] args) {  
  6.        String fileName="D:"+File.separator;  
  7.        File f=new File(fileName);  
  8.        print(f);  
  9.     }  
  10.    public static void print(File f){  
  11.        if(f!=null){  
  12.            if(f.isDirectory()){  
  13.                 File[] fileArray=f.listFiles();  
  14.                 if(fileArray!=null){  
  15.                     for (int i = 0; i <fileArray.length; i++) {  
  16.                         //递归调用  
  17.                         print(fileArray[i]);  
  18.                     }  
  19.                }  
  20.            }  
  21.            else{  
  22.                 System.out.println(f);  
  23.            }  
  24.        }  
  25.     }  
  26. }  

 

//               prop.put("textsize",18);

10.RandomAccessFile类

该目的并非流连串中的生龙活虎员,其包装了字节流,同期还包裹了二个缓冲区(字符数组),通过中间的指针来操作字符数组中的数据。该指标特点:

该对象只可以操作文件,所以构造函数选用两系列型的参数:a.字符串文件路线;b.File对象。

该对象既可以够对文本举行读操作,也能拓宽写操作,在进展对象实例化时可钦点操作格局(r,rwState of Qatar

瞩目:该对象在实例化时,假设要操作的公文不设有,会自动成立;如若文件存在,写多少未内定地方,会从头最初写,即覆盖原有的开始和结果。能够用于三十二线程下载或五个线程同有的时候候写多少到文件。

【案例】使用RandomAccessFile写入文件

 

[java] view plain copy

 

  1. /** 
  2.  * 使用RandomAccessFile写入文件 
  3.  * */  
  4. import java.io.*;  
  5. class hello{  
  6.     public static void main(String[]args) throws IOException {  
  7.         StringfileName="D:"+File.separator+"hello.txt";  
  8.         File f=new File(fileName);  
  9.         RandomAccessFile demo=newRandomAccessFile(f,"rw");  
  10.        demo.writeBytes("asdsad");  
  11.         demo.writeInt(12);  
  12.         demo.writeBoolean(true);  
  13.         demo.writeChar('A');  
  14.         demo.writeFloat(1.21f);  
  15.         demo.writeDouble(12.123);  
  16.         demo.close();    
  17.     }  
  18. }  

 

//               prop.get("textsize");

Java IO流的高档概念

//保存值

编码难题

【案例 】拿到地方的暗许编码

 

[java] view plain copy

 

  1. /** 
  2.  * 得到本地的私下认可编码 
  3.  * */  
  4. publicclass CharSetDemo{  
  5.     public static void main(String[] args){  
  6.         System.out.println("系统暗中同意编码为:"+ System.getProperty("file.encoding"卡塔尔国卡塔尔国;  
  7.     }  
  8. }  

 

【案例 】乱码的产生

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.OutputStream;  
  5.    
  6. /** 
  7.  * 乱码的产生 
  8.  * */  
  9. public class CharSetDemo2{  
  10.     public static void main(String[] args) throws IOException{  
  11.         File file = new File("d:" + File.separator + "hello.txt");  
  12.         OutputStream out = new FileOutputStream(file);  
  13.         byte[] bytes = "你好".getBytes("ISO8859-1");  
  14.         out.write(bytes);  
  15.         out.close();  
  16.     }//输出结果为乱码,系统暗许编码为GBK,而这里编码为ISO8859-1  
  17. }  

prop.setProperty("textsize","18");

对象的连串化

指标体系化就是把叁个指标产生二进制数据流的生机勃勃种方法。

叁个类要想被连串化,就能够必得达成java.io.Serializable接口。即使那么些接口中绝非别的格局,就像同早前的cloneable接口同样。完成了那几个接口之后,就表示那一个类具有被系列化的力量。先让大家得以完毕两个存有体系化本事的类吧:

【案例 】达成全部序列化技艺的类

 

[java] view plain copy

 

  1. import java.io.*;  
  2. /** 
  3.  * 完成全数系列化技巧的类 
  4.  * */  
  5. public class SerializableDemo implements Serializable{  
  6.     public SerializableDemo(){  
  7.           
  8.     }  
  9.     publicSerializableDemo(String name, int age){  
  10.         this.name=name;  
  11.         this.age=age;  
  12.     }  
  13.     @Override  
  14.     public String toString(){  
  15.         return "姓名:"+name+"  年龄:"+age;  
  16.     }  
  17.     private String name;  
  18.     private int age;  
  19. }  

 

【案例 】连串化一个对象 – ObjectOutputStream

 

[java] view plain copy

 

  1. import java.io.Serializable;  
  2. import java.io.File;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.ObjectOutputStream;  
  6. /** 
  7.  * 实现全体系列化本事的类 
  8.  * */  
  9. public class Person implements Serializable{  
  10.     public Person(){  
  11.      }  
  12.     public Person(String name,int age){  
  13.         this.name = name;  
  14.         this.age = age;  
  15.     }  
  16.     @Override  
  17.     public String toString(){  
  18.         return "姓名:" +name + "  年龄:" +age;  
  19.     }  
  20.     private String name;  
  21.     private int age;  
  22. }  
  23. /** 
  24.  * 示范ObjectOutputStream 
  25.  * */  
  26. public class ObjectOutputStreamDemo{  
  27.     public static voidmain(String[] args) throws IOException{  
  28.         File file = newFile("d:" + File.separator + "hello.txt");  
  29.         ObjectOutputStream oos= new ObjectOutputStream(new FileOutputStream(  
  30.                 file));  
  31.         oos.writeObject(newPerson("rollen", 20));  
  32.         oos.close();  
  33.     }  
  34. }  

 

【案例 】反种类化—ObjectInputStream

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.ObjectInputStream;  
  4.    
  5. /** 
  6.  * ObjectInputStream示范 
  7.  * */  
  8. public class ObjectInputStreamDemo{  
  9.     public static voidmain(String[] args) throws Exception{  
  10.         File file = new File("d:" +File.separator + "hello.txt");  
  11.         ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(  
  12.                 file));  
  13.         Object obj =input.readObject();  
  14.         input.close();  
  15.         System.out.println(obj);  
  16.     }  
  17. }  

 

注意:被Serializable接口注明的类的靶子的质量都将被体系化,可是只要想自定义连串化的剧情的时候,就必要落到实处Externalizable接口。

当贰个类要使用Externalizable这几个接口的时候,这一个类中应当要有三个无参的布局函数,若无的话,在结构的时候会生出特别,这是因为在反种类话的时候会暗中认可调用无参的构造函数。

这两天我们来演示一下种类化和反系列话:

【案例 】使用Externalizable来定制系列化和反类别化操作

 

[java] view plain copy

 

  1. package IO;  
  2.    
  3. import java.io.Externalizable;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8. import java.io.ObjectInput;  
  9. import java.io.ObjectInputStream;  
  10. import java.io.ObjectOutput;  
  11. import java.io.ObjectOutputStream;  
  12.    
  13. /** 
  14.  * 类别化和反种类化的操作 
  15.  * */  
  16. public class ExternalizableDemo{  
  17.     public static voidmain(String[] args) throws Exception{  
  18.         ser(); // 序列化  
  19.         dser(卡塔尔国; // 反种类话  
  20.     }  
  21.    
  22.     public static void ser()throws Exception{  
  23.         File file = newFile("d:" + File.separator + "hello.txt");  
  24.         ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(  
  25.                 file));  
  26.         out.writeObject(newPerson("rollen", 20));  
  27.         out.close();  
  28.     }  
  29.    
  30.     public static void dser()throws Exception{  
  31.         File file = newFile("d:" + File.separator + "hello.txt");  
  32.         ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(  
  33.                 file));  
  34.         Object obj =input.readObject();  
  35.         input.close();  
  36.        System.out.println(obj);  
  37.     }  
  38. }  
  39.    
  40. class Person implements Externalizable{  
  41.     public Person(){  
  42.    
  43.     }  
  44.    
  45.     public Person(String name,int age){  
  46.         this.name = name;  
  47.         this.age = age;  
  48.     }  
  49.    
  50.     @Override  
  51.     public String toString(){  
  52.         return "姓名:" +name + "  年龄:" +age;  
  53.     }  
  54.    
  55.     // 复写那几个办法,依据须要能够保留的性质或然具体内容,在类别化的时候使用  
  56.     @Override  
  57.     public voidwriteExternal(ObjectOutput out) throws IOException{  
  58.        out.writeObject(this.name);  
  59.         out.writeInt(age);  
  60.     }  
  61.    
  62.     // 复写那么些情势,遵照需求读取内容 反体系话的时候需求  
  63.     @Override  
  64.     public voidreadExternal(ObjectInput in) throws IOException,  
  65.            ClassNotFoundException{  
  66.         this.name = (String)in.readObject();  
  67.         this.age =in.readInt();  
  68.     }  
  69.    
  70.     private String name;  
  71.     private int age;  
  72. }  

 

留意:Serializable接口落成的操作实际是吗三个指标中的全体天性进行体系化,当然也得以动用大家上运用是Externalizable接口以促成都部队分属性的类别化,不过这样的操作相比较劳顿,

当我们选取Serializable接口完成种类化操作的时候,如若八个对象的某叁性情能不想被类别化保存下来,那么大家能够使用transient关键字打开说明:

【案例 】使用transient关键字定制连串化和反类别化操作

 

[java] view plain copy

 

  1. package IO;  
  2.    
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8. import java.io.Serializable;  
  9.    
  10. /** 
  11.  * 系列化和反连串化的操作 
  12.  * */  
  13. public class serDemo{  
  14.     public static voidmain(String[] args) throws Exception{  
  15.         ser(); // 序列化  
  16.         dser(卡塔尔; // 反体系话  
  17.     }  
  18.    
  19.     public static void ser()throws Exception{  
  20.         File file = newFile("d:" + File.separator + "hello.txt");  
  21.         ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(  
  22.                 file));  
  23.         out.writeObject(newPerson1("rollen", 20));  
  24.         out.close();  
  25.     }  
  26.    
  27.     public static void dser()throws Exception{  
  28.         File file = newFile("d:" + File.separator + "hello.txt");  
  29.         ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(  
  30.                 file));  
  31.         Object obj =input.readObject();  
  32.         input.close();  
  33.        System.out.println(obj);  
  34.     }  
  35. }  
  36.    
  37. class Person1 implements Serializable{  
  38.     public Person1(){  
  39.    
  40.     }  
  41.    
  42.     public Person1(Stringname, int age){  
  43.         this.name = name;  
  44.         this.age = age;  
  45.     }  
  46.    
  47.     @Override  
  48.     public String toString(){  
  49.         return "姓名:" +name + "  年龄:" +age;  
  50.     }  
  51.    
  52.     // 注意这里  
  53.     private transient Stringname;  
  54.     private int age;  
  55. }  

 

【运维结果】:

姓名:null  年龄:20

【案例 】连串化大器晚成组对象

 

[java] view plain copy

 

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.ObjectInputStream;  
  5. import java.io.ObjectOutputStream;  
  6. import java.io.Serializable;  
  7.    
  8. /** 
  9.  * 种类化意气风发组对象 
  10.  * */  
  11. public class SerDemo1{  
  12.     public static voidmain(String[] args) throws Exception{  
  13.         Student[] stu = { newStudent("hello", 20), new Student("world", 30),  
  14.                 newStudent("rollen", 40) };  
  15.         ser(stu);  
  16.         Object[] obj = dser();  
  17.         for(int i = 0; i <obj.length; ++i){  
  18.             Student s =(Student) obj[i];  
  19.            System.out.println(s);  
  20.         }  
  21.     }  
  22.    
  23.     // 序列化  
  24.     public static voidser(Object[] obj) throws Exception{  
  25.         File file = newFile("d:" + File.separator + "hello.txt");  
  26.         ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(  
  27.                 file));  
  28.         out.writeObject(obj);  
  29.         out.close();  
  30.     }  
  31.    
  32.     // 反连串化  
  33.     public static Object[]dser() throws Exception{  
  34.         File file = newFile("d:" + File.separator + "hello.txt");  
  35.         ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(  
  36.                 file));  
  37.         Object[] obj =(Object[]) input.readObject();  
  38.         input.close();  
  39.         return obj;  
  40.     }  
  41. }  
  42.    
  43. class Student implements Serializable{  
  44.     public Student(){  
  45.    
  46.     }  
  47.    
  48.     public Student(Stringname, int age){  
  49.         this.name = name;  
  50.         this.age = age;  
  51.     }  
  52.    
  53.     @Override  
  54.     public String toString(){  
  55.         return "姓名:  " + name + "  年龄:" + age;  
  56.     }  
  57.    
  58.     private String name;  
  59.     private int age;  
  60. }  

prop.setProperty("textcolor","red");

参谋文献:

1、

2、

//获取值

String size =prop.getProperty("textsize");

String color=prop.getProperty("textcolor");

System.out.println(size);

System.out.println(color);

//将质量保存到磁盘上

//Properties的效率是将数据漫长化保存,实际上正是将数据保存在磁盘上

//               prop.save(out, comments);

FileOutputStream fos = new FileOutputStream("prop.properties");

prop.store(fos, "注释");

//从磁盘上读取属性数据

Properties prop2 = newProperties();

FileInputStream fis = newFileInputStream("prop.properties");

prop2.load(fis);

System.out.println(prop2);

//遍历Properties集合(是Map集合)

//list方法经常是用来调节和测验用的

prop2.list(System.out);

//守旧的遍历Map集结的主意,通过keyset方法获取键的集合,然而成分皆以Object类型

//               prop2.keySet();

Set     keyset = prop2.stringPropertyNames();

for (String key : keyset) {

String value =prop2.getProperty(key);

System.out.println(key+"..........."+value);

}

}

}

实例:写二个前后相继,供给客商只可以展开5次,在第6次张开的时候就抛出至极提醒“展开战败”

publicclass Ex {

public static void main(String[] args){

System.out.println("程序开启......."卡塔尔;

//检验选拔的次数

check();

System.out.println("程序平日化运转......."State of Qatar;

System.out.println("程序结束......."卡塔尔国;

}

private static void check() {

/*

* 思路:记录客户张开程序的次数,每一趟展开的时候都记叁回,将次数保存在安插文件中,

* 每一次张开的时候读取上三次记录的次数,要是过量上限,就提示客商

*/

//

FileInputStream fis =null;

FileOutputStream fos = null;

try {

Properties prop =new Properties();

File file = newFile("prop_ex.properties");

//要确认保障文件存在

if(!file.exists()){

file.createNewFile();

}

fis = new FileInputStream(file);

//从文件中加载数据到Properties群集中

prop.load(fis);

//通过键获取值,即使键值对荒诞不经,就回到内定的暗许值

int count=Integer.parseInt(prop.getProperty("count","0"));

count ++;

//判定展开的次数是不是已经超(Jing Chao卡塔尔(قطر‎越了上限

if(count>5){

throw newRuntimeException("适用用次数已经超(jīng chāoState of Qatar过5次上限,请续费!......."State of Qatar;

}else{

//若无超越

fos = newFileOutputStream(file);

prop.setProperty("count",String.valueOf(count));

prop.store(fos,"open count");

}

} catch (IOException e) {

// TODO: handleexception

}finally{

if(fos != null){

try {

fos.close();

fos= null;

} catch(IOException e) {

//TODO Auto-generated catch block

e.printStackTrace();

}

}

if(fis != null){

try {

fis.close();

fis= null;

} catch(IOException e) {

//TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

}

1.2    内存流

数组流

byte[] bytes ={97,98,99,100,101};//源字节数组

ByteArrayInputStream bais =//在源数组上创立八个内部存款和储蓄器输入流

newByteArrayInputStream(bytes);

int n=0;

byte[] buf = new byte[4];

//读4个字节放到缓冲buf中,重返有效读取数

while((n=bais.read(buf))!=-1){

for(int i=0;i

System.out.println(buf[i]);  //打印

}

}

}

//没有必要关闭

//创造二个内存输出流,能够透过它向内置的字节数组中写字节

ByteArrayOutputStream baos=new ByteArrayOutputStream();

baos.write(65卡塔尔(قطر‎;//往内置字节数组中写一个字节

baos.write(66);

baos.write(67);

//从当中拿出事情发生早前写的字节生成的数组

byte[] array =baos.toByteArray();

for(byte b : array卡塔尔{//遍历打字与印刷,用于注脚

System.out.println(b);

}

//源文件流

FileInputStream fis = newFileInputStream("g:/output.txt");

//目的内存输出流

ByteArrayOutputStream baos=new  ByteArrayOutputStream();

int n=0;

本文由澳门网络娱乐游戏平台发布于Web前端,转载请注明出处:澳门官网唯一授权入口Java IO流详尽解析

相关阅读