java IO 流中（笔记二十一）

最新推荐文章于 2023-02-06 22:01:56 发布

北街风

最新推荐文章于 2023-02-06 22:01:56 发布

阅读量212

点赞数

分类专栏： java 文章标签： java 编程语言

diaolove

本文链接：https://blog.csdn.net/qq_45047809/article/details/117466366

版权

java 专栏收录该内容

101 篇文章 3 订阅

订阅专栏

一、IO流原理及流的分类

1、Java IO原理

I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

2、流的分类

按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
按数据流的流向不同分为：输入流，输出流
按流的角色的不同分为：节点流（文件流），处理流

1. Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。

2. 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

、

3、IO 流体系

对FileReader的基本使用，读取一个文本

// 说明点:
    //1. read()的理解:返回读入的一个字符。如果达到文件末尾，返回-1
    //2．异常的处理:为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
//    3．读入的文件一定要存在，否则就会报FiLeNotFoundException。
    @Test
    public void Test() throws IOException {
//        1、实例化file类的对象，指明要操作的文件
        FileReader fr = null;
        try {
            File file = new File("D:\\www\\wwwroot\\hi.txt");
//        2、提供具体的流
            fr = new FileReader(file);
//        3、数据的读入
//        read()返回读入的一个字符。如果达到文件末尾，返回-1
//        方式一：
            int data = fr.read();
            while (data !=-1){
  
                System.out.print((char)data);
                data = fr.read();
//         方式二：
//        int data;
//        while ((data = fr.read())!=-1){
//            System.out.print((char)data);
//        }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
//          4.流的关闭操作
                if (fr !=null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
//结果会在控制台输出

//    从内存中写出数据到硬盘的文件里。
//    说明：
//    1.输出操作：对应的file可以不存在的。并不会报异常
//     2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
//     File对应的硬盘中的文件如果存在:
//          如果流使用的构造器是:FiLewriter(file,false)/ FiLewriter(filel）:对原有文件的覆盖
//          FileWriter(file,true); //会在原有的基础上添加数据
    @Test
    public void testFileWriter() throws IOException {
        FileWriter fw = null;
        try {
            File file = new File("D:\\www\\wwwroot\\hi.txt");

//            fw = new FileWriter(file); //会覆盖原文件的数据  默认false
//            fw = new FileWriter(file,true); //会在原有的基础上添加数据
            fw = new FileWriter(file,false);
            fw.write("I'm diaolove!\n");
            fw.write("2000-01-01");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

图片复制操作：

//实现对图片的复制操作
    @Test
    public void testFileInputOutputStream1() {
//
        FileInputStream fis=null;
        FileOutputStream fos =null;
     try {
        File srcFile1 = new File("龙猫.jpg");
        File srcFile2 = new File("龙猫2.jpg");

//
         fis = new FileInputStream(srcFile1);
         fos = new FileOutputStream(srcFile2);

//        复制的过程
        byte[] buffer = new byte[5];
        int len;//记录每次读取的字节个数
        while ((len = fis.read(buffer)) != -1) {
           fos.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally

    {
        if (fis != null) {
            try {
                //4.关闭资源
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (fos != null) {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
          }
        }
    }

视频复制操作：


    @Test
    public void testCopyFile(){
        long start = System.currentTimeMillis();

        String  srcPath ="C:\\Users\\Administrator\\Desktop\\臭猪.mp4";
        String destPath="C:\\Users\\Administrator\\Desktop\\臭猪2.mp4"; //修改路径也可以复制文本文件
        copyFile(srcPath,destPath);

        long end =System.currentTimeMillis();
        System.out.println("复制操作花费的时间为："+(end-start));

    }

    //    指定路径文件的复制
    public void copyFile(String  srcPath,String destPath){
        FileInputStream fis=null;
        FileOutputStream fos =null;
        try {
            File srcFile1 = new File(srcPath);
            File srcFile2 = new File(destPath);

//
            fis = new FileInputStream(srcFile1);
            fos = new FileOutputStream(srcFile2);

//        复制的过程
            byte[] buffer = new byte[1024];
            int len;//记录每次读取的字节个数
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally

        {
            if (fis != null) {
                try {
                    //4.关闭资源
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

节点流：直接从数据源或目的地读写数据

处理流：不直接连接到数据源或目的地，而是“连接”在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。

InputStream & Reader

InputStream 和 Reader 是所有输入流的基类。
InputStream（典型实现：FileInputStream）
int read()
int read(byte[] b)
int read(byte[] b, int off, int len)
Reader（典型实现：FileReader）
int read()
int read(char [] c)
int read(char [] c, int off, int len) 程序中打开的文件 IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件 IO 资源。
FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream 用于读取非文本数据之类的原始字节流。要读取字符流，需要使用 FileReader

InputStream

int read()从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。
int read(byte[] b, int off,int len) 将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。
public void close() throws IOException 关闭此输入流并释放与该流关联的所有系统资源。

Reader

int read() 读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)（2个字节的Unicode码），如果已到达流的末尾，则返回 -1
int read(char[] cbuf) 将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
int read(char[] cbuf,int off,int len) 将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
public void close() throws IOException 关闭此输入流并释放与该流关联的所有系统资源。

OutputStream & Writer

OutputStream 和 Writer 也非常相似：
void write(int b/int c);
void write(byte[] b/char[] cbuf);
void write(byte[] b/char[] buff, int off, int len);
void flush();
void close(); 需要先刷新，再关闭此流
因为字符流直接以字符作为操作单位，所以 Writer 可以用字符串来替换字符数组，即以 String 对象作为参数
void write(String str);
void write(String str, int off, int len);
FileOutputStream 从文件系统中的某个文件中获得输出字节。FileOutputStream 用于写出非文本数据之类的原始字节流。要写出字符流，需要使用 FileWriter

OutputStream

void write(int b) OutputStream 将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。即写入0~255范围的。
void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
void write(byte[] b,int off,int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
public void flush()throws IOException 刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。
public void close() throws IOException 关闭此输出流并释放与该流关联的所有系统资源。

Writer

void write(int c) 写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。即写入0 到 65535 之间的Unicode码。
void write(char[] cbuf) 写入字符数组。
void write(char[] cbuf,int off,int len) 写入字符数组的某一部分。从off开始，写入len个字符
void write(String str) 写入字符串。  void write(String str,int off,int len) 写入字符串的某一部分。
void flush() 刷新该流的缓冲，则立即将它们写入预期目标。
public void close() throws IOException 关闭此输出流并释放与该流关联的所有系统资源。

二、节点流(或文件流)

1、注意点

定义文件路径时，注意：可以用“/”或者“\\”。
在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文件将被覆盖。
如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。
在读取文件时，必须保证该文件已存在，否则报异常。
字节流操作字节，比如：.mp3，.avi，.rmvb，mp4，.jpg，.doc，.ppt
字符流操作字符，只能操作普通文本文件。最常见的文本文件：.txt，.java，.c，.cpp 等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件。

三、缓冲流

为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
缓冲流要“套接”在相应的节点流之上，根据数据操作单位可以把缓冲流分为：
BufferedInputStream 和 BufferedOutputStream
BufferedReader 和 BufferedWriter
当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区
当使用BufferedInputStream读取字节文件时，BufferedInputStream会一次性从文件中读取8192个(8Kb)，存在缓冲区中，直到缓冲区装满了，才重新从文件中读取下一个8192个字节数组。
向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。使用方法 flush()可以强制将缓冲区的内容全部写入输出流
关闭流的顺序和打开流的顺序相反。只要关闭最外层流即可，关闭最外层流也会相应关闭内层节点流
flush()方法的使用：手动将buffer中内容写入文件
如果是带缓冲区的流对象的close()方法，不但会关闭流，还会在关闭流之前刷新缓冲区，关闭后不能再写出


/**
 * @Description: $处理流之一:缓冲流的使用
 * 1.缓冲流:
 * BufferedInputstream
 * BufferedoutputStream
 * BufferedReader
 * Bufferedwriter
 *
 * 2.作用:提供流的读取、写入的速度
 *  提高读写速度的原因：内部提供了一个缓冲区
 * @Author: dyq
 * @Date: $
 */
public class BufferedTest {
//    实现非文本文件的复制
    @Test
    public  void  BufferedStreamTest() throws IOException {
          FileInputStream fis=null;
          FileOutputStream fos =null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
//       1.造文件

            File srcFile1 = new File("龙猫.jpg");
            File srcFile2 = new File("龙猫3.jpg");
//        2、造流
//        2.1造节点流
            fis = new FileInputStream(srcFile1);
            fos = new FileOutputStream(srcFile2);
//        2.2造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

//        3.复制的细节：读取，写入
            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer))!= -1){
               bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //        4、资源关闭
            //要求:先关闭外层的流，再关闭内层的流
            if (bos!=null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            //说明：
            //关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略
//            fos.close();
//            fis.close();
        }
    }



    @Test
    public void testcopy(){
        long start = System.currentTimeMillis();

//        String  srcPath ="D:\\www\\wwwroot\\hi.txt";
//        String destPath="D:\\www\\wwwroot\\hi3.txt";
        String  srcPath ="C:\\Users\\Administrator\\Desktop\\臭猪.mp4";
        String destPath="C:\\Users\\Administrator\\Desktop\\臭猪2.mp4";
        copyFile(srcPath,destPath);

        long end =System.currentTimeMillis();
        System.out.println("复制操作花费的时间为："+(end-start));

    }
    //    实现文件复制的方法
    public void copyFile(String srcPath,String destPath){
        FileInputStream fis=null;
        FileOutputStream fos =null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
//       1.造文件
            File srcFile1 = new File(srcPath);
            File srcFile2 = new File(destPath);

//        2、造流
//        2.1造节点流
            fis = new FileInputStream(srcFile1);
            fos = new FileOutputStream(srcFile2);
//        2.2造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

//        3.复制的细节：读取，写入
            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer))!= -1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //        4、资源关闭
            //要求:先关闭外层的流，再关闭内层的流
            if (bos!=null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            //说明：
            //关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略
//            fos.close();
//            fis.close();
        }
      }
    @Test
    public  void  testBufferedReaderBufferedWriter() throws IOException {
//
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader(new File("D:\\www\\wwwroot\\hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("D:\\www\\wwwroot\\hello4.txt")));
//            读写操作
//            方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while ((len=br.read(cbuf))!= -1){
//                bw.write(cbuf,0,len);
//            }
//            方式二：使用String
            String data;
            while((data = br.readLine()) != null){
//                 方法一：
//                bw.write(data+"\n");//data中不包含换行符
//                方法二：
                bw.write(data);//data中不包含换行符
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //     关闭资源
            if (bw!=null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 }

1、练习

1、实现图片的加密解密

//    图片加密
    @Test
    public  void  Test1() throws IOException {

            FileInputStream fis =null;
            FileOutputStream fos =null;
        try {
//            加密  打开龙.jpg报错
//            fis =  new FileInputStream("龙猫.jpg");
//            fos =new FileOutputStream("龙.jpg");
//           解密   打开龙猫5.jpg ,可以打开
            fis =  new FileInputStream("龙.jpg");
            fos =new FileOutputStream("龙猫5.jpg");

            byte[] buffer = new byte[20];
            int len;
            while ((len = fis.read(buffer))!= -1){
    //            字节数组进行修改
    //            错误的
    //            for(byte b:buffer){
    //                b=(byte)(b^5);
    //            }
    //            正确的
                for(int i =0;i<len;i++){
                    buffer[i] =(byte)(buffer[i] ^5);
                }
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

2、获取文本上每个字符出现的次数
提示:遍历文木的每一个字符;字符及出现的次数保存在Map中;将Map中数据
写入文件

/**
 * 练习2:获取文本上字符出现的次数,把数据写入文件
 *
 * 思路：
 * 1.遍历文本每一个字符
 * 2.字符出现的次数存在Map中
 *
 * Map<Character,Integer> map = new HashMap<Character,Integer>();
 * map.put('a',18);
 * map.put('你',2);
 *
 * 3.把map中的数据写入文件
 *
 * @author shkstart
 * @create 2019 下午 3:47
 */
public class WordCount {
    /*
    说明：如果使用单元测试，文件相对路径为当前module
          如果使用main()测试，文件相对路径为当前工程
     */
    @Test
    public void testWordCount() {
        FileReader fr = null;
        BufferedWriter bw = null;
        try {
            //1.创建Map集合
            Map<Character, Integer> map = new HashMap<Character, Integer>();

            //2.遍历每一个字符,每一个字符出现的次数放到map中
            fr = new FileReader("情书.txt");
            int c = 0;
            while ((c = fr.read()) != -1) {
                //int 还原 char
                char ch = (char) c;
                // 判断char是否在map中第一次出现
                if (map.get(ch) == null) {
                    map.put(ch, 1);
                } else {
                    map.put(ch, map.get(ch) + 1);
                }
            }

            //3.把map中数据存在文件count.txt
            //3.1 创建Writer
            bw = new BufferedWriter(new FileWriter("wordcount.txt"));

            //3.2 遍历map,再写入数据
            Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
            for (Map.Entry<Character, Integer> entry : entrySet) {
                switch (entry.getKey()) {
                    case ' ':
                        bw.write("空格=" + entry.getValue());
                        break;
                    case '\t'://\t表示tab 键字符
                        bw.write("tab键=" + entry.getValue());
                        break;
                    case '\r'://
                        bw.write("回车=" + entry.getValue());
                        break;
                    case '\n'://
                        bw.write("换行=" + entry.getValue());
                        break;
                    default:
                        bw.write(entry.getKey() + "=" + entry.getValue());
                        break;
                }
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关流
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}

四、转换流

转换流提供了在字节流和字符流之间的转换
Java API提供了两个转换流：
InputStreamReader：将InputStream转换为Reader
OutputStreamWriter：将Writer转换为OutputStream
字节流中的数据都是字符时，转成字符流操作更高效。
很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。

InputStreamReader

实现将字节的输入流按指定字符集转换为字符的输入流。

需要和InputStream“套接”。

构造器

public InputStreamReader(InputStream in)

public InputSreamReader(InputStream in,String charsetName)

如： Reader isr = new InputStreamReader(System.in,”gbk”); （gbk为指定字符集）

OutputStreamWriter

实现将字符的输出流按指定字符集转换为字节的输出流。
需要和OutputStream“套接”。
构造器

public OutputStreamWriter(OutputStream out)

public OutputSreamWriter(OutputStream out,String charsetName)

/**处理流之二:转换流的使用
 * 1.转换流:属于字符流
      InputstreamReader:将一个字节的输入流转换为字符的输入流
      outputstreamlvriter:将一个字符的输出流转换为字节的输出流
 2.作用:提供字节流与字符流之间的转换

 3．解码:字节、字节数组--->字符数组、字符串
   编码:字符数组、字符串--->字节、字节数组

 4.字符集

 * @Description: $
 * @Author: dyq
 * @Date: $
 */
public class InputStreamReaderTest {
    @Test
    public void test() throws IOException {
        FileInputStream fis = null;
        InputStreamReader isr1 = null; //使用系统默认的字符集
        try {
            fis=new FileInputStream("情书.txt");
//        InputStreamReader isr = new InputStreamReader(fis); //使用系统默认的字符集
//        参数2，指明了字符集，具体使用那个字符集，取决于文件“情书.txt”保存时使用的字符集
            isr1 = new InputStreamReader(fis,"UTF-8");

            char[] cbuf = new char[20];
            int len;
            while((len=isr1.read(cbuf))!=-1){
                String str = new String(cbuf,0,len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(isr1 !=null){
                try {
                    isr1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
//   综合使用工nputStreamReader和Outputstreamlwriter
    @Test
    public void Test2() throws IOException {
//       造文件，，造流
        File file1  = new File("情书.txt");
        File file2 = new File("情书啊.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//        读写过程
        char[] cbuf = new char[20];
        int len;
        while((len=isr.read(cbuf))!=-1){
            String str = new String(cbuf,0,len);
            System.out.println(str);
        }
//        关闭资源
        isr.close();
        osw.close();
    }
}

拓展：字符编码：https://blog.csdn.net/qq_45047809/article/details/117781113

五，标准输入、输出流(了解)

System.in和System.out分别代表了系统标准的输入和输出设备 (参考：System (Java SE 11 & JDK 11 ) (runoob.com))
默认输入设备是：键盘，输出设备是：显示器
System.in的类型是InputStream  System.out的类型是PrintStream，其是OutputStream的子类 FilterOutputStream 的子类
重定向：通过System类的setIn，setOut方法对默认设备进行改变。
public static void setIn(InputStream in)
public static void setOut(PrintStream out)

例题：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * @Description: $
 * @Author: dyq
 * @Date: $
 */
public class OtherStreamTest {
/*1.标准的输入、输出流
1.1  system.in:标准的输入流，默认从键盘输入
     system.out:标准的输出流，默认从控制台输出
     1.2
    system类的setIn)) / setout(()方式重新指定输入和输出的流。
* */
//    从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续
//    进行输入操作，直至当输入“e”或者“exit”时，退出程序。
//    方法一：使用Scanner实现，调用next（）
//Scanner scanner = new Scanner(System.in);
//    方法二：使用System.in实现,system.in --->转换流---> BufferedReader的readline(


    public static void main(String[] args) {

        BufferedReader br =null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br =  new BufferedReader(isr);

            while(true){
                System.out.println("请输入字符串：");
                String data= br.readLine();
                if ("e".equalsIgnoreCase(data)|| "exit".equalsIgnoreCase(data)){
                    System.out.println("程序结束");
                    break;
                }
                String upperCase = data .toUpperCase();
                System.out.println(upperCase);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

六、打印流（了解）

实现将基本数据类型的数据格式转化为字符串输出
打印流：PrintStream和PrintWriter
提供了一系列重载的print()和println()方法，用于多种数据类型的输出
PrintStream和PrintWriter的输出不会抛出IOException异常
PrintStream和PrintWriter有自动flush功能
PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
System.out返回的是PrintStream的实例

@Test
    public void Test(){
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File("D:\\www\\wwwroot\\hello.txt"));
// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
            ps = new PrintStream(fos, true);
            if (ps != null) {// 把标准输出流(控制台输出)改成文件
                System.setOut(ps);
            }
            for (int i = 0; i <= 255; i++) { // 输出ASCII字符
                System.out.print((char) i);
                if (i % 50 == 0) { // 每50个数据一行
                    System.out.println(); // 换行
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ps != null) {
                ps.close();
            }
        }
    }

七、数据流(了解)

为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。
数据流有两个类：(用于读取和写出基本数据类型、String类的数据）
DataInputStream 和 DataOutputStream
分别“套接”在 InputStream 和 OutputStream 子类的流上
DataInputStream中的方法

boolean readBoolean() byte readByte()

char readChar() float readFloat()

double readDouble() short readShort()

long readLong() int readInt()

String readUTF() void readFully(byte[] b)

DataOutputStream中的方法
将上述的方法的read改为相应的write即可。

  @Test
    public void Test1() { //读入数据
        DataOutputStream dos = null;
        try { // 创建连接到指定文件的数据输出流对象
            dos = new DataOutputStream(new FileOutputStream("destData.txt"));
            dos.writeUTF("diaolove"); // 写UTF字符串
            dos.writeBoolean(false); // 写入布尔值
            dos.writeLong(1234567890L); // 写入长整数
            System.out.println("写文件成功!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally { // 关闭流对象
            try {
                if (dos != null) {
// 关闭过滤流时,会自动关闭它包装的底层节点流
                    dos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void Test2() {//写出数据
        DataInputStream dis = null;
        try {
            dis = new DataInputStream(new FileInputStream("destData.txt"));
            String info = dis.readUTF();
            boolean flag = dis.readBoolean();
            long time = dis.readLong();
            System.out.println(info);
            System.out.println(flag);
            System.out.println(time);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dis != null) {
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

北街风

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
2
评论
java IO 流中（笔记二十一）

一、IO流原理及流的分类 1、Java IO原理I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。 Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。 java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。 ...
复制链接

扫一扫