java基础——IO总结

IO笔记
File类：
File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象来操作文件和文件夹。
创建一个File对象：
File file=new File("C:\\Users\\Administrator\\Desktop\\book.txt")
创建好了文件对象后，就可以对文件进行操作，如下以file对象为例对文件的部分操作：
1.创建文件：file.createNewFile(),当文件没有被创建的得情况下，第一次创建文件成功会返回true值，如果该文件已经被创建了，则会返回false值。注意：new File一个没创建的文件为对象的时候该文件同时被创建，所以可以不用这个方法。
2.通过文件路径，判断该文件或目录是否存在,如果存在则获取该文件或目录的名字，以及大小。
if(file.exists()//文件是否存在;){
String filename=file.getname();//获取文件的名字long l=file.length()//获取文件的长度
}
3.创建目录：file.mkdir(),这里要注意，如果要创建的目录没有父目录则使用该方法无法创建目录，想要解决这个问题，就要使用file.mkdirs()方法，可以同时创建子目录以及该目录的父目录。
4.要判断该文件对象表示的是一个目录或者文件
if(file.isDirectory){ System.out.print("该file对象是一个目录");}
if(file.isFile){ System.out.print("该file对象是一个文件");}
5.文件删除：file.delete(),要注意的是，删除文件的前提是要close掉IO流。
IO流
按照数据流的方向不同可以分为：输入流和输出流。（输入和输出都在站在程序的角度上考虑的，它们的使用一般都是成对出现。）
按照处理数据单位不同可以分为：字节流和字符流。（字节流和字符流的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。）
Jdk提供的流继承了四大类：InputStream(字节输入流)，OutputStream（字节输出流），Reader（字符输入流），Writer（字符输出流）。
对文件进行操作：FileInputStream（字节输入流），FileOutputStream（字节输出流），FileReader（字符输入流），FileWriter（字符输出流）。
1.FileInputStream（字节输入流）和FileOutputStream（字节输出流）
举例：将数据写到file文件中，并将file文件中的数据读出来。
FileOutputStream out = null;
FileInputStream file=null;
try {out = new FileOutputStream(file,true);//创建一个输出流，true表示将数据曾经到以前数据的后面，不覆盖以前文件中的数据，可以不写，则默认为false,表示将写入的数据把以前的数据覆盖。
input=new FileInputStream(file);//创建一个输入流
} catch (FileNotFoundException e) {//如果指定文件不存在，或者无法打开进行读取，则抛出 FileNotFoundException。 
e.printStackTrace();
}
try {byte[] s={98,99,100};
out.write(s);//通过write()方法把数据写入文件

if(file.available()>0){//文件中的字节数大于0
System.out.println(file.read());//这里读取文件中的数据一个字符
b=new byte[fileinput.available()];
System.out.println(fileinput.read(b, 0, b.length));// 输入流中将文件中的字符的数据读入一个 b数组中。
for(int i=0;i<b.length;i++){
System.out.println("byte["+i+"]="+b[i]) ;//打印出文件中的数据
}
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(out!=null){//没有数据写入时，关闭这个流
try {
out.flush();
out.close();//关闭输出流，关闭之前要刷新缓冲
input.close();//关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.FileReader（字符输入流）和FileWriter（字符输出流）
try {
    FileWriter fw=new FileWriter(file,true);
FileReader fr=new FileReader(file);
fw.write("hello!!!!");//写数据
  char[] ch=new char[100];
  fr.read(ch);
   System.out.println(new String(ch).trim());
 
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
    e.printStackTrace();
  }finally{
if(out!=null){//没有数据写入时，关闭这个流
try {
 fw.flush();//刷新该流的缓冲
 fw.close();//关闭此流
 fr.close();//关闭此流
} catch (IOException e) {
e.printStackTrace();
}
}
3.Buffered缓冲流：BufferedInputStream，BufferedOutputStream，BufferedReader,BufferedWriter,是带缓冲区的处理流，缓冲区的作用的主要目的是：避免每次和硬盘打交道，提高数据访问的效率。


try { BufferedInputStream buffer=new BufferedInputStream(new FileInputStream(file));
if(buffer.available()>0){//文件中的字节数大于0
if(buffer.markSupported()){//此输入流是否支持 mark 和 reset 方法
buffer.mark(0);//在输入流中的当前位置上作标记
for(int i=0;i<4;i++){
System.out.println();
buffer.mark(0);
System.out.print((char)buffer.read());//读取数据并打印
buffer.reset();//将此流重新定位到对此输入流最后调用 mark 方法时的位置（距离最近的mark）
System.out.print((char)buffer.read());
System.out.print((char)buffer.read());
}

}
}


} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
4.BufferedReader和BufferedWriter
将一个文件中的数据以每行随机的字符个数写100行在另一个文件中。
BufferedReader breader=null;
BufferedWriter bwriter=null;
try {
breader=new BufferedReader(new FileReader("C:/Users/Administrator/Desktop/100.txt"));
bwriter=new BufferedWriter(new FileWriter("C:/Users/Administrator/Desktop/lo.txt")); 
String str=breader.readLine();//每次读取一行数据并将数据保存到str中
int s=0;
for(int i=0;i<100;i++){//写100行
int ran=(int)(Math.random()*(str.length()/100+1));//随机出每行字数的个数
//将每行的数据写到sr中
String sr=str.substring(s, s+ran);//
bwriter.write(sr);//把sr中的数据写到新的文件中
//新添加一行
bwriter.newLine();
s=s+ran;//文件中的数据
}
bwriter.write(str.substring(s));//将剩下所有的数据写到文件中的第100行中
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{

breader.close();
bwriter.flush();
bwriter.close();

}


}


}


5. 数据流：DataInputStream和DataOutputStream
DataInputStream datainput=null;
DataOutputStream dataout=null;
try {
datainput=new DataInputStream(new FileInputStream("C:/Users/Administrator/Desktop/lo.txt"));
dataout=new DataOutputStream(new FileOutputStream("C:/Users/Administrator/Desktop/lo.txt"));
dataout.writeBoolean(true);//写入一个Boolean类型的值
dataout.writeInt(234343);//写入一个int类型的值
dataout.writeChars("Hello!!");//写入一个字符串
//要先创建DataoutputStream才能正常读出里面的数据
System.out.println(datainput.readBoolean());//读一个Boolean值
System.out.println(datainput.readInt());//读一个int值
//想要读出一串字符串，要多次read,一次只能read一个字符。 eg:Hello! 打印出的是：  He ll o !
System.out.print(datainput.readChar());
System.out.print(datainput.readChar());
System.out.print(datainput.readChar());
System.out.print(datainput.readChar());
System.out.print(datainput.readChar());
System.out.print(datainput.readChar());
System.out.print(datainput.readChar());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(datainput!=null){
dataout.flush();//刷新缓冲
dataout.close();//关闭此流
datainput.close();//关闭此流
}
}
}

6.对象流：ObjectInputStream，ObjectOutputStream，把封装的对象直接输出，而不是一个个在转换成字符串再输出。


ObjectOutputStream objout=null;
ObjectInputStream objinput=null;
try {
Cat cat=new Cat();
objout=new ObjectOutputStream(new FileOutputStream("../java20141223/src/com/zhangzeqiu/group/iodatastream/Cat.obj"));
objout.writeObject(cat);//将对象中的数据写到文件中


objinput=new ObjectInputStream( new FileInputStream("../java20141223/src/com/zhangzeqiu/group/iodatastream/Cat.obj"));
try {
Cat cat1=(Cat)objinput.readObject();//读取数据
System.out.println(cat1.name);
System.out.println(cat1.age);
System.out.println(cat1.weight);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}


}
 
}
 class Cat implements Serializable{
//属性
//姓名
 String name="dvfsdfv";
//年龄
 int age=12;
//体重
transient  int weight=45; 
  }
使用对象流需要实现Serializable接口，否则会报错。而若用transient关键字修饰成员变量，不写入该成员变量，若是引用类型的成员变量为null，值类型的成员变量为0.