IO编程笔记

Question

                     IO编程笔记
File文件
package am;import java.io.File;
import java.io.IOException;public class FileDemo { public static void main(String[] args) {
File file=new File("D:"+File.separator+"io"+File.separator+"a.txt");
try {
file.createNewFile();
System.out.println("文件创建成功！");
} catch (IOException e) {
System.out.println("文件创建失败！");
e.printStackTrace();
}

try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(file.exists()==true){
file.delete();
System.out.println("文件删除成功");
}else{
System.out.println("删除失败");
}

}
}什么是绝对路径：D:\\io\\a.txt   D:/io/a.txt
绝对路径有一个最大的特点：就是路径是从某个盘符开始的。什么是相对路径：io/a.txt   特点：看不到盘符。一、          Java流式的输入输出原理：
流是用于读写数据的。以前学习过的File类，它封装的是文件名，我们想读一个文件，必须通过流的方式来读。可以把文件想像成一个水桶，IO流就像一根连接到水桶上的水管一样，当打开水管的水笼头，就开始出水。这根能流出水的管道就叫流。
有时候，一根管道的功能有效，这就需要在一根管道的外面再包装一层功能更强大的管道，比如通过网络传递过来的的是字节0101…,而通过外面管道的包装，可以将0101转化成字符串Hello,world,这样更便于我们的开发。
在本章，我们就是要学习这些功能不同的管道，这就是Java的流。
二、 流的分类：
在java.io包中定义了多个流类型（类或抽象类）来实现输入/输出功能。可以从不同的角度对其进行分类：按数据流的方向不同可以分为输入流和输出流。
按处理数据的单位不同可以分为字节流和字符流。
字节流是最原始的数据，就是0101…,一个字节是8位，按照一个字节一个字节的读。
字符流是每次读取的单位是一个字符。一个字符一个字符的向外读。（每个字符是2个字节。）按照功能不同可以分为节点流和处理流。输入流/输出流：是从程序内存的角度来区分输入输出。
把不同的流想象成不同的管道。一端连着程序，另一端连着数据源。
1. 什么是节点流？
节点流是可以从一个特定的数据源（节点）读写数据（如：文件、内存）。
 
2．什么是处理流？
   处理流是连接在已存在的流（包括节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能。
  
 
观察上表，凡是以Stream结尾的都是字节流，这种流采用的是最原始的一个字节一个字节读取与写入的方式。
Reader是一个字符一个字符读入。
Writer是一个字符一个字符写出。
下面具体分析这四个抽象类及各自的子类：
InputStream:
 
FileInputStream:从文件读取数据。
PipedInputStream:从管道读取数据。
FilterInputStream:从过滤器读取数据。
ByteArrayInputStream:从字节数组读取数据。
SequenceInputStream:从序列中读取数据。
StringBufferInputStream:从一个字符串读取数据。
ObjectInputStream:直接从流中读取一个对象。
什么叫序列化？对象转化成字节的过程被称为序列化。反过来，字节转化为对象的过程称为反序列化。
 
Int read()方法每调用一次只读取一个字节。
Int read(byte[] buffer):方法每调用一次会读取一个字节数组，具体的字节个数会通过返回值显示出来。
Int read(byte[] buffer,int offset,int length):方法每调用一次会把读取到的多个字节从指定的索引开始把length个字节存储在buffer字节数组中。OutputStream:
 
 
一个良好的编程习惯是调用close()方法前先调用flush()方法，将缓存中的数据全部写到硬盘上，然后再关闭管道。Reader:
 
此类及子类的读取方式是每次读取1个字符，相当于2个字节。这对于中国的汉字日本的假名等文字处理非常重要。因为一个汉字是两个字节。
对于汉字的读写若采用字节处理，很有可能会读写半个汉字，之后无法显示。
 
Writer:
 
 
 
节点流：是直接访问数据源。比如一个流（管道）直接访问一个文件，一个内存中的数组，内存中的字符串，管道（线程和线程之间的通信）中。
 
import java.io.*;
public class TestFileInputStream {
  public static void main(String[] args) {
    int b = 0;
    FileInputStream in = null;
    try {
      in = new FileInputStream("d:\\share\\java\\io\\TestFileInputStream.java");
    } catch (FileNotFoundException e) {
      System.out.println("找不到指定文件"); 
      System.exit(-1);
    }
    
    try {
      long num = 0;
      while((b=in.read())!=-1){
        System.out.print((char)b); 
        num++;
      }
      in.close();  
      System.out.println();
      System.out.println("共读取了 "+num+" 个字节");
    } catch (IOException e1) {
      System.out.println("文件读取错误"); System.exit(-1);
    }
  }
}import java.io.*;
public class TestFileOutputStream {
  public static void main(String[] args) {
  int b = 0;
  FileInputStream in = null;
  FileOutputStream out = null;
  try {
    in = new FileInputStream("d:/share/java/HelloWorld.java");
    out = new FileOutputStream("d:/share/java/io/HW.java");
    while((b=in.read())!=-1){
      out.write(b);
    }
    in.close(); 
    out.close();
  } catch (FileNotFoundException e2) {
    System.out.println("找不到指定文件"); System.exit(-1);
  } catch (IOException e1) {
    System.out.println("文件复制错误"); System.exit(-1);
  }
  System.out.println("文件已复制");
  }
}
 

Answer 1

import java.io.*;public class RandomAFD{
public static void main(String args[]) throws IOException{
PushbackInputStream pis = new PushbackInputStream(System.in,20);
RandomAccessFile raf = new RandomAccessFile(new File("./RandomAFD.txt"),"rw");
int c;
int temp1=0;
int temp2=0;
int temp3=0;
int temp4=0;
while((c=pis.read())!=-1)
{
switch(c){
case 'q':
raf.write(c);
if((temp1=pis.read())=='u'){
raf.write(temp1);
if((temp2=pis.read())=='i'){
raf.write(temp2);
if((temp3=pis.read())=='t'){
raf.write(temp3);
if((temp4=pis.read())=='e'){
raf.write(temp4);
pis.close();
}
else{
pis.unread(temp4);
}
}
else{
pis.unread(temp3);
}
}
else{
pis.unread(temp2);
}
}
else{
pis.unread(temp1);
}
break;
default:
raf.write(c);
}
}
raf.readLine();
}
}