欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Java-字节流、字符流-第20节

程序员文章站 2022-06-16 20:27:50
...

学习目标：

  • 深刻理解流的概念，明确流的使用方法；
  • 熟练的使用流对文件进行操作；
  • 能够使用Propreties集合进行相关键值对的存取操作。

学习内容：

一、IO流

Java-字节流、字符流-第20节

输入输出流，以字节或字符的形式进行硬盘与缓存之间的传输

  • 1、字节输入流
    java.io.InputStream 抽象类表示字节输入流的所有类的超类

    a、成员方法
	-	public int read();		从输入流中读取下一个字节
	-	public int read(byte[] b);	从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
	-	public void close();		关闭此输入流并释放与该流关联的所有系统资源
b、子类java.io.FileInputStream extends InputStream;
	字节文件输入流
	-	作用：把硬盘中的数据读取到内存中使用
	-	构造方法
		FileInputStream(String name);	创建一个向具有指定名称的文件中写入数据的输出文件名
		FileInputStream(File file);	创建一个向指定File对象表示的文件中写入数据的文件输出流
		参数：读取文件的数据源
			String name:文件的路径
			File file:文件	
	-	构造方法的作用
		1、创建一个FileInputStream对象
		2、把FileInputStream对象指向要读取的文件
	-	读取数据的原理（硬盘->内存）
		java程序->JVM（java虚拟机）->OS（操作系统）->os调用读取数据的方法->读取文件
	-	字节输入流的使用步骤
		1、创建一个FileInputStream对象，构造方法中绑定要读取的文件
		2、使用FileInputStream对象调用read函数读取文件
		3、释放资源（使用流会占用一定的资源，清空提高程序的效率）
	-	一次读取多个字节
		public int read(byte[] b);	从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
		PS：
			String(byte[] b);		将字节数组转换成字符串
			String(byte[] b, int offset, int length);	将指定位置与长度的字节数组转换成字符串
	PS：明确两件事
		1、方法的参数byte[]的作用？
			a、起到缓冲作用，存储每次读取到的多少个字节
			b、数组的长度一般定义为1024（1kb）或者1024的整数倍
		2、方法的返回值int是什么？
			a、每次读取到的有效字节个数

  • 2、字节输出流
    java.io.OutputStream 抽象类表示字节输出流类的超类

    a、成员方法
	-	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);	将指定的字节输出流
b、子类java.io.FileOutputStream extends OutputStream;
	字节文件输出流
	-	作用：把内存中的字节数据写入到硬盘的文件中
	-	构造方法
		FileOutputStream(String name);	创建一个向具有指定名称的文件中写入数据的输出文件名
		FileOutputStream(File file);	创建一个向指定File对象表示的文件中写入数据的文件输出流
		参数：写入数据的目的地
			String name:目的地是一个文件的路径
			File file:目的地是一个文件
	-	构造方法的作用
		1、创建一个FileOutputStream对象
		2、根据构造方法中传递的文件名/文件创建一个空文件
		3、把FileOutputStream对象指向创建好的文件
	-	写入数据的原理（内存-》硬盘）
		java程序->JVM（java虚拟机）->OS（操作系统）->os调用写数据的方法->把数据写入到文件中
	-	字节输出流的使用步骤
		1、创建一个FileOutputStream对象
		2、调用对象的write方法，将数据写入到文件中
		3、释放资源（使用流会占用一定的资源，清空提高程序的效率）
	-	追加写/续写：使用两个参数的构造方法
		FileOutputStream(String name, boolean append);	创建一个向具有指定名称的文件中写入数据的输出文件名
		FileOutputStream(File file, boolean append);	创建一个向指定File对象表示的文件中写入数据的文件输出流
		参数：写入数据的目的地
			String name:目的地是一个文件的路径
			File file:目的地是一个文件
			boolean append:追加写开关
				true:创建对象不会覆盖源文件，继续在文件的末尾追加数据
				false：创建一个新文件，覆盖源文件
	-	写换行、换行符号
		Windows：\r\n
		Linux:/n
		Mac:/r

  • 3、字符输入流
    java.io.Reader; 表示字符输入流的所有类的超类

    a、成员方法
	-	public int read();	一次读取一个字符并返回
	-	public int read(char[] cbuf);	一次读取多个字符，将字符存入字符数组缓冲区
	-	public void close();	释放资源（使用流会占用一定的资源，清空提高程序的效率）
