IO （四）

2022-12-31 12:58:00

1 深度遍历文件夹

示例：

package java20;

import java.io.File;
import java.io.FilenameFilter;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 2017/10/14
 * 说明：
 */
public class FileDemo {
    public static void main(String[] args) {
       File dir = new File("D:\\code");
       listAll(dir);

    }

    /**
     * 深度遍历文件夹
     * @param dir
     */
    private static void listAll(File dir) {
        System.out.println("文件夹:"+dir.getAbsolutePath());
        File[] files = dir.listFiles();
        for(File file : files){
            if(file.isDirectory()){
                listAll(file);
            }else{
                System.out.println("文件:"+file.getAbsolutePath());
            }

        }
    }

}

2 Properties

2.1 Properties的特点

该集合中的键和值都是字符串类型的。
集合中的数据可以保存在流中，或者从流中获取。

2.2 构造方法

创建一个没有默认值的空属性列表

public Properties()

2.3 常用方法

设置属性值

public Object setProperty(String key,String value)

根据指定的键获取值

public String getProperty(String key)

返回属性列表的所有键的枚举

public Enumeration<?> propertyNames()

返回此属性列表中的键的set集合

public Set<String> stringPropertyNames()

示例：

package java20;

import java.util.Enumeration;
import java.util.Properties;
import java.util.Set;

/**
 * 2017/10/15
 * 说明：
 */
public class PropertiesDemo {
    public static void main(String[] args) {
        Properties pros = new Properties();

        pros.setProperty("zhangsan","20");
        pros.setProperty("lisi","26");
        pros.setProperty("wangwu","27");

        //第一种方式获取所有的键值
        Enumeration<?> enumeration = pros.propertyNames();
        while(enumeration.hasMoreElements()){
            String name = (String) enumeration.nextElement();
            String value = pros.getProperty(name);
            System.out.println(name+":"+value);

        }

        System.out.println("------------------------------");

        //第二种方式获取所有的键值
        Set<String> names = pros.stringPropertyNames();
        for(String name:names){
            String value = pros.getProperty(name);
            System.out.println(name+":"+value);
        }

    }
}

将属性列表写入输出流

public void store(OutputStream out,String comments) throws IOException

将属性列表写入输出流

public void store(Writer writer,String comments) throws IOException

示例：

package java20;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Set;

/**
 * 2017/10/15
 * 说明：
 */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        Properties pros = new Properties();

        pros.setProperty("zhangsan","20");
        pros.setProperty("lisi","26");
        pros.setProperty("wangwu","27");

        FileWriter fs = new FileWriter("pros.properties");

        pros.store(fs,"properties文件");

        fs.close();

    }
}

从输入流中读取属性列表

public void load(InputStream inStream) throws IOException

从输入流中读取属性列表

public void load(Reader reader)  throws IOException

示例：

package java20;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Set;

/**
 * 2017/10/15
 * 说明：
 */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        Properties pros = new Properties();

        FileReader fr = new FileReader("pros.properties");

        pros.load(fr);

        Set<String> names = pros.stringPropertyNames();
        for(String name:names){
            String value = pros.getProperty(name);
            System.out.println(name+":"+value);
        }

    }
}

修改属性文件中的值

package java20;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Set;

/**
 * 2017/10/15
 * 说明：
 */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        Properties pros = new Properties();

        FileReader fr = new FileReader("pros.properties");

        pros.load(fr);

        pros.setProperty("zhangsan","60");

        FileWriter fw = new FileWriter("pros.properties");

        pros.store(fw,"修改属性文件");

        fw.close();
        fr.close();

    }
}

示例：获取一个应用程序运行的次数，如果超过5次，给出使用次数并体术请注册的信息，并不要运行程序。

package java20;

import java.io.*;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Set;

