黑马程序员--IO流

-----------------ASP.Net+Unity开发 、.Net培训 、期待与您交流！ ---------------

 

 

IO概述：

IO流用来处理设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的对象都在IO包中

流按操作数据分为两种：字节流与字符流

流按流向分为：输入流，输出流。

IO流常用基类。

字节流的抽象基类：

InputStream ,OutputStream.

字符流的抽象基类：

Reader，Writer。

文件写入，及其异常处理。

import java.io.FileWriter;


public class FileWriterDemo {
	public static void main(String[] args){
		FileWriter fw = null ;//特别重要。不能定义在try里边。否则关闭流的对象和写入流的对象不一致。
		try {
			fw = new FileWriter("c:\\yuan");
			//fw=new FileWriter("c:\\yuan",true); 表示对已有文件的续写。
			fw.write("are you ok");
			fw.flush();//刷新流。
		} catch (Exception e) {
			System.out.println(e.toString());
		}		
		finally{
			if(fw!=null){
			try{
				fw.close();//关闭流资源。注意，在关闭流资源之前，是先刷新流的。
			}
			catch (Exception e) {
				System.out.println(e.toString());
			}
		}
	}

}

文件读取的几种方式：文件读取的几种方式：文件读取的几种方式：

import java.io.*;
public class FileReaderDemo{
	public static void main(String[] args) throws IOException{
		FileReader fr = new FileReader("c:\\zhou");
		//第一种方式：
		//第二种方式：
		char[] ch = new char[1024];
		int num=0;
		while((num=fr.read(ch))!=-1){
			System.out.println(new String(ch,0,num));
		}
		fr.close();
	}
}

 

拷贝文件：

eg：将c盘下文件数据存储到D盘的一个文件中。

步骤：

1，在D盘创建一个文件。用于存储c盘文件中数据。

2，定义读取流和C盘文件关联。

3，通过不断的读写完成数据存储。

4，关闭资源。

字符流的缓冲区

BufferedWriter

缓冲区的出现提高了对数据的读写效率

所以在创建缓冲区之前，必须要先有流对象。

该缓冲区提供了一个跨平台的换行符。newLine();

package io;
import java.io.*;
public class BufferedWriterDemo {
	public static void main(String[] args){
		//创建一个字符写入流对象
		FileWriter fw =null;
		BufferedWriter bfw=null;
		try {
			fw = new FileWriter("D:\\zhou.txt");
			//为了提高字符写入流效率，加入了缓冲技术。
			bfw = new BufferedWriter(fw);
			bfw.write("are you sb?") ;
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		finally{
			try {
				//其实关闭缓冲区，就是关闭缓冲区中的流对象。
				bfw.close();
			}
			 catch (IOException e) {
				e.printStackTrace();
		}
	}
}
}

 

BufferedReader

字符读取流的缓冲区：

该缓冲区提供了一个一次读一行的方法readLine()，方便于对文本文件的获取。

当返回为null时，表示读到文件末尾。

 

import java.io.*;
class BufferedReaderDemo{
	public static void main(String[] args) throws Exception{
		FileReader fr = new FileReader("buf.txt");
		BufferedReader bufr = new BufferedReader(fr);
		String line=null;
		while((line=bufr.readLine())!=null){
		      System.out.println(line)
		}
		bufr.close();
	}
}

装饰设计模式：

当想要对已有的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能

并提供加强功能。那么自定义的类称为装饰类。

装饰类通常会根据构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。

装饰设计模式要比继承更加灵活，避免了继承体系臃肿。而且降低了类与类之间关系

装饰类因为增强已有对象，具备的功能和已有功能是相同的，所以装饰类和被装饰类都是属于同一体系中。

字节流：

InputStream

OutputStream

import java.io.*;
class FileStream{
	public static void main(String[] args){
		writeFile();
	}
	public static void writeFile() throws IOException{
		FileOutputStream fos = new FileOutputStream("fos.txt");
		fos.write("abcde".getBytes());
		//此处不用flush();
		fos.close();
	}
	public static void readFile_1() throws IOException{
		FileInputStream fis = new FileInputStream("fos.txt");
		int ch =0;
		while ((ch=fis.read())!=-1){
			System.out.println((char)ch);
		}
		fis.close();
	}


	public static void readFile_2() throws IOException{
		FileOutputStream fos = new FileOutputStream("fos.txt");
		byte[] buf = new byte[1024];
		int len =0;
		while((len=fis.read(buf))!=-1){
			System.out.println(new String(buf,0,len));
		}
		fis.close();
	}
	public static void readFile_3 throws IOException{
		FileInputStream fis = new FileInputStream("fos.txt");
		byte[] buf = new byte[fis.avaiable()];
		fis.read(buf);
		System.out.println(new String(buf));
	}
}

字节流的缓冲区：

BufferedOutputStream

BufferedInputStream

读取键盘录入。

System.out:对应的是标准输出设备，控制台。

System.in :对应是标准输入设备。

import java.io.*;
public class ReadIn {
	public static void main(String[] args) throws IOException {
		InputStream is =System.in;
		StringBuilder sb = new StringBuilder();
		while(true){
			int ch=is.read();
			if(ch=='\r')
				continue;
			if(ch=='\n'){
				String s = sb.toString();
				if("over".equals(s))
					break;
				System.out.println(s);
				sb.delete(0,sb.length());
			}
			else
				sb.append((char)ch);
			}
		}


}

读取转换流：InputStreamReader 字节通往字符的桥梁。

写入转换流： OutputStreamWriter 字符通往字节的桥梁

通常，涉及到字符编码转换时，需要用到转换流。

import java.io.*;
class TransStreamDemo{
	public static void main(String[] args)throws IOException{
		//获取键盘录入对象。
		//InputStream in = System.in;
		//将字节对象转成字符流对象，使用转换流。InputStreamReader
		//InputStreamReader isr = new InputStreamReader(in);
		//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader。
		//BufferedReader bfr= new BufferedReader(isr);
		BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));

