什么是io

input output
输入：播放器打开视频。（读，东西类容不变）
输出：写word到磁盘（写）。（东西类容增加）

数据源

提供数据的媒介。（数据的来源）
源设备：为程序提供数据。一般为输入流。
目标设备：程序数据的目的，地一般对应输出流。
程序相当于一个黑盒子。（对于普通人来说）

什么是流

（对程序而言）

• 一串连续动态的数据集合。
• 就是形容数据传输的过程。
• 

处理对象分类

节点流：可以直接读取数据的。
处理流：不直接连接到数据源或目的地的，（目的：提高性能

java四大io抽象类及其他

inputStream

简介

• 由于是抽象内，需要子类进行重写。
• 向程序中输入数据。且数据单位字节为8bit。
• 返回-1读取完毕。

常用方法

1. int read();读取1字节数据，并将字节的值作为int类型返回范围（0~255）。
2. void close();关闭输入流对象，释放相关系统资源。

OutputStream

简介

抽象类是表示自己输出流的所有类的父类。输出流接收输出字节并将好这些字节发送到某地。

常用方法：

void write(int n);向目的地写入一个字节。
void close();关闭输出流对象，释放相关资源。

总结

都是字节流。
以字节为单位获取数据，命名以上Stram结尾的流一般是字节流。（FileinputStream）（图片，视频）

Reader

• 用于读取字符流抽象类。数据单位为字符。
• int read():读取一个字符的数据，并将这个数据的值作为int 类型返回返回（0~65535）Unicode。如果读取完毕，则返回-1；
• void close()；关闭流对象释放相关系统资源。

Writer

用于输出字符流抽象内数据单位为字符。
void Writer(int n); 向输出流中写入一个字符。
void close();关闭输出流对象，释放相关系统资源。

总结

以字符为单位数据获取数据，命名以上Reader/Writer结尾的流一般是字符流，如FileReader,FileWriter。（文本文件）。

用FileInputStream打开文件（输入文件）

注意：
只能一个一个读。

package javaio;

import java.io.FileInputStream;

public class firm01 {
    public static void main(String[] args) {
        //创建字节输入流

FileInputStream  fis=null;//在try的外面创建流对象，原因是以后还要关闭。不能成为局部变量。
        try {
             fis = new FileInputStream("D:/a.txt.txt");//注意文件名
char s1=(char)fis.read();//只能打印一个值
char s2=(char)fis.read();//只能打印一个值
char s3=(char)fis.read();//只能打印一个值
int s4=fis.read();//只能打印一个值

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            System.out.println(s4);

        } catch (Exception e) {
            e.printStackTrace();

        }finally {
            if(fis!=null) {
                try {
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();//e是Throwable的实例异常对象，
                    // 用在catch语句中，e相当于一个形参，
                    // 一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理
                }
            }
        }
    }
}

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

改进
说明：

1. //强制转化 （类型）变量名 高->底
   //自动转化 底到高
   //byte ，short ->char->int->long->float->double
2. 速度：StringBuilder>StringBuffer>String

package javaio;

import java.io.FileInputStream;

public class firmo2 {
    public static void main(String[] args) {
        //创建字节输入流

        FileInputStream  fis=null;//在try的外面关闭流对象，原因是以后还要关闭。不能成为局部变量。
        try {
            StringBuilder SB=new StringBuilder();
            fis = new FileInputStream("D:/a.txt.txt");//注意文件名
            int temp=0;//因为最后输出完会返回-1.所以用int型，然后可以//强//制转化为char型
         //   while(fis!=null)若这样写，fis会一直输出因为java.io.FileInputStream@1b6d3586，永远不为null
            while((temp=fis.read())!=-1)//读完之后会返回-1
            {
              //  System.out.println(temp);
                SB.append((char)temp);//SB获取所有temp。
            }
            System.out.println(SB.toString());//输出
        } catch (Exception e) {
            e.printStackTrace();

        }finally {
            if(fis!=null) {
                try {
                    fis.close();
                }catch (Exception e){
                    e.printStackTrace();//e是Throwable的实例异常对象，
                    // 用在catch语句中，相当于一个形参，
                    // 一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理
                }
            }
        }
    }
}

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