/**
 * 2017/10/15
 * 说明：
 */
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        //将所需要的配置文件封装成File对象
        File config = new File("count.properties");
        if(!config.exists()){
            config.createNewFile();
        }
        FileInputStream fis = new FileInputStream(config);
        Properties pros = new Properties();
        pros.load(fis);

        //从集合中通过键获取次数
        String times = pros.getProperty("times");
        int count = 0;
        if(times != null){
            count = Integer.parseInt(times);
            if(count >= 5){
                System.out.println("使用次数已到，请注册");
                return;
            }
        }

        count ++;

        //将改变的后的次数重新存储到集合中
        pros.setProperty("times",String.valueOf(count));

        FileOutputStream fos = new FileOutputStream(config);

        pros.store(fos,"");

        fos.close();
        fis.close();

    }
}

3 打印流

3.1 PrintStream

3.1.1 PrintStream简介

PrintStream为其它输出流添加了功能，使得它们能够方便的打印各种数据值的表现形式。它还提供了其它两项功能。与其它输出流不同，PrintStream永远不会抛出IOException。
异常情况仅设置可通过checkError方法测试的内部标志。
为了自动刷新，可以创建一个PrintStream，这意味着可在写入byte数组之后调用flush方法，可调用其中一个println方法，或写入一个换行符或字节('\n')。

3.1.2 构造方法

创建一个具有指定文件且不带自动刷新的打印流

public PrintStream(File file) throws FileNotFoundException

创建具有指定文件名称和字符集且不带自动刷新的打印流

public PrintStream(File file,String csn) throws FileNotFoundException UnsupportedEncodingException

创建打印流

public PrintStream(OutputStream out)

创建打印流

public PrintStream(OutputStream out, boolean autoFlush)

创建打印流

public PrintStream(OutputStream out,boolean autoFlush,String encoding) throws UnsupportedEncodingException

创建具有指定文件名且不带自定刷新的打印流

public PrintStream(String fileName) throws FileNotFoundException

创建指定文件名称和字符集且不带自动刷新的打印流

public PrintStream(String fileName,String csn) throws FileNotFoundException, UnsupportedEncodingException

3.1.3 方法

将指定字符添加到此输出流

public PrintStream append(char c)

将指定字符序列添加到此输出流

public PrintStream append(CharSequence csq)

将指定字符序列的子序列添加到此输出流

public PrintStream append(CharSequence csq, int start, int end)

刷新流并检查其错误状态

public boolean checkError()

清除此流的内部标志

protected void clearError()

关闭流

public void close()

刷新该流的缓冲

public void flush()

使用指定格式字符串和参数将格式化字符串写入到此输出流中

public PrintStream format(Locale l,String format, Object... args)

使用指定格式字符串和参数将格式化字符串写入到此输出流中

public PrintStream format(String format, Object... args)

打印boolean值

public void print(boolean b)

打印字符

public void print(char c)

打印字符数组

public void print(char[] s)

打印double精度浮点数

public void print(double d)

打印float精度浮点数

public void print(double d)

打印整数

public void print(int i)

打印long整数

public void print(long l)

打印对象

public void print(Object obj)

打印字符串

public void print(String s)

使用指定格式字符串和参数将格式化的字符串写入此wirter的便捷方法

public PrintWriter printf(Locale l,String format,Object... args)

使用指定格式字符串和参数将格式的字符串写入此writer的便捷方法

public PrintWriter printf(String format,Object... args)

通过写入分隔符字符串终止当前行

public void println()

打印boolean值，然后终止该行

public void println(boolean x)

打印字符，然后终止该行

public void println(char x)

打印字符数组，然后终止该行

public void println(char[] x)

打印double精度浮点数，然后终止该行

public void println(double x)

打印float精度浮点数，然后终止该行

public void println(float x)

打印int整数，然后终止该行

public void println(int x)

打印long类型整数，然后终止该行

public void println(long x)

打印Object，然后终止该行

public void println(Object x)

打印String，然后终止该行

public void println(String x)

指示已发生错误

protected void setError()

写入字符数组

public void write(char[] buf)

写入字符数组的某一部分

public void write(char[] buf, int off,int len)

写入单个字符

public void write(int c)

