一、文件的创建
-------------------------------------------------------
File类，表示磁盘上的文件或目录，可对文件或目录进行操作.
* 常用方法
File.separator separator用于表示目录间的分隔符
creatNewFile() 创建一个新文件
mkdir() 创建一个目录
delete() 可以将文件删除
deleteonExit() 当程序终止后删除文件
createTempFile() 创建临时文件
list() 反回当前目录下的所有文件名和子目录的名字
isDirectory() 判断是不是目录
isFile 判是不是文件
FilenameFilter() 文件名的过滤器，它是个接口，
它有个方法accept(File dir,String name)返回企为值为boolean型，判断每个文件名是不是，符合要求
1. 创建一个文件
File f=new File("1.txt");
f.creatNewFile(); //创建一个名为1.txt的文件
f.mkdir(); //创建一个名为1.txt的目录
2. File f=new File("E://java//abc//1.text"); //在windows下可以这么做，在linux下则不行,linux下没有盘符
f.createNewFile(); 在e:/java/abc下创建1.text文件
-----------------------------------------------------
3. File fDir=new File(File.separator); //separator用于表示目录间的分隔符，这里是表示在系统根目录下
也可以 File fDir=new File(/); Windows可以这样表示跟目录
String strFile="java"+File.separator+"abc"+file.separator+"1.txt"; // java/abc/1.txt
File f=new File(fDir,strFile); //fDir是创建文件的父目录，strFile是文件位置
f.createNewfile();
f.delete() //可以将文件删除
f.deleteonExit() //当程序终止后删除文件
Thread.sleep(3000); //3秒后程序会结束，这样这个文件创建3秒后，程序结束，然后执deleteonExit删除文件
--------------------------------
4. for (int i=0;i<5;i++)
{ File f=File.createTempFile("winsun",".tmp"); //创建5个临时文件，文件名是winsun，后缀名是tmp,文件位置在环境
变量的temp所指定的临时文件的目录下 createTempFile是一个静态变量，可以直接调用
f.deleteOnExit();
}
Thread.sleep(3000);
for (int i=0;i<5;i++)
{ File.createTempFile("winsun",".tmp"); } //可以这样直接创建5个临时文件
---------------------------------
5. File fDir=new File(File.separator);
String strFile="java"+File.separator+"abc"+file.separator+"aa"; //因为list()显示的目录是从当
前文件所在盘开始的，所以必须
从跟目录一直找到要用到的文件目录
File f=new File(fDir,strFile);
if (f.isDirectory()) //判断是不是目录
{ String[] names=f.list(); //list返回的是一个String类型的静态数组
for (int i;i<names.length;i++)
{ System.out.println(names[i]); }
}
else
{ System.out.println("没有该目录");
}
------------------------------------------
6. 文件名的过滤器的用法
File fDir=new File(File.separator);
String strFile="java"+File.separator+"abc";
File f=new File(fDir,strFile);
String[] names=f.list(new FilenameFilter() //在list()中建个文件过滤器
{ public boolean accept(File dir,String name)
{ return name.indexOf(".java")!=-1; } // 显示扩展名为.java的文件,如果不等于-1返回true,否则返回flase
}); //匿名内部类,在查看java原文件中看到，File的list(FilenameFilter filter)方法中,自已调用了accept方法,
for (int i;i<names.length;i++)
{ System.out.println(names[i]); }
---------------------------------------------
*********************************************
---------------------------------------------
二、文件的读写
流的分类：1、节点流：从特定的地方读写的流类，例如：磁盘或一块内存区域。
2、过滤流：使用节点流作为输入输出。过滤流是使用一个已经存在的输入流或输出流连接创建的。
* InputStream
三个基本的读方法
abstract int read() : 读取一个字节的数据，但是按整型返回的,如果返回-1表示读到了文件流的末尾。
整型占四个字节，它的第一个字节才是有效的数据（注意）
int read(byte[] b) : 将数据读入一个字节数组，同时返回实际读取的字节数
int read(byte[]b,int off,int len)
其它方法
long skip(long n): 在输入流中跳过n个字节，并返回实际跳过的字节数。
int available(): 返回可读取的字节数。
void close():关闭输入流，释放和这个流相关的系统资源。
void mark(),void reset(),booleanmarkSupported(),在这个流中都是空实现的方法
* ouputStream
三个基本的写方法
abstract void write(int b): 往输出流中写入一个字节，但传进去一个整型的数据，它只写整型的第一个字节
void write(byte[] b)
void write(byte[]b,int off,int len)
其它方法
void flush(): 刷新输出流，强制缓冲区中的输出字节被写出。(它只对使用了缓冲的流类起作用)
void close()：关闭输出流
--------------------------------
System.in 和 System.out 的 in 和out 都是PrintStream类型的
import java.io.*;
class StreamTest
{ public static void main(String[] args)throws Exception
{ int data;
while((data=System.in.read())!=-1) //read它可以读取一个字节的数据，但它的返回值是一个整型，如果返回-1说明
已经到了流的结尾
{ System.out.write(data);} //write方法的参数也是整型
}
}
---------------------------------------------------
***文件输入输出流 FileInputStream FileOutputStream (节点流)***
FileOutputStream fos=new FileOutputStream("1.txt")
fos.write("http://hongxuan.ful.cn".getBytes()); //write只能写入一个字节或是一个字节数组，不能写入字符串,但它的getBytes能获取一个字节数组
fos.close();
FileOutputStream fos=new FileOutputStream("1.txt",true) //后面加true是在文件后面追加
fos.write("http://hongxuan.ful.cn".getBytes());
fos.close();
FileInputStream fis=new FileInputStream("1.txt");
byte[] buf=new byte[100];
int len=fis.read(buf);
System.out.println(new String(buf,0,len));
fis.close();
StringBuffer s=new StringBuffer();
FileInputSteam fis=new FileInputStream();
int c;
while ((c=fis.read())!=-1)
s.append((char)c);
System.out.println(s.toString);
----------------------------------------
**BufferedInputStream BufferedOutputStream () (过滤流)使用已经存在的节点来构造,提供带缓冲的读写，提高了读写效
率
BufferedInputStream 真正实现了mark()和reset()方法
BufferedOutputStream 实现了flush()方法
FileOutputStream fos=new FileOutputStream("1.txt");
BufferedOutputstream bos=new BufferedOutputStream(fos);
bos.write("http://hongxuan.ful.cn",getBytes()); //这时1.txt中并没有数据，数据在缓充区中,因为缓充区中还没有满
// bos.flush(); //刷新缓充区，执行这条语句，就会把缓冲区中的内容写到1.txt文件中
bos.close(); //如果不加bos.flush()的话bos.close()后，也会把数据写到1.txt中了
FileInputStream fis=new FileInputStream("1.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
byte[] buf=new byte[100];
int len=bis.read(buf);
System.out.println(new String(buf,0,len));
bis.close();
-------------------------------
**DataInputStream 和 DataOutputStream (过滤流) 提供了读写java中的基本数据类型的功能
FileOutputStream fos=new FileOutputStream("1.txt");
BufferedOutputstream bos=new BufferedOutputStream(fos);
DataOutputStream dos=new DataOutputStream(bos); //将3个流连到一起
byte b=3; int i=78; char ch='a'; float f=4.5f;
dos.writeByte(b);
dos.writeint(b);
dos.writeChar(b);
dos.writeFloat(b);
dos.close();
FileInputStream fis=new FileInputStream("1.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
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();
------------------------------------------------------
** PipedInputStream 和 PipedOutputStream (管道流,用于线程间的通信，必须同时构造管道输入流和管道输出流)
*PipedInputStream的两个构造方法
PipedInputStream()
PipedInputStream(PipedOutputStream src)
PipedInputStream 的方法connect(PipedOutputStream src) 使此传送输入流连接到传送输出流 src。
import java.io.*;
class PipedStreamTest
{ public static void main(String[] args)
{ PipedOutputStream pos=new PipedOutputStream();
PipedInputStream pis=new PipedInputStream();
//在连接时会抛出个异常
try{ pos.connect(pis); //可以用管道输出流连管道输入流，也可用管道输入流连管理输出流
可定成 pis.connect(pos);
new Produer(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(); }
}
}
--------------------------------------------------------------
--------------------------------------------------------------
--------------------------------------------------------------
--------------------------------------------------------------
reader writer (两个抽象类)
InputStreamReader 从字节流到字符流的转换
OutputStreamWriter 从字符流到字节流的转换
// 带缓冲的字符流
BufferedWriter
BufferedReader
//用字符流向文本文件中写入数据
FileOutputStream fos=new FileOutputStream("1.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos);//将字符流转为字节流的输出
BufferedWriter bw=new BufferedWriter(osw);
bw.write("http://hongxuan.ful.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();
----------------------------------------------------------
----------------------------------------------------------
----------------------------------------------------------
****RandomAccessFile类同时实现了DataInput和DataOutput接口，可以对文件随机存取，在文件任何位置
读取或写入数据。
它有一个指针，用来进行读写操作的下一数据的位置。
写入一个字符串的方法
writeBytes(String s); 将一个字符的两个字节的第一个字节写入到文件中，第二个字节舍弃(最好不用)
writeChars(String s); 将两个字节表示的一个数据，全都写入到文件中
writeUTF(String str); 英文件一般占一个字节，中文是三个字节,它会在写入数据的前面两个字节处，记录
写入数据的长度,比如写入"myblog"这样6个字符,它会在"myblog"前记录个6。表明
"myblog"占六个字节长度,对应的有一个readUTF() (最好用这个)
getFilePointer: 文件指针，获取文件当前位置
seek(long pos): 设置文件指针的偏移量，将pos设为0，文件指针就指向文件起始位置。
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()) //获取一个文件的长度，它的返回值是一个long型
{ 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);
}
pubic void readStudent(RandomAccessFile raf) throws IOException
{ num=raf.readInt();
name=raf.readUTF();
score=raf.readDouble();
}
}
--------------------------------------------------
--------------------------------------------------
--------------------------------------------------
*****对象序列化
* 将对象转换为字节流保存起来，并在日后还原这个对象，这种机制叫做对象序列化。
* 将一个对象保存到永久存储设备上称为持续性。
* 一个对象要想能够实现序列化，必须实现Serializable接口或Externalizable接口。
Serializable接口中没有任何方法，是个空接口，是个标识接口，对象去实现这个接口，表明这个对象，可以进行
序列化了。
Externalizable接口它继承自Serializable接口
---实现对象的序列化，可利用io包中的两个类,
ObjectOutputStream,它实现了DataOutput接口，它提供了往输出流中写入java基本数据类型的功能，
ObjectOutputStream()
ObjectOutputStream(OutputStream out)
它的方法，writeObject(Object obj)可以写入指定的对象，到对象的输出流中，它可以完成对象的序列化。
ObjectInputStream,它实现了DataInput接口，它也提供了java基本数据类型读写的功能,
它的方法，readObject()从对象输入流中读取一个对象。可实现对象的反序列化操作。
*当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。
*如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
*如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个
NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化。
import java.io.*;
class ObjectSerialTest
{ public static void main(String[] args) throws Exception
{ Employee e1=new Employee("zhangsan",25,3000.50);
Employee e1=new Employee("lisi",24,3200.40);
Employee e1=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(); //它返回的是一个Object类型，所以得转换成Employee类型
System.out.println(e.name":"+e.age+":"+e.salary);
}
}
}
class Employee implements Serializable
{ String name;
int age;
double salary; //如果在salary前加上transient,salary这个变量也不会保存
transient Thread t=new Thread(); 这里的线程对象t是个不可序列化的对象，但前面要是加个transient,
t这个对象就不会参与到序列化当中.
public Employee(String name,int age,double salary)
{ this.name=name;
this.age=age;
this.salary=salary;
}
//下面的两个方法比较特殊，private的方法，一般不可以被外部调用，但下面的两个方法，可以被调用
如果想对 对象进行控制，可以用下面的两个方法,按自已的想法去读写对象信息, 下面的这两方法就是
在读和写的时候都没有加salary这个变量
private void writeObject(ObjectOutputStream oos) throws IOException
{ oos.writeInt(age);
oos.writeUTF(name);
System.out.println("Write Object");
}
private void readObject(ObjectInputStream ois) throws IOException
{ oos.writeInt(age);
oos.writeUTF(name);
System.out.println("Read Object");
}
}