Java IO流操作

1）创建源或者目标对象（拿文件流举例）     
    输入操作：把文件中的数据流向到程序中，此时文件是源，程序是目标.     
    输出操作：把程序中的数据流向到文件中，此时文件是目标，程序是源.
2）创建IO流对象     
    输入操作：创建输入流对象.     
    输出操作：创建输出流对象.
3）具体的IO操作     
    输入操作：输入流对象的read方法.     
    输出操作：输出流对象的write方法.
4):关闭资源(勿忘).：一旦资源关闭之后，就不能使用流对象了，否则报错.     
    输入操作：输入流对象.close().     
    输出操作：输出流对象.close().

//创建文件
File file = new File("E:/javaSE/file01/text.txt");
		
//如果file文件不存在，则自动创建该文件，每次从文件开头写入数据
FileOutputStream fos = new FileOutputStream(file);
//每次从文件末尾写入数据
//FileOutputStream fos = new FileOutputStream(file,true);
		
//写入字节流数据
fos.write(97); //写单个字节 a
fos.write("hello! abc.".getBytes()); //getByte()将字符串转换成字节数组
		
fos.flush();
fos.close();

		//创建文件
		File file = new File("E:/javaSE/file01/text.txt");
				
		FileInputStream fis = new FileInputStream(file);
		
		//创建一个字节数组存放读取的字节数据
		byte[] buf = new byte[10];	//一次最多读取10个字节
		int len = -1;
		while((len=fis.read(buf)) != -1) {
			String str = new String(buf,0,len);//字节数据构造新的 String 
			System.out.println(str);
		}
		fis.close();

//结果
ahello! ab
c.

    public static void main(String[] args) {
        InputStream in = null;
        OutputStream out = null;
        try {
            // 1.创建源和目标
            File srcf = new File("E:/javaSE/file01/text.txt");
            File destf = new File("E:/javaSE/file01/text_copy.txt");
            // 2.创建输入流和输出流对象
            in = new FileInputStream(srcf);
            out = new FileOutputStream(destf);
            // 3.读取/写出操作
            byte[] buffer = new byte[1024]; // 创建容量为1024的缓冲区(存储已经读取到的数据)
            int len = -1; // 返回-1 表示读取完毕
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len); // 将数据从buffer中写出去
            }
        } catch (Exception e) { // 处理异常
            e.printStackTrace();
        } finally {
            // 4.关闭资源
            try {
                if (in == null) {
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (out == null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 1.创建源和目标
        File srcf = new File("E:/javaSE/file01/text.txt");
        File destf = new File("E:/javaSE/file01/text_copy.txt");
        try (
                //打开资源的代码
                // 2.创建输入流和输出流对象
                InputStream in = new FileInputStream(srcf);
                OutputStream out = new FileOutputStream(destf);
        ) {
            // 3.读取/写出操作
            byte[] buffer = new byte[1024];//创建容量为1024的缓冲区(存储已经读取到的数据)
            int len = -1; //返回-1 表示读取完毕
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len); //将数据从buffer中写出去
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // 1.创建源和目标
        File srcf = new File("E:/javaSE/file01/text.txt");
        File destf = new File("E:/javaSE/file01/text_copy.txt");
        try (
                //打开资源的代码
                // 2.创建输入流和输出流对象
                Reader  in =  new FileReader(srcf);
                Writer out = new FileWriter(destf);
        ) {
            // 3.读取/写出操作
            char[] buffer =  new char[1024];//创建容量为1024的缓冲区(存储已经读取到的数据)
            int len = -1; //返回-1 表示读取完毕
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len); //将数据从buffer中写出去
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // 1.创建源和目标
        File srcf = new File("E:/javaSE/file01/text.txt");
        try (
                //打开资源的代码
                // 2.创建输入流和输出流对象
                InputStream in = new FileInputStream(srcf);
                // 创建字节数组输出流
                ByteArrayOutputStream arrayOut = new ByteArrayOutputStream()
        ) {
            // 3.读取/写出操作
            byte[] buffer = new byte[1024];//创建容量为1024的缓冲区(存储已经读取到的数据)
            int len = -1; //返回-1 表示读取完毕
            while ((len = in.read(buffer)) != -1) {
                arrayOut.write(buffer, 0, len); //将数据从buffer中写出去
            }
            byte[] bytes = arrayOut.toByteArray();
            System.out.println(bytes.length); //80

            // 创建字节数组输入流
            ByteArrayInputStream arrayInput = new ByteArrayInputStream(bytes);
            System.out.println((char)arrayInput.read()); // s 
            System.out.println(arrayInput.available()); //79:读一个，还剩79

            arrayInput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

public class PipedStreamDemo {

    public static void main(String[] args) {
        //创建一个线程池
        ExecutorService executorService = Executors.newCachedThreadPool();

        try {
            //创建输入和输出管道流
            PipedOutputStream pos = new PipedOutputStream();
            PipedInputStream pis = new PipedInputStream(pos);

            //创建发送线程和接收线程对象，并把管道流赋值
            Sender sender = new Sender(pos);
            Reciever reciever = new Reciever(pis);

            //提交给线程池运行发送线程和接收线程
            executorService.execute(sender);
            executorService.execute(reciever);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //通知线程池，不再接受新的任务，并执行完成当前正在运行的线程后关闭线程池。
        executorService.shutdown();
        try {
            //shutdown 后可能正在运行的线程很长时间都运行不完成，这里设置超过1分钟，强制执行 Interruptor 结束线程。
            executorService.awaitTermination(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 发送者
    static class Sender extends Thread {
        private PipedOutputStream pos;

        public Sender(PipedOutputStream pos) {
            super();
            this.pos = pos;
        }

        @Override
        public void run() {
            try {
                String s = "hello world, amazing java !";
                System.out.println("Sender:" + s);
                byte[] buf = s.getBytes();
                pos.write(buf, 0, buf.length);
                pos.close();
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    // 接受者
    static class Reciever extends Thread {
        private PipedInputStream pis;

        public Reciever(PipedInputStream pis) {
            super();
            this.pis = pis;
        }

        @Override
        public void run() {
            try {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                byte[] buf = new byte[1024];
                int len = 0;
                while ((len = pis.read(buf)) != -1) {
                    baos.write(buf, 0, len);
                }
                byte[] result = baos.toByteArray();
                String s = new String(result, 0, result.length);
                System.out.println("Reciever:" + s);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    public static void main(String[] args) {
        //内部维护缓存（string对象）
        StringWriter sw = new StringWriter();
        sw.append("go ");
        sw.write("test ");
        sw.write("sdk ");
        sw.write("hello");
        sw.flush();
        //获取缓存中的内容
        System.out.println(sw.toString());
        //获取缓存中的内容，内容装在StringBuffer对像中缓存
        StringBuffer sb = sw.getBuffer();
        //获取StringBuffer中缓存中的内容
        System.out.println(sb.toString());

        //
        stringReader(sb.toString());// go test sdk hello输出count = 4
    }

    //计算一个字符串有多少个单词
    private static void stringReader(String info) {
        StringReader sr = new StringReader(info);

        // 流标记器，分析流
        StreamTokenizer st = new StreamTokenizer(sr);
        int count = 0;
        try {
            while (st.nextToken() != StreamTokenizer.TT_EOF) {
                //在调用 nextToken 方法之后，ttype字段将包含刚读取的标记的类型
                //ttype字段将包含刚读取的标记的类型,TT_EOF指示已读到流末尾的常量。

                // 如果是一个单词
                if (st.ttype == StreamTokenizer.TT_WORD) {
                    //TT_NUMBER指示已读到一个数字标记的常量 //TT_WORD指示已读到一个文字标记的常量
                    count++;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        sr.close();
        System.out.println("count = " + count);
    }

		//创建文件
		File file = new File("E:/javaSE/file01/text.txt");
		
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
		
		//写入字节流数据
		bos.write(97); //写单个字节 a
		bos.write("hello! abc.".getBytes()); //getByte()将字符串转换成字节数组
		
		bos.flush();
		bos.close();

		//创建文件
		File file = new File("E:/javaSE/file01/text.txt");
		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
		//创建一个字节数组存放读取的字节数据
		byte[] buf = new byte[10];	//一次最多读取10个字节
		int len = -1;
		while((len=bis.read(buf)) != -1) {
			String str = new String(buf,0,len);//字节数据构造新的 String 
			System.out.println(str);
		}
		bis.close();

    public static void main(String[] args) {
        // 1.创建源和目标
        File srcf = new File("E:/javaSE/file01/text.txt");
        File destf = new File("E:/javaSE/file01/text_copy.txt");
        try (
                //打开资源的代码
                // 2.创建输入流和输出流对象
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcf));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destf));
        ) {
            // 3.读取/写出操作
            byte[] buffer =  new byte[1024];;//创建容量为1024的缓冲区(存储已经读取到的数据)
            int len = -1; //返回-1 表示读取完毕
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len); //将数据从buffer中写出去
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

		//创建文件
		File file = new File("E:/javaSE/file01/text.txt");
		
		BufferedWriter bw = new BufferedWriter(new FileWriter(file));
		
		//写入字符流数据
		bw.write(97); 		//写单个字符 a
		bw.newLine();  		//写入换行符
		bw.write("hello! abc."); //写字符串
		
		bw.flush();
		bw.close();

		//创建文件
		File file = new File("E:/javaSE/file01/text.txt");
		
		BufferedReader br = new BufferedReader(new FileReader(file));
		
		//读数据
		String str = null;
		while((str=br.readLine()) != null) { //readLine()读取一行
			System.out.println(str);
		}
		br.close();
//结果
a
hello! abc.

    public static void main(String[] args) {
        // 1.创建源和目标
        File srcf = new File("E:/javaSE/file01/text.txt");
        File destf = new File("E:/javaSE/file01/text_copy.txt");
        try (
                //打开资源的代码
                // 2.创建输入流和输出流对象
                BufferedReader br = new BufferedReader(new FileReader(srcf));
                BufferedWriter bw = new BufferedWriter(new FileWriter(destf));
        ) {
            // 3.读取/写出操作
            //byte[] buffer =  new byte[1024];;//创建容量为1024的缓冲区(存储已经读取到的数据)
            String line = null; //返回-1 表示读取完毕
            while ((line = br.readLine()) != null) {
                bw.write(line); //读一行写一行，也可以和上边实例一样使用read(char[] cbuf, int off, int len)
                bw.newLine();   // 换行
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

		//创建文件
		File file = new File("E:/javaSE/file01/text.txt");
		
		//将字节输出流转换字符输出流
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file));
		BufferedWriter bw = new BufferedWriter(osw);
		
		//写入字符流数据
		bw.write(97); 		//写单个字符 a
		bw.newLine();  		//写入换行符
		bw.write("hello! abc."); //写字符串
		
		bw.flush();
		bw.close();

		//创建文件
		File file = new File("E:/javaSE/file01/text_ggbk.txt");
		
		//将字节输入流转换字符输入流
		InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "GBK");
		BufferedReader br = new BufferedReader(isr);
		
		//读数据
		String str = null;
		while((str=br.readLine()) != null) { //readLine()读取一行
			System.out.println(str);
		}
		br.close();

//结果
a
hello! abc.

public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private String username;
    transient private String password; // 理论上说静态和 瞬态 的字段是不能做序列化的
    private int age;

    ...
}

    public static void main(String[] args) throws Exception {
        File  file = new File("E:/javaSE/file01/text.txt");
        //writeObject(file);
        ReaderObject(file);
    }

    // 序列化操作
    private static void writeObject(File file) throws IOException {
        //对象只能调用自己编译类型里面的方法
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
        out.writeObject(new User("admin","admin123",18));//将对象内容写入文件
        out.close();
    }
    // 序列化操作
    private static void ReaderObject(File file) throws IOException, ClassNotFoundException {
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
        User user = (User)in.readObject();
        System.out.println(user); // User{username='admin', password='null', age=18}
        in.close();
    }

    public static void main(String[] args) throws Exception {   
        PrintStream ps = new PrintStream(new FileOutputStream(new File("E:/javaSE/text.txt"),true));//true是带自动刷新

        ps.write("abbbaaa".getBytes());
        ps.print(true); //可以往文件打印任意类型的数据
        ps.close();
    }

    public static void main(String[] args) throws Exception {    
        PrintWriter pw = new PrintWriter(new FileOutputStream(new File("E:/javaSE/text.txt"),true));//true是带自动刷新

        pw.write("abbbaaa");
        pw.print(true); //可以往文件打印任意类型的数据
        pw.close();
    }

    public static void main(String[] args) throws Exception {
        File  file = new File("E:/javaSE/text.txt");
       // write(file);
        read(file);
    }

    private static void read(File file) throws Exception {
        DataInputStream in = new DataInputStream(new FileInputStream(file));
        System.out.println(in.readByte());
        System.out.println(in.readChar());//只能用相对应的方式来读取
        System.out.println(in.readUTF());
        //System.out.println(in.readInt());
        in.close();

    }

    private static void write(File file) throws Exception {
        DataOutputStream out = new DataOutputStream(new FileOutputStream(file));
        out.writeByte(66);// byte
        out.writeChar('穷');// char
        out.writeUTF("天王盖地虎!");// string
        out.close();
    }

    public static void main(String[] args) throws Exception {
        // System.out.println("begin..");
        // int data = System.in.read();// 接收键盘录入的一个字节 /标准输入
        // System.out.println(data); // 标准输出
        // System.out.println("end..");
        // 重新定向标准输入流
        System.setIn(new FileInputStream("E:/javaSE/text.txt"));
        // 重新定向标准输出流
        System.setOut(new PrintStream("E:/javaSE/text.txt"));
        System.out.println("begin..");
        int data = System.in.read();
        System.out.println(data);
        System.out.println("end..");
    }

    public static void main(String[] args) throws Exception {        
        // 扫描文件中的数据
        Scanner sc= new Scanner(new File("E:/javaSE/text.txt"),"UTF-8");
        // 扫描键盘输入的数据
        //Scanner sc = new Scanner(System.in);
        // 扫面字符串的数据
        // Scanner sc = new Scanner("天王盖地虎");

        while (sc.hasNextLine()) {
            String line = sc.nextLine();
            System.out.println("--》 " + line);

        }
        sc.close();
    }

    public static void main(String[] args) throws Exception {
        // 创建Properties对象
        Properties p = new Properties();
        InputStream inStream = new FileInputStream("E:/javaSE/db.properties");
        p.load(inStream);// 加载之后.数据都在p对象中;

        System.out.println(p); // {password=admin123, username=admin3}
        System.out.println("账号 : " +p.getProperty("username"));
        System.out.println("密码 : " +p.getProperty("password"));
    }

    public static void main(String[] args) throws IOException {
        File  f1 = new File("E:/javaSE/file01/text.txt");
        File  f2 = new File("E:/javaSE/file01/text_copy.txt");
        SequenceInputStream in = new SequenceInputStream(new FileInputStream(f1),new FileInputStream(f2));
        byte[] ch = new byte[1024];
        int len = -1 ;
        while((len = in.read(ch))!= -1 ){
            System.out.println(new String(ch,0,len));
        }
        in.close();
    }