IO 流

一、java IO流的概念

java的io是实现和输入的基础，可以方便的实现数据的输入和输出操作。在java中把不同的舒润/输出源（键盘，文件，网络连接等）抽象表述为“流”（stream）。

二、IO流的分类

（一、）按照不同的分类方式，可以把不同的类型。常用的分类三种：

1.按照流的流分向，可以分为输入流和输出流；

输入流：

输入流：只能从中读取数据，而不能向其写入数据；
InputStream和Reader为基类

输出流

输出流：只能向其写入数据，而不能向其读取数据；
OutputStream和Writer为基类

2.操作单元划分，可以划分为字节流和字符流；

字节流

字节输入流：InputStream基类
字节输出流：OutputStream基类

字符流

字符输入流：Reader基类
字节输出流：Writer基类

3.按照流的角色划分为节点流和处理流；

节点流

节点流：节点流从一个特定的数据源读写数据。即节点流是直接操作文件，网络等的流，例如FileInputStream和FileOutputStream，他们直接从文件中读取或往文件中写入字节流。

img

处理流

处理流：“连接”在已存在的流（节点流或处理流）之上通过对数据的处理为程序提供更为强大的读写功能。过滤流是使用一个已经存在的输入流或输出流连接创建的，过滤流就是对节点流进行一系列的包装。例如BufferedInputStream和BufferedOutputStream，使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率，以及DataInputStream和DataOutputStream，使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。他们都属于过滤流。

(二、)java输入/输出流体系中常用的流的分类表

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FilelnputStream	FileOutlnputStream	FileReader	FileWriter
访问数组	ByteArraylnStream	ByteArrayOutlnStream	CharArrayReader	CharArrayWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedlnputStream	BufferedOutlnputStream	BufferedReader	BufferedWriter
转化流			InputStreamReader	OutputStreamWriter
对象流	ObjectlnputStream	ObjectOutputStream

转换流都能将字符流转成字节流

2.1InputStream

引入相关的类： InputStream ins =null;

构建输入流，例如FileInputStream：

ins =new FileInputStream（new File（path））;

操控字节输入流的，所用的方法也是针对字节的。

常用方法：

三、工作内容

3.1创建文件夹

File file = new File("D://b");
file.mkdir();

3.2创建文档

public void fileTest() throws Exception{
        File file = new File("D://a.txt");
        boolean newFile = file.createNewFile();
        System.out.println(newFile);
    }

3.3删除文档或文档夹

public void fileTest() throws Exception{
        File file = new File("D://a.txt");
         boolean newFile = file.delete();
        System.out.println(newFile);
    }

3.4检查文档是否可以写，读，执行，存在

public void fileTest() throws Exception{
        File file = new File("D://a.txt");
        //能否执行
        System.out.println(file.canExecute());
        //能否读
        System.out.println(file.canRead());
        //能否写入
        System.out.println(file.canWrite());
        //文档是否存在
        System.out.println(file.exists());
    }

3.5文档路径显示

System.out.println(file.getCanonicalPath());

3.6查看是否为文件夹

System.out.println(file.isDirectory());

3.7finally（最终）

try {
    System.out.println("The count is " + Integer.parseInt(count));
} catch (NumberFormatException e) {
    System.out.println("No count");
} finally {
    System.out.println("In finally");
}

3.8io流拷贝文件

package com.xinzhi;

import org.junit.Test;

import java.io.*;

/**
 * @author:荆少奇
 * @create:2020/11/8 17:29
 */
