请选择 进入手机版 | 继续访问电脑版
搜索
房产
装修
汽车
婚嫁
健康
理财
旅游
美食
跳蚤
二手房
租房
招聘
二手车
教育
茶座
我要买房
买东西
装修家居
交友
职场
生活
网购
亲子
情感
龙城车友
找美食
谈婚论嫁
美女
兴趣
八卦
宠物
手机

JavaSE学习笔记(14)---File类和IO流(字节流和字符流)

[复制链接]
查看: 51|回复: 0

3万

主题

3万

帖子

9万

积分

管理员

Rank: 9Rank: 9Rank: 9

积分
91650
发表于 2020-2-15 05:22 | 显示全部楼层 |阅读模式
JavaSE进修笔记(14)---File类和IO流(字节省和字符流)

File类

概述

java.io.File 类是文件和目录途径名的笼统表现,重要用于文件和目录的建立、查找和删除等操纵。
机关方式


  • public File(String pathname) :经过将给定的途径名字符串转换为笼统途径名来建立新的 File实例。
  • public File(String parent, String child) :从父途径名字符串和子途径名字符串建立新的 File实例。
  • public File(File parent, String child) :从父笼统途径名和子途径名字符串建立新的 File实例。
  • 机关举例,代码以下:
  1. // 文件途径名String pathname = "D:\\aaa.txt";File file1 = new File(pathname); // 文件途径名String pathname2 = "D:\\aaa\\bbb.txt";File file2 = new File(pathname2); // 经过父途径和子途径字符串 String parent = "d:\\aaa"; String child = "bbb.txt"; File file3 = new File(parent, child);// 经过父级File工具和子途径字符串File parentDir = new File("d:\\aaa");String child = "bbb.txt";File file4 = new File(parentDir, child);
复制代码
小贴士:

  • 一个File工具代表硬盘中现实存在的一个文件大要目录。
  • 不管该途径下能否存在文件大要目录,都不影响File工具的建立。
常用方式

获得功用的方式

  • public String getAbsolutePath() :返回此File的绝对途径名字符串。
  • public String getPath() :将此File转换为途径名字符串。
  • public String getName() :返回由此File表现的文件或目录的称号。
  • public long length() :返回由此File表现的文件的长度。
    方式演示,代码以下:
    1. public class FileGet {    public static void main(String[] args) {        File f = new File("d:/aaa/bbb.java");             System.out.println("文件绝对途径:"+f.getAbsolutePath());        System.out.println("文件机关途径:"+f.getPath());        System.out.println("文件称号:"+f.getName());        System.out.println("文件长度:"+f.length()+"字节");        File f2 = new File("d:/aaa");             System.out.println("目录绝对途径:"+f2.getAbsolutePath());        System.out.println("目录机关途径:"+f2.getPath());        System.out.println("目录称号:"+f2.getName());        System.out.println("目录长度:"+f2.length());    }}输出成果:文件绝对途径:d:\aaa\bbb.java文件机关途径:d:\aaa\bbb.java文件称号:bbb.java文件长度:636字节目录绝对途径:d:\aaa目录机关途径:d:\aaa目录称号:aaa目录长度:4096
    复制代码
