Java API —— IO流

1、IO流概述

　　· IO流用来处理设备之间的数据传输

　　· 上传文件和下载文件

　　· Java对数据的操作是通过流的方式

　　· Java用于操作流的对象都在IO包中

2、IO流分类

1）按照数据流向

输入流     读入数据

输出流     写出数据

2） 按照数据类型

字节流：

　　　　　　字节输入流 读取数据 InputStream

　　　　　　字节输出流 写出数据 OutputStream

字符流：

　　　　　　字符输入流 读取数据 Reader

　　　　　　字符输出流 写出数据 Writer

3）什么情况下使用哪种流呢?

如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。

如果你什么都不知道，就用字节流

3、IO流常用基类

　　1） 字节流的抽象基类：

　　　　InputStream ，OutputStream。

　　2） 字符流的抽象基类：

　　　　Reader ， Writer。

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

　　　　如：InputStream的子类FileInputStream。

　　　　如：Reader的子类FileReader。

4、字节流写数据

      1）OutputStream   ->  FileOutputStream    

　　　　分析发现其实更适合用字符流，但是由于字节流先出现，所以，我们考虑先使用字节流后面再讲会什么出现字符流。

　　2） FileOutputStream的构造方法   

　　　　FileOutputStream(File file)

FileOutputStream(String name)

　　3）字节流写数据的方式

　　　　· public void write(int b)

　　　　· public void write(byte[] b)

　　　　· public void write(byte[] b,int off,int len)

例子1：

package iodemos;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
* 需求：我要往一个文本文件中输入一句话："hello,io"
*
* 分析：
*         A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
*         B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
*
* 通过上面的分析后我们知道要使用：OutputStream
* 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
* 所以，我们要找一个具体的子类。
* 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
* 文件是哪个单词：File
* 然后用的是字节输出流，联起来就是：FileOutputStream
* 注意：每种基类的子类都是以父类名作为后缀名。
*         XxxOutputStream
*         XxxInputStream
*         XxxReader
*         XxxWriter
* 查看FileOutputStream的构造方法：
*         FileOutputStream(File file)
*        FileOutputStream(String name)
*
* 字节输出流操作步骤：
*         A:创建字节输出流对象
*         B:写数据
*         C:释放资源
*/
public class IODemo01 {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        // FileOutputStream(File file)
//        File file = new File("fos.txt");
//        FileOutputStream fos = new FileOutputStream(file);
        // FileOutputStream(String name)
        FileOutputStream fos = new FileOutputStream("fos.txt");
        /*
         * 创建字节输出流对象了做了几件事情：
         * A:调用系统功能去创建文件
         * B:创建fos对象
         * C:把fos对象指向这个文件
         */
        //写数据
        fos.write("hello,IO".getBytes());
        fos.write("java".getBytes());
        //释放资源
        //关闭此文件输出流并释放与此流有关的所有系统资源。
        fos.close();
        /*
         * 为什么一定要close()呢?
         * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
         * B:通知系统去释放跟该文件相关的资源
         */
        //java.io.IOException: Stream Closed
        //fos.write("java".getBytes());
    }
}

例子2：

package iodemos;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 字节输出流操作步骤：
 * A:创建字节输出流对象
 * B:调用write()方法
 * C:释放资源
 *
 * public void write(int b):写一个字节
 * public void write(byte[] b):写一个字节数组
 * public void write(byte[] b,int off,int len):写一个字节数组的一部分
 */
public class IODemo02 {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        // OutputStream os = new FileOutputStream("fos2.txt"); // 多态
        FileOutputStream fos = new FileOutputStream("fos2.txt");
        // 调用write()方法
        //fos.write(97); //97 -- 底层二进制数据    -- 通过记事本打开 -- 找97对应的字符值 -- a
        // fos.write(57);
        // fos.write(55);
        //public void write(byte[] b):写一个字节数组
        byte[] bys = {97,98,99,100,101};
        fos.write(bys);
        //public void write(byte[] b,int off,int len):写一个字节数组的一部分
        fos.write(bys,1,3);
        //释放资源
        fos.close();
    }
}

输出到文件fos2.txt：

abcdebcd

例子3：

package iodemos;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 如何实现数据的换行?
 *         为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
 *         如何实现呢?写入换行符号即可。
 *         有些文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
 *         因为不同的系统针对不同的换行符号识别是不一样的?
 *         windows:\r\n
 *         linux:\n
 *         Mac:\r
 *         而一些常见的个高级记事本，是可以识别任意换行符号的。
 *
 * 如何实现数据的追加写入?
 *         用构造方法带第二个参数是true的情况即可
 */
