天天看点
返回

java入门篇（24） IO流拓展一、数据输入输出流的概述和使二、内存操作流三、打印流的概述和特点

文章目录

  • 一、数据输入输出流的概述和使
    • 1.1 数据输入输出流的概述
    • 1.2 构造方法
    • 1.3 输入输出流的特点
    • 1.4 案例
  • 二、内存操作流
    • 2.1操作字节数组
    • 2.2 操作字符数组
    • 2.3 操作字符串
  • 三、打印流的概述和特点
    • 3.1 打印流的分类
    • 3.2 打印流的特点
    • 3.3自动刷新的方法
    • 3.4打印流复制文本文件
    • 3.5 标准输入输出流概述和输出语句的本质
    • 3.6 二种方式实现键盘录入
    • 3.7 输出语句用字符缓冲流改进

一、数据输入输出流的概述和使

1.1 数据输入输出流的概述

  • 数据输入流: DataInputStream
  • 数据输出流: DataOutputStream

1.2 构造方法

  • DataInputStream(InputStream in)

使用指定的底层 InputStream （字节输入流的超类）创建一个 DataInputStream。

  • DataOutputStream(OutputStream out)

创建一个新的数据输出流，将数据写入指定基础输出流（字节输出流的超类）。

1.3 输入输出流的特点

  • 可以写基本数据类型,可以读取基本数据类型
  • 读数据的顺序必须和写数据的顺序一致

1.4 案例

注意:如果写入的是字符数组，则读的时候将字符数组作为read()的参数。

public class DataInputstream_text1 {
    public static void main(String[] args) throws IOException {
        DataOutputStream b = new DataOutputStream(new FileOutputStream("b.txt"));
        DataInputStream  a = new DataInputStream(new FileInputStream("b.txt"));
        b.write(12);
        b.write(new byte[]{'a','b','c'});
        b.writeUTF("张");
        System.out.println(a.read());
        System.out.println(a.read(new byte[]{'a','b','c'}));
        System.out.println(a.readUTF());
        a.close();
        b.close();
    }
}

二、内存操作流

特点:不关联文件，所有数据的操作都在内存中完成，内存操作流也无需关闭

2.1操作字节数组

2.1.1

  • ByteArrayOutputStream
  • ByteArrayInputStream

2.1.2 特点：

  • 此流关闭无效，所以无需关闭
  • ByteArrayOutputStream实现了一个输出流，其中的数据被写入一个数组里，随着数据的传输，数组的容量不断的增加。
  • 通过toByteArray()和toString()方法将缓冲区的字节转换为字符串。

2.1.3

案例

一次读取一个字节数组:

public class DataInputstream_text1 {
    public static void main(String[] args) throws IOException {
       ByteArrayOutputStream a = new ByteArrayOutputStream();
       a.write(88);
       a.write(new byte[]{'s','w','w'});
       a.write("栈".getBytes());
        byte[] array = a.toByteArray();
        System.out.println(new String(array));
        System.out.println(a.toString());

        ByteArrayInputStream b = new ByteArrayInputStream(array);
        byte[] arrays = new byte[1024];
        int len = b.read(arrays);
        System.out.println(new String(arrays, 0, len));
    }
}

一次读取一个字节

int by = 0 ;
	while((by = bais.read()) != -1){
		System.out.println((char)by);//注意这里无法转换成字符
}

2.2 操作字符数组

  • CharArrayWrite
  • CharArrayReader

特点：

  • 也是通过toCharArray()方法和toString()方法来获取缓冲区中的内容。
  • 可以写入字符串

2.3 操作字符串

  • StringWriter
  • StringReader

特点:

  • 通过toString()方法获得缓冲区内容，但是都在一行

三、打印流的概述和特点

3.1 打印流的分类

  • 字节流打印流
  • 字符打印流
  • PrintStream 
//PrintStream(File file)
//创建具有指定文件且不带自动行刷新的新打印流。
public class DataInputstream_text1 {
    public static void main(String[] args) throws IOException {
       PrintStream out = new PrintStream(new File("b"));
        out.println('b');
        out.println('c');
        out.flush();
        out.close();  
        }
 }
  • PrintWriter 
public class DataInputstream_text1 {
    public static void main(String[] args) throws IOException {
      PrintWriter a = new PrintWriter(new File("d:\\a.txt"));
      a.println(23);
      a.print(false);
      a.flush();
      a.close();
    }
}

