java学习--IO

Java流操作有关的类或接口:

java学习--IO

IO中的继承图表

java学习--IO

流的概念和作用

流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。 


IO流的分类

  • 根据处理数据类型的不同分为:字符流和字节流
  • 根据数据流向不同分为:输入流和输出流
 

字符流和字节流

字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。 字节流和字符流的区别:

  • 读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
  • 处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。

结论:只要是处理纯文本数据,就优先考虑使用字符流。 除此之外都使用字节流。

 

输入流和输出流

对输入流只能进行读操作,对输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。  


Java IO流对象

1.输入字节流InputStreamIO 中输入字节流的继承图可见上图,可以看出:

  1. InputStream 是所有的输入字节流的父类,它是一个抽象类。
  2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流,它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据,与Piped 相关的知识后续单独介绍。
  3. ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。

 

2.输出字节流OutputStream

IO 中输出字节流的继承图可见上图,可以看出:

  1. OutputStream 是所有的输出字节流的父类,它是一个抽象类。
  2. ByteArrayOutputStream、FileOutputStream 是两种基本的介质流,它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据,
  3. ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流


3.字节流的输入与输出的对应

java学习--IO

图中蓝色的为主要的对应部分,红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。从上面的图中可以看出Java IO 中的字节流是极其对称的。“存在及合理”我们看看这些字节流中不太对称的几个类吧!

  1. LineNumberInputStream 主要完成从流中读取数据时,会得到相应的行号,至于什么时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部分,我们完全可以自己建立一个LineNumberOutputStream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行号,看起来也是可以的。好像更不入流了。
  2. PushbackInputStream 的功能是查看最后一个字节,不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream 几乎实现相近的功能。
  3. StringBufferInputStream 已经被Deprecated,本身就不应该出现在InputStream 部分,主要因为String 应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。
  4. SequenceInputStream 可以认为是一个工具类,将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除,还完全不影响IO 包的结构,却让其更“纯洁”――纯洁的Decorator 模式。
  5. PrintStream 也可以认为是一个辅助工具。主要可以向其他输出流,或者FileInputStream 写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO 包!System.out 和System.out 就是PrintStream 的实例!

 

PushbackInputStream用法举例

1.  java.io.PushbackInputStream拥有一个PushBack缓冲区,从PushbackInputStream读出数据后,只要PushBack缓冲区没有满,就可以使用unread()将数据推回流的前端。

2.  假设一个文本文件中同时存储有ASCII码范围的英文字符与BIG5范围的中文字符。想要判断那些位置是ASCII而哪些位置是BIG5中文字符,BIG5中文字符使用两个字节来表示一个中文字,而ASCII只使用一个字节来表示英文字符。

3.  Big5中文为了与ASCII兼容,低字节范围内0xA4-0xF9,而高字节为0x40--0x7E以及0xA1--0xFE。存储时低字节先存,再存高字节,所以读取时只要先读到字节是在0xA4--0xF9,就表示它可能是一个中文字符的前半数据。

4.  下面的范例说明PushbackInputStream的功能,一次从文件中读取两个字节,并检查两个字节合并后的整数值是否在0xA440--0xFFFF之间,这样可以简单地判断其两个字节合并后是否为BIG码。如果是BIG5码则使用这两个字节产生String实例以显示汉字字符;如果不在这个范围之内,则可能是个ASCII范围内的字符,您可以显示第一个字节的字符表示,并将第二个字节推回流,以待下一次可以重新读取。



package ysu.hxy;

import java.io.*;

public class PushbackInputStreamDemo
{
	public static void main(String[] args)
	{
		try
		{
			PushbackInputStream pushbackInputStream =
				new PushbackInputStream(new FileInputStream(args[0]));

			byte[] array = new byte[2];

			int tmp = 0;
			int count = 0;

			while((count = pushbackInputStream.read(array))!=-1)
			{
				//两个字节转换为整数 
				tmp = (short)((array[0] << 8) | (array[1] & 0xff));
				tmp = tmp & 0xFFFF;

				//判断是否为BIG5,如果是则显示BIG5中文字
				if(tmp >= 0xA440 && tmp < 0xFFFF)
				{
					System.out.println("BIG5:" + new String(array));
				}
				else
				{
					//将第二个字节推回流
					pushbackInputStream.unread(array,1,1);
					//显示ASCII范围的字符
					System.out.println("ASCII: " + (char)array[0]);
				}
			}
			pushbackInputStream.close();
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println("请指定文件名称");
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
	}
}


4.字符输入流Reader

在上面的继承关系图中可以看出:

  1. Reader 是所有的输入字符流的父类,它是一个抽象类。
  2. CharReader、StringReader 是两种基本的介质流,它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。
  3. BufferedReader 很明显就是一个装饰器,它和其子类负责装饰其它Reader 对象。
  4. FilterReader 是所有自定义具体装饰流的父类,其子类PushbackReader 对Reader 对象进行装饰,会增加一个行号。
  5. InputStreamReader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。后面会有Reader 与InputStream 的对应关系。

 

5.字符输出流Writer

在上面的关系图中可以看出:

  1. Writer 是所有的输出字符流的父类,它是一个抽象类。
  2. CharArrayWriter、StringWriter 是两种基本的介质流,它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据,
  3. BufferedWriter 是一个装饰器为Writer 提供缓冲功能。
  4. PrintWriter 和PrintStream 极其类似,功能和使用也非常相似。
  5. OutputStreamWriter 是OutputStream 到Writer 转换的桥梁,它的子类FileWriter 其实就是一个实现此功能的具体类(具体可以研究一SourceCode)。功能和使用和OutputStream 极其类似,后面会有它们的对应图。

 

6.字符流的输入与输出的对应

java学习--IO

7.字符流与字节流转换

转换流的特点:

  1. 其是字符流和字节流之间的桥梁
  2. 可对读取到的字节数据经过指定编码转换成字符
  3. 可对读取到的字符数据经过指定编码转换成字节

何时使用转换流?

  1. 当字节和字符之间有转换动作时;
  2. 流操作的数据需要编码或解码时。

具体的对象体现:

  1. InputStreamReader:字节到字符的桥梁
  2. OutputStreamWriter:字符到字节的桥梁

这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。

 

8.File类

File类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息,包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名,判断指定文件是否存在、获得当前目录中的文件列表,创建、删除文件和目录等方法。  

9.RandomAccessFile类

该对象并不是流体系中的一员,其封装了字节流,同时还封装了一个缓冲区(字符数组),通过内部的指针来操作字符数组中的数据。 该对象特点:

  1. 该对象只能操作文件,所以构造函数接收两种类型的参数:a.字符串文件路径;b.File对象。
  2. 该对象既可以对文件进行读操作,也能进行写操作,在进行对象实例化时可指定操作模式(r,rw)

注意:该对象在实例化时,如果要操作的文件不存在,会自动创建;如果文件存在,写数据未指定位置,会从头开始写,即覆盖原有的内容。 可以用于多线程下载或多个线程同时写数据到文件。

============================================================================================
1、Stream的应用
import java.io.*;

class StreamTest
{
	public static void main(String[] args) throws Exception
	{
		/*int data;
		while((data=System.in.read())!=-1)
		{
			System.out.write(data);
		}*/
		
		/*FileOutputStream fos=new FileOutputStream("1.txt");
		//fos.write("http://www.mybole.com.cn".getBytes());
		//fos.close();
		BufferedOutputStream bos=new BufferedOutputStream(fos);
		//bos.write("http://www.mybole.com.cn".getBytes());
		//bos.flush();
		//bos.close();
		DataOutputStream dos=new DataOutputStream(bos);
		
		byte b=3;
		int i=78;
		char ch='a';
		float f=4.5f;
		dos.writeByte(b);
		dos.writeInt(i);
		dos.writeChar(ch);
		dos.writeFloat(f);
		dos.close();
		FileInputStream fis=new FileInputStream("1.txt");
		BufferedInputStream bis=new BufferedInputStream(fis);*/
		/*byte[] buf=new byte[100];
		//int len=fis.read(buf);
		int len=bis.read(buf);
		System.out.println(new String(buf,0,len));
		//fis.close();
		bis.close();*/
		/*DataInputStream dis=new DataInputStream(bis);
		System.out.println(dis.readByte());
		System.out.println(dis.readInt());
		System.out.println(dis.readChar());
		System.out.println(dis.readFloat());
		dis.close();*/
		/*FileOutputStream fos=new FileOutputStream("1.txt");
		OutputStreamWriter osw=new OutputStreamWriter(fos);
		BufferedWriter bw=new BufferedWriter(osw);
		bw.write("http://www.mybole.com.cn");
		bw.close();
		
		FileInputStream fis=new FileInputStream("1.txt");
		InputStreamReader isr=new InputStreamReader(fis);
		BufferedReader br=new BufferedReader(isr);
		System.out.println(br.readLine());
		br.close();*/
		
		InputStreamReader isr=new InputStreamReader(System.in);
		BufferedReader br=new BufferedReader(isr);
		String strLine;
		while((strLine=br.readLine())!=null)
		{
			System.out.println(strLine);
		}
		br.close();
		
	}
	
}

=====================================================================================================
2、PipedStream的应用
import java.io.*;
class PipedStreamTest
{
	public static void main(String[] args)
	{
		PipedOutputStream pos=new PipedOutputStream();
		PipedInputStream pis=new PipedInputStream();
		try
		{
			pos.connect(pis);
			new Producer(pos).start();
			new Consumer(pis).start();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		
	}
}

class Producer extends Thread
{
	private PipedOutputStream pos;
	public Producer(PipedOutputStream pos)
	{
		this.pos=pos;
	}
	public void run()
	{
		try
		{
			pos.write("Hello,welcome you!".getBytes());
			pos.close();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
}

class Consumer extends Thread
{
	private PipedInputStream pis;
	public Consumer(PipedInputStream pis)
	{
		this.pis=pis;
	}
	public void run()
	{
		try
		{
			byte[] buf=new byte[100];
			int len=pis.read(buf);
			System.out.println(new String(buf,0,len));
			pis.close();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}
}

============================================================================
3、ObjectSerialStream
import java.io.*;

class ObjectSerialTest
{
	public static void main(String[] args) throws Exception
	{
		Employee e1=new Employee("zhangsan",25,3000.50);
		Employee e2=new Employee("lisi",24,3200.40);
		Employee e3=new Employee("wangwu",27,3800.55);
		
		FileOutputStream fos=new FileOutputStream("employee.txt");
		ObjectOutputStream oos=new ObjectOutputStream(fos);
		oos.writeObject(e1);
		oos.writeObject(e2);
		oos.writeObject(e3);
		oos.close();
		
		FileInputStream fis=new FileInputStream("employee.txt");
		ObjectInputStream ois=new ObjectInputStream(fis);
		Employee e;
		for(int i=0;i<3;i++)
		{
			e=(Employee)ois.readObject();
			System.out.println(e.name+":"+e.age+":"+e.salary);
		}
		ois.close();
	}
}

class Employee implements Serializable
{
	String name;
	int age;
	double salary;
	transient Thread t=new Thread();
	public Employee(String name,int age,double salary)
	{
		this.name=name;
		this.age=age;
		this.salary=salary;
	}
	private void writeObject(java.io.ObjectOutputStream oos) throws IOException
	{
		oos.writeInt(age);
		oos.writeUTF(name);
		System.out.println("Write Object");
	}
	private void readObject(java.io.ObjectInputStream ois) throws IOException
	{
		age=ois.readInt();
		name=ois.readUTF();
		System.out.println("Read Object");
	}

}

=============================================================================
4、RandomFIle
import java.io.*;

class RandomFileTest
{
	public static void main(String[] args) throws Exception
	{
		Student s1=new Student(1,"zhangsan",98.5);
		Student s2=new Student(2,"lisi",96.5);
		Student s3=new Student(3,"wangwu",78.5);
		RandomAccessFile raf=new RandomAccessFile("student.txt","rw");
		s1.writeStudent(raf);
		s2.writeStudent(raf);
		s3.writeStudent(raf);
		
		Student s=new Student();
		raf.seek(0);
		for(long i=0;i<raf.length();i=raf.getFilePointer())
		{
			s.readStudent(raf);
			System.out.println(s.num+":"+s.name+":"+s.score);
		}
		raf.close();
	}
}

class Student
{
	int num;
	String name;
	double score;
	public Student()
	{
	}
	public Student(int num,String name,double score)
	{
		this.num=num;
		this.name=name;
		this.score=score;
	}
	public void writeStudent(RandomAccessFile raf) throws IOException
	{
		raf.writeInt(num);
		raf.writeUTF(name);
		raf.writeDouble(score);
	}
	public void readStudent(RandomAccessFile raf) throws IOException
	{
		num=raf.readInt();
		name=raf.readUTF();
		score=raf.readDouble();
	}
}

=========================================================================
5、File
import java.io.*;
class FileTest
{
	public static void main(String[] args) throws Exception
	{
		//File f=new File("1.txt");
		//f.createNewFile();
		//f.mkdir();
		//File f=new File("E:\\JavaLesson\\Lesson7\\1.txt");
		//f.createNewFile();
		/*File fDir=new File(File.separator);
		String strFile="JavaLesson"+File.separator+"Lesson7"+
			File.separator+"1.txt";
		File f=new File(fDir,strFile);
		f.createNewFile();
		//f.delete();
		f.deleteOnExit();
		Thread.sleep(3000);*/
		/*for(int i=0;i<5;i++)
		{
			File f=File.createTempFile("winsun",".tmp");
			f.deleteOnExit();
		}
		Thread.sleep(3000);*/
		File fDir=new File(File.separator);
		String strFile="JavaLesson"+File.separator+"Lesson6";
		File f=new File(fDir,strFile);
		String[] names=f.list(new FilenameFilter()
		{
			public boolean accept(File dir,String name)
			{
				return name.indexOf(".java")!=-1;
			}
		});
		for(int i=0;i<names.length;i++)
		{
			System.out.println(names[i]);
		}
	}
}

=====================================================================================
6、
import java.util.*;
import java.nio.charset.*;
class CharsetTest
{
	public static void main(String[] args) throws Exception
	{
		/*Map m=Charset.availableCharsets();
		Set names=m.keySet();
		Iterator it=names.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}*/
		Properties pps=System.getProperties();
		//pps.list(System.out);
		pps.put("file.encoding","ISO-8859-1");
		int data;
		byte[] buf=new byte[100];
		int i=0;
		while((data=System.in.read())!='q')
		{
			buf[i]=(byte)data;
			i++;
		}
		String str=new String(buf,0,i);
		//System.out.println(str);
		String strGBK=new String(str.getBytes("ISO-8859-1"),"GBK");
		System.out.println(strGBK);
	}
}



java学习--IO,布布扣,bubuko.com

java学习--IO

上一篇:【转】深入理解C++的动态绑定和静态绑定 & 不要重定义虚函数中的默认参数


下一篇:feedparser win7 python 安装