public class IODemo03 {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        //FileOutputStream fos = new FileOutputStream("fos3.txt");
        // 创建一个向具有指定 name 的文件中写入数据的输出文件流。
        // 如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
        FileOutputStream fos = new FileOutputStream("fos3.txt",true);
        // 写数据
        for (int x = 0; x < 10; x++) {
            fos.write(("hello"+x).getBytes());
            fos.write("\r\n".getBytes());
        }
        // 释放资源
        fos.close();
    }
}

　　4）加入异常处理的IO流操作

package iodemos;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 加入异常处理的字节输出流操作
 */
public class IODemo04 {
    public static void main(String[] args) {
        // 分开做异常处理
//        FileOutputStream fos = null;
//        try {
//            fos = new FileOutputStream("fos04.txt");
//        } catch (FileNotFoundException e) {
//            e.printStackTrace();
//        }
//        try {
//            fos.write("java".getBytes());
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        try {
//            fos.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
        // 一起做异常处理
//        try {
//            FileOutputStream fos = new FileOutputStream("fos04.txt");
//            fos.write("java".getBytes());
//            fos.close();
//        }catch (FileNotFoundException e){
//            e.printStackTrace();
//        }catch (IOException e){
//            e.printStackTrace();
//        }
        // 改进版
        // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream("fos04.txt");
            fos.write("java".getBytes());
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            // 如果fos不是null，才需要close()
            if(fos != null){
                // 为了保证close()一定会执行，就放到这里了
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

　　5）字节流读取数据

　　　　· InputStream

　　　　　　FileInputStream

　　　　· FileInputStream的构造方法

　　　　　　FileInputStream(File file)

　　　　　　FileInputStream(String name)

　　　　· FileInputStream的成员方法

　　　　　　public int read()

　　　　　　public int read(byte[] b)

例子1：

package inputstream;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 字节输入流操作步骤：
 * A:创建字节输入流对象
 * B:调用read()方法读取数据，并把数据显示在控制台
 * C:释放资源
 *
 * 读取数据的方式：
 * A:int read():一次读取一个字节
 * B:int read(byte[] b):一次读取一个字节数组
 */
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        // FileInputStream(String name)
        FileInputStream fis = new FileInputStream("fis.txt");
        // 调用read()方法读取数据，并把数据显示在控制台
        // 用循环改进
//        int by = fis.read();
//        while (by != -1) {
//            System.out.print((char) by);
//            by = fis.read();
//        }
        // 最终版代码
        int b = 0;
        // 读取，赋值，判断
        while ((b = fis.read()) != -1) {
            System.out.print((char) b);
        }
        //释放资源
        fis.close();
    }
}

例子2：计算机如何识别两个字节拼接成一个中文

package iodemos;
import java.util.Arrays;
/*
 * 计算机是如何识别什么时候该把两个字节转换为一个中文呢?
 * 在计算机中中文的存储分两个字节：
 *         第一个字节肯定是负数。
 *         第二个字节常见的是负数，可能有正数。但是没影响。
 */
public class IODemo06 {
    public static void main(String[] args) {
        //String s = "abcde";
        //[97, 98, 99, 100, 101]
        String s = "我爱你中国";
        //[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]

        byte[] bys = s.getBytes();
        System.out.println(Arrays.toString(bys));
    }
}

例子3：一次读取一个字节数组

read(byte[] b) 和 new String(b,0,len)一起用

package iodemos;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
public class IODemo10 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream fis = new FileInputStream("fis2.txt");
        // 数组的长度一般是1024或者1024的整数倍
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len)); //千万要带上len的使用
        }
        // 释放资源
        fis.close();
    }
}

    6）字节流复制数据练习

        · 把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

package iodemos;
import inputstream.FileInputStreamDemo01;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 复制文本文件。
 *
 * 数据源：从哪里来
 * a.txt    --    读取数据    --    FileInputStream
 *
 * 目的地：到哪里去
 * b.txt    --    写数据        --    FileOutputStream
 *
 * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
 *
 * 这一次复制中文没有出现任何问题，为什么呢?
 * 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
 * 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
 * 它会自己做转换。
 */
public class IODemo05 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("a.txt");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("b.txt");
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        // 释放资源(先关谁都行)
        fis.close();
        fos.close();
    }
}