b、java.io.FileReader extends InputStreamReader extends Reader;
	文件字符输入流
	-	作用：把硬盘的文件以字符的方式写入到内存中
	-	构造方法
		FileReader(String filename);
		FileReader(File file);
		参数：读取文件的数据源
		File file:文件	
	-	构造方法的作用
		1、创建一个FileReader对象
		2、把FileReader对象指向要读取的文件
	-	字符输人流的使用步骤
		1、创建一个FileReader对象，构造方法中绑定要读取的文件
		2、使用FileReader对象调用read函数读取文件
		3、释放资源（使用流会占用一定的资源，清空提高程序的效率）

  • 4、字符输出流
    java.io.Writer 写入字符流的抽象类

    a、成员方法
	-	abstract  void close() 
		关闭此流，但要先刷新它。 
	-	abstract  void flush() 
		刷新该流的缓冲。 
	-	void write(char[] cbuf) 
		写入字符数组。 
	-	abstract  void write(char[] cbuf, int off, int len) 
		写入字符数组的某一部分。 
	-	void write(int c) 
		写入单个字符。 
	-	void write(String str) 
		写入字符串。 
	-	void write(String str, int off, int len) 
		写入字符串的某一部分。 
b、子类public class FileWriter extends OutputStreamWriter  extends Writer
	文件字符输出流
	-	作用：把内存中的字符数据写入到硬盘的文件中
	-	构造方法：
		FileWriter(File file) 
			根据给定的 File 对象构造一个 FileWriter 对象。
		FileWriter(String fileName) 
			根据给定的文件名构造一个 FileWriter 对象。
		参数：
			fileName - 一个字符串，表示与系统有关的文件名。 
			file - 要写入数据的 File 对象。
	-	构造方法的作用
		1、创建一个FileWriter对象
		2、根据构造方法中传递的文件名/文件创建一个空文件
		3、把FileWriter对象指向创建好的文件		
	-	字符输出流的使用步骤
		1、创建一个FileWriter对象，构造方法中传入要写入的目的地
		2、调用对象的write方法，将数据写入到内存缓冲区（字符转换为字节的过程）
		2、调用对象的flush方法，将内存缓冲区中的数据刷新到文件中
		3、释放资源（使用流会占用一定的资源，清空提高程序的效率）

  • PS:

    -	1个中文字符		GBK：2个字节		UTF-8：3个字节
-	flush与close的区别
		flush 将内存缓冲区中的数据刷新到文件中，流可以被继续使用
		close 将内存缓冲区中的数据刷新到文件中，并关闭流服务，不能够在被使用

二、Properties集合

  • 1、简介

    a、public class Properties extends Hashtable<Object,Object>
b、Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。
	属性列表中每个键及其对应值都是一个字符串。

  • 2、成员方法

    a、 String getProperty(String key) 用指定的键在此属性列表中搜索属性。 
b、	Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串，
	如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。 
c、 void load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。 
d、 Object setProperty(String key, String value) 调用 Hashtable 的方法 put。 
e、 void store(OutputStream out, String comments) 以适合使用 load(InputStream) 方法加载
	到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。

  • 3、注意

    a、将Propreties集合存储在文件中时，可以用#将键值对进行注释
b、Properties集合的键与值默认都是字符串形式
c、当键值对中含有中文时，要用字符流进行文件的保存与读取

学习产出：

1、 字节输出流

package mypackage.day16.demo01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("a.txt");
        fos.write('b');
        fos.write(new byte[] {95,96,97,98});
        fos.write(new byte[] {95,96,97,98},1,3);
        byte[] bytes = "你好".getBytes();
        System.out.println(bytes);
        fos.write(bytes);
        fos.close();
    }
}


package mypackage.day16.demo01;

import java.io.FileOutputStream;
import java.io.IOException;

public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("a.txt", true);
        byte[] bytes = "你好".getBytes();
        fos.write(bytes);
        fos.write("\r\n".getBytes());
        fos.write(bytes);
        fos.close();
    }
}

2、字节输入流

package mypackage.day16.demo02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        // 创建对象
        FileInputStream fis = new FileInputStream("a.txt");
        // 读取一个字节，下面的接着上面的读
        /*
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        */
        // 创建while循环，不知道循环多少步
        int len = 0;
        while ((len = fis.read())!=-1){
            System.out.println((char)len);
        }
        // 释放内存
        fis.close();
    }
}


package mypackage.day16.demo02;

import java.io.FileInputStream;
import java.io.IOException;

public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        // 创建对象
        FileInputStream fis = new FileInputStream("a.txt");
        byte[] bytes = new byte[2];
        int len = fis.read(bytes);
        System.out.println(len);
        System.out.println(new String(bytes));
        len = fis.read(bytes);
        System.out.println(len);
        System.out.println(new String(bytes));
        len = fis.read(bytes);
        System.out.println(len);
        System.out.println(new String(bytes));
        len = fis.read(bytes);
        System.out.println(len);
        System.out.println(new String(bytes));
        // 释放内存
        fis.close();
    }
}

3、 字符输出流

package mypackage.day16.demo04;

import java.io.FileWriter;
import java.io.IOException;

public class Demo01FileWriter {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("demo04\\a\\1.txt");
        fw.write("你好，世界！");
        fw.flush();
        char[] chars = {'a','b','c'};
        fw.write(chars);
        fw.write(chars,1,1);
        fw.close();
    }
}

4、练习：复制文件
Java-字节流、字符流-第20节

package mypackage.day16.demo03;

/*
文件复制练习：一读一写
明确：
    数据源："E:\\java\\IdeaProjects\\basicCode\\code\\src\\mypackage\\day16\\demo03\\a\\对号.jpg"
    数据的目的地："E:\\java\\IdeaProjects\\basicCode\\code\\src\\mypackage\\day16\\demo03\\b\\对号.jpg"
文件复制的步骤：
    1、创建一个字节输入流对象，构造方法中绑定要读取文件的对象
    2、创建一个字节输出流对象，构造方法中绑定要写入的目的地
    3、使用字节输入流对象中的方法read读取文件
    4、使用字节输出流的方法write，把读取到的字节写入目的地文件
    5、关闭字节流（先关闭字节输出流，在关闭字节输入流，因为写完一定读完）
 */

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExcise {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        FileInputStream inputStream = new FileInputStream("E:\\java\\IdeaProjects\\basicCode\\code\\src\\mypackage\\day16\\demo03\\a\\对号.jpg");
        FileOutputStream outputStream = new FileOutputStream("E:\\java\\IdeaProjects\\basicCode\\code\\src\\mypackage\\day16\\demo03\\b\\复制的对号.jpg");
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = inputStream.read(bytes))!=-1){
            System.out.println(bytes);
            outputStream.write(bytes);
        }
        long e = System.currentTimeMillis();
        outputStream.close();
        inputStream.close();
        System.out.println("复制耗时："+(e-s)+"毫秒");
    }
}

5、对流进行try catch 的使用

package mypackage.day16.demo04;

import java.io.FileWriter;

public class DemoTryCatch {
    public static void main(String[] args) {
        // JVM7新特性
        try (FileWriter fw = new FileWriter("demo04\\a\\1.txt");
        ){
            fw.write("你好，世界！");
            fw.flush();
            char[] chars = {'a','b','c'};
            fw.write(chars);
            fw.write(chars,1,1);
        }catch (Exception e){
            System.out.println(e);
        }
    }
}


package mypackage.day16.demo04;

import java.io.FileWriter;
import java.io.IOException;

public class DemoTryCatch1 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("demo04\\a\\1.txt");
        try (fw
        ){
            fw.write("你好，世界！");
            fw.flush();
            char[] chars = {'a','b','c'};
            fw.write(chars);
            fw.write(chars,1,1);
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

6、Propreties的使用

package mypackage.day16.dmeo05;

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

public class DemoPropreties01 {
    public static void main(String[] args) {
        createP();
    }

    private static void createP() {
        Properties prop = new Properties();
        prop.setProperty("a","1");
        prop.setProperty("b","2");
        prop.setProperty("c","3");
        prop.setProperty("d","4");
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
    }
}


package mypackage.day16.dmeo05;

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

public class DemoPropreties02 {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        prop.setProperty("a","1");
        prop.setProperty("b","2");
        prop.setProperty("c","3");
        prop.setProperty("d","4");
        prop.setProperty("e","5");
        FileWriter fw = new FileWriter("a.txt");
        prop.store(fw," ");
        fw.close();
    }
}


package mypackage.day16.dmeo05;

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

public class DemoPropreties03 {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        FileReader fr = new FileReader("a.txt");
        prop.load(fr);
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            String value = prop.getProperty(key);
            System.out.println(key+"="+value);
        }
        fr.close();
    }
}
相关标签： java jvm

上一篇： 请教.有哪位高手用过Zend Guard吗

下一篇： 关于时间计算的结总

推荐阅读