public class IOTest {
    //查找
    @Test
   public void coplyTest() {
        //把一个文件移到另一个地方
        FileInputStream is = null;
        FileOutputStream os = null;
        try {
            File file = new File("D://a/a/a.mp3")；
            is = new FileInputStream("D://a/a/a.mp3");
            os = new FileOutputStream("D://a/b/a.mp3");
            long length = file.length();
            int bay = 1024;
            long completed = 0L;
            byte[] bytes = new byte[bay];
            int len;
            while ((len = is.read(bytes)) != -1){
                completed += bay;
                os.write(bytes,0,len);
                System.out.println("已经拷贝了：" + String.format("%.2f",((double)completed/length)*100) + "%");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

重要

is = new FileInputStream("D://a/a/a.mp3");
os = new FileOutputStream("D://a/b/a.mp3");
int bay = 1024;
byte[] bytes = new byte[bay];
int len;
while ((len = is.read(bytes)) != -1){
      os.write(bytes,0,len);
}

3.9io流读文件内容

public void readFiler() throws IOException {
        //InputStream:是一个抽象类
        // \:是一个 转移符
        //表示磁盘路径的两种表示方式：1、\\   2、/
        try {
            //从文件地址中读取内容到程序中
            //1、建立连接
            InputStream is = new FileInputStream("D://a.txt");
            //2、开始读取信息
            /*
            //方法1：一次只读一个
            System.out.println(is.read());//读取的是字节型的：49
            System.out.println((byte)is.read());//50
            */
            byte[] bytes = new byte[18];
            //把所有的数据读取到这个字节当中
            //声明一个int存储每次读取到的数据
            int i = 0;
            //定义一个记录索引的变量
            int index = 0;
            //循环读取每个数据
            while ((i = is.read()) != -1) {
                //把读取的数据放到i中
                bytes[index] = (byte) i;
                index++;
            }
            //把字节数组转成字符串
            System.out.println(new String(bytes));
            //关闭流
            is.close();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }
    }

3.10IO流写入内容


         * IO写入内容
         * 字节流
         */
        public void writeFile() throw Exception{
            //对一根管道到文件上
            FileOutputStream fo = new FileOutputStream ("D://a");
            String str = "hello js";
            //写出去
            fo.write (str.getBytes ());

            fo.flush ();
            fo.close ();
        }
        //字符流
        public void writeFile2() throw Exception{
            //对一根管道到文件上
            FileWriter fw = new FileWriter ("D://a");
            //写出去
            fw.write ("中华人民共和国");

            fw.flush ();
            fw.close ();
        }

        public void writeFile3() throw Exception {
            //对一根管道到文件上
            FileWriter fw = new FileWriter ("D://a");
          //  BufferedWriter bw = new BufferedWriter (fw);
            //写出去
            fw.append ("aa").append ("bb").append ("cc");

            fw.flush ();
            fw.close ();
        }

3.11打印流和文件追加

public void writeFile4()throw Exception {
            //对一根管道到文件上
            FileWriter fw = new FileWriter ("D://a.txt",true);
            PrintWriter printWriter = new PrintWriter (fw);
            Scanner scanner = new Scanner (System.in);
            //  BufferedWriter bw = new BufferedWriter (fw);
            //写出去
            String flag = null;
            while (!"exit".equals (flag)){
                flag = scanner.next ();
                System.out.println (flag);
                fw.flush ();
            }

            fw.close ();
        }

3.12面向对象注册并存储

package com.xinzhi;

import java.io.*;
import java.util.Scanner;

/**
 * @author:荆少奇
 * @create:2020/11/8 21:51
 */
public class Register {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的用户名：");
        String userName = scanner.next();
        System.out.println("请输入您的密码：");
        String passWord = scanner.next();
        Register register = new Register();
        register.register(userName,passWord);
    }

    /**
     * 注册方法
     * @param userName
     * @param passWord
     */
    public void register(String userName,String passWord){
        User user = new User(userName,passWord);
        //方法
        saveUser(user);
    }

    /**
     * 保存用户
     * @param user
     */
    private void saveUser(User user) {
        /**
         * 输出流
         */
        Writer writer = null;
        PrintWriter pw = null;
        try {
            //常量类里的东西
            File userFile = new File(Constant.BASE_PATH + Constant.USER_FILE_NAME);
            if (!userFile.exists()) {
                userFile.createNewFile();
            }
            writer = new FileWriter (userFile,true);
            pw = new PrintWriter (writer);
            pw.append(user.getUserName())
                    //换行\n\t(制表符)
                    .append("---")
                    .append(user.getPassword())
                    .append("\n");
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (pw != null){
                pw.close();
            }
        }
    }
}

package com.xinzhi;

/**
 * @author:荆少奇
 * @create:2020/11/8 21:56
 */
public class Constant {
    /**
     * 常量类
     * 目录
     */
    public static final String BASE_PATH = "D://";
    public static final String USER_FILE_NAME = "user.txt";
}

package com.xinzhi;

/**
 * @author:荆少奇
 * @create:2020/11/8 21:51
 */
public class User {
    private String userName;
    private String password;

    public User(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    /**
     * 获取get和set
     * @return
     */
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

数据的持久化

[图片上传失败...(image-d29c71-1604848851858)]

3.13.io流对象流序列化和反序列化

implements Serializable对象序列化接口

/**
         * 对象流
         * 序列化
         */
        public void testObjcet() throw Exception{
            //搞个文件流
            FileOutputStream fo = new FileOutputStream ("D://ab.temp");
            ObjectOutputStream oos = new ObjectOutputStream (fo);

            User user = new User ();
            user.getUserName ("中国");

            oos.writeObject (user);

            oos.flush ();
            oos.close ();
        }

/**
         * 对象流
         * 反序列化
         */
        public void testObjcet2() throw Exception{
            //搞个文件流
            FileInputStream fi = new FileInputStream ("D://ab.temp");
            ObjectInputStream ois = new ObjectInputStream (fi);

            //Objectc强转成User
            User user = (User)ois.readObject ();
            System.out.println (user.getUserName ());


            ois.close ();
        }

3.14.网络编程入门

package com.xinzhi;

import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author:荆少奇
 * @create:2020/11/8 22:44
 */
public class QQServer {
    public static void main(String[] args) throws IOException {
        //创建一个服务器
        ServerSocket ss = new ServerSocket ();
        //服务器绑定端口
        ss.bind(new InetSocketAddress (3303));
        //服务器等端口消息
        System.out.println ("服务器已经启动监听制在3303端口");
        Socket accept = ss.accept ();
        //如果有消息来了就接受
        InputStream inputStream = accept.getInputStream ();
        byte[] buff = new byte[1024];
        int len;
        while((len = inputStream.read (buff)) != -1){
            System.out.println (new String(buff,0,len));
        }
        inputStream.close ();

    }
}

package com.xinzhi;

import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * @author:荆少奇
 * @create:2020/11/8 23:02
 */
public class QQ {

    public static void main(String[] args) throws Exception{
        //创建一个客户端
        Socket socket = new Socket ();
        //客户端连接服务器
        socket.connect (new InetSocketAddress ("192.168.1.12",3303));
        OutputStream outputStream = socket.getOutputStream ();
        String mag = "hello server!";
        outputStream.write (mag.getBytes ());

        outputStream.flush ();
        outputStream.close ();

    }
}

2020-11-08 IO流