　　· 把c:\a\a.txt内容复制到c:\b\b.txt中

方式一：

package iodemos;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 需求：把c盘下的a.txt的内容复制到c盘下的b.txt中
 *
 * 数据源：
 *         c:\a\a.txt    --    读取数据--    FileInputStream
 * 目的地：
 *         c:\b\b.txt    --    写出数据    --    FileOutputStream
 */
public class IODemo07 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\a\\a.txt");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("c:\\b\\b.txt");
        // 复制数据
        int by = 0;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

方式二：

package iodemos;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
public class IODemo11 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\a\\a.txt");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("c:\\b\\b.txt");
        // 复制数据
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

　　· 把c:\aa.jpg内容复制到当前项目目录下的mn.jpg中

package iodemos;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 需求：把c:\\aa.jpg内容复制到当前项目目录下的mn.jpg中
 *
 * 数据源：
 *         c:\\aa.jpg    --读取数据--FileInputStream
 * 目的地：
 *         mn.jpg--写出数据--FileOutputStream
 */
public class IODemo08 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\aa.jpg");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("mn.jpg");
        // 复制数据
        int by = 0;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

　　· 把c:\abc.mp4复制到当前项目目录下的copy.mp4中(效率低)

 方式一：

 

package iodemos;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 需求：把c:\\abc.mp4复制到当前项目目录下的copy.mp4中
 *
 * 数据源：
 *         c:\\abc.mp4--读取数据--FileInputStream
 * 目的地：
 *         copy.mp4--写出数据--FileOutputStream
 */
public class IODemo09 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\abc.mp4");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("copy.mp4");
        // 复制数据
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

方式二：

package iodemos;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
public class IODemo12 {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("c:\\abc.mp4");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("copy.mp4");
        // 复制数据
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        // 释放资源
        fos.close();
        fis.close();
    }
}

5、字节缓冲流

　　1）字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流

　　2）字节缓冲输出流：BufferedOutputStream

　　3）字节缓冲输入流：BufferedInputStream

例子1：

package iodemos;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
 * 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
 * 这种类被称为：缓冲区类(高效类)
 * 写数据：BufferedOutputStream
 * 读数据：BufferedInputStream
 *
 * 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
 *
 * 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
 * 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。
 */
public class IODemo13 {
    public static void main(String[] args) throws IOException {
        // BufferedOutputStream(OutputStream out)
//        FileOutputStream fos = new FileOutputStream("bos.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        // 简单写法
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
        // 写数据
        bos.write("hello".getBytes());
        // 释放资源
        bos.close();
    }
}

例子2：

package iodemos;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * Created by gao on 15-12-27.
 */
/*
 * 注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。
 */
public class IODemo14 {
    public static void main(String[] args) throws IOException {
        // BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
        // 读取数据
//        int by = 0;
//        while ((by = bis.read()) != -1) {
//            System.out.print((char) by);
//        }
        int len = 0;
        byte[] bys = new byte[1024];
        while ((len = bis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));
        }
        // 释放资源
        bis.close();
    }
}

例子3：四种方式复制mp4

package cn.itcast_06;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 *
 * 字节流四种方式复制文件：
 * 基本字节流一次读写一个字节：    共耗时：117235毫秒
 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒
 * 高效字节流一次读写一个字节： 共耗时：1141毫秒
 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒
 */
public class CopyMp4Demo {
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        // method1("e:\\哥有老婆.mp4", "copy1.mp4");
        // method2("e:\\哥有老婆.mp4", "copy2.mp4");
        // method3("e:\\哥有老婆.mp4", "copy3.mp4");
        method4("e:\\哥有老婆.mp4", "copy4.mp4");
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
    // 高效字节流一次读写一个字节数组：
    public static void method4(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
    // 高效字节流一次读写一个字节：
    public static void method3(String srcString, String destString)
            throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                srcString));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destString));
        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }
    // 基本字节流一次读写一个字节数组
    public static void method2(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        fos.close();
        fis.close();
    }
    // 基本字节流一次读写一个字节
    public static void method1(String srcString, String destString)
            throws IOException {
        FileInputStream fis = new FileInputStream(srcString);
        FileOutputStream fos = new FileOutputStream(destString);
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}
时间： 2024-07-30 06:12:18

Java API —— IO流的相关文章