file文件

操作file文件。

package javaio;//对文件进行操作
import java.io.File;
public class firm0 {
    public static void main(String[] args)throws Exception {
        File file =new File("d:/c.txt");//创建
        System.out.println( file.createNewFile());//成功返回ture
       // System.out.println(file.delete());//删除
        System.out.println(file.exists());//看是否存在
        System.out.println(file.getName());//返回文件名
        System.out.println(file.isFile());//是不是文件
        System.out.println(file.isHidden());//是不是影藏文件(属性->影藏文件)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

操作目录

package javaio;
//针对目录==文件夹
import 常用类.string;
import java.io.File;
public class file1 {
    public static void main(String[] args) {
        //创建File对象
        File file1 = new File("D:/SAM");//没有文件类型，就是目录
        System.out.println(file1.mkdir());//创建单级目录
        File file12 = new File("D:/S/m/q");//没有文件类型，就是目录
        System.out.println(file12.mkdirs());//mkdirs创建多级目录
        System.out.println(file1.isFile());//判断是不是一个文件
        System.out.println(file1.exists());//查询目录是否存在
        System.out.println(file1.isDirectory());//判断当前路径是否为目录
        System.out.println(file12.getParentFile());
        System.out.println(file12.getParentFile().getName());///调用单级目录可能不输出
        ;//
        File file2 = new File("d:/");//注意文件的格式 “d:/”
        String[] srr = file2.list();
        //String temp="ff";
        for (String temp : srr) {//返回所有文件与目录
            System.out.println(temp);
        }
        System.out.println("################################");
        File[] arr2=file2.listFiles();
        for(File temp:arr2)
        {
            System.out.println(temp);
        }

    }
}

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

读取图片文件

package javaio;

import java.io.File;
import java.io.FileInputStream;
//读取文本文件
public class fileinputstream {
    public static void main(String[] args) {
//几乎固定模板//
        FileInputStream fis4 = null;
        try {//创建文件字节输入流
        fis4=new FileInputStream("d:/实验图片.jpg");
        int temp=0;
        while((temp=fis4.read())!=-1)
            {
                System.out.println(temp);
            }
        } catch (Exception e)
        {
            e.printStackTrace();
        } finally {
            try {
                if (fis4 != null) {//不等于空，就把它关了？
                    fis4.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            
        }
    }
}
//输出图片贼长的int类型不过在（0~255）之间。
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

复制文件位置·

package javaio;

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

public class fileoutputstream {
    public static void main(String[] args) {
        FileInputStream fis5 = null;
        FileOutputStream fos = null;
        try {
fis5 =new FileInputStream("d:/实验图片.jpg");
fos=new FileOutputStream("d:/复制图片位置.jpg");
int temp =0;
while((temp=fis5.read())!=-1) {
    fos.write(temp);
}//将数据从内存写入磁盘
            fos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis5!=null) {
                    fis5.close();
                }
                if(fos!=null)
                {
                    fos.close();
                }
            }catch (Exception e ) {
                    e.printStackTrace();
            }
        }
        }
        }

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

通过缓冲区提高读写效率

相当于把以前的一个字节一个字节之间的读取换位用一个容器很多字节一起读取。

方法1

package javaio;

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

public class quickfileoutputstream {
    public static void main(String[] args) {
        FileInputStream fis5 = null;
        FileOutputStream fos = null;
        try {
            fis5 =new FileInputStream("d:/瀑布.jpg");//创建输入流
            fos=new FileOutputStream("d:/复制瀑布位置.jpg");//创建输出流
            /
            byte[]buff=new byte[2048];//创建缓冲区，提高读写效率。
            /
            int temp =0;
          //  while((temp=fis5.read())!=-1) {//返回当前数组长度

                while((temp=fis5.read(buff))!=-1) {//返回当前数组长度
                //fos.write(temp);//改进
                fos.write(buff,0,temp);
            }//将数据从内存写入磁盘
            fos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(fis5!=null) {
                    fis5.close();
                }
                if(fos!=null)
                {
                    fos.close();
                }
            }catch (Exception e ) {
                e.printStackTrace();
            }
        }
    }
}

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