I/O流

1.理论：

1.File  文件的操作

 创建文件夹（目录）
 mkdir/mkdirs
 创建文件
 createNewFile
 
 把我们自己写的功能打成jar包！
 
 
 2.IO流
   
       编码格式     gb2312  gbk  iso-8859-1    utf-8 
   
 
 
 一组有序的数据序列，我们称之为流！
 
  按照流的走向，我们分为：   输入流和输出流！
  
         源头                        参照物
   自来水公司  ======》 水龙头  ======》使用水（取水）
                      输入流                     输出流
  
      我们输入内容（文字，视频，音频，图片，java对象.....）   到  内存中=====》输入流 
  
     我们从内存中获取（文字，视频，音频，图片，java对象.....）             =====》输出流 
     
     我们所研究的流  以内存 为参照物！
     
     
     所有的输入流都有read()  读
     所有的输出流都有write() 写
     
  基类    
 
 按照数据处理 分为以下 几种！！
 
 
 字节流         byte字节          int类型  4个字节      中文占几个字节？  GBK  2个字节！   utf-8  3个字节！数字和字母都是一个！
    a b c = 我
    
    InputStream
   OutputStream
   都是抽象类，我们使用他们的实现类！
   
   
   释放资源的时候有个原则：
      先开后关！

    input
    output
    
    output.close();
    input.close();


 字符流
      Reader
      Writer
      
缓冲流
     BufferedReader 
     BufferedWriter
 
 
 2进制流 （图片，视频.....）
   DataInputStream
   DataOutputStream
 
 
 序列化和反序列化
    是持久化技术中的其中一种实现方式！
 
 ObjectInputStream
 ObjectOutputStream
2.字节流

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
 * 字节 输入流    从电脑中的某个盘符下的某个文件中   到   内存！！！
 */
public class FileInputStreamDemo {

    public static void main(String[] args) {
        InputStream stream = null;
        try {
            stream = new FileInputStream("e:/io.txt");
            System.out.println("输入流中可读取的字节数：" + stream.available());
            // 定义一个变量 接收int类型的返回值
            int num = 0;
            // 获取文件中的内容
            while ((num = stream.read()) != -1) {
                System.out.println((char) num);
            }
            /**
             * stream.read()
             *       从stream中读取一个8位的字节！然后转换成了0-255之间的整数返回！
             *       如果读到了stream的结尾，返回-1！
             * 
             * stream.read(byte[] b)
             *       从stream中读取若干个字节，保存到了b字节数组中！
             *       返回的整数表示读取了多少个字节！如果读到了stream的结尾，返回-1！
             * 
             * stream.read(byte[] b,int off,int length)
             *       从stream中读取若干个字节，保存到了b字节数组中！
             *       参数off:在b字节数组中开始保存数据的起始下标！
             *       length：读取的字节数量！返回的整数表示读取了多少个字节！
             *       如果读到了stream的结尾，返回-1！
             */
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally { // 释放资源
            try {
                stream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * 字节  输出流
 */
public class FileOutputStreamDemo {

    public static void main(String[] args) {
        OutputStream stream = null;
        try {
            stream = new FileOutputStream("e:/io.txt"); // 不会覆盖之前的内容
            stream.write("我爱你中国!！".getBytes());
            stream.flush(); // 无效
            /**
             * OutputStream本身没有设置缓冲区！
             * 它的子类中有！ 比如 BufferedOutputStream 和PrintStream中有带缓冲区！
             * 
             * 举个例子：
             *   你家在黄土高坡！
             *   现在需要从松花江上给老家送 松花蛋！
             *   
             *   比如说  你现在需要1000个松花蛋！
             *   没有缓冲区 就是   每生产一个就会送一个到你家！
             *   这样需要送1000次！
             *   有缓冲区，就是先把生产出来的松花蛋放进仓库！等仓库满了之后或者flush（）的时候
             *   才去发送！
             *   
             *   flush（） 举例：
             *   现在我的仓库有50个松花蛋！  但是 用户flush（）， 那么不需要等待仓库装满！
             *   立即发送！
             */
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                stream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

3.字符流

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

/*
 * 字符  输入流
 */
public class FileReaderDemo {

    public static void main(String[] args) {

        // 创建输入流对象
        Reader reader = null;
        try {
            reader = new FileReader("e:/io.txt");
            int num = 0;
            // 创建char类型的字符数组 用来保存 输入流中的数据
            char[] words = new char[1024];
            // 创建字符串对象
            StringBuffer sb = new StringBuffer();
            while ((num = reader.read(words)) != -1) {
                sb.append(words);
            }
            System.out.println(sb.toString());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

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

/**
 * 字符输出流
 */
public class FileWriterDemo {

    public static void main(String[] args) {
        Writer writer = null;
        try {
            writer = new FileWriter("e:/io.txt", true);
            // 开始从内存中输出到 文件中
            writer.write("我也爱你！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                writer.close(); // 释放资源
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

4.缓冲区输入输出流

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * 
 * BufferedReader
 * 
 *  01.带有缓冲区的  输入流
 *  02.可以逐行读取
 */
public class BufferedReaderDemo {

    public static void main(String[] args) {
        Reader reader = null;
        BufferedReader br = null;

        try {
            reader = new FileReader("e:/io.txt");
            br = new BufferedReader(reader);
            StringBuffer sb = new StringBuffer();
            String line = null;
            // 开始循环读取
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            System.out.println(sb.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try { // 释放资源
                br.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * 带有缓冲区的  输出流
 */
public class BufferedWriterDemo {

    public static void main(String[] args) {

        Writer writer = null;
        BufferedWriter bw = null;
        try {
            writer = new FileWriter("e:/io.txt", true);
            bw = new BufferedWriter(writer);
            // 开始输出
            bw.write("今天天气不错1111！");
            bw.newLine();
            bw.write("今天天气不错呀2222！");
            bw.flush();
            bw.write("今天天气不错呀3333！");
            bw.write("今天天气不错呀4444！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }

}

5.二进制输入输出流

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 2进制 的输入 输出流 
 */
public class DataStreamDemo {

    public static void main(String[] args) throws Exception {
        InputStream in = new FileInputStream("e:/U2/music.mp3");
        // 从电脑中读取某个2进制文件
        DataInputStream dis = new DataInputStream(in);

        OutputStream out = new FileOutputStream("e:/haha.mp3");
        // 需要从内存中 放到电脑中的指定位置
        DataOutputStream dos = new DataOutputStream(out);

        int num = 0;
        // 读取之后 直接 写入
        while ((num = dis.read()) != -1) {
            // 写入
            dos.write(num);
        }

        dos.close();
        dis.close();
        out.close();
        in.close();

    }

}

 6.序列化和反序列化

import java.io.Serializable;

/**
 * 这个类创建的对象 就可以 序列化
 */
public class User implements Serializable {

    private String name; // 用户名
    private String password; // 密码

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

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

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

    public User() {
        super();
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", password=" + password + "]";
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.Scanner;

/**
 * 序列化 和 反序列化
 */
public class ObjectStreamDemo {
    static Scanner input = new Scanner(System.in);

    public static void main(String[] args) throws Exception {
        // 调用add
        add();

        // 登录的方法
        System.out.println("请输入您的用户名：");
        String name = input.next();
        System.out.println("请输入您的密码：");
        String password = input.next();
        /**
         * 用户输入的这个用户名和密码  需要和 文件中的对象 进行比较
         * 01.怎么从文件中获取这个对象到 内存中呢？
         * 02.使用ObjectInputStream  输入流
         */

        InputStream in = new FileInputStream("e:/student.txt");
        ObjectInputStream ois = new ObjectInputStream(in);
        User user = (User) ois.readObject();
        if (user.getPassword().equals(password) && user.getName().equals(name)) {
            System.out.println("登录成功！");
        } else {
            System.out.println("登陆失败！");
        }

        ois.close();
        in.close();
    }

    // 注册用户
    public static void add() throws Exception {
        System.out.println("请输入您的用户名：");
        String name = input.next();
        System.out.println("请输入您的密码：");
        String password = input.next();
        // 创建用户对象
        User user = new User(name, password);

        // 想把我们这个user对象放进文件中
        OutputStream out = new FileOutputStream("e:/student.txt");
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(user);
        oos.close();
        out.close();

    }

}