		//OutputStream out = System.out;
		//OutputStreamWriter osw = new OutputStreamWriter(out);
		//BufferedWriter bfw = new BufferedWriter(osw);
		BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(System.out));
		String line=null;
		while((line=bfw.read())!=null){
			if("over".equals(line))
				break;
			bfw.write(line.toUpperCase());
			buw.newLine();
			bfw.flush();
		}
		buf.close();
	}
}

流操作的基本规律：

1，明确源和目的。

源：输入流。InputStream Reader

目的：输出流 OutputStream Writer

2，操作的数据是否是纯文本

是：字符流

否：字节流

3，当体系明确后，在明确要使用哪个具体对象。

通过设备来进行区分。

源设备：内存，硬盘，键盘。

目的设备：内存，硬盘，控制台。

System.setIn().System.setOut();可以改变标准输入输出。

File概述：

File类：用来将文件或者文件夹封装成对象的类。

方便对文件或文件夹的属性进行操作。

创建File类的三种方式：

package io;
import java.io.*;
public class FileDemo {
	public static void main(String[] args) {
		//第一种方式：
		File f1 = new File("zx.txt");
		//第二种方式：
		File f2 = new File("D:\\zx","zx.txt");
		//第三种方式：
		File d = new File("D:\\zx");
		File f3 = new File(d,"zxx.txt");
		System.out.println(f1+"---"+f2+"---"+f3);
		//separator字段是跨平台的分割符
		File f4 = new File("D:"+File.separator+"zx","zxxx.txt");
	}
}

File类的常见方法：

1，创建。

boolean createNewFile(): 在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

和输出流不一样，输出流对象一创建文件，如果文件已存在，会覆盖。

boolean mkdir():创建文件夹

boolean mkdirs():创建多级文件夹。

2，删除。

boolean delete():删除失败返回假

void deleteOnExit(): 在程序退出时删除指定文件

3，判断。

boolean canExcute():测试应用程序是否可以执行此抽象路径名表示的文件

boolean exists():判断文件是否存在

记住：在判断文件对象是否是文件或者目录时，必须先判断该文件对象封装的内容是否存在

boolean isFile()

boolean isDirectory()

boolean isHidden()

    boolean isAbsolute():判断是否是绝对路径。

4，获取。

getName()

getPath()

getParent():返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。

getAbsolutePath()

lastModified()

length()

boolean renameTo(): 重新命名此抽象路径名表示的文件。有点像剪切功能。

static File[] listFoots():列出可用的文件系统根

String[] list():返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

注意：调用list方法的file对象必须封装了一个目录。该目录还必须存在。否则会发生空指针异常

String[] list(FilenameFilter filter): 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

删除一个带内容的目录。

删除原理：

在windows中，删除目录从里面往外删除的。

Properties 是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。是集合中和IO技术相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件

那么在加载数据时，需要数据有固定格式：键=值。

打印流：该流提供了打印方法，可以将各种数据类型的数据都原样打印

PrintStream 字节打印流

构造函数可以接收的参数类型

1，file对象。File

2,字符串路径。String

3，字节输出流。OutputStream

PrintWriter 字符打印流

1，file对象。File

2,字符串路径。String

3，字节输出流。OutputStream

4,字符输出流 。 Writer

SequenceInputStream 序列流

对多个流进行合并

ObjectInputStream ObjectOutputStream 操作对象。

被操作的对象需要实现Serializable(标记接口)

RandomAccessFile

该类不是IO体系中子类，而是直接继承自Object。但是它是IO包中成员，因为它具备读写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePinter获取指针位置，

同时可以通过seek改变指针位置。

其实完成读写的原理就是内部封装了字节流。

通过构造函数可以看出，该类只能操作文件。

而且操作的文件还有模式：只读r 读写rw等。

而且该对象的构造函数要操作的文件不存在，会自动创建，如果存在则不会覆盖。

注意：seek() 与skipBytes()的区别是skipBytes()只能由前往后跳不能由后往前跳。

DataInputStream 与 DataOutputStream 可以用于操作基本数据类型的数据的流对象。

用于操作字节数组的流对象

ByteArrayInputStream ：在构造的时候，需要接收数据源，而且数据源是一个字节数组。

ByteArrayOutputStream : 在构造的时候，不用定义数据目的，因为对象内部已经定义了一个可以数组

这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源。所以不用close关闭资源。

流操作规律：

源设备

键盘 System.in 硬盘 FileStream  内存 ArrayStream

目的设备

控制台 System.out 硬盘 FileStream 内存 ArrayStream

用流的读写思想来操作数组。

常见的编码表

ASCII：美国标准信息交换码。用一个字节的7位表示。

ISO8859-1：拉丁码表。欧洲码表。用一个字节的8位表示。

GB2312：中国的中文编码表。每个字节的高位都是1。

GBK：中国的中文编码表升级，融合了更多的中文文字符号。

unicode：国际标准码，融合了多种文字。所有文字都用两个字节表示，java语言使用unicode。

utf-8:能用一个字节表示就用一个字节表示，最多用三个字节来表示一个字符，而且每个字节都有一个标示头。

编码：字符串变成字节数组。

解码：字节数组变成字符串。

String -->byte[]; str.getBytes();

byte[] -->String; new String(byte[],charseName);

 

 

 

                          ------------- ASP.Net+Unity开发 、.Net培训 、期待与您交流！ ------------

                         详情请查看：www.itheima.com