io流

• 写入文件：

  1.创建流对象，建立数据存放文件

  • FileWriterfw= new FileWriter(“Test.txt”);

  2.调用流对象的写入方法，将数据写入流

  • fw.write(“text”);

  3.关闭流资源，并将流中的数据清空到文件中。

  • fw.close();

try {
            //可能产生异常的代码
        } catch (Exception e) {
            // TODO: handle exception //异常代码处理
        }
        finally {
            //无论异常不异常都会执行的代码
        }
oos.close();//文件流结束必须有close

/**
     * 输出指定文件下的所有文件夹名  只能输出其下一级的文件夹名
     * @param file
     */public static void show(File file){
        if (file.isDirectory()) {
            File[] file3=file.list Files();
            for (File file2 : file3) {
                System.out.println(file2.getName());
            }
        }
    }

/**
     * 
     *输入字节流
     * @param file
     * @throws IOException  抛异常
     */public static void get(File file) throws IOException{
        FileInputStream fis=new FileInputStream(file);
        System.out.println("可读字节数："+fis.available());
        System.out.println("文件内容为：");
        int data;
        while ((data=fis.read())!=-1) {//读不到字节fis.read())为-1
            System.out.println(String.valueOf((char)data));//如果文件中能读到字节，就以字符串形式输出，
        }
    }

/**
     * 输出字节
     * @param file
     * @throws IOException     
     */public static void showf(Filefile) throws IOException{
        String str="good good study";
        byte[] words=str.getBytes();
   //第二个参数不写时默认为false，就是替换，为true就是追加
        FileOutputStream fe=new FileOutputStream(file,true);
        fe.write(words, 0, words.length);
    }

• InputStream（典型实现：FileInputStream）
• int  read()：从输入流中读取单个字节，返回所读取的字节数据
• int read(byte[] b)
• intread(byte[] b,intoff,intlen)

• Reader（典型实现：FileReader）
• int read()
• int read(char [] c)   ：c:一次读并存入数组多少个字节！！！！！！！
• int read(char [] c,int off,int len)
• 程序中打开的文件IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件IO资源。

• OutputStream和Writer也非常相似：
• void write(intb/intc);
• void write(byte[] b/char[]cbuf);
• void write(byte[] b/char[] buff,int off,intlen);
• void flush();
• void close();需要先刷新，再关闭此流
• 因为字符流直接以字符作为操作单位，所以Writer可以用字符串来替换字符数组，即以String对象作为参数
• void write(Stringstr);
• void write(String str,int off,int len);

• fw.close();

• 在读取文件时，必须保证该文件已存在，否则出异常。

BufferedWriter 相其对应的节点流多了  newline()换行方法    

bw.flush();

刷新缓冲区

BufferedReader 相其对应的节点流多了 readline()  读一行方法

**用BufferedReader     BufferedWriter实现文件内容复制

方法一：

BufferedReader br = null;
BufferedWriter bw = null;		
try {
//step1:创建缓冲流对象：它是过滤流，是对节点流的包装
br = newBufferedReader(new FileReader("d:\\IOTest\\source.txt"));
bw = new BufferedWriter(new FileWriter("d:\\IOTest\\destBF.txt"));
Stringstr = null;
while ((str = br.readLine()) != null) { //一次读取字符文本文件的一行字符
bw.write(str); //一次写入一行字符串
bw.newLine();  //写入行分隔符
} bw.flush();  //step2:刷新缓冲区
} catch (IOException e) {
e.printStackTrace();
} 
finally {
// step3: 关闭IO流对象try {
if (bw != null) {
bw.close();  //关闭过滤流时,会自动关闭它所包装的底层节点流
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (br != null) {
br.close();
}  } catch (IOException e) {
e.printStackTrace();
}  }

方法二：创建一个文件复制         方法

public class FileReaderTest {
	publicstaticvoid main(String[] args) {
		bufferReader("d:\\cc.txt", "d:\\ii.txt");
	}

	publicstaticboolean bufferReader(String file1, String file2) {
		try {
			File file = new File(file1);
			if (file.exists()) {
				BufferedReader bufferedReader = newBufferedReader(new FileReader(file1));
				BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file2));
				Stringline = null;
				while ((line = bufferedReader.readLine()) != null) {
					bufferedWriter.write(line);
					bufferedWriter.newLine();
					bufferedReader.close();
					bufferedWriter.close();
					returntrue;
				}
			} else {
				return  false;
			}
		} catch (Exception e) {
			// TODO: handle exception
		}
		return  false;
	}
}

用bufferwriter实现写入内容         方法

