精华内容
下载资源
问答
  • 2017-04-29 19:54:47

    首先看一下File类的常用方法

    •File类的对象不但可以表示文件,还可以表示目录,在程序中一个File类对象可以代表一个文件或目录;

    •当创建一个文件对象后,就可以利用它来对文件或目录的属性进行操作,如:文件名、最后修改日期、文件大小等等;

    需要注意的是,File对象并不能直接对文件进行读/写操作,只能查看文件的属性;

    方 法 原 型

    说    明

    boolean exists()

    判断文件是否存在,存在返回true,否则返回false

    boolean isFile()

    判断是否为文件,是文件返回true,否则返回false

    boolean isDirectory()

    判断是否为目录,是目录返回true,否则返回false

    String getName()

    获得文件的名称

    String getAbsolutePath()

    获得文件的绝对路径

    long length()

    获得文件的长度(字节数

    boolean createNewFile()

    throws IOException

    创建新文件,创建成功返回true,否则返回false,有可能抛出IOException异常,必须捕捉

    boolean delete()

    删除文件,删除成功返回true,否则返回false

    File[] listFiles()

    返回文件夹内的子文件与子文件夹的数组

    File类示例

    package file;


    import java.io.File;


    public class FileDemo {


    public static void main(String[] args) {
    File file = new File("test.txt");
    System.out.println("文件或目录是否存在:"+file.exists());
    System.out.println("是文件吗:"+file.isFile());
    System.out.println("是目录吗:"+file.isDirectory());
    System.out.println("名称:"+file.getName());
    System.out.println("绝对路径:"+file.getAbsolutePath());
    System.out.println("文件大小:"+file.length());
    System.out.println("获取自由空间的大小"+file.getFreeSpace());
    System.out.println("有文件夹吗"+file.mkdirs());
    System.out.println("有父文件吗"+file.getParentFile());
    System.out.println("可以写吗"+file.canWrite());
    System.out.println("是可执行文件吗"+file.setExecutable(false));
    }


    }

    •根据流动方同,流分为输入流向的不和输出流;
    •对于输入和输出流,由于传输格式的不同,又分为字节流和字符流:
    –字节流是指8位的通用字节流,以字节为基本单位,在java.io包中,对于字节流进行操作的类大部分继承于InputStream(输入字节流)类和OutputStream(输出字节流)类;
    –字符流是指16位的Unicode字符流,以字符(两个字节)为基本单位,非常适合处理字符串和文本,对于字符流进行操作的类大部分继承于Reader(读取流)类和Writer(写入流)类。

    •FileInputStream类称为文件输入流,继承于InputStream类,是进行文件读操作的最基本类;
    •它的作用是将文件中的数据输入到内存中,我们可以利用它来读文件;
    •由于它属于字节流,因此在读取Unicode字符(如中文)的文件时可能会出现问题。

    •FileInputStream类和FileOutputStream类是成对出现的,一个进行输入(读文件)操作,一个进行输出(写文件)操作;
    •由于采用字节方式进行数据传输,不必考虑数据的格式问题,这两个类对文件操作的效率较高;
    •可以使用这两个类完成复制文件的操作。

    复制文件示例

    publicclass CopyFileDemo {

      public static void main(String[] args)throws IOException {

        File srcFile =new File("src.dat");    //源文件对象

        File destFile =new File("dest.dat");  //目标文件对象

        if (!(destFile.exists())){  //判断目标文件是否存在

          destFile.createNewFile();  //如果不存在则创建新文件

        }

        //使用源文件对象创建文件输入流对象

        FileInputStreamfis =new FileInputStream(srcFile);

        //使用目标文件对象创建文件输出流对象

        FileOutputStreamfos =new FileOutputStream(destFile);

        byte[] buf =new byte[1024];  //创建字节数组,作为临时缓冲

        System.out.println("开始复制文件...");

        while (fis.read(buf) !=-1) {  //循环从文件输入流中读取数据

          fos.write(buf);    //写入到文件输出流中

        }

        System.out.println("文件复制成功!");

        fis.close();    //关闭流

        fos.close();

      }

    }

    ***************************************************************************************下面来看字符流***************************************************************************

    •FileInputStream类和FileOutputStream类虽然可以高效率地读/写文件,但对于Unicode编码的文件,使用它们有可能出现乱码;
    •考虑到Java是跨平台的语言,要经常操作Unicode编码的文件,使用字符流操作文件是有必要的;
    •使用字符流将涉及到以下4个类:
    –FileReader类和FileWriter类;
    BufferedReader类和BufferedWriter类

    FileReader类称为文件读取流,允许以字符流的形式对文件进行读操作
    •该类将从文件中逐个地读取字符,效率比较低下,因此一般将该类对象包装到缓冲流中进行操作。BufferedReader类主要为字符流提供缓冲

    FileReader配合BufferedReader读文件

    public class RraderDemo

    {

      public static voidmain(String[] args)throws IOException

      {

        File file =new File("test.txt");

        //通过文件对象创建文件读取流对象

        FileReaderfr =new FileReader(file);

        //将文件读取流包装成缓冲读取流

        BufferedReaderbr =new BufferedReader(fr);

       

        String str;

        while ((str = br.readLine())!= null)  //逐行读取数据

        {

          System.out.println(str);

        }

        br.close();   //关闭流

        fr.close();   //关闭流

      }

    }

    FileWriter类称为文件写入流,以字符流的形式对文件进行写操作
    与FileReader类相似,FileWriter类同样需要使用缓冲流进行包装
    FileWriter配合BufferedWriter写文件示例

    public class WriterDemo

    {

      public static voidmain(String[] args)throws IOException

      {

        File file =new File("test.txt");

        //通过文件对象创建文件输出字符流对象

        FileWriterfw =new FileWriter(file);

        //将文件输出字符流包装成缓冲流

        BufferedWriterbw =new BufferedWriter(fw);

        bw.write("大家好!");

        bw.write("我正在学习Java。");

        bw.newLine();    //换个新行

        bw.write("请多多指教。");

        bw.newLine();    //换新行

        bw.write("Luckybug@21cn.com");

        bw.close();      //关闭流

        fw.close();      //关闭流

      }

    }

    从控制台接受输入

    •System.in的read方法可以从控制台接受输入;
    •但由于in实际上是一个InputStream类的对象,它只能以字节形式接收数据,并且一次只能接受一个字节,这使输入操作很不便;
    •必须将System.in进行处理,才可以顺利地从控制台接受输入,这将使用到:
    –InputStreamReader类
    –BufferedReader类

    InputStreamReader类用于将InputStream类型的字节输入流对象转换成Reader类型的字符读取流对象;

    •可以使用它来转换System.in,如:

      InputStreamReaderisr =new InputStreamReader(System.in);

    •这样的字符流效率很低,再使用BufferedReader类来为其建立缓冲,如:

       BufferedReaderbr =new BufferedReader(isr);

    •这样,就可以从控制台接受输入了。

    从控制台接受输入示例

    publicclass ConsoleInputDemo

    {

      public static void main(String[] args)throws IOException

      {

        //将System.in转化成字符流对象

        InputStreamReaderisr =new InputStreamReader(System.in);

        //用缓冲流进行包装

        BufferedReaderbr =new BufferedReader(isr);

       

        System.out.println("请输入您的姓名:");

        String name = br.readLine();  //接受输入

        System.out.println("请输入您的年龄:");

        int age= Integer.parseInt(br.readLine());  //接受输入

       

        System.out.println("您的姓名:"+ name);

        System.out.println("您的年龄:"+ age);

       

        br.close();   //关闭流

        isr.close();  //关闭流

      }

    }

    从控制台输入并写入到文件示例

    /*本例从控制台接受输入,然后写入到文件中,直到用户输入"!!!"为止*/

    File file =new File("input.txt");   //创建文件对象

    if (!file.exists())                  //判断该文件是否存在,如果不存在则创建新文件

    {

        file.createNewFile();

    }

    FileWriterfr =new FileWriter(file);   //针对文件对象创建文件写入流对象

    BufferedWriterbw =new BufferedWriter(fr);   //为文件写入流建立缓冲流

    //将控制台输入对象转化成字符流,并建立缓冲流

    BufferedReader bin = new BufferedReader(new InputStreamReader(System.in));

    String str = bin.readLine();    //接受从控制台输入的一行字符串

    while (!(str.equals("!!!")))    //如果输入"!!!"则代表输入结束

    {

        bw.write(str);              //将从控制台输入的字符串写入到文件中

        bw.newLine();               //换新行

        str = bin.readLine();       //再从控制台接受输入

    }

    //关闭所有已经打开的流

    bw.close();

    fr.close();

    bin.close();

    基本数据类型的读/写

    •FileInputStream和FileOutputStream在读写文件时不考虑数据的类型;
    •FileWriter和FileReader在读写文件时,将所有的数据都看做字符;
    但有时候,我们需要将各种类型的数据写入文件或是从文件中读取,DataInputStream类和DataOutputStream类可以满足需要

    DataInputStream类

    •DataInputStream类可以输入任何类型的数据,但它不可以单独 使用,需要要配合其它字节输入流一起使用;

    //将文件输入流包装成数据输入流,以便从文件中读取各种类型的数据
      FileInputStream fis = newFileInputStream("data.dat");
      DataInputStreamdis = new DataInputStream(fis);

    DataInputStream类的常用方法

    方 法 原 型

    说    明

    final boolean readBoolean()

    throws IOException

    从数据输入流中读取一个boolean型数据

    final char readChar()

    throws IOException

    从数据输入流中读取一个char型数据

    final int readInt()

    throws IOException

    从数据输入流中读取一个int型数据

    final long readLong()

    throws IOException

    从数据输入流中读取一个long型数据

    final float readFloat()

    throws IOException

    从数据输入流中读取一个float型数据

    final double readDouble()

    throws IOException

    从数据输入流中读取一个double型数据



    •DataOutputStream类可以输出任何类型的数据,同样也需要配合其他字节输出流一起使用;
    //将文件输出流包装成数据输出流,以便往文件中写入各种类型的数据
      FileOutputStreamfos = new FileOutputStream("data.dat");
      DataOutputStream dos = new DataOutputStream(fos);

    DataOutputStream类的常用方法

    方 法 原 型

    说    明

    final void writeBoolean(boolean v)

    throws IOException

    往数据输出流中写入一个boolean型数据

    final void writeChar(char v)

    throws IOException

    往数据输出流中写入一个char型数据

    final void writeInt(int v)

    throws IOException

    往数据输出流中写入一个int型数据

    final void writeLong(long v)

    throws IOException

    往数据输出流中写入一个long型数据

    final void writeFloat(float v)

    throws IOException

    往数据输出流中写入一个float型数据

    final void writeDouble(double v)

    throws IOException

    往数据输出流中写入一个double型数据

    总结:

    •java.io包是Java内置的包,其中包含一系列对输入/输出进行操作的类;
    •File类的对象可以访问文件(或目录)的属性,但不可以进行读/写操作;
    •从方向上讲,流分为输入流和输出流,但从格式上区分的话,流分为字节流和字符流
    •使用FileInputStream类和FileOutputStream类以字节流方式对文件进行读/写操作,这是操作文件最基本的两个类;

    •FileReader类和FileWriter类配合BufferedReader类和BufferedWriter类可以以字符流方式对文件进行读/写操作;
    •从控制台接受输入要使用到InputStreamReader类和BufferedReader类;
    •DataInputStream类和DataOutputStream类允许读/写各种基本数据类型;
    绝大部分的IO操作都可能抛出IOException





    更多相关内容
  • 面试必问的 Java 字节流与字符流

    千次阅读 2019-02-25 07:00:00
    一些人不屑于看,看了标题就私信我“能能写点高级的,看了这标题我就知道内容了,再这样我就取关了!” 但是也有人表示喜欢看。“内容虽然基础,但是看完后我有了新的认知!” 所以,我的尴尬的取关数据是时候给...

    点击上方“业余草”,选择“置顶公众号”

    第一时间获取技术干货和业界资讯!

    640?wx_fmt=png

     

    最近,我写的都是一些基础知识。一些人不屑于看,看了标题就私信我“能不能写点高级的,看了这标题我就知道内容了,再这样我就取关了!”

    但是也有人表示喜欢看。“内容虽然基础,但是看完后我有了新的认知!”

    所以,我的尴尬的取关数据是时候给大家展示一下了。

    640

    最近 30 天的趋势图如下所示。

    640

    我要感谢一部分网友通过转发、评论等形式对我的支持!谢谢你们!


    好了,下面我们开始今天的内容。

    字节流和字符流其实很好理解!

    字节流就是 Byte 流,字节就是 Byte。

    字符流就是 Character 流,字符就是 Character。

    这里面有两个单位换算大家需要记住一下。

    • 1 byte = 8 bit

    • 1 char = 2 byte = 16 bit

    虽然 1 bit 才是数据真正的最小单位,但 1 bit 的信息量太少了。要表示一个有用的信息,需要好几个 bit 一起表示。所以大多数情况下,字节是数据最小的基本单位。

    比如,我们熟知的基本型的大小都是 8 bit(也就是1字节)的整数倍:

    • boolean: 1 byte

    • short: 2 byte

    • int: 4 byte

    • float: 4 byte

    • long: 8 byte

    • double: 8 byte

    到这里,我们认识的都是字节。但是,Java I/O 的编码系统提供的 Java IO 库有两个支系,面向字节流的 InputStream 和 OutputStream;面向字符的 Reader 和 Writer。

    为什么要有字符流呢?那是因为英文,我们可以用字节来表示,但是中文、日文、韩文等没法用字节来表示了,所有人们就想到了新的字符编码集。比如,Unicode 字符集,GB 18030,GBK,Big5,ISO-8859-1 等。

    所以,最终就是一个字符用 1 个、2 个或 4 个字节组成。总而言之,一切都是字节流,其实没有字符流这个东西。字符只是根据编码集对字节流翻译之后的产物。

    所以,字节流的 InputStream 和 OutputStream 才是一切的基础。实际总线中流动的只有字节流。需要对字节流做特殊解码才能得到字符流。Java 中负责从字节流向字符流解码的桥梁是InputStreamReader 和 InputStreamWriter。

    看下面的 InputStreamReader 和 OutputStreamWriter 的结构图。

    640

    实际负责编码和解码的是 StreamDecoder 类和 StreamEncoder 类。编码过程中必须指定使用的字符编码集 Charset。所以 InputStreamReader 和 OutputStreamWriter 的构造器都带有 Charset 类型的参数。

    如果没有指定编码集,将使用系统默认编码集。而我们经常使用的 FileInputReader 和 FileOutputWriter 就是 InputStreamReader 和 OutputStreamWriter 的派生类。

    到现在,你是不是想起了那句话。“世界上本来没有路,走的人多了,也就变成了路。”

    计算机中本没有字符流,一开始只适用于英文,但是互联网属于全人类的,所以人们又搞出了字符流。字符只是包装的字节而已。

    原文链接:浅谈 Java 中的字节流与字符流

    640

    10T技术资源大放送!包括但不限于:C/C++,Linux,Python,Java,PHP,人工智能,GO等等。在公众号内回复对应关键字或框架名字,即可免费获取!!

    640?wx_fmt=png

     你再主动一点点 640?  我们就有故事了

    展开全文
  • Java I/O(字节流、字符流与转换流)

    千次阅读 2019-04-26 12:06:18
    **File类支持文件内容处理,如果要处理文件内容,必须要通过流的...字节流与字符流操作的本质区别只有一个:字节流是原生的操作,而字符流是经过处理后的操作。 在进行网络数据传输、磁盘数据保存所保存所支持的...

    **File类不支持文件内容处理,如果要处理文件内容,必须要通过流的操作模式来完成。流分为输入流和输出流。
    在java.io包中,流分为两种:字节流与字符流:

    • 字节流:InputStream、OutputStream
    • 字符流:Reader、Writer**
      在这里插入图片描述
      在这里插入图片描述

    字节流与字符流操作的本质区别只有一个:字节流是原生的操作,而字符流是经过处理后的操作。
    在进行网络数据传输、磁盘数据保存所保存所支持的数据类型只有:字节。

    而所有磁盘中的数据必须先读取到内存后才能进行操作,而内存中会帮助我们把字节变为字符。字符更加适合处理中文。

    不管使用的是字节流还是字符流,其基本的操作流程几乎是一样的,以文件操作为例。
    根据文件路径创建File类对象 ;

    • 根据字节流或字符流的子类实例化父类对象 ;

    • 进行数据的读取或写入操作

    • 关闭流(close())

    对于IO操作属于资源处理,所有的资源处理操作(IO操作、数据库操作、网络)最后必须要进行关闭。

    字节输出流(OutputStream)
    OutputStream类的定义结构

    public abstract class OutputStream implements Closeable, Flushable
    

    OutputStream类实现Closeable, Flushable这两个接口,这两个接口中的方法:

    Closeable: public void close() throws IOException;
    Flushable: public void flush() throws IOException;
    

    OutputStream类中定义的其他方法:

    • 将给定的字节数组内容全部输出:public void write(byte b[]) throws IOException

    • 将部分字节数组内容输出:public void write(byte b[], int off, int len) throws IOException

    • 输出单个字节:public abstract void write(int b) throws IOException

    由于OutputStream是一个抽象类,所以要想为父类实例化,就必须要使用子类。由于方法名称都由父类声明好了,所以我们在此处只需要关系子类的构造方法。如果要进行文件的操作,可以使用FileOutputStream类来处理,这个类的构造方法如下:
    接收File类(覆盖):public FileOutputStream(File file) throws FileNotFoundException
    接收File类(追加):public FileOutputStream(File file, boolean append)

    实现文件的内容输出:

    package com.bittech;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    public class Test {
        public static void main(String[] args) throws Exception{
            File file = new File("E:"+File.separator+"1"+File.separator+"test");
            if (!file.getParentFile().exists()) { // 必须保证父目录存在
                file.getParentFile().mkdirs() ; // 创建多级父目录
            }
    // OutputStream是一个抽象类,所以需要通过子类进行实例化,此时只能操作File类
            OutputStream output = new FileOutputStream(file) ;
    // 要求输出到文件的内容
            String msg = "我们都是一家人!" ;
    // 将内容变为字节数组
            output.write(msg.getBytes());
    // 关闭输出
            output.close();
        }
    }
    

    在进行文件输出的时候,所有的文件会自动帮助用户创建,不在需要调用createFile()方法手工创建。
    这个时候程序如果重复执行,并不会出现内容追加的情况而是一直在覆盖。如果需要文件内容追加,则需要调用FileOutputStream提供的另外一种构造方法。

    文件内容的追加:

    package www.bittech;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File files=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!files.getParentFile().exists()){// 必须保证父目录存在
                files.getParentFile().mkdirs();//创建多级父目录
            }
            //OutputStream是一个抽象类,所以需要通过子类进行实例化,此时只能操作File类
            OutputStream out=new FileOutputStream(files,true);
             要求输出到文件的内容
            String msg="快快乐乐的一家人!\n";
            //将内容变为字节数组
            out.write(msg.getBytes());
             关闭输出
            out.close();
        }
    }
    

    1.输出流如果文件不存在,自动创建
    2.FileOutputStream中 append默认是false会覆盖内容,若为true,则字节写入文件的末尾而不是开头。

    AutoCloseable自动关闭支持
    从JDk1.7开始追加了一个AutoCloseable接口,这个接口的主要目的是自动进行关闭处理,但是这种处理一般不好用,因为使用它必须结合try…catch。

    AutoCloseable接口使用:

    package www.bittech;
    
    class Message implements AutoCloseable{
        public Message(){
            System.out.println("创建一条新消息!");
        }
        public void close() throws Exception{
            System.out.println("[AutoCloseable自动关闭方法!]");
        }
        public void print(){
            System.out.println("www.bittech");
        }
    }
    public class Test {
        public static void main(String[] args) {
            try (Message msg=new Message()){//必须在try中定义对象
                msg.print();
            }catch (Exception e){
    
            }
        }
    }
    

    推荐使用close手工关闭!

    字节输入流:InputStream
    利用了OutputStream实现了程序输出内容到文件的处理,下面使用InputStream类在程序中读取文件内容。
    InputStream类的定义如下:

    public abstract class InputStream implements Closeable
    

    InputStream类只实现了Closeable接口,在InputStream类中提供有如下方法:

    • 读取数据到字节数组中,返回数据的读取个数。如果此时开辟的字节数组大小大于读取的数据大小,则返回的就是读取个数;如果要读取的数据大于数组的内容,那么这个时候返回的就是数组长度;如果没有数据了还在读,则返回-1: public int read(byte b[]) throws IOException.最常用方法
    • 读取部分数据到字节数组中,每次只读取传递数组的部分内容,如果读取满了则返回长度(len),如果没有读取满则返回读取的数据个数,如果读取到最后没有数据了返回-1:public int read(byte b[], int off,int len) throws IOException
    • 读取单个字节,每次读取一个字节的内容,直到没有数据了返回-1:public abstract int read() throws IOException;同OutputStream的使用一样,InputStream是一个抽象类,如果要对其实例化,同样也需要使用子类。如果要对文件进行处理,则使用FileInputStream类。

    实现文件信息的读取:

    package www.bittech;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test");
            if(file.exists()) {
                InputStream input = new FileInputStream(file);
                byte[] date = new byte[1024];//每次可以读取的最大数量
                int len = input.read(date);//此时数据读取到数组中
                String result=new String(date,0,len);//将字节数组转换为String
                System.out.println(result);
                input.close();
            }
        }
    }
    

    字符输出流:Writer
    字符适合于处理中文数据,Writer是字符输出流的处理类,这个类的定义如下:

    public abstract class Writer implements Appendable, Closeable, Flushable
    

    与OutputStream相比多了一个Appendable接口。
    在Writer类里面也提供write()方法,而且该方法接收的类型都是char型,要注意的是,Writer类提供了一个直接输出字符串的方法:

    public void write(String str) throws IOException
    

    通过Writer实现输出:

    package www.bittech;
    
    import java.io.File;
    import java.io.Writer;
    import java.io.FileWriter;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!file.getParentFile().exists()){//必须保证父目录存在
                file.getParentFile().mkdirs();//创建多级父目录
            }
            Writer out=new FileWriter(file,true);
            out.write("今天天气真好!");
            out.close();
        }
    }
    

    字符输入流:Reader
    Reader依然也是一个抽象类。如果要进行文件读取,同样的,使用FileReader。
    在上面讲到的Writer类中提供有方法直接向目标源写入字符串,而在Reader类中没有方法可以直接读取字符串类型,这个时候只能通过字符数组进行读取操作。

    通过文件读取数据:

    package www.bittech;
    
    import java.io.File;
    import java.io.Reader;
    import java.io.FileReader;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
             1.定义文件路径
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
             2.必须保证文件存在才能进行处理
            if(file.exists()){
                Reader in=new FileReader(file);
                char[] date=new char[1024];//每次可读取的最大数量
                int len=in.read(date);// 将数据读取到字符数组中
                String result=new String(date,0,len);
                System.out.println(result);
                in.close();
            }
        }
    }
    

    字符流适合处理中文,字节流适合处理一切数据类型(对中文支持不好)。

    字节流vs字符流
    使用字节流和字符流从代码形式上区别不大。但是如果从实际开发来讲,字节流一定是优先考虑的,只有在处理中文时才会考虑字符流。因为所有的字符都需要通过内存缓冲来进行处理。所有字符流的操作,无论是写入还是输出,数据都先保存在缓存中。如果字符流不关闭,数据就有可能保存在缓存中并没有输出到目标源。这种情况下就必须强制刷新才能够得到完整数据。

    字符流刷新操作:

    package www.bittech;
    
    import java.io.File;
    import java.io.Writer;
    import java.io.FileWriter;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!file.getParentFile().exists()){//必须保证父目录存在
                file.getParentFile().mkdirs();//创建多级父目录
            }
            Writer out=new FileWriter(file,true);
            out.write("今天天气真好!");
            out.flush();//写上此语句表示强制清空缓冲内容,所有内容都输出
        }
    }
    

    在以后进行IO处理的时候,如果处理的是图片、音乐、文字都可以使用字节流,而只有处理中文的时候才会使用字符流。

    转换流
    字节流和字符流是可以进行相互转换的。
    OutputStreamWriter:将字节输出流变为字符输出流(Writer对于文字的输出要比OutputStream方便)
    InputStreamReader:将字节输入流变为字符输入流(InputStream读取的是字节,不方便中文的处理)

    它们的继承关系以及构造方法:

    public class OutputStreamWriter extends Writer
    public OutputStreamWriter(OutputStream out)
    
    
    public class InputStreamReader extends Reader
    public InputStreamReader(InputStream in)
    

    实现字节流与字符流的转换:

    package www.bittech;
    
    import java.io.*;
    
    
    public class Test {
        public static void main(String[] args) throws Exception{
            File file=new File("E:"+File.separator+"1"+File.separator+"test.txt");
            if(!file.getParentFile().exists()){//必须保证父目录存在
                file.getParentFile().mkdirs();//创建多级父目录`在这里插入代码片`
            }
            OutputStream output= new FileOutputStream(file);
            Writer out=new OutputStreamWriter(output);//字节流转为字符流
            out.write("今天是你生日吗?");
            out.close();
        }
    }
    

    FileOutputStream、FileInputStream、FileWriter、FileReader之间的继承关系:
    在这里插入图片描述

    展开全文
  • 字节流与字符流的区别及相互转换

    千次阅读 2017-10-20 08:41:13
    先来看一下流的概念:  在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。...字节流与字符流  在ja

    转载:http://www.cnblogs.com/sjjsh/p/5269781.html

    先来看一下流的概念:

         在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。

         程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。

    字节流与字符流

         在java.io包中操作文件内容的主要有两大类:字节流、字符流,两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成,输入使的是InputStream,在字符流中输出主要是使用Writer类完成,输入流主要使用Reader类完成。(这四个都是抽象类)

         java中提供了专用于输入输出功能的包Java.io,其中包括:
         InputStream,OutputStream,Reader,Writer
         InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
         Reader和 Writer.两个是为字符流(一个字符占两个字节)设计的,主要用来处理字符或字符串.

         字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!如果是音频文件、图片、歌曲,就用字节流好点,如果是关系到中文(文本)的,用字符流好点
         所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列

          字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以
         字节流是最基本的,所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据,它是按字节来处理的 但实际中很多的数据是文本,又提出了字符流的概念,它是按虚拟机的encode来处理,也就是要进行字符集的转化 这两个之间通过 InputStreamReader,OutputStreamWriter来关联,实际上是通过byte[]和String来关联 在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的 。

         字节流和字符流的操作过程:   

         以文件操作为例,主要的操作流程如下:

        1 使用File类打开一个文件

        2 通过字节流或字符流的子类,指定输出的位置

        3 进行读/写操作

        4 关闭输入/输出

         IO操作属于资源操作,一定要记得关闭 

         字节流的操作:

         字节流主要是操作byte类型数据,以byte数组为准,主要操作类就是OutputStream、InputStream     

         字节输出流:OutputStream

      OutputStream是整个IO包中字节输出流的最大父类,此类的定义如下:

    public abstract class OutputStream extends Object implements Closeable,Flushable

      从以上的定义可以发现,此类是一个抽象类,如果想要使用此类的话,则首先必须通过子类实例化对象,那么如果现在要操作的是一个文件,则可以使用:FileOutputStream类。通过向上转型之后,可以为OutputStream实例化

      Closeable表示可以关闭的操作,因为程序运行到最后肯定要关闭

      Flushable:表示刷新,清空内存中的数据

      FileOutputStream类的构造方法如下:

    public FileOutputStream(File file)throws FileNotFoundException

     

    写数据:

    复制代码
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    public class Test11 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
             String str="Hello World";
             byte[] b=str.getBytes();
             out.write(b);//因为是字节流,所以要转化成字节数组进行输出
             out.close();
         }
     }
    
    也可以一个字节一个字节进行输出,如下:
    
     import java.io.File;
     import java.io.FileOutputStream;
     import java.io.IOException;
     import java.io.OutputStream;
     
     public class Test11 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              OutputStream out=new FileOutputStream(f);//如果文件不存在会自动创建
             String str="Hello World";
             byte[] b=str.getBytes();
             for(int i=0;i<b.length;i++){
                 out.write(b[i]);
             }
             out.close();
         }
     }
    复制代码

    以上输出只会进行覆盖,如果要追加的话,请看FileOutputStream类的另一个构造方法:

    public FileOutputStream(File file,boolean append)throws FileNotFoundException

    在构造方法中,如果将append的值设置为true,则表示在文件的末尾追加内容。

    复制代码
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
     
     public class Test11 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              OutputStream out=new FileOutputStream(f,true);//追加内容
             String str="\r\nHello World";
             byte[] b=str.getBytes();
             for(int i=0;i<b.length;i++){
                 out.write(b[i]);
             }
             out.close();
         }
     }
    复制代码

      字节输入流:InputStream

      既然程序可以向文件中写入内容,则就可以通过InputStream从文件中把内容读取进来,首先来看InputStream类的定义:

          public abstract class InputStream extends Object implements Closeable

      与OutputStream类一样,InputStream本身也是一个抽象类,必须依靠其子类,如果现在是从文件中读取,就用FileInputStream来实现。

      观察FileInputStream类的构造方法:

          public FileInputStream(File file)throws FileNotFoundException

      读文件:

    复制代码
     import java.io.File;
     import java.io.FileInputStream;
     import java.io.IOException;
     import java.io.InputStream;
     
      public class Test12 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              InputStream in=new FileInputStream(f);
             byte[] b=new byte[(int) f.length()];  //根据文件的大小来定义字节数组的大小int len=in.read(b);
             in.close();
             System.out.println(new String(b,0,len));
         }
     }
    复制代码

    换种方式,一个字节一个字节读入

    复制代码
     import java.io.File;
     import java.io.FileInputStream;
     import java.io.IOException;
     import java.io.InputStream;
     
      public class Test14 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              InputStream in=new FileInputStream(f);
             byte[] b=new byte[(int) f.length()];
             for(int i=0;i<b.length;i++){
                 b[i]=(byte) in.read();
             }
             in.close();
             System.out.println(new String(b));
         }
     }
    复制代码

    但以上情况只适合知道输入文件的大小,不知道的话用如下方法:

    复制代码
     import java.io.File;
     import java.io.FileInputStream;
     import java.io.IOException;
     import java.io.InputStream;
     
      public class Test15 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              InputStream in=new FileInputStream(f);
             byte[] b=new byte[1024];
             int temp=0;
             int len=0;
             while((temp=in.read())!=-1){//-1为文件读完的标志
                 b[len]=(byte) temp;
                 len++;
            }
             in.close();
             System.out.println(new String(b,0,len));
         }
     }
    复制代码

      字符流

      在程序中一个字符等于两个字节,那么java提供了Reader、Writer两个专门操作字符流的类。


      字符输出流:Writer

      Writer本身是一个字符流的输出类,此类的定义如下:

         public abstract class Writer extends Object implements Appendable,Closeable,Flushable

      此类本身也是一个抽象类,如果要使用此类,则肯定要使用其子类,此时如果是向文件中写入内容,所以应该使用FileWriter的子类。

      FileWriter类的构造方法定义如下:

         public FileWriter(File file)throws IOException

      字符流的操作比字节流操作好在一点,就是可以直接输出字符串了,不用再像之前那样进行转换操作了。

      写文件:

    复制代码
    import java.io.File;
     import java.io.FileWriter;
     import java.io.IOException;
     import java.io.Writer;
     
      public class Test16 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              Writer out=new FileWriter(f);
             String str="Hello World";
             out.write(str);
             out.close();
         }
     }
    
    在默认情况下再次输出会覆盖,追加的方法也是在构造函数上加上追加标记
    
    import java.io.File;
     import java.io.FileWriter;
     import java.io.IOException;
     import java.io.Writer;
     
      public class Test17 {
         public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              Writer out=new FileWriter(f,true);//追加
             String str="\r\nHello World";
             out.write(str);
             out.close();
         }
     }
    复制代码

      字符输入流:Reader

      Reader是使用字符的方式从文件中取出数据,Reader类的定义如下:

        public abstract class Reader extends Objects implements Readable,Closeable

      Reader本身也是抽象类,如果现在要从文件中读取内容,则可以直接使用FileReader子类。

      FileReader的构造方法定义如下:

        public FileReader(File file)throws FileNotFoundException

      以字符数组的形式读取出数据:

    复制代码
     import java.io.File;
     import java.io.FileReader;
     import java.io.IOException;
     import java.io.Reader;
     
      public class Test18 {
          public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              Reader input=new FileReader(f);
             char[] c=new char[1024];
             int len=input.read(c);
             input.close();
             System.out.println(new String(c,0,len));
         }
     }
    
    也可以用循环方式,判断是否读到底
    
    import java.io.File;
    import java.io.FileReader;
     import java.io.IOException;
     import java.io.Reader;
    
     public class Test19 {
         public static void main(String[] args) throws IOException {
              File f = new File("d:" + File.separator+"test.txt");
              Reader input=new FileReader(f);
             char[] c=new char[1024];
             int temp=0;
             int len=0;
             while((temp=input.read())!=-1){
                 c[len]=(char) temp;
                 len++;
             }
             input.close();
             System.out.println(new String(c,0,len));
         }
     }
    复制代码

      字节流与字符流的区别

      字节流和字符流使用是非常相似的,那么除了操作代码的不同之外,还有哪些不同呢?

      字节流在操作的时候本身是不会用到缓冲区(内存)的,是与文件本身直接操作的,而字符流在操作的时候是使用到缓冲区的

      字节流在操作文件时,即使不关闭资源(close方法),文件也能输出,但是如果字符流不使用close方法的话,则不会输出任何内容,说明字符流用的是缓冲区,并且可以使用flush方法强制进行刷新缓冲区,这时才能在不close的情况下输出内容

      那开发中究竟用字节流好还是用字符流好呢?

      在所有的硬盘上保存文件或进行传输的时候都是以字节的方法进行的,包括图片也是按字节完成,而字符是只有在内存中才会形成的,所以使用字节的操作是最多的。

      如果要java程序实现一个拷贝功能,应该选用字节流进行操作(可能拷贝的是图片),并且采用边读边写的方式(节省内存)。

    字节流与字符流的转换

         虽然Java支持字节流和字符流,但有时需要在字节流和字符流两者之间转换。InputStreamReader和OutputStreamWriter,这两个为类是字节流和字符流之间相互转换的类。

      InputSreamReader用于将一个字节流中的字节解码成字符:

      有两个构造方法:

        InputStreamReader(InputStream in);

        功能:用默认字符集创建一个InputStreamReader对象

        InputStreamReader(InputStream in,String CharsetName);

        功能:接收已指定字符集名的字符串,并用该字符创建对象

      OutputStream用于将写入的字符编码成字节后写入一个字节流。

      同样有两个构造方法:

        OutputStreamWriter(OutputStream out);

        功能:用默认字符集创建一个OutputStreamWriter对象;

        OutputStreamWriter(OutputStream out,String  CharSetName);

        功能:接收已指定字符集名的字符串,并用该字符集创建OutputStreamWrite对象

          为了避免频繁的转换字节流和字符流,对以上两个类进行了封装。

      BufferedWriter类封装了OutputStreamWriter类;

      BufferedReader类封装了InputStreamReader类;

      封装格式:

      BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));

      BufferedReader in= new BufferedReader(new InputStreamReader(System.in);

      利用下面的语句,可以从控制台读取一行字符串:

      BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

      String line=in.readLine();

    Never mind!准备好才能迎接机会!
    展开全文
  • File文件,字节输入,字节输入字符输入,字节输出的详解 File文件概述 1.File类型:用于表示一个文件或者是文件夹的路径的对象(抽象路径名) 2.路径:用于描述文件或者是文件夹的所在路径的所在的字符串 3....
  • Java之IO流---字符流

    千次阅读 2016-09-28 00:00:29
    1.1 字符流的由来在上篇,我提到过用字节流读取中文汉字打印在控制台上,会出现乱码的情况,原因就赘述了。可见,对于字符的操作,强大如斯的字节流也有失利的时候。这个时候我们本篇的主角—字符流就登上了历史的...
  • 先来看一下流的概念: &amp;nbsp; &amp;nbsp; &amp;nbsp;在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流...字节流与字符流 &amp;nbsp; &amp;nbsp; &amp
  • 工作中经常遇到java编码问题,...Java读取文件的方式总体可以分为两类:按字节读取和按字符读取。按字节读取就是采用InputStream.read()方法来读取字节,然后保存到一个byte[]数组中,最后经常用new String(byte[]
  • IO

    千次阅读 2016-12-22 15:56:59
    1. 下面哪个属于面向字符的输入? A. BufferedWriter B. FileInputStream C. ObjectInputStream D. InputStreamReader 答案:D 解析:Java 的 IO 操作中有面向字节(Byte)和面向字符(Character)两种...
  • Java之IO流---字节流,字符流,buffer,file

    千次阅读 2018-05-05 21:38:22
    1.概述1.1 IO流的引入 IO流在...我们可以对它进行如下分类:按处理的数据类型可分为字节流(byte)与字符流(char)按流的流向可分为输入流(in)与输出流(out)按流的功能可分为节点流(Node)和过滤流(Filter)本篇侧重...
  • 过滤

    千次阅读 2021-02-04 13:58:08
    InputStreamReader和OutputStreamWriter提供了字节流和字符流之间的桥接转换功能,用于与字节数据到字符 数据之间的转换,无需编程实现将字节拼接为字符 转换流可以在构造时指定其编码字符集 InputStreamReader用于...
  • 【Java-IO】File、搜索删除剪切、字符集、字符编码、字符编码比较、乱码、字节流、将内存中的数据写入文件、字符流、缓冲流、Scanner、格式化输出、数据流、对象流、序列化与反序列化、Files工具类、Input/Output ...
  • 博主声明: 转载请在开头附加本文链接及作者信息,并标记... I/O 关于数据的存储,分为内部存储和外部存储。内部存储就像内存一样,是一种临时性的对数据进行储存的方式,这种方式存储的数据量不大,但是获...
  • 本文代码实现基本按照《数据结构》课本目录顺序... 下面给出带头的单链表标准实现: 定义节点: typedef struct node { int data; struct node * next; }Node; 尾插: void pushBackList(Node ** list, int data) { ...
  • ASCII码可见字符过滤处理

    千次阅读 2018-04-19 10:46:27
    Function/Control Code/Character in ASCIIVersion: 2011-02-15Author: green-waste (at) 163.com【什么是 Function Code 功能码或 Function Character...128 个字符。其中前 32 个, 0-31 ,即 0x00-0x1F...
  • Java IO常见面试问题

    万次阅读 多人点赞 2019-04-25 14:05:36
    IO 先要明白一个基础问题: 1.什么是比特(Bit)?什么是字节(Byte)?什么是字符(Char)?以及他们的区别? Bit 位,是计算机最小的二进制单位 ,取0或1,主要用于计算机操作。 Byte 字节,是数据的最小单位,由8...
  • Java 208 道面试题:Java 基础模块答案

    万次阅读 多人点赞 2019-03-05 11:39:29
    String 不属于基础类型,基础类型有 8 种:byte、boolean、char、short、int、float、long、double,而 String 属于对象。 7.java 中操作字符串都有哪些类?它们之间有什么区别? 操作字符串的类有:String、...
  • 本文介绍了Java IO的基本概念,使用方法,以及使用的注意事项等。帮助你更好地理解和使用Java的IO。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 喜欢的话麻烦点一下星哈谢谢。 文章...
  • 底层使用的红黑树 7.java BIO NIO AIO 序列化 字节操作:使用inputStream和outPutSream实现,字节是传输和存储的最小单位 字符操作:inputStreamReader:将字节流解码成字符流 OutPutStramWriter:将字符流编码成...
  • C++ 字符串库函数的自定义实现

    千次阅读 2021-02-06 21:13:41
    字符串处理函数包括几大类可以满足对char*字符串大部分操作,需要包括头文件<cstring>或者<string.h>,选择几个仔细研究一下: #include <iostream> #include <cstring> #include <...
  • 字符编码那些事--彻底理解掌握编码知识

    万次阅读 多人点赞 2020-05-04 16:42:33
    每一个程序员都可避免的遇到字符编码的问题,很多人在字符编码方面同样遇到不少问题,而且一直对各种编码懵懵懂懂、楚。这篇文章就是针对字符编码中的一些问题进行了详细的阐述,能从根本上理解字符编码。
  • 媒体及媒体传输协议简介

    千次阅读 多人点赞 2019-06-01 22:26:10
    媒体(streaming media):是指将一连串的媒体数据压缩后,经过网上分段发送数据,在网上即时传输影音以供观赏的一种技术与过程,此技术使得数据包得以像流水一样发送;如果使用此技术,就必须在使用前下载整个...
  • C++里string类字符串输入的用法

    千次阅读 多人点赞 2020-09-04 11:56:29
    学C++的时候,这几个输入函数弄的有点迷糊;这里做个小结,为了自己复习,也希望对后来者能有所...//跳过一个字符,例如想要的回车,空格等字符 1、cin>> 用法1:最基本,也是最常用的用法,输入一个数字...
  • 1.以下不属于人工智能领域的Python第三方库是( )。A.KerasB.PyTorchC.MXNetD.PyOCRD【解析】PyOCR是图像字符识别方向的第三方库;PyTorch、MXNet、Keras都属于人工智能领域的第三方库。2.以下不属于数据分析领域的...
  • 日常Java练习题(每天进步一点点系列)

    万次阅读 多人点赞 2021-05-30 14:33:41
    直接看到答案太好,那我把答案的颜色设置为透明,答案位置还是在题目后面,需要鼠标选中才能看见(操作如下图),同时为了手机端的小伙伴(手机端也可以长按选中查看),我还会把所有答案放到文章最下面,希望给...
  • 深入理解Java中的IO

    千次阅读 2018-08-15 16:37:59
    ,本身就应该出现在InputStream部分,主要因为String应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。 4. SequenceInputStream可以认为是...
  • java 输入输出详解及分类

    千次阅读 多人点赞 2018-08-09 19:42:07
    字节流与字符流的详解,文件流,数据流 2017年04月29日 19:54:47 阅读数:1294   首先看一下File类的常用方法   •File类的对象不但可以表示文件,还可以表示目录,在程序中一个File类对象可以代表一个文件...
  • 一文弄懂字符串编码

    千次阅读 2019-07-29 19:18:04
    字符(character) 在计算机和电信领域中,字符(Character)是一个信息单位。对使用字母系统或音节文字等自然语言,它大约对应为一个音位、类音位的单位或符号。简单来讲就是一个汉字、假名、韩文字……,或是一个...
  • C++的字符串输入方式

    千次阅读 2022-03-18 16:02:34
    C++字符字符串的几种输入方法
  • 牛逼!Java 从入门到精通,超全汇总版

    万次阅读 多人点赞 2021-05-06 19:40:33
    有人问图中为什么没有并发或者 Java 虚拟机这些,这些属于中高级内容,刚开始学 Java 不用懂什么并发和 JVM!!!有一些人或者培训班都喜欢秀自己懂 xxx ,懂 xxx ,这就是误导小白么。 那么话又说回来了,如何...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 128,599
精华内容 51,439
关键字:

下面哪些不属于字符流