写入字符串

public void write(String s)

写入字符串的某一部分

public void write(String s,int off,int len)

3.1.4 示例：

示例：

package java20;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

/**
 * 2017/10/15
 * 说明：
 */
public class PrintStreamDemo {
    public static void main(String[] args) throws FileNotFoundException {
        PrintStream ps = new PrintStream(new FileOutputStream("aaa.txt"),true);

        ps.print(1);
        ps.print('a');
        ps.println("你好啊");
        ps.println("你好啊");

        ps.flush();
        ps.close();

    }
}

3.2 PrintWriter

3.2.1 PrintWriter简介

向文本输出流打印对象的格式化表示形式，此类实现了在PrintStream的所有print方法，它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。
如果启用了自动刷新，则只有调用println、printf或format的其中一个方法时才可能完成此操作，而不是每当正好输出换行符的时候才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。
此类中的方法不会抛出IO异常，尽管其某些构造方法可能会抛出异常。

3.2.2 构造方法

使用指定文件创建不具有自动刷新的PrintWriter

public PrintWriter(File file) throws FileNotFoundException

创建具有指定文件和字符集且不带有自动刷新的PrintWriter

public PrintWriter(File file,String csn) throws FileNotFoundException, UnsupportedEncodingException

根据现有的OutputStream创建不带有自动刷新的PrintWriter

public PrintWriter(OutputStream out)

根据现有的OutputStream创建PrintWriter

public PrintWriter(OutputStream out,boolean autoFlush)

创建具有指定文件名且不带有自动刷新的PrintWriter

public PrintWriter(String fileName) throws FileNotFoundException

创建具有制定文件名称和字符集且不带有自动刷新的PrintWriter

public PrintWriter(String fileName,String csn) throws FileNotFoundException, UnsupportedEncodingException

创建不带有自动刷新的PrintWriter

public PrintWriter(Writer out)

创建带自动刷新的PrintWriter

public PrintWriter(Writer out, boolean autoFlush)

3.2.3 方法

将指定字符添加到此writer

public PrintWriter append(char c)

将指定的字符序列添加到此writer

public PrintWriter append(CharSequence csq)

将指定字符序列的子序列添加到此writer

public PrintWriter append(CharSequence csq, int start, int end)

如果流没有关闭，则刷新流且检查其错误状态

public boolean checkError()

清除此流的错误状态

protected void clearError()

关闭该流并释放与之关联的所有系统资源

public void close()

刷新该流的缓冲

public void flush()

使用指定格式的字符串和参数将一个格式化字符串写入此writer中

public PrintWriter format(Locale l,String format,Object... args)

使用指定格式的字符串和参数将一个格式化字符串写入此writer中

public PrintWriter format(String format,Object... args)

打印boolean值

public void print(boolean b)

打印字符

public void print(char c)

打印字符数组

public void print(char[] s)

打印double类型的值

public void print(double d)

打印float类型的值

public void print(float f)

打印int类型的值

public void print(int i)

打印long类型的值

public void print(long l)

打印对象

public void print(Object obj)

打印字符串

public void print(String s)

使用指定格式字符串和参数将格式化的字符串写入此writer的便捷方法

public PrintWriter printf(Locale l,String format, Object... args)

使用指定格式字符串和参数将格式化的字符串写入此writer的便捷方法

public PrintWriter printf(String format,Object... args)

通过写入行分隔符字符串终止当前行

public void println()

打印boolean类型的值，然后终止该行

public void println(boolean x)

打印字符，然后终止该行

public void println(char x)

打印字符数组，然后终止该行

public void println(char[] x)

打印double类型的值，然后终止改行

public void println(double x)

打印浮点数，然后终止该行

public void println(float x)

打印整数，然后终止该行

public void println(int x)

打印long类型整数，然后终止该行

public void println(long x)

打印Object类型的值，然后终止该行

public void println(Object x)

打印String类型的值，然后终止该行

public void println(String x)

指示已发生错误

protected void setError()

写入字符数组