API中说明:length(),表现文件的长度。可是File工具表现目录,则返回值未指定。
绝对途径和相对途径


  • 绝对途径:从盘符起头的途径,这是一个完整的途径。
  • 相对途径:相对于项目目录的途径,这是一个便利的途径,斥地中经常操纵。
  1. public class FilePath {    public static void main(String[] args) {        // D盘下的bbb.java文件        File f = new File("D:\\bbb.java");        System.out.println(f.getAbsolutePath());                // 项目下的bbb.java文件        File f2 = new File("bbb.java");        System.out.println(f2.getAbsolutePath());    }}输出成果:D:\bbb.javaD:\idea_project_test4\bbb.java
复制代码
判定功用的方式


  • public boolean exists() :此File表现的文件或目录能否现实存在。
  • public boolean isDirectory() :此File表现的能否为目录。
  • public boolean isFile() :此File表现的能否为文件。
方式演示,代码以下:
  1. public class FileIs {    public static void main(String[] args) {        File f = new File("d:\\aaa\\bbb.java");        File f2 = new File("d:\\aaa");        // 判定能否存在        System.out.println("d:\\aaa\\bbb.java 能否存在:"+f.exists());        System.out.println("d:\\aaa 能否存在:"+f2.exists());        // 判定是文件照旧目录        System.out.println("d:\\aaa 文件?:"+f2.isFile());        System.out.println("d:\\aaa 目录?:"+f2.isDirectory());    }}输出成果:d:\aaa\bbb.java 能否存在:trued:\aaa 能否存在:trued:\aaa 文件?:falsed:\aaa 目录?:true
复制代码
建立删除功用的方式


  • public boolean createNewFile() :当且仅当具有该称号的文件尚不存在时,建立一个新的空文件。
  • public boolean delete() :删除由此File表现的文件或目录。
  • public boolean mkdir() :建立由此File表现的目录。
  • public boolean mkdirs() :建立由此File表现的目录,包含任何须须但不存在的父目录。
方式演示,代码以下:
  1. public class FileCreateDelete {    public static void main(String[] args) throws IOException {        // 文件的建立        File f = new File("aaa.txt");        System.out.println("能否存在:"+f.exists()); // false        System.out.println("能否建立:"+f.createNewFile()); // true        System.out.println("能否存在:"+f.exists()); // true                // 目录的建立        File f2= new File("newDir");            System.out.println("能否存在:"+f2.exists());// false        System.out.println("能否建立:"+f2.mkdir()); // true        System.out.println("能否存在:"+f2.exists());// true        // 建立多级目录        File f3= new File("newDira\\newDirb");        System.out.println(f3.mkdir());// false        File f4= new File("newDira\\newDirb");        System.out.println(f4.mkdirs());// true              // 文件的删除        System.out.println(f.delete());// true              // 目录的删除        System.out.println(f2.delete());// true        System.out.println(f4.delete());// false    }}
复制代码
API中说明:delete方式,假如此File表现目录,则目录必须为空才华删除。
目录的遍历


  • public String[] list() :返回一个String数组,表现该File目录中的全数子文件或目录。
  • public File[] listFiles() :返回一个File数组,表现该File目录中的全数的子文件或目录。
  1. public class FileFor {    public static void main(String[] args) {        File dir = new File("d:\\java_code");              //获得当前目录下的文件以及文件夹的称号。        String[] names = dir.list();        for(String name : names){            System.out.println(name);        }        //获得当前目录下的文件以及文件夹工具,只要拿到了文件工具,那末便可以获得更多信息        File[] files = dir.listFiles();        for (File file : files) {            System.out.println(file);        }    }}
复制代码
小贴士:
挪用listFiles方式的File工具,表现的必须是现实存在的目录,否则返回null,没法举行遍历。
IO概述

什么是IO

保存中,你必定履历过这样的场景。当你编辑一个文本文件,忘记了ctrl+s ,大要文件就白白编辑了。当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。那末数据都是在哪些装惫亓呢?键盘、内存、硬盘、外接装备等等。
我们把这类数据的传输,可以看做是一种数据的活动,依照活动的偏向,之内存为基准,分为输入input 和输出output ,即流向内存是输入流,流出内存的输出流。
Java中I/O操纵重如果教唆用java.io包下的内容,举行输入、输出操纵。输入也叫做读取数据,输出也叫造作写出数据。
IO的分类

按照数据的流向分为:输入流输出流

  • 输入流 :把数据从其他装备上读取到内存中的流。
  • 输出流 :把数据从内存 中写出到其他装惫亓流。
格式数据的典范分为:字节省字符流

  • 字节省 :以字节为单元,读写数据的流。
  • 字符流 :以字符为单元,读写数据的流。
IO的流向说明


  • 输入:硬盘到内存
  • 输出:内存到硬盘
顶级父类们

输入流输出流字节省字节输入流
InputStream字节输出流
OutputStream字符流字符输入流
Reader字符输出流
Writer字节省

齐全皆为字节

齐全文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那末传输时一样如此。所以,字节省可以传输尽情文件数据。在操纵流的时候,我们要时候明白,不管操纵什么样的流工具,底层传输的始终为二进制数据。
字节输出流【OutputStream】

java.io.OutputStream笼统类是表现字节输出流的全数类的超类,将指定的字节信息写出到方针地。它界说了字节输出流的底子共性功用方式。

  • public void close() :封闭此输出流并开释与此流相关联的任何系统资本。
  • public void flush() :革新此输出流并强逼任何缓冲的输出字节被写出。
  • public void write(byte[] b):将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) :从指定的字节数组写入 len字节,从偏移量 off起头输出到此输出流。
  • public abstract void write(int b) :将指定的字节输出流。
小贴士:
close方式,当完成流的操纵时,必须挪用此方式,开释系统资本。
FileOutputStream类

OutputStream有很多子类,我们从最简单的一个子类起头。
java.io.FileOutputStream类是文件输出流,用于将数据写出到文件。
机关方式


  • public FileOutputStream(File file):建立文件输出流以写入由指定的 File工具表现的文件。
  • public FileOutputStream(String name): 建立文件输出流以指定的称号写入文件。
当你建立一个流工具时,必须传入一个文件途径。该途径下,假如没有这个文件,会建立该文件。倘使有这个文件,会清空这个文件的数据。

  • 机关举例,代码以下:
  1. public class FileOutputStreamConstructor throws IOException {    public static void main(String[] args) {        // 操纵File工具建立流工具        File file = new File("a.txt");        FileOutputStream fos = new FileOutputStream(file);              // 操纵文件称号建立流工具        FileOutputStream fos = new FileOutputStream("b.txt");    }}
复制代码
写出字节数据


  • 写出字节:write(int b) 方式,每次可以写出一个字节数据,代码操纵演示:
  1. public class FOSWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileOutputStream fos = new FileOutputStream("fos.txt");             // 写出数据        fos.write(97); // 写出第1个字节        fos.write(98); // 写出第2个字节        fos.write(99); // 写出第3个字节        // 封闭资本        fos.close();    }}输出成果:abc
复制代码
小贴士:

  • 固然参数为int典范四个字节,可是只会保存一个字节的信息写出。
  • 流操纵终了后,必须开释系统资本,挪用close方式,万万记得。

  • 写出字节数组:write(byte[] b),每次可以写出数组中的数据,代码操纵演示:
  1. public class FOSWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileOutputStream fos = new FileOutputStream("fos.txt");             // 字符串转换为字节数组        byte[] b = "一二三四五六".getBytes();        // 写出字节数组数据        fos.write(b);        // 封闭资本        fos.close();    }}输出成果:一二三四五六
复制代码

  • 写出指定长度字节数组:write(byte[] b, int off, int len) ,每次写出从off索引发头,len个字节,代码操纵演示:
  1. public class FOSWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileOutputStream fos = new FileOutputStream("fos.txt");             // 字符串转换为字节数组        byte[] b = "abcde".getBytes();        // 写出从索引2起头,2个字节。索引2是c,两个字节,也就是cd。        fos.write(b,2,2);        // 封闭资本        fos.close();    }}输出成果:cd
复制代码
数据追加续写

经过以上的演示,每次步伐运转,建立输出流工具,城市清空方针文件中的数据。怎样保存方针文件中数据,还能继续增加新数据呢?

  • public FileOutputStream(File file, boolean append): 建立文件输出流以写入由指定的 File工具表现的文件。
  • public FileOutputStream(String name, boolean append): 建立文件输出流以指定的称号写入文件。
这两个机关方式,参数中都必要传入一个boolean典范的值,true 表现追加数据,false 表现清空原稀有据。这样建立的输出流工具,便可以指定能否追加续写了,代码操纵演示:
  1. public class FOSWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileOutputStream fos = new FileOutputStream("fos.txt",true);             // 字符串转换为字节数组        byte[] b = "abcde".getBytes();        // 写出从索引2起头,2个字节。索引2是c,两个字节,也就是cd。        fos.write(b);        // 封闭资本        fos.close();    }}文件操纵前:cd文件操纵后:cdabcde
复制代码
写出换行

Windows系统里,换行标记是\r\n 。
以指定能否追加续写了,代码操纵演示:
  1. public class FOSWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileOutputStream fos = new FileOutputStream("fos.txt");          // 界说字节数组        byte[] words = {97,98,99,100,101};        // 遍历数组        for (int i = 0; i < words.length; i++) {            // 写出一个字节            fos.write(words[i]);            // 写出一个换行, 换行标记转成数组写出            fos.write("\r\n".getBytes());        }        // 封闭资本        fos.close();    }}输出成果:abcde
复制代码


  • 回车符\r和换行符\n :

    • 回车符:回到一行的开首(return)。
    • 换行符:下一行(newline)。

  • 系统中的换行:

    • Windows系统里,每行结尾是 回车+换行 ,即\r\n;
    • Unix系统里,每行结尾只要 换行 ,即\n;
    • Mac系统里,每行结尾是 回车 ,即\r。从 Mac OS X起头与Linux同一。

字节输入流【InputStream】

java.io.InputStream笼统类是表现字节输入流的全数类的超类,可以读取字节信息到内存中。它界说了字节输入流的底子共性功用方式。

  • public void close() :封闭此输入流并开释与此流相关联的任何系统资本。
  • public abstract int read(): 从输入流读取数据的下一个字节。
  • public int read(byte[] b): 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
小贴士:
close方式,当完成流的操纵时,必须挪用此方式,开释系统资本。
FileInputStream类

java.io.FileInputStream类是文件输入流,从文件中读取字节。
机关方式


  • FileInputStream(File file): 经过翻开与现实文件的毗连来建立一个 FileInputStream ,该文件由文件系统中的 File工具 file命名。
  • FileInputStream(String name): 经过翻开与现实文件的毗连来建立一个 FileInputStream ,该文件由文件系统中的途径名 name命名。
当你建立一个流工具时,必须传入一个文件途径。该途径下,假如没有该文件,会抛出FileNotFoundException 。

  • 机关举例,代码以下:
  1. public class FileInputStreamConstructor throws IOException{    public static void main(String[] args) {        // 操纵File工具建立流工具        File file = new File("a.txt");        FileInputStream fos = new FileInputStream(file);              // 操纵文件称号建立流工具        FileInputStream fos = new FileInputStream("b.txt");    }}
复制代码
读取字节数据


  • 读取字节:read方式,每次可以读取一个字节的数据,提拔为int典范,读取到文件结尾,返回-1,代码操纵演示:
  1. public class FISRead {    public static void main(String[] args) throws IOException{        // 操纵文件称号建立流工具        FileInputStream fis = new FileInputStream("read.txt");        // 读取数据,返回一个字节        int read = fis.read();        System.out.println((char) read);        read = fis.read();        System.out.println((char) read);        read = fis.read();        System.out.println((char) read);        read = fis.read();        System.out.println((char) read);        read = fis.read();        System.out.println((char) read);        // 读取到结尾,返回-1        read = fis.read();        System.out.println( read);        // 封闭资本        fis.close();    }}输出成果:abcde-1
复制代码
循环改良读取方式,代码操纵演示:
  1. public class FISRead {    public static void main(String[] args) throws IOException{        // 操纵文件称号建立流工具        FileInputStream fis = new FileInputStream("read.txt");        // 界说变量,保存数据        int b ;        // 循环读取        while ((b = fis.read())!=-1) {            System.out.println((char)b);        }        // 封闭资本        fis.close();    }}输出成果:abcde
复制代码
小贴士:

  • 固然读取了一个字节,可是会自动提拔为int典范。
  • 流操纵终了后,必须开释系统资本,挪用close方式,万万记得。

  • 操纵字节数组读取:read(byte[] b),每次读取b的长度个字节到数组中,返回读取到的有用字节个数,读取到结尾时,返回-1 ,代码操纵演示:
  1. public class FISRead {    public static void main(String[] args) throws IOException{        // 操纵文件称号建立流工具.        FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde        // 界说变量,作为有用个数        int len ;        // 界说字节数组,作为装字节数据的容器           byte[] b = new byte[2];        // 循环读取        while (( len= fis.read(b))!=-1) {            // 每次读取后,把数组酿成字符串打印            System.out.println(new String(b));        }        // 封闭资本        fis.close();    }}输出成果:abcded
复制代码
毛病数据d,是由于末端一次读取时,只读取一个字节e,数组中,上次读取的数据没有被完全更换,所以要经过len ,获得有用的字节,代码操纵演示:
  1. public class FISRead {    public static void main(String[] args) throws IOException{        // 操纵文件称号建立流工具.        FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde        // 界说变量,作为有用个数        int len ;        // 界说字节数组,作为装字节数据的容器           byte[] b = new byte[2];        // 循环读取        while (( len= fis.read(b))!=-1) {            // 每次读取后,把数组的有用字节部分,酿成字符串打印            System.out.println(new String(b,0,len));//  len 每次读取的有用字节个数        }        // 封闭资本        fis.close();    }}输出成果:abcde
复制代码
小贴士:
操纵数组读取,每次读取多个字节,淘汰了系统间的IO操纵次数,从而进步了读写的服从,倡议斥地中操纵。
字节省练习:图片复制

复制道理图解
我的关键词 JavaSE进修笔记(14)---File类和IO流(字节省和字符流)  热门消息 1933084-20200214230210620-515557536

案例实现

复制图片文件,代码操纵演示:
  1. public class Copy {    public static void main(String[] args) throws IOException {        // 1.建立流工具        // 1.1 指定数据源        FileInputStream fis = new FileInputStream("D:\\test.jpg");        // 1.2 指定方针地        FileOutputStream fos = new FileOutputStream("test_copy.jpg");        // 2.读写数据        // 2.1 界说数组        byte[] b = new byte[1024];        // 2.2 界说长度        int len;        // 2.3 循环读取        while ((len = fis.read(b))!=-1) {            // 2.4 写出数据            fos.write(b, 0 , len);        }        // 3.封闭资本        fos.close();        fis.close();    }}
复制代码
小贴士:
流的封闭原则:先开后关,后开先关。
字符流

当操纵字节省读取文本文件时,大要会有一个小题目。就是碰到中翰墨符时,大要不会表示完整的字符,那是由于一其中翰墨符大要占用多个字节存储。所以Java供给一些字符流类,以字符为单元读写数据,专门用于处置文本文件。
字符输入流【Reader】

java.io.Reader笼统类是表现用于读取字符流的全数类的超类,可以读取字符信息到内存中。它界说了字符输入流的底子共性功用方式。

  • public void close() :封闭此流并开释与此流相关联的任何系统资本。
  • public int read(): 从输入流读取一个字符。
  • public int read(char[] cbuf): 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。
FileReader类

java.io.FileReader类是读取字符文件的便当类。机关时操纵系统默许的字符编码和默许字节缓冲区。
小贴士:

  • 字符编码:字节与字符的对应法则。Windows系统的中文编码默许是GBK编码表。
    idea中UTF-8
  • 字节缓冲区:一个字节数组,用光姑且存储字节数据。
机关方式


  • FileReader(File file): 建立一个新的 FileReader ,给定要读取的File工具。
  • FileReader(String fileName): 建立一个新的 FileReader ,给定要读取的文件的称号。
当你建立一个流工具时,必须传入一个文件途径。类似于FileInputStream 。

  • 机关举例,代码以下:
  1. public class FileReaderConstructor throws IOException{    public static void main(String[] args) {        // 操纵File工具建立流工具        File file = new File("a.txt");        FileReader fr = new FileReader(file);              // 操纵文件称号建立流工具        FileReader fr = new FileReader("b.txt");    }}
复制代码
读取字符数据

read.txt里是“一二三四五”

  • 读取字符:read方式,每次可以读取一个字符的数据,提拔为int典范,读取到文件结尾,返回-1,循环读取,代码操纵演示:
  1. public class FRRead {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileReader fr = new FileReader("read.txt");        // 界说变量,保存数据        int b ;        // 循环读取        while ((b = fr.read())!=-1) {            System.out.println((char)b);        }        // 封闭资本        fr.close();    }}输出成果:一二三四五
复制代码
小贴士:固然读取了一个字符,可是会自动提拔为int典范。

  • 操纵字符数组读取:read(char[] cbuf),每次读取b的长度个字符到数组中,返回读取到的有用字符个数,读取到结尾时,返回-1 ,代码操纵演示:
  1. public class FRRead {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileReader fr = new FileReader("read.txt");        // 界说变量,保存有用字符个数        int len ;        // 界说字符数组,作为装字符数据的容器         char[] cbuf = new char[2];        // 循环读取        while ((len = fr.read(cbuf))!=-1) {            System.out.println(new String(cbuf));        }        // 封闭资本        fr.close();    }}输出成果:一二三四五四
复制代码
获得有用的字符改良,代码操纵演示:
  1. public class FISRead {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileReader fr = new FileReader("read.txt");        // 界说变量,保存有用字符个数        int len ;        // 界说字符数组,作为装字符数据的容器        char[] cbuf = new char[2];        // 循环读取        while ((len = fr.read(cbuf))!=-1) {            System.out.println(new String(cbuf,0,len));        }        // 封闭资本        fr.close();    }}输出成果:一二三四五
复制代码
字符输出流【Writer】

java.io.Writer笼统类是表现用于写出字符流的全数类的超类,将指定的字符信息写出到方针地。它界说了字节输出流的底子共性功用方式。

  • void write(int c) 写入单个字符。
  • void write(char[] cbuf)写入字符数组。
  • abstract  void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的起头索引,len写的字符个数。
  • void write(String str)写入字符串。
  • void write(String str, int off, int len) 写入字符串的某一部分,off字符串的起头索引,len写的字符个数。
  • void flush()革新该流的缓冲。
  • void close() 封闭此流,但要先革新它。
FileWriter类

java.io.FileWriter类是写出字符到文件的便当类。机关时操纵系统默许的字符编码和默许字节缓冲区。
机关方式


  • FileWriter(File file): 建立一个新的 FileWriter,给定要读取的File工具。
  • FileWriter(String fileName): 建立一个新的 FileWriter,给定要读取的文件的称号。
当你建立一个流工具时,必须传入一个文件途径,类似于FileOutputStream。

  • 机关举例,代码以下:
  1. public class FileWriterConstructor {    public static void main(String[] args) throws IOException {        // 操纵File工具建立流工具        File file = new File("a.txt");        FileWriter fw = new FileWriter(file);              // 操纵文件称号建立流工具        FileWriter fw = new FileWriter("b.txt");    }}
复制代码
底子写出数据

写出字符:write(int b) 方式,每次可以写出一个字符数据,代码操纵演示:
  1. public class FWWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileWriter fw = new FileWriter("fw.txt");             // 写出数据        fw.write(97); // 写出第1个字符        fw.write(&#39;b&#39;); // 写出第2个字符        fw.write(&#39;C&#39;); // 写出第3个字符        fw.write(30000); // 写出第4个字符,中文编码表中30000对应一个汉字。              /*        【留意】封闭资本时,与FileOutputStream不同。         假如不封闭,数据只是保存到缓冲区,并未保存到文件。        */        // fw.close();    }}输出成果:abC田
复制代码
小贴士:

  • 固然参数为int典范四个字节,可是只会保存一个字符的信息写出。
  • 未挪用close方式,数据只是保存到了缓冲区,并未写出到文件中。
封闭和革新

由于内置缓冲区的原因原由,假如不封闭输出流,没法写出字符到文件中。可是封闭的流工具,是没法继续写出数据的。假如我们既想写出数据,又想继续操纵流,就必要flush 方式了。

  • flush :革新缓冲区,流工具可以继续操纵。
  • close:先革新缓冲区,然后看护系统开释资本。流工具不成以再被操纵了。
代码操纵演示:
  1. public class FWWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileWriter fw = new FileWriter("fw.txt");        // 写出数据,经过flush        fw.write(&#39;刷&#39;); // 写出第1个字符        fw.flush();        fw.write(&#39;新&#39;); // 继续写出第2个字符,写出乐成        fw.flush();              // 写出数据,经过close        fw.write(&#39;关&#39;); // 写出第1个字符        fw.close();        fw.write(&#39;闭&#39;); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed        fw.close();    }}
复制代码
小贴士:即即是flush方式写出了数据,操纵的末端照旧要挪用close方式,开释系统资本。
写出其他数据


  • 写出字符数组 :write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ,每次可以写出字符数组中的数据,用法类似FileOutputStream,代码操纵演示:
  1. public class FWWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileWriter fw = new FileWriter("fw.txt");             // 字符串转换为字节数组        char[] chars = "黑马步伐员".toCharArray();              // 写出字符数组        fw.write(chars); // 黑马步伐员                // 写出从索引2起头,2个字节。索引2是&#39;程&#39;,两个字节,也就是&#39;步伐&#39;。        fw.write(b,2,2); // 步伐              // 封闭资本        fos.close();    }}
复制代码

  • 写出字符串:write(String str) 和 write(String str, int off, int len) ,每次可以写出字符串中的数据,更加方便,代码操纵演示:
  1. public class FWWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具        FileWriter fw = new FileWriter("fw.txt");             // 字符串        String msg = "黑马步伐员";              // 写出字符数组        fw.write(msg); //黑马步伐员              // 写出从索引2起头,2个字节。索引2是&#39;程&#39;,两个字节,也就是&#39;步伐&#39;。        fw.write(msg,2,2);  // 步伐                // 封闭资本        fos.close();    }}
复制代码

  • 续写和换行:操纵类似于FileOutputStream。
  1. public class FWWrite {    public static void main(String[] args) throws IOException {        // 操纵文件称号建立流工具,可以续写数据        FileWriter fw = new FileWriter("fw.txt",true);             // 写出字符串        fw.write("黑马");        // 写出换行        fw.write("\r\n");        // 写出字符串        fw.write("步伐员");        // 封闭资本        fw.close();    }}输出成果:黑马步伐员
复制代码
小贴士:字符流,只能操纵文本文件,不能操纵图片,视频等非文本文件。
当我们纯真读大要写文本文件时 操纵字符流 其他情况操纵字节省
IO很是的处置

JDK7前处置

之前的入门练习,我们不停把很是抛出,而现实斥地中并不能这样处置,倡议操纵try...catch...finally 代码块,处置很是部分,代码操纵演示:
  1. public class HandleException1 {    public static void main(String[] args) {        // 声明变量        FileWriter fw = null;        try {            //建立流工具            fw = new FileWriter("fw.txt");            // 写出数据            fw.write("黑马步伐员"); //黑马步伐员        } catch (IOException e) {            e.printStackTrace();        } finally {            try {                if (fw != null) {                    fw.close();                }            } catch (IOException e) {                e.printStackTrace();            }        }    }}
复制代码
JDK7的处置

还可以操纵JDK7优化后的try-with-resource 语句,该语句确保了每个资本在语句竣事时封闭。所谓的资本(resource)是指在步伐完成后,必须封闭的工具。
格式:
  1. try (建立流工具语句,假如多个,操纵&#39;;&#39;离隔) {    // 读写数据} catch (IOException e) {    e.printStackTrace();}
复制代码
代码操纵演示:
  1. public class HandleException2 {    public static void main(String[] args) {        // 建立流工具        try ( FileWriter fw = new FileWriter("fw.txt"); ) {            // 写出数据            fw.write("黑马步伐员"); //黑马步伐员        } catch (IOException e) {            e.printStackTrace();        }    }}
复制代码
JDK9的改良

JDK9中try-with-resource 的改良,对于引入工具的方式,支持的加倍简便。被引入的工具,一样可以自动封闭,无需手动close,我们来了解一下格式。
改良前格式:
  1. // 被final修饰的工具final Resource resource1 = new Resource("resource1");// 普通工具Resource resource2 = new Resource("resource2");// 引入方式:建立新的变量保存try (Resource r1 = resource1;     Resource r2 = resource2) {     // 操纵工具}
复制代码
改良后格式:
  1. // 被final修饰的工具final Resource resource1 = new Resource("resource1");// 普通工具Resource resource2 = new Resource("resource2");// 引入方式:间接引入try (resource1; resource2) {     // 操纵工具}
复制代码
改良后,代码操纵演示:
  1. public class TryDemo {    public static void main(String[] args) throws IOException {        // 建立流工具        final  FileReader fr  = new FileReader("in.txt");        FileWriter fw = new FileWriter("out.txt");        // 引入到try中        try (fr; fw) {            // 界说变量            int b;            // 读取数据            while ((b = fr.read())!=-1) {                // 写出数据                fw.write(b);            }        } catch (IOException e) {            e.printStackTrace();        }    }}
复制代码
属性集

概述

java.util.Properties 继续于Hashtable ,来表现一个长久的属性集。它操纵键值结构存储数据,每个键及其对应值都是一个字符串。该类也被很多Java类操纵,比如获得系统属性时,System.getProperties 方式就是返回一个Properties工具。
Properties类

机关方式


  • public Properties() :建立一个空的属性列表。
底子的存储方式


  • public Object setProperty(String key, String value) : 保存一对属性。
  • public String getProperty(String key) :操纵此属性列表中指定的键搜索属性值。
  • public Set stringPropertyNames() :全数键的称号的聚集。
  1. public class ProDemo {    public static void main(String[] args) throws FileNotFoundException {        // 建立属性集工具        Properties properties = new Properties();        // 增加键值对元素        properties.setProperty("filename", "a.txt");        properties.setProperty("length", "209385038");        properties.setProperty("location", "D:\\a.txt");        // 打印属性集工具        System.out.println(properties);        // 经过键,获得属性值        System.out.println(properties.getProperty("filename"));        System.out.println(properties.getProperty("length"));        System.out.println(properties.getProperty("location"));        // 遍历属性集,获得全数键的聚集        Set strings = properties.stringPropertyNames();        // 打印键值对        for (String key : strings ) {            System.out.println(key+" -- "+properties.getProperty(key));        }    }}输出成果:{filename=a.txt, length=209385038, location=D:\a.txt}a.txt209385038D:\a.txtfilename -- a.txtlength -- 209385038location -- D:\a.txt
复制代码
与流相关的方式


  • public void load(InputStream inStream): 从字节输入流中读取键值对。
参数中操纵了字节输入流,经过流工具,可以关联到某文件上,这样便可以大要加载文本中的数据了。文本数据格式:
  1. filename=a.txtlength=209385038location=D:\a.txt
复制代码
加载代码演示:
  1. public class ProDemo2 {    public static void main(String[] args) throws FileNotFoundException {        // 建立属性集工具        Properties pro = new Properties();        // 加载文本中信息到属性集        pro.load(new FileInputStream("read.txt"));        // 遍历聚集并打印        Set strings = pro.stringPropertyNames();        for (String key : strings ) {            System.out.println(key+" -- "+pro.getProperty(key));        }     }}输出成果:filename -- a.txtlength -- 209385038location -- D:\a.txt
复制代码
小贴士:文本中的数据,必须是键值对形式,可以操纵空格、等号、冒号等标记分隔。

免责声明:假如加害了您的权益,请联系站长,我们会实时删除侵权内容,感谢合作!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Copyright © 2006-2014 WAYSFOCUS 影像 你 我 他,中国商业影视一站式解决平台 版权所有 法律顾问:高律师 客服电话:0791-88289918
技术支持:迪恩网络科技公司  Powered by Discuz! X3.2
快速回复 返回顶部 返回列表