对于java i/o流的看法

在java也提供了一些方法对于输入输出流。

文件数据流：

不用多说肯定是把文件当成数据流的来源，通过FileInputStream，FileOutputStream,这两个类实现。

基本的定义是这样的  FileInputStream file=new FileInputStream("文件的地址”);

FileOutputStream flie=new FileOutputStream("文件的地址");

package com.shurushuchu;
import java.io.*;
public class fileoutputstream {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			FileOutputStream file=new FileOutputStream("myfile");
			file.write('q');
			file.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		catch(IOException e)
		{
		
		}

	}

}

package com.shurushuchu;
import java.io.*;
public class flieinputstreamtext {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try
		{
			FileInputStream file=new FileInputStream("myFile");
			while(file.available()>0)
			System.out.println(file.read());
			file.close();
			
		}
		catch(FileNotFoundException e)
		{
			
		}
		catch(EOFException e)
		{
			
		}
		catch(IOException e)
		{
			
		}

	}

}

上面的只是很简单的文件流没什么可多讲的。

缓冲区数据流：现在的电脑i/o率要看硬件的，快慢相差十分的大，所以为了加快速度就建立了缓冲区这么一个概念。

FileInputStream fis=new FileInputStream("文件的位置");

BufferedInputStream is=new BufferedInputStream(fis);

可以使用从inputstream继承的那些函数。比如read();

当然在关闭缓冲区输出流的时候最好要使用flush();把其中剩下的一些数据取出来。（flush你们可以百度一下这个函数）。

数据数据流：现在的数据有很多的类型。例如int,double,float,等等;在取出来的时候可能会不方面，因此可以使用

DataInputStream和DataoutputStream;

当然这两个在使用之前先要使用上面的文件数据流

FileInputStream fis=new FileInputStream("文件的位置");

DataInputStream is=new DataInputStream(fis);

里面有很多的函数：

byte readByte();

long  readLong();

int readInt();

boolean readBoolean();

double readDouble();

char readChar();

float readFloat();

short readShort();

String readUTF();

当然对于DataoutputStream也有很多函数 这里不一一举例了。

管道数据流：这个是用在线程之间的一种数据流的方法。而且他们两个必须同时一起使用 不能单独的，也就是必须有可用的输入端和输出端。

PipedInputStream pis=new PipedInputStream();

PipedOutputStream pos=new PipedOutputStream();

pis.connect(pos);//连接为了两个流。

或者：

PipedInputStream pis=new PipedInputStream();

PipedOutputStream pos=new PipedOutputStream(pis);

package com.shurushuchu;
import java.io.*;
public class flieinputstreamtext {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PipedOutputStream pos=new PipedOutputStream();
		try {
			PipedInputStream pis=new PipedInputStream(pos);
			int c=1;
			pos.write(c);
			System.out.println(pis.read());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

对象数据流：

把对象当作一种流，通过使用ObjectInputStream和ObjectOutputStream来实现，它也是要用文件数据流当作参数的，因为如果不用它无法读取或者写入文件中。

package com.shurushuchu;
import java.io.*;
import java.util.Date;
public class flieinputstreamtext {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FileOutputStream s;
		try {
			Date d=new Date();
			s = new FileOutputStream("myfile");
			ObjectOutputStream f=new ObjectOutputStream(s);
			f.writeObject(d);
			f.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

现在来说一下可持久性：

就是把一个对象的属性保存下来 把数据什么的传到其他地方（或者没有都可以，可以使用对象输入流重新获得）。而且必须实现接口Serializable

package com.shurushuchu;

import java.io.Serializable;

public class Student implements Serializable {
	int id;
	String name;
	int age;
	String department;
	public Student(int id,String name,int age,String department)
	{
		this.id=id;
		this.name=name;
		this.age=age;
		this.department=department;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

上面的就是确定了某个对象的属性！

package com.shurushuchu;
import java.io.*;

public class Objet implements Serializable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student srt=new Student(98,"xx",15,"wqe");
		try {
			FileOutputStream fo=new FileOutputStream("myfile");
			ObjectOutputStream so=new ObjectOutputStream(fo);
			so.writeObject(srt);
			so.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

这个就是把这个属性写到了某个文件中

package com.shurushuchu;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Ob implements Serializable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student srt;
		try {
			FileInputStream fo=new FileInputStream("myfile");
			ObjectInputStream so=new ObjectInputStream(fo);
			srt=(Student)so.readObject();
			so.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

重新把某个属性给了变量  所以只要有了他本身的属性就可以一直产生它自己的数据。

当然对于一些无法保存状态的对象怎么办呢 ？  可以使用transient解决 比如Thread这个线程类的，或者是你不想在重新产生数据的时候让别人看到就可以使用这个修饰，那么相当是加密的一种方法。（我的感觉是加密的）。

上面说的都是数据流，现在来说一下字符流

这个类就是专门用来解决对于字符的处理，使用了两个类InputStreamWriter和OutputStreamReader。

这两个实现的功能的函数和他们的父类InputStream和OutputStream一样所以在这里不介绍了。

但是大家想一下是不是这样的话也有可能产生硬件之间i/o速率很慢的情况 所以也使用了缓冲区这个方法。

package com.shurushuchu;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.Reader;

public class qwe {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			FileInputStream fo=new FileInputStream("myfile.text");
			InputStreamReader so2=new InputStreamReader(fo);
			BufferedReader re=new BufferedReader(so2);
			String s;
			while((s=re.readLine())!=null)
			{
				System.out.println(s)；
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

就是像这样的方法使用就可以了。

最后一点就是对于文件本身的处理

在使用流之前是不是需要知道一些关于这个文件的信息，所以可以使用File类

String getName();获取文件名

String getPath();获取文件路径

String getSbsolutePath();获取文件绝对路径

String getParent();获取文件父文件夹

boolean renameTo(new name)改变文件夹名字

boolean exists();检测文件对象是不是真的存在

boolean canWrite();检测文件对象是不是处于可写

boolean canRead();检测文件对象是不是可读

boolean isFile();检测文件对象是不是文件

boolean isDirectory();检测文件是否是目录

boolean isAbsolute();检测文件对象是不是绝对路径

boolean mkdir();创建新目录

boolean mkdirs();创建新目录

但是这样在访问文件内部的时候不是可选择性的，意思就是机器按照他自己的开始传入流，当然我们也可以使用RandomAccessFile这个类选择从哪里开始读入

myfile=new RandomAccessFile(myFile,r或者rw)（r代表只读不能改变内容，rw可以读也可以改变内容）。

long getFilePointer()  返回指针当前的位置

void seek(long c)把指针至于绝对位置然后可以移动c个位子。

long length() 返回文件的长度。

今晚就说到这里了 困了睡觉觉了

~\(≧▽≦)/~。