public void write(char[] buf)

写入字符数组的一部分

public void write(char[] buf,int off, int len)

写入单个字符

public void write(int c)

写入字符串

public void write(String s)

写入字符串的某一部分

public void write(String s, int off,  int len)

4 SequenceInputStream 序列流

4.1 SequenceInputStream简介

SequenceInputStream表示其他输入流的逻辑串联，它从输入流的有序集合开始，并从第一个输入流开始读取，直到达文件末尾，接着从第二个输入流读取，依次类推，直到达到包含的最后一个输入流的文件末尾处为止。

4.2 构造方法

通过参数来初始化新建SequenceInputStream，该参数必须是生成运行时类型为InputStream对象的Enumeration类型参数

public SequenceInputStream(Enumeration<? extends InputStream> e)

通过参数来初始化新建SequenceInputStream（将按顺序读取这两个参数，先读取s1，然后读取s2），以提供此SequenceInputStream读取的字节

public SequenceInputStream(InputStream s1, InputStream s2)

4.3 方法

关闭此输入流病释放与此流相关联的所有系统资源

public void close() throws IOException

从此输入流中读取下一个数据字节

public int read() throws IOException

将最多len个数据字节从此输入流读入byte数组

public int read(byte[] b, int off, int len) throws IOException

4.4 示例

示例：

package java20;

import java.io.*;
import java.util.Vector;

/**
 * 2017/10/15
 * 说明：
 */
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        Vector<InputStream> vector = new Vector<>();
        vector.add(new FileInputStream("test1.txt"));
        vector.add(new FileInputStream("test2.txt"));
        vector.add(new FileInputStream("test3.txt"));

        SequenceInputStream si = new SequenceInputStream(vector.elements());

        byte[] buffer = new byte[1024];

        int len = 0;

        while((len = si.read(buffer)) != -1){
            System.out.println(new String(buffer,0,len));
        }

    }
}

示例：

package java20;

import java.io.*;
import java.util.*;

/**
 * 2017/10/15
 * 说明：
 */
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        List<InputStream> list = new ArrayList<>();
        list.add(new FileInputStream("test1.txt"));
        list.add(new FileInputStream("test2.txt"));
        list.add(new FileInputStream("test3.txt"));

        Iterator<InputStream> iterator = list.iterator();

        Enumeration<InputStream> enumerations = new Enumeration<InputStream>() {
            @Override
            public boolean hasMoreElements() {
                return iterator.hasNext();
            }

            @Override
            public InputStream nextElement() {
                return iterator.next();
            }
        };

        SequenceInputStream si = new SequenceInputStream(enumerations);

        byte[] buffer = new byte[1024];

        int len = 0;

        while((len = si.read(buffer)) != -1){
            System.out.println(new String(buffer,0,len));
        }

    }
}

示例：

package java20;

import java.io.*;
import java.util.*;

/**
 * 2017/10/15
 * 说明：
 */
public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        List<InputStream> list = new ArrayList<>();
        list.add(new FileInputStream("test1.txt"));
        list.add(new FileInputStream("test2.txt"));
        list.add(new FileInputStream("test3.txt"));

        Enumeration<InputStream> enumerations = Collections.enumeration(list);

        SequenceInputStream si = new SequenceInputStream(enumerations);

        byte[] buffer = new byte[1024];

        int len = 0;

        while((len = si.read(buffer)) != -1){
            System.out.println(new String(buffer,0,len));
        }

    }
}

码农公寓

1 深度遍历文件夹

2 Properties

2.1 Properties的特点

2.2 构造方法

2.3 常用方法

3 打印流

3.1 PrintStream

3.1.1 PrintStream简介

3.1.2 构造方法

3.1.3 方法

3.1.4 示例：

3.2 PrintWriter

3.2.1 PrintWriter简介

3.2.2 构造方法

3.2.3 方法

4 SequenceInputStream 序列流

4.1 SequenceInputStream简介

4.2 构造方法

4.3 方法

4.4 示例

相关文章