public static void bufferedWriter(String path,String[] strs,boolean isNew) throws IOException{
		FileWriter fwrite=new FileWriter(path, isNew);

               BufferedWriter bWrite=new BufferedWriter(fwrite);

              for (String string : strs) {

                        bWrite.write(string);
                        bWrite.newLine();
		}
		bWrite.flush();
                bWrite.close();
	}

publicvoid testMyInput() throws Exception{
    FileInputStream fis = new FileInputStream("dbcp.txt");
    FileOutputStream fos = new FileOutputStream("dbcp5.txt");

    InputStreamReader isr = new InputStreamReader(fis,"GBK");
    OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");

    BufferedReader br = newBufferedReader(isr);
    BufferedWriter bw = new BufferedWriter(osw);

    String  str = null;
    while((str = br.readLine()) != null){
        bw.write(str);
        bw.newLine();
        bw.flush();
}    bw.close();  br.close();}

FileInputStream fis=new FileInputStream("d:\\c.txt");
		//一种读取数据的简单方式 用 fileinputstrea
		System.setIn(fis);//将默认从键盘录入改为从指定文件流录入，
		Scanner scanner=new Scanner(System.in);
		String xString=scanner.next();
		System.out.println("读取到的文件为"+xString);

                PrintStream psPrintStream=null;
		psPrintStream=new PrintStream(new FileOutputStream("d:\\c.txt"));
		System.setOut(psPrintStream);//将默认从控制台输出改为输出到文件流
		System.out.println("qwertyuytrewdfgfdfgh");
		psPrintStream.close();

System.out.println("请输入信息(退出输入e或exit):");
//把"标准"输入流(键盘输入)这个字节流包装成字符流,再包装成缓冲流BufferedReader br = newBufferedReader(
	new InputStreamReader(System.in));
String s = null;
try {
while ((s = br.readLine()) != null) {  //读取用户输入的一行数据 --> 阻塞程序if (s.equalsIgnoreCase("e") || s.equalsIgnoreCase("exit")) {
	 System.out.println("安全退出!!");
		break;
}
/将读取到的整行字符串转成大写输出
System.out.println("-->:"+s.toUpperCase());
System.out.println("继续输入信息");
}	} catch (IOException e) {
	e.printStackTrace();
	} finally { 
	try {
	if (br != null) {
	br.close();  //关闭过滤流时,会自动关闭它包装的底层节点流
}	} catch (IOException e) {
	e.printStackTrace();
}	}

FileOutputStream fos = null;
	try {
		fos = new FileOutputStream(newFile("D:\\IO\\text.txt"));
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	}//创建打印输出流,设置为自动刷新模式(写入换行符或字节 ‘\n‘ 时都会刷新输出缓冲区)
	PrintStream ps = new PrintStream(fos,true);
	if (ps != null) {	// 把标准输出流(控制台输出)改成文件
		System.setOut(ps);}
	for (int i = 0; i <= 255; i++) {  //输出ASCII字符
		System.out.print((char)i);
		if (i % 50 == 0) {   //每50个数据一行
			System.out.println(); // 换行
		}  }
	ps.close();

DataOutputStream dos = null;
	try {	//创建连接到指定文件的数据输出流对象
		dos = new DataOutputStream(new FileOutputStream(
					"d:\\IOTest\\destData.dat"));
			dos.writeUTF("ab中国");  //写UTF字符串
			dos.writeBoolean(false);  //写入布尔值
			dos.writeLong(1234567890L);  //写入长整数
			System.out.println("写文件成功!");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {	//关闭流对象try {
			if (dos != null) {
			// 关闭过滤流时,会自动关闭它包装的底层节点流
			dos.close(); 
			}
		} catch (IOException e) {
			e.printStackTrace();
		}	}

序列化:将对象写入到磁盘或者进行网络传输。
要求对象必须实现序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test3.txt"));
Person p = new Person("韩梅梅",18,"中华大街",new Pet());
oos.writeObject(p);
oos.flush();
oos.close();
//反序列化：将磁盘中的对象数据源读出。
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test3.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();

/*
 * RandomAccessFile:支持随机访问
 * 1.既可以充当一个输入流，有可以充当一个输出流
 * 2.支持从文件的开头读取、写入
 * 3.支持从任意位置的读取、写入（插入）
 */publicclass TestRandomAccessFile {

//实现插入的效果：在d字符后面插入“xy”

publicvoid test4(){ RandomAccessFile raf = null; try { raf = new RandomAccessFile(newFile("hello1.txt"),"rw"); raf.seek(4); byte[] b = newbyte[10]; int len; StringBuffer sb = new StringBuffer(); while((len = raf.read(b)) != -1){ sb.append(new String(b,0,len)); } raf.seek(4); raf.write("xy".getBytes()); raf.write(sb.toString().getBytes()); }catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally{ if(raf != null){ try { raf.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }