javaIO流


  javaIO流….笔记

流向区分

  应当以程序或者内存为参照物,(从文件或屏幕等)往内存中读入叫做输入流,反之输出流。

数据类型区分

  字节流和字符流,现有的字节流,后来为了方便文本数据操作,才有的字符流,java中一个字符占两个字节。

  • 一般是默认按照数据类型分类的,不是流向。

基类

  字节流的基类:InputStream,outputStream
  字符流的基类:Reader,Writer

FileOutputStream & FileInputStream

  • 往文件中读写数据就用FileOutputStream & FileInputStream
  • 向文件写入数据

    1
    2
    3
    4
    5
    6
    7
    8
    //创建字节输出流对象,分三步,注意try catch包裹
    //创建字节输出流对象
    FileOutputStream fos=new FileOutputStream("fos.txt");//fos就像一条水管连接到文件上
    //写数据
    fos.write("hello,IO".getBytes());//调用write,数据就像水流顺着水管到文件中
    //释放资源
    //关闭文件输出流并释放与此流有关的资源
    fos.close();
  • 不同系统,换行不同
      Windows:\r\n
      linux:\n
      mac:\r

  • 实现数据追加

    1
    2
    //第二个为true时,在末尾处追加
    FileOutputStream(String name, boolean append)
  • 加入异常处理的字节输出流

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    FileOutputStream fos=null;
    try{
    fos=new FileOutputStream("fos.txt");
    fos.write("java".getBytes());
    }catch(FileNodFoundException e){
    e.printStackTrace();
    }catch(IOException e){
    e.printStackTrace();
    }finally{
    //如果fos不是null,才close
    if(fos!=null){
    try{
    fos.close();
    }catch(IOException e){
    e.printStackTrace();
    }
    }
    }
  • FileInputStream文件的字节读入流

  • 读入流需要有文件,输出流会自动创建
    1
    2
    3
    4
    5
    6
    FileInputStream 从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。 
    FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流,请考虑使用 FileReader。
    int read() //每读一个字节会自动往下移一个位置,如果已到达文件末尾,则返回 -1。
    从此输入流中读取一个数据字节。
    int read(byte[] b)
    从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
1
2
3
4
5
6
7
8
9
10
11
//也是需要三步
//以下代码只能读英文,中文会乱码
//创建输入流对象
FileInputStream fis=new FileOutputStream("fis.txt");
//读入字节
int by=0;
while((by=fis.read())!=-1){
System.out.print((char)by);
}
//释放资源
fis.close();
  • 中文处理
      一个中文字符分为两个字节,第一个字节ASCII肯定是负数,第二个不一定。只需见一个负数,就跟后面一个字节组成一个字符。

  • 一次读取一个字节数组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    import java.io.FileInputStream;
    import java.io.IOException;

    /***
    * 一次读取一个字节数组:int read(byte[]b); 返回值是实际读取的字节个数
    *
    * @author TWS
    *
    */

    public class CopyFiledemo2 {
    public static void main(String[] args) throws IOException {
    FileInputStream fis = new FileInputStream("fis.txt");
    byte[] bys = new byte[5];
    int len = 0;
    while ((len = fis.read(bys)) != -1) {
    System.out.print(new String(bys, 0, len));
    }
    fis.close();

    }
    }

BufferedOutputStream & BufferedInputStream

  • 缓冲区类,其作用是缓冲,相当于一个水杯。
    1
    2
    3
    4
    BufferedInputStream(InputStream in) 
    创建一个 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。
    BufferedInputStream(InputStream in, int size)
    创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数,即输入流 in,以便将来使用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;

/**
* 字节流四种方式复制文件:
* 基本字节流一次一个字节,一次一个数组
* 高效字节流一次一个字节,一次一个数组
* @author TWS
*
*/

public class CopyFiledemo3 {
public static void main(String[] args) throws IOException{
long start=System.currentTimeMillis();
//method1("F:\\教程\\java视频\\day20\\avi\\20.01_IO流(递归概述和注意事项).avi","1.avi");
method2("F:\\教程\\java视频\\day20\\avi\\20.01_IO流(递归概述和注意事项).avi","1.avi");
long end=System.currentTimeMillis();
System.out.println("共耗时:"+(end-start));
}

//字节缓冲区方式
public static void method1(String string, String string2) throws IOException {
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(string));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(string2));
byte[] bys=new byte[1024];
int len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}

//用字符缓冲区方式,移动视频时不如上一种高效
public static void method2(String string, String string2) throws IOException {
BufferedReader br=new BufferedReader(new FileReader(string));
BufferedWriter bw=new BufferedWriter(new FileWriter(string2));
char[] bys=new char[1024];
int len=0;
while((len=br.read(bys))!=-1){
bw.write(bys, 0, len);
}
br.close();
bw.close();

}
}

字符流类似

  • 学会了字节流,字符流类似
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    字节流:
    InputStream
    FileInputStream
    BufferedInputStream
    Outputstream
    FileOutputStream
    BufferedOutputStream
    字符流:
    Reader
    FileReader
    BufferedReader
    Writer
    FileWriter
    BufferedWriter

编码表

ASCII:美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1:拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312:中国的中文编码表。
GBK:中国的中文编码表升级,融合了更多的中文文字符号。
GB18030:GBK的取代版本
BIG-5码 :通行于台湾、香港地区的一个繁体字编码方案,俗称“大五码”。
Unicode:国际标准码,融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8:最多用三个字节来表示一个字符。

UTF-8不同,它定义了一种“区间规则”,这种规则可以和ASCII编码保持最大程度的兼容:
它将Unicode编码为00000000-0000007F的字符,用单个字节来表示
它将Unicode编码为00000080-000007FF的字符用两个字节表示
它将Unicode编码为00000800-0000FFFF的字符用3字节表示 

IO流小结


IO流图解

字符缓冲流读写字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//最为推荐的一种方式
// 字符缓冲流一次读写一个字符串
private static void method5(String srcString, String destString)
throws IOException {
BufferedReader br = new BufferedReader(new FileReader(srcString));
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}

bw.close();
br.close();
}

欢迎与我分享你的看法。
转载请注明出处:http://taowusheng.cn/
微博:寒枫–0-0–
知乎:https://www.zhihu.com/people/tao-wu-sheng
豆瓣:YIFEI