Java API —— IO流(数据操作流 &amp; 内存操作流 &amp; 打印流 &amp; 标准输入输出流 &amp; 随机访问流 &amp; 合并流 &amp; 序列化流 &amp; Properties &amp; NIO)

1.操作基本数据类型的流 1) 操作基本数据类型 · DataInputStream:数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型.应用程序可以使用数据输出流写入稍后由数据输入流读取的数据. · DataOutputStream:数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中.然后,应用程序可以使用数据输入流将数据读入. package datastreamdemos; import java.io.*; /** * Created b

Java API —— IO流小结

练习题: 1.复制文本文件 package cn.itcast_01; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /* * 复制文本文件 * * 分析: * 复制数据,如果我们知道用记事本打开并能够读懂,就用字符流,否则用字节流. * 通过该原理,我们知

JAVA中IO流总结

本文是在学习中的总结,欢迎转载但请注明出处:http://write.blog.csdn.net/postedit/42119261 我想你对JAVA的IO流有所了解,平时使用的也比较的多,但是对于其具体分类和继承体系可能知道的并不多,可能也很少去看相关的API文档,找出其中的关系和各自的应用情形.本文简单对常用的IO流进行分类整理,并简单举例说明其应用.希望本文对你有所帮助. (A)IO流大致分为两种: (1)字节流:对应抽象类为InputStream(输入流)和 OutputStream(输

java常用IO流数据流小结

  类名 常用方法 说明 输入流 InputStream int read(); 只能读字节流,虽然返回值是int,但只有低8位起作用. DataInputStream Type readType(); 可以读二进制流,可以读byte,short,int,long,double等二进制流. BufferedReader String readLine(); 可以读文本行. 输出流 OutputStream void write(int); 只能写字节流,虽然形参是int,但只有低8为起作用. D

【Java】IO流简单分辨

转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/5827509.html Java的IO流体系十分庞大,并且体系层次稍复杂,很容易记混或记错.在此,我把平时经常用到的几个流类的简易区分以及体系层次整理出来,方便记忆与辨析.本人对IO了解尚浅,文章如有错漏,恳请前辈指正,感激不尽! 字节流体系: 基类:InputStream/outputStream(抽象类,不能new) 子类: 文件IO字节流:FileInputStream/FileoutputStream

【JAVA的 IO流之FileInputStream和FileOutputStream】

java的 IO流即输入输出流,流是一组有顺序的,有起点和终点的字节结合,是对数据传输的总称.即数据在两设备间的传输称为流,流的本质是数据传输. IO流可以分为字节流和字符流.给出相应的IO结构图: 在接下来的一段时间里,将会慢慢介绍各种流的使用,本篇博客先介绍字节流的FileOutputStream和相对应的FileInputStream. 一.FileOutputStream(文件输出流) OutputStream是一个抽象类,抽象类必须通过子类实现.现在要向文件里输出就要用FileOutp

java的IO流，字节流和字符流

java操作文件都是通过流来处理的,(其实其他很多语言也是这样) 第一:java的IO流,分为:输入流 和 输出流(这真是废话,这是从流向的角度来说的) 第二:java的所有IO流,只分为:字节流 和 字符流(其实就是传输的颗粒,传输的基本单位) 总结:凡是处理纯文本的优先考虑字符流:其他的才考虑使用字节流

Java之IO流---字节流

1.1 IO流的引入 IO流在很多语言已有体现,诸如C语言的stdio.h,C++中的iostream.Java中的IO流大抵是用于在控制台.磁盘.内存上进行数据的读写操作,完成数据的传递. 我们可以对它进行如下分类: 按处理的数据类型可分为字节流与字符流 按流的流向可分为输入流(in)与输出流(out) 按流的功能可分为节点流(Node)和过滤流(Filter) 本篇侧重于梳理字节流相关的知识,毕竟作为字符流的前辈,它还是非常重要的.下篇继续梳理字符流. 1.2 IO流的继承体系图 大概描述了

Java笔记-IO流的运用

1.InputStream和System.in(Scanner) InputStream 输出流以字节为单位来获取数据,且需要复杂的判断并创建字节数组作为缓冲 另外字节转换为字符时容易出现中文乱码的情况:Scanner Java扫描器类,可以从输入流中读取指定类型的数据或字符串. 对于字符数据的读取,应该使用Scanner扫描器进行封装,然后获取字符串类型的数据 2. out和err out和err是System类的两个static类成员变量: out:主要是输出调试信息的输出流,以黑色显示 e