JAVA学习笔记(二十八) - 字节流 InputStream & OutputStream

Scanner类和nextLine()方法

import java.util.Scanner;

/*
 * Scanner类，用于从控制台输入数据，字节输入流
 * next()方法
 * 1.对输入有效字符之前的输入的空格、tab、回车等，会自动忽略
 * 2.只有在输入有效字符后，才会将空格、tab、回车作为结束符
 * 3.无法获取带有空格的字符串
 * 
 * nextLine()方法
 * 1.结束符只有回车，即返回回车之前所有的字符
 * 2.可以获取带有空格的字符串
 * 3.实现一次读取一行
 */
public class Test02 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入数据：");
        //String data=input.next();
        String data=input.nextLine();
        System.out.println("数据："+data);
        System.out.println("长度："+data.length());
    }
}

InputStream字节输入流

/*
 * InputStream字节输入流
 * int read()
 * System.in 标准输入流，默认为键盘
 * System.out标准输出流，默认为显示器
 */
public class Test03 {
    public static void main(String[] args) {
        try {
            InputStream is=System.in;//定义一个字节输入流
            System.out.println("请输入数据：");
            int data=is.read();//每次读取一个字节，返回int类型的字节值
            while(data!=-1){ //如果没有读取到数据则返回-1
                //System.out.println(data);
                System.out.print((char)data);//转换为字符并输出，如果是中文会出现乱码
                data=is.read();//接着读取数据
            }

            is.close();//关闭流
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.IOException;
import java.io.InputStream;

/*
 * InputStream类
 * int read(byte[] b)
 */
public class Test04 {
    public static void main(String[] args) {
        InputStream is = null;
        try {
            // 定義一個字節輸入流
            is = System.in;
            // 定義一個字節數組，用於保存数据
            byte[] buffer = new byte[100];
            System.out.println("请输入数据：");
            // 将数据读到字节数组中，返回实际读取的字节数
            int num = is.read(buffer);
            System.out.println("实际读取的字节数：" + num);
            // 输出字节数组中的数据
            for (byte b : buffer) {
                System.out.println(b + "=" + (char) b);
            }

            //将字节数组转换为字符串
            System.out.println("*****直接转换整个字节数组");
            String str=new String(buffer);
            System.out.println("字符串："+str);
            System.out.println("长度："+str.length());

            System.out.println("*****转换指定长度的字节数组");
            String str2=new String(buffer, 0, num);//将字节数组转换为字符串，从第0个开始，转换num个
            System.out.println("字符串："+str2);
            System.out.println("长度："+str2.length());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();// 关闭流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileInputStream文件字节输入流

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

/*
 * FileInputStream文件字节输入流，继承自InputSteam
 */
public class Test05 {
    public static void main(String[] args) throws IOException {
        test3();
    }

    public static void test1() throws IOException {
        // File file = new File("d:\\Java\\hello.txt");
        // FileInputStream fis = new FileInputStream(file);
        FileInputStream fis = new FileInputStream("d:\\Java\\hello.txt");
        int data = fis.read();// 如果读到文件末尾，返回-1
        while (data != -1) {// 判断是否读取到数据
            System.out.println((char) data);
            data = fis.read();// 继承读取
        }
        fis.close();// 关闭流
    }

    public static void test2() throws IOException {
        FileInputStream fis = new FileInputStream("d:\\Java\\hello.txt");
        byte[] buffer = new byte[10];
        int num = fis.read(buffer, 0, buffer.length);
        while (num != -1) {
            String str = new String(buffer, 0, num);// 将字节数组转换为字符串
            System.out.println(str);
            num = fis.read(buffer, 0, buffer.length);
        }

        fis.close();
    }

    public static void test3() throws IOException {
        FileInputStream fis = new FileInputStream("d:\\Java\\hello.txt");
        System.out.println("当前文件输入流大小："+fis.available());
        byte[] buffer = new byte[fis.available()];
        fis.read(buffer);//将数据读取到字节数组buffer中
        System.out.println(new String(buffer));

        fis.close();
    }
}

FileOutputStream文件字节输出流

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * FileOutputStream文件字节输出流，继承自OutputStream
 */
public class Test06 {
    public static void main(String[] args) throws IOException {
        File file=new File("D:\\Java\\itany.txt");
        //创建一个FileOutputStream实例，默认会覆盖原文件的内容
        FileOutputStream fos=new FileOutputStream(file,true);
        //fos.write(97);//写入一个字节
        //byte[] info="hello world!".getBytes();//将字符串转换为字节数组
        byte[] info="哈哈哈哈".getBytes("utf-8");

        fos.write(info);

        fos.flush();//刷新缓冲区，写入数据
        fos.close();

        System.out.println("写入数据成功！");
    }
}

文件的复制

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

/*
 * 文件的复制
 */
public class Test07 {
    public static void main(String[] args) {
        test2();
    }

    // 每次读取一个字节
    public static void test1() {
        // 定义文件输入输出流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("D:\\Java\\hello.txt");
            fos = new FileOutputStream("D:\\Java\\world.txt");
            int data = -1;
            while ((data = fis.read()) != -1) {
                fos.write(data);
                // data=fis.read();
            }
            fos.flush();
            System.out.println("文件复制成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 使用字节数组做为桥梁
    public static void test2() {
        // 定义文件输入输出流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream("D:\\Java\\hello.txt");
            fos = new FileOutputStream("D:\\Java\\world.txt");
            byte[] buffer=new byte[10];
            int num=fis.read(buffer);
            while (num!= -1) {
                fos.write(buffer,0,num);
                num=fis.read(buffer);
            }
            fos.flush();
            System.out.println("文件复制成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}