字节流与字符流

1. IO分类

根据数据的流向分为:输入流和输出流。

• 输入流:把数据从其他设备上读取到内存中的流。
• 输出流:把数据从内存J中写出到其他设备上的流。

格局数据的类型分为:字节流和字符流。

• 字节流:以字节为单位,读写数据的流。
• 字符流:以字符为单位,读写数据的流。

1.1 io流说明图解

注意：
字节流:适合读取音频。视频。图片等二进制文件
字符流:适合读取纯文本文件

2. 字节流

2.1 一切皆为字节

一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都-一个-一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。

2.2 outputstream

java. io. OutputStream抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
public void close() ] : 关闭此输出流并释放与此流相关联的任何系统资源。
public void flush()」: 刷新此输出流并强制任何缓冲的输出字节被写出。
| public void write(byte[] b) :将b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, int len)] : 从指定的字节数组写入len字节,从偏移量off开始输
出到此输出流。
public abstract void write(int b) ] : 将指定的字节输出流。
小贴士:
close方法,当完成流的操作时,必须调用此方法,释放系统资源。
演示一：换行输出abcdef

import java.io.*;
/*追加写/续写:
public FileOutputStream(String name, boolean append)throws FiLeNotFoundException
public FileOutputStream(File file, boolean append) throws FiLeNotFoundException
boolean append:
true:创建对象不会覆盖源文件，继续在文件末尾追加写入数据
false:创建一 个新文件，覆盖源文件
换行:写换行符号
windows \r\n
Linux /n
mac /r
*/
/**
 * @author Administrator
 */
public class Test01 {
    public static void main(String[] args) throws IOException {
        OutputStream ops = new FileOutputStream("a.txt");
        byte[] wo = {97,98,99,100,101,102};
        for (int i = 0; i < wo.length; i++) {
            ops.write(wo[i]);
            //把换行字符转换为数组
            ops.write("\r\n".getBytes());

        }
        ops.close();

    }
}
   /* 输出
       * a
       * b
       * c
       * d
       * e
       * f*/      

演示二：创建文本输出轩成笔记

public class Test02 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fops = new FileOutputStream("b.txt");
        byte[]  bytes = "轩成笔记".getBytes();
        fops.write(bytes);
        fops.close();
//输出：轩成笔记

    }
}

关于换行

• 回车符\r和换行符[\n] :
• 回车符:回到一-行的开头( return).
• 换行符:下一行(newline)。

●系统中的换行:

• Windows系统里,每行结尾是回车+换行」,即\r\n);
• Unix系统里,每行结尾只有换行」,即\n];
• Mac系统里,每行结尾是回车,即\r。从Mac OS X开始与Linux统- 。

2.3 InputStream

FileInputStream(File file) :通过打开与实际文件的连接来创建一个FileInputStream , 该文件由文件系
统中的File对象file命名。

FileInputStream(String name) ]:通过打开与实际文件的连接来创建一个FilenputStream , 该文件由文件
系统中的路径名name命名。
当你创建一个流对象时,必须传入-个文件路径。该路径下, 如果没有该文件,会抛出F ileNotF oundException }。

import java.io.FileInputStream;
import java.io.IOException;

public class Test03 {
    public static void main(String[] args) throws IOException {
        FileInputStream fips = new FileInputStream("a.txt");
        int num=0;
        while ((num=fips.read())!=-1){
            System.out.println((char) num);
        }
        fips.close();
    }

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

public class Test04 {
    public static void main(String[] args) throws IOException {
        FileInputStream fips = new FileInputStream("a.txt");
        int len;
        byte[] bytes= new byte[1024];
        while ((len=fips.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        fips.close();
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test05 {
    public static void main(String[] args) throws IOException {
        FileInputStream fip = new FileInputStream("D:\\美女壁纸\\美女壁纸\\1.jpg");
        FileOutputStream fos = new FileOutputStream("E:\\1.jpg");
        byte[] bytes = new byte[1024];
        int len;
        while ((len=fip.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fip.close();
        fos.close();

    }

2.4 FileReader

| java. io. Reader抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。它定义了字符输入
流的基本共性功能方法。
●
public void close() : 关闭此流并释放与此流相关联的任何系统资源。
●public int read()]:从输入流读取-一个字符。
public int read(char[] cbuf) ]: 从输入流中读取-些字符,并将它们存储到字符数组cbuf中。

FileReader(File file)」 :
创建一个新的FileReader , 给定要读取的File对象。
FileReader(String fileName): 创建一个新的FileReader , 给定要读取的文件的名称。

import java.io.FileReader;
import java.io.IOException;

public class Test06 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("b.txt");
        int len;
        while ((len=fr.read())!=-1){
            System.out.println((char) len);
        }
        fr.close();
    }
}

2.5 FileWriter

●Filewriter(File file)]: 创建一个新的FileWriter ,给定要读取的File对象。
●Filelriter(string fileName)」:创建一个新的FileWriter ,给定要读取的文件的名称。
当你创建一个流对象时,必须传入-一个文件路径,类似于FileOutputStream.

因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据的。如果我们既想写出数据,又想继续使用流,就需要flush方法了。
flush : 刷新缓冲区,流对象可以继续使用。
●Close :先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。
注意：字符流输出流写的时候需要刷新,字节流可以不用

参数: boolean append-
true:创建对象不会覆盖源文件，继续在文件末尾追加写入数据
false:创建一 个新文件，覆盖源文件
所以这个与字节输出流恰恰相反
换行: 写换行符号
vindows \r\n .
_inux /n
nac /r

/*java. io. Writer
java. io. OutputStreamWriter
java. io. FileWriter
public void write(int c) throws IOException写一 个字符
public void write(char[] cbuf, int off, int len) throws IOException写入字符数组的- 一部分。
public void write(char[] cbuf) throws IOException写入一 个字符数组。
public abstract void fLush() throws IOException刷新流。
public abstract void close() throws IOException关闭流，先刷新
注意：字符流输出流写的时候需要刷新,字节流可以不用
*/
public class Test07 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("c.txt");
//        fw.write("我是你爸爸");
       char[] chars = "今天太勤快".toCharArray();
       fw.write(chars);
        fw.flush();
        fw.close();
    }
}

在JDK1.7之前使用try… catch…finally处理流中的异常和释放流资源
格式:
try{
可能出现异常的代码
}catch(异常类型变量名){
异常的处理逻辑
}finally{
资源释放

import java.io.FileWriter;
import java.io.IOException;

/*续写和换行
续写，追加写:使用两个参数的构造方法
- -public FileWriter(String fileName, boolean append) throws IOException
构造一个Filewriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。
- -public FileWriter(File file, boolean append)throws IOException
给一个File对象构造一个FileWriter对象。 如果第 二个参数是true，则字节将写入文件的末尾而不
参数: boolean append--
true:创建对象不会覆盖源文件，继续在文件末尾追加写入数据
false:创建一一个新文件，覆盖源文件
换行:写换行符号
windows \r\n .
Linux /n
mac /r
*/
public class Test08 {
    public static void main(String[] args)  {
        FileWriter fw= null;
        try {
             fw = new FileWriter("d.txt");
            for (int i = 0; i <10 ; i++) {
                fw.write("你是什么人啊"+"\r\n");
            }
            fw.flush();
        }catch (Exception e){
            System.out.println(e);
        }finally {
            if (fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

JDK7新特性:
在try.的后面可以增加一个小括号 ()，在括号中定义流对象
，那么这个流对象的作用域就在try中有效
try中的代码执行完毕，会自动把流对象释放，就不用再写finnaly了
格式:
try(定义流对象;定义流对象…){
可能会出现异常的代码
}catch(异常类型变量名){
异常的处理逻辑

/*JDK7新特性:
在try.的后面可以增加一个小括号 ()，在括号中定义流对象
，那么这个流对象的作用域就在try中有效
try中的代码执行完毕，会自动把流对象释放，就不用再写finnaly了
格式:
try(定义流对象;定义流对象...){
可能会出现异常的代码
}catch(异常类型变量名){
异常的处理逻辑
}
*/
public class Test09 {
    public static void main(String[] args) {
        try (FileInputStream fip = new FileInputStream("D:\\美女壁纸\\美女壁纸\\1.jpg");
             FileOutputStream fos = new FileOutputStream("E:\\1.jpg")){
            byte[] bytes = new byte[1024];
            int len;
            while ((len=fip.read(bytes))!=-1){
                fos.write(bytes,0,len);
            }
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

Properties

java. util. Properties
Properties表示一个持 久的属性集，Properties 可以保存在流中或从流中加载
Properties.集合是唯一一个 和I0流相结合的集合
Properties集合中的store.方法，把集合中临时数据，持久化写入到硬盘存储
Properties.集合中的Load方法，把硬盘中保存的文件(键值对)，读取到集合中使
注意:是- -个双列集合，key 和alue都是String类型
*/
/*注意1:是一 个双列集合，key和ivalue都是String类型
注意2:
1.存储键值对的文件中,键与值默认的连接符号可以使用,空格(其他符号
2.存储键值对的文件中可以使用#进行注释,被注释的键值对不会再被读取
3.存储键值对的文件中,键与值默认都是字符串,不用再加引号

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

/*java. util. Hashtable<object, object>
java. util. Properties
Properties表示一个持 久的属性集，Properties 可以保存在流中或从流中加载
Properties.集合是唯一一个 和I0流相结合的集合
Properties集合中的store.方法，把集合中临时数据，持久化写入到硬盘存储
Properties.集合中的Load方法，把硬盘中保存的文件(键值对)，读取到集合中使
注意:是- -个双列集合，key 和alue都是String类型
*/
/*注意1:是一 个双列集合，key和ivalue都是String类型
注意2:
1.存储键值对的文件中,键与值默认的连接符号可以使用,空格(其他符号
2.存储键值对的文件中可以使用#进行注释,被注释的键值对不会再被读取
3.存储键值对的文件中,键与值默认都是字符串,不用再加引号
*/
public class Test10 {
    public static void main(String[] args) throws IOException {
        show03();

    }
/*Properties集合中的Load方法，把硬盘中保存的文件(键值对)，读取到集合中使用
public void Load(Reader reader)
throws IOException 以简单的线性格式从输入字符流读取属性列表
*/
    private static void show03() throws IOException {
        Properties pro = new Properties();
        pro.load(new FileReader("e"));
        Set<String> set = pro.stringPropertyNames();
        for (String s : set) {
            System.out.println(pro.getProperty(s)+"="+s);
        }

    }

    /*Properties集合中的store方法，把集合中临时数据，持久化写入到硬盘存储
    public void store(OutputStream out, String comments ) throws IOException
    将此属性列表(键和元素对)写入此Properties表中，以适合于使用Load(InputStream)方法加载到Properties表中的格式输出流。
    public void store (Writer writer, String comments)throws IOException
    将此Properties.表中的此属性列表(键和元素对)以适合使用Load(Reader)方法的格式写入输出字符流。
    */
    private static void show02() throws IOException {
        Properties pro = new Properties();
        pro.setProperty("1","今");
        pro.setProperty("2","天");
        pro.setProperty("3","天");
        pro.setProperty("4","气");
        pro.setProperty("5","晴");
        pro.store(new FileWriter("e"),"注释");
    }

    private static void show01() {
        Properties pro = new Properties();
        pro.setProperty("1","今");
        pro.setProperty("2","天");
        pro.setProperty("3","天");
        pro.setProperty("4","气");
        pro.setProperty("5","晴");
       /* System.out.println(pro.getProperty("1"));
        System.out.println(pro.getProperty("2"));
        System.out.println(pro.getProperty("3"));
        System.out.println(pro.getProperty("4"));
        System.out.println(pro.getProperty("5"));*/
        Set<String> set = pro.stringPropertyNames();
        for (String s : set) {
            System.out.println(pro.getProperty(s));
        }

    }
}