3.2 打印流的特点

  • 不关联源文件，只能输出数据，不能对读取数据
  • 可以操作任意数据类型的数据 调用print() 方法可以写任意数据类型
  • 如果我们启用自动刷新,那么在调用println、printf 或 format 方法中的一个方法的时候,会完成自动刷新
  • 这个流可以直接对文件进行操作, 就是构造方法的参数可以传递文件或者文件路径

3.3自动刷新的方法

通过以下构造创建对象 能够启动自动刷新 然后调用println、printf 或 format 方法中的一个方法的时候,会完成自动刷新

  • public PrintWriter(OutputStream out, boolean autoFlush)

    启动自动刷新,第二个参数传入true

案例:

public class DataInputstream_text1 {
    public static void main(String[] args) throws IOException {
      PrintWriter a = new PrintWriter(new FileOutputStream("d:\\a.txt"), true);
      a.println(23);
      a.print(false);
      a.print("sddfss");
      a.close();
    }
}
  • public PrintWriter(Writer out, boolean autoFlush) 
public class DataInputstream_text1 {
    public static void main(String[] args) throws IOException {
        PrintWriter a = new PrintWriter(new FileWriter("d:\\a.txt"), true);
        a.println(23);
        a.print(false);
        a.print("sddfss");
        a.close();
    }
}

3.4打印流复制文本文件 

public class DataInputstream_text1 {
    public static void main(String[] args) throws IOException {
        FileInputStream a = new FileInputStream("a.txt");
        PrintWriter a1 = new PrintWriter("d:\\a.txt");
        PrintStream a2 = new PrintStream(System.out);
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = a.read(bytes)) != -1) {
            a1.print(new String(bytes, 0, len));
        }
        a.close();
        a1.close();
    }
}

3.5 标准输入输出流概述和输出语句的本质

在System这个类中存在两个静态的成员变量:

  • public static final InputStream in

    标准输入流, 对应的设备是键盘

  • public static final PrintStream out

    标准输出流 , 对应的设备就是显示器

  • System.in的类型是InputStream.
  • System.out的类型是PrintStream是OutputStream的孙子类FilterOutputStream 的子类

3.5.1输出语句的本质

// 获取标准输出流
		PrintStream ps = System.out ;
		// 写数据
		ps.println(23) ;
		ps.println("你好呀") ;
		System.out.println("你好呀") ;
		System.out.println();

3.6 二种方式实现键盘录入

  • Scanner
  • BufferedReader的readLine方法。

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

3.7 输出语句用字符缓冲流改进

获取System下的in成员变量

InputStream in = System.in ;

是一个字节输入流对象,那么我们就可以通过这个字节输入流对象进行读取键盘录入的数据.

* 那么我们在这个地方使用那种读取方式. 经过分析,这两种读取方式都不太合适.因为数据是客户通过键盘录入
	 * 进来的,而我们希望直接读取一行数据. 而既然要读取一行数据,那么我们就需要使用readLine方法,而这个方法
	 * 是属于BufferedReader的方法,而我们就需要创建一个BufferedReader对象进行读取数据.而我们这in有属于
	 * 字节流,而创建BufferedReader对象的时候需要一个字符流,而我们就需要将这个字节流转换成字符流,那么既然
	 * 要对其进行转换,那么就需要使用转换流. 需要使用InputStreamReader
	 */

// // 把in通过转换流转换成一个字符流

// InputStreamReader isr = new InputStreamReader(in) ;

//

// // 创建BufferedReader对象

// BufferedReader br = new BufferedReader(isr) ;

// 创建BufferedReader对象
	BufferedReader br = new BufferedReader(new InputStreamReader(in)) ;
	
	// 读取数据
	/**
	 * 想结束就需要自定义结束标记. 886
	 */
	String result = null ;
	while((result = br.readLine()) != null){
		if("886".equals(result)){
			break ;
		}
		System.out.println(result);
	}
	
	// 释放资源
	br.close() ;

###22.11_IO流(随机访问流概述和写出数据)(了解)

A:随机访问流概述
	RandomAccessFile概述 最大特点 能读能写
	RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
	支持对随机访问文件的读取和写入。

	 RandomAccessFile的父类是Object , 这个流对象可以用来读取数据也可以用来写数据.可以操作任意数据类型的数据.
           
  • 我们可以通过getFilePointer方法获取文件指针,并且可以通过seek方法设置文件指针
    B:案例演示: 随机访问流写出数据 
    // 创建对象
 RandomAccessFile raf = new RandomAccessFile("raf.txt" , "rw");
 
 // 写数据
 raf.writeInt(100) ;
 raf.writeChar('中') ;
 raf.writeUTF("你好") ;
 
 // 释放资源
 raf.close() ;

###22.12_IO流(随机访问流读取数据和操作文件指针)(了解)

A:案例演示:	随机访问流读取数据和操作文件指针

	// 创建对象
	RandomAccessFile raf = new RandomAccessFile("raf.txt" , "rw");
	
	// 读取数据
	int a = raf.readInt() ;
	System.out.println(a);	
	System.out.println(raf.getFilePointer());//4 获取文件指针 按字节获取的 写了个int 所以是4
	
	char ch = raf.readChar() ;
	System.out.println(ch);
	System.out.println(raf.getFilePointer());// 获取文件指针
	
	String result = raf.readUTF() ;//这里会多读两个字节 是因为writeUTF("你好") 会多写两个字节
	System.out.println(result);
	System.out.println(raf.getFilePointer());
	
	// 设置文件指针的位置 可以往回读
	raf.seek(4) ;
	ch = raf.readChar() ;
	System.out.println(ch);
	
	// 释放资源
	raf.close() ;

###22.13_IO流(序列化流和反序列化流的概述和使用)(理解)

A:序列化流的概述
	所谓的序列化：就是把对象通过流的方式存储到文件中.注意：此对象 要重写Serializable 接口才能被序列化
	反序列化：就是把文件中存储的对象以流的方式还原成对象
	序列化流:	ObjectOutputStream
	反序列化流:	ObjectInputStream

像这样一个接口中如果没有方法,那么这样的接口我们将其称之为标记接口(用来给类打标记的，相当于猪肉身上盖个章)

一个对象可以被序列化的前提是这个对象对应的类必须实现Serializable接口

B:案例演示:	对象序列化和反序列化的基本使用

序列化
// public ObjectOutputStream(OutputStream out)
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt")) ;
	
	// 创建对象
	Student s = new Student("刘亦菲" , 18) ;
	
	// public final void writeObject(Object obj)
	oos.writeObject(s) ;
	
	// 释放资源
	oos.close() ;
           
反序列化
	// public ObjectInputStream(InputStream in)
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt")) ;
	
	// public final Object readObject()
	Object obj = ois.readObject() ;	
	
	// 向下转换
	Student s = (Student)obj ;
	System.out.println(s.getName() + "----" + s.getAge());
			
	// 释放资源
	ois.close() ;

###22.14_IO流(如何解决序列化时候的黄色警告线问题)(理解)

A:案例演示:	解决序列化时候的黄色警告线问题
  • 我们的一个类可以被序列化的前提是需要这个类实现Serializable接口,就需要给这个类添加一个标记.

  • 在完成序列化以后,序列化文件中还存在一个标记,然后在进行反序列化的时候,

    会验证这个标记和序列化前的标记是否一致,如果一致就正常进行反序列化,如果

  • 不一致就报错了. 而现在我们把这个类做了修改,将相当于更改了标记,而导致这两个标记不一致,就报错了.
  • 解决问题: 只要让这个两个标记一致,就不会报错了吧
  • 怎么让这两个标记一致呢? 不用担心,很简单,难道你们没有看见黄色警告线吗? ctrl + 1 , 生成出来

###22.15_IO流(如何让对象的成员变量不被序列化)(理解)

A:案例演示:	如何让对象的成员变量不被序列化
	使用transient关键字声明不需要序列化的成员变量

	private transient int age ;// 可以阻止成员变量的序列化使用transient

###22.16_IO流(Properties的概述和作为Map集合的使用)(掌握)

A:Properties的概述
	查看API
	Properties 类表示了一个持久的属性集。
	Properties 可保存在流中或从流中加载。
	属性列表中每个键及其对应值都是一个字符串。
	Properties父类是Hashtable
           
  • 属于双列集合,这个集合中的键和值都是字符串 Properties不能指定泛型

    B:案例演示: Properties作为Map集合的使用

    // 创建一个Properties对象

    Properties prop = new Properties() ;

    // 添加元素
 prop.put("张三", "23") ;
 prop.put("李四", "24") ;
 prop.put("王五", "25") ;
 
 // 遍历
 // 第一种方式: 通过键找值

// Set keySet = prop.keySet() ;

// for(Object obj : keySet){

//

// // 通过键找值

// Object object = prop.get(obj) ;

// System.out.println(obj + “----” + object);

// }

// 第二种方式: 通过键值对对象获取键和值
	Set<Entry<Object,Object>> entrySet = prop.entrySet() ;
	
	for(Entry<Object,Object> en : entrySet){
		
		// 获取键
		Object key = en.getKey() ;
		Object value = en.getValue() ;
		
		// 输出
		System.out.println(key + "---" + value);
		
	}

###22.17_IO流(Properties的特殊功能使用)(掌握)

A:Properties的特殊功能
	public Object setProperty(String key,String value)
	public String getProperty(String key)
	public Set<String> stringPropertyNames()
B:案例演示:	Properties的特殊功能


// 创建对象
	Properties prop = new Properties() ;
	
	// public Object setProperty(String key,String value):	添加元素
	/**
	 * 第一次添加元素的时候返回的是null
	 * 下一次添加元素的时候返回的是上一次键对应的值
	 */
	System.out.println(prop.setProperty("文章", "马伊琍")) ;

// System.out.println(prop.setProperty(“文章”, “姚笛”)) ;

prop.setProperty(“玉帝”, “王母”) ;

prop.setProperty(“贾宝玉”, “林黛玉”) ;

// public String getProperty(String key):根据键获取值

// System.out.println(prop.getProperty(“文章”));

// System.out.println(prop.getProperty(“文章2”));

// public Set<String> stringPropertyNames():获取所有的键对应的Set集合

// Set names = prop.stringPropertyNames() ;

// for(String name : names){

// System.out.println(name);

// }

/**
	 * Properties集合的特有的遍历方式:	根据键找值
	 */
	Set<String> names = prop.stringPropertyNames() ;
	for(String name : names){
		
		// 获取值
		String value = prop.getProperty(name) ;
		
		// 输出
		System.out.println(name + "----" + value);
		
	}
	
	// 输出
	System.out.println("prop:" + prop);

###22.18_IO流(Properties的load()和store()功能)(掌握)

A:Properties的load()和store()功能
	 Properties和IO流进行配合使用:
           
  • public void load(Reader reader): 读取键值对数据把数据存储到Properties中
           
  • public void store(Writer writer, String comments)把Properties集合中的键值对数据写入到文件中, comments注释

    B:案例演示

    Properties的load()和store()功能

    存数据到文本文件中

    // 创建Properties集合对象

    Properties prop = new Properties() ;

    // 添加元素
 prop.setProperty("张三", "23") ;
 prop.setProperty("李四", "24") ;
 prop.setProperty("王五", "25") ;
 
 // public void store(Writer writer, String comments)	把Properties集合中的键值对数据写入到文件中, comments注释
 // 创建输出流对象
 FileWriter fw = new FileWriter("userInfo.txt") ;
 prop.store(fw, "姓名和年龄对应信息") ;
 
 // 释放资源
 fw.close() ;
    从文本文件中读取数据

###22.19_IO流(判断文件中是否有指定的键如果有就修改值的)(掌握)

A:案例演示
	需求：我有一个文本文件，我知道数据是键值对形式的，但是不知道内容是什么。
	      请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其值为”100”

	 分析:
           
  • a:  把文本文件中的数据加载到Properties集合中
           
  • b:  判断这个集合中是否有"lisi"这个键
           
  • 如果有直接修改其值为100
           
  • c:  把集合中的数据再次存储到文本文件中

// 创建Properties集合

Properties prop = new Properties() ;

// 把文本文件中的数据加载到Properties集合中
	prop.load(new FileReader("names.txt")) ;
	
	// 获取所有的键对应的set集合
	Set<String> names = prop.stringPropertyNames() ;
	
	// 判断
	if(names.contains("lisi")){
		
		// 修改其值
		prop.setProperty("lisi", "100") ;//键相同，值覆盖
		
	}
	
	// 把集合中的数据存储到文本文件中
	prop.store(new FileWriter("names.txt"), null) ;

###22.19_IO流(SequenceInputStream)(掌握)

A:案例需求:将a.txt和b.txt两个文本文件的内容合并到c.txt

B:案例需求:采用SequenceInputStream来改进

C:作业:将一个music.mp3文件,拆分成多个小文件,再将多个小文件,合并成一个mp3文件

D:SequenceInputStream 
	表示其他输入流的逻辑串联。
	它从输入流的有序集合开始，
	并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，
	依次类推，直到到达包含的最后一个输入流的文件末尾为止
	a:构造方法
	SequenceInputStream(InputStream s1, InputStream s2) 
	通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），
	以提供从此 SequenceInputStream 读取的字节。
	b:构造方法
	SequenceInputStream(Enumeration<? extends InputStream> e) 
	 通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。

###22.20_day22总结

JAVA基础知识 输入输出流 内存流 打印流
上一篇: Java IO(输入输出)流IO流
下一篇: java输入输出流基础_JAVA基础-输入输出流

继续阅读