字节流，字符流，对象流，序列化，持久化

第一：读写字符串

input（读文件里的内容） 的步骤：
对于文件里的内容，是个很长的字符串，而我们每次要读取的是一个字节数组或者一个字符数组
1.读字符串（文件里的内容），可以按字节读，也可以按字节数组读
2.输出（如果是按照字节读的就按照字节输出，如果是按照字节数组读的就按照字符串的方式输出）

output:(把东西（字符串）写入文件)
1.先定义一个字符串
2.将字符串转化成字节数组（两种方式基本一样，第一种因为是一个一个的输出，因此多了一个for循环）
3，然后写入，输出

 

Reader:字符输入流（抽象类）
       FileReader:文件字符输入流
       int read()  int :读取字符的编码
       int read(char []ch) int表示读取字符的个数  ，ch是读取的字符内容
       
Writer:字符输出流（抽象类）:必须刷新
     实现类：
        （1）.FileWriter(文件输出流，处理流)                   
         (2).write（int c）c是要写入字符的编码
flash:写的时候都写入了内存（这时候内存中是二进制），内存中现在把编码组织好了（变成自己能够看的），之后刷新，就把字符放入了文件中。
close里面自动调用了flash,因此close方法也会达到刷新的作用。

注意：

InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象,
Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串

 

第二：读写字符串相关代码（字符流：输入流与输出流）

package com.charTest;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class ReaderWriterTest {
 /**
  *
  *  @方法的作用：字符输入输出流
  *  @作者：褚永也
  *  @日期：2014-7-16 下午4:33:25
  *  @返回值类型：void
  */
 public static void main(String[] args) {
  File file = new File("src/com/charTEst/test.txt");
  
  write1(file);
  write2(file);
  System.out.println("--------------------");
  read1(file);
  
  read2(file);
 }
 /**
  *
  *  @方法的作用：每次读取一个字符，code表示这个字符的二进制编码
  *  @作者：褚永也
  *  @日期：2014-7-16 下午3:43:46
  *  @返回值类型：void
  */
 public static void read1(File file){
  try {
   FileReader fr = new FileReader(file);
   int code=0;//字符的二进制编码
   while((code=fr.read())!=-1){
    System.out.println(code+"  "+(char)code);
   }
  } catch (Exception e) {
   e.printStackTrace();
  } 
 }
 /**
  *
  *  @方法的作用：每次读取一个字符数组，len表示此数组的长度
  *  @作者：褚永也
  *  @日期：2014-7-16 下午4:06:29
  *  @返回值类型：void
  */
 public static void read2(File file){
  try {
   FileReader fr = new FileReader(file);
   char[] ch=new char[6];//每次读6个
   int len=0;//每次循环的元素个数
   while((len=fr.read(ch))!=-1){
    System.out.println(String.valueOf(ch,0,len));//转化成数组
   }
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } 
 }
 /**
  *
  *  @方法的作用：每次写入一个字符
  *  @作者：褚永也
  *  @日期：2014-7-16 下午4:20:11
  *  @返回值类型：void
  */
 public static void write1(File file){
  try {
   FileWriter fw = new FileWriter(file,true);
   String content="dsfdsfds第三方可敬的酸辣粉静安寺看到了伐sssss放大法";
   for(char c:content.toCharArray()){    
    fw.write(c);
    System.out.println(c); 
   }
   
   fw.flush();//注意要刷新，才能显示刚才写入的内容
   fw.close();
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
 }
 /**
  *
  *  @方法的作用：写入一个字符数组
  *  @作者：褚永也
  *  @日期：2014-7-16 下午4:31:08
  *  @返回值类型：void
  */
 public static void write2(File file){
  try {
   FileWriter fw = new FileWriter(file,true);
   String content="dsfdsfds第三方可敬的酸辣粉静安寺看到了伐sssss放大法";
   fw.write(content.toCharArray(), 10, 20);
   fw.flush();
   fw.close(); 
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
 }
}

 

第三：对象流的概念

对象流：是字节流（也是处理流），ObjectInputStream对象输入流，也是InputStream的子类。
要求对象保存到记事本中
ObjectInputStream依赖于Fileoutputstream，Fileoutputstream是在铺管道
序列化接口中没有任何方法，就是个标示接口
//对对象里的数据进行解码，可是对象里的数据没法解码，因为对象的编码没有规律。（对象以二进制的形式保存了）
注释：在把对象写入文件的时候，对象的内容出现了乱码，但是在读取这个对象的内容的时候就能正常的读取出来

 

第四：对象流相关代码

package com.objectStreamTest;

import java.io.Serializable;

public class User implements Serializable{
 private String username;
 private String userpass;
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
 public String getUserpass() {
  return userpass;
 }
 public void setUserpass(String userpass) {
  this.userpass = userpass;
 }
 public User() {
  super();
  // TODO Auto-generated constructor stub
 }
 public User(String username, String userpass) {
  super();
  this.username = username;
  this.userpass = userpass;
 }
 @Override
 public String toString() {
  return "User [username=" + username + ", userpass=" + userpass + "]";
 }
 

}

 

package com.objectStreamTest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectStreamTest {

 /**
  *  @方法的作用：定义一个类，将该的对象进行序列化和反序列化操作
  *  @作者：褚永也
  *  @日期：2014-7-16 下午8:59:18
  *  @返回值类型：void
  */
 public static void main(String[] args) {
  File file = new File("src/com/objectStreamTest/test.txt");
  //对象序列化
  try { 
       FileOutputStream out=new FileOutputStream(file);
       ObjectOutputStream oos=new ObjectOutputStream(out);
       User u=new User("dddd","11111");
       oos.writeObject(u);
   
  } catch (Exception e) {
   e.printStackTrace();
  }
 
 
    //对象反序列化
     try {
      FileInputStream in=new FileInputStream(file);
    ObjectInputStream ois=new ObjectInputStream(in);
    Object obj = ois.readObject();
    if(obj instanceof User){
     User user=(User)obj;
     System.out.println(user.toString());
    }
  } catch (Exception e) {
   e.printStackTrace();
  }
 
 } 
}

 

 

第五：用Properties模拟用户登录

package com.login;

import java.io.FileInputStream;

import java.util.Properties;
import java.util.Scanner;

public class Login {
 /**
  *
  *  @方法的作用：用Properties文件保存用户和密码，模拟登陆功能，用键盘输入的用户和密码
                                                    和Properties文件保存用户和密码封装的用户和密码比较
  *  @作者：褚永也
  *  @日期：2014-7-16 下午9:23:36
  *  @返回值类型：void
  */
 public static void main(String[] args) {
  Properties p = new Properties();
  try {
   p.load(new FileInputStream("src/com/login/test.properties"));//提前在test.properties里写好东西。把这个文件加载一下就获得了文件里的东西
   //System.out.println(p.getProperty("username"));
  } catch (Exception e) {
   e.printStackTrace();
  }
  
  Scanner input = new Scanner(System.in);
  System.out.println("请输入用户名：");
  String username = input.next();
  if(p.getProperty("username").equals(username)){
   System.out.println("请输入密码");
   String userpass = input.next();
   if(p.getProperty("userpass").equals(userpass)){
    System.out.println("登陆成功");
   }else{
    System.out.println("登陆失败，密码有误");
   }
  }else{
   System.out.println("登陆失败，用户名有误");
  }
 }

}

test.properties里面的东西是：

username=张三

userpass=1234

 

第五：字节流的输入流与输出流

package com.byteTest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class FileInputOutputStreamTest {

 /**
  *  @方法的作用：测试文件字节输入输出流
  *  @作者：褚永也
  *  @日期：2014-7-16 下午2:10:29
  *  @返回值类型：void
  */
 public static void main(String[] args) {
  File file = new File("F:\\test\\sub/a.txt");
  input1(file);
  input2(file);
  System.out.println("----------");
  output1(file);
  output2(file);
 }
 
 
 /**
  *
  *  @方法的作用：文件输出流，每次向文件中写入一个字节。
  *  @作者：褚永也
  *  @日期：2014-7-16 下午3:22:50
  *  @返回值类型：void
  */
 public static void output1(File file){
  try {
   FileOutputStream fos = new  FileOutputStream(file,true);
   String content="abcdefghijklmnopqrstuvwxyz";
   byte[] bt=content.getBytes();//先将字符串转化成字节数组在输入到文件中
   for(byte b:bt){
    System.out.println(b);
    fos.write(b);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
 
 
 /**
  *
  *  @方法的作用：字节输出流，向文件中写入一个字节数组。
  *  @作者：褚永也
  *  @日期：2014-7-16 下午3:24:31
  *  @返回值类型：void
  */
 public static void output2(File file){
  try {
   FileOutputStream fos = new  FileOutputStream(file,true);
   String content="abcdefghijklmnopqrstuvwxyz";
   byte[] bt=content.getBytes();//先将字符串转化成字节数组
   //fos.write(bt, 0, content.length());
   fos.write(bt, 1, bt.length-4);//写入的时候可以截取这个字节数组
   System.out.println(bt);
  } catch (Exception e) {
   e.printStackTrace();
  }
  
 }
 
 
 /**
  *
  *  @方法的作用：每次读取一个字节，用的是FileInputStream类中的read方法，无参
  *  @作者：褚永也
  *  @日期：2014-7-16 下午2:48:12
  *  @返回值类型：void
  */
 public static void input1(File file){
  try {
   FileInputStream fis = new FileInputStream(file);
   int b=0;
   while((b=fis.read())!=-1){//fis.read()这里的返回值b表示的是每个字节的二进制编码
    System.out.println(b);//打印二进制编码
    System.out.println((char)b);//把二进制编码转化成char字符类型然后输出具体内容
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  
  
 }
 
 
 
 /**
  *
  *  @方法的作用：每次读取一个字节数组，用的是FileInputStream类中的read（byte[] b）方法，带参
  *           
  *  @作者：褚永也
  *  @日期：2014-7-16 下午3:02:56
  *  @返回值类型：void
  */
 public static void input2(File file){
  try {
   FileInputStream fis = new FileInputStream(file);
   byte[] b=new byte[9];//给每次循环定义大小。每次读9个字节
   int len=0;
   while((len=fis.read(b))!=-1){ //fis.read(b)这里的返回值len表示本次循环的这个数组中的元素个数
    //fis.read(b);这句话不用写，因为写在了len=fis.read(b)中了
    String str=new String(b,0,len);
    System.out.println(str);
    
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

}

第六：图片处理：

1.

package com.image;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class ImageTest {
 /**
  *
  *  @方法的作用：用字节流将一张图片由d盘拷贝到e盘
  *  @作者：褚永也
  *  @日期：2014-7-16 下午8:17:38
  *  @返回值类型：void
  */
 public static void main(String[] args) {
        FileInputStream fis = null; 
        FileOutputStream fos = null; 
        File file=new File("f:\\login_bg.jpg");
         try {
           fis = new FileInputStream(file); 
           fos = new FileOutputStream("D:\\"+file.getName()); 
                  
                 byte[] buf = new byte[1024]; 
                  
                 int len = 0; 
                 while((len  = fis.read(buf))!=-1) 
                 { 
                     fos.write(buf, 0, len); 
                 } 
                  
             }  
         catch (Exception e) {  
             e.printStackTrace(); 
             }     
         finally 
         { 
             try  
             { 
                 if(fis!=null) 
                 fis.close(); 
             } catch (Exception e) {   
                 e.printStackTrace(); 
             } 
             try  
             { 
                 if(fos!=null) 
                 fos.close(); 
             }  
             catch (Exception e) {   
                 e.printStackTrace(); 
             } 
         } 
          
 }}

 

 

2.

package com.image;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class TxtTest1 {

 /**
  *  @方法的作用：用字节流将一张图片由d盘拷贝到e盘... 用字节流将一个记事本由e盘拷贝到d盘
  *  @作者：褚永也
  *  @日期：2014-7-16 下午7:03:57
  *  @返回值类型：void
  */
 public static void main(String[] args) {
  //1.对文本中的内容的拷贝
  /*File file1=new File("F:\\test1\\a.txt");
  File file2=new File("F:\\test1\\b.txt");*/
    //2.对图片的拷贝
  /*File file1=new File("f:\\login_bg.jpg");//原图片
  File file2=new File("D:\\2.jpg");//拷贝到这个目录下，名字改成2.jpg*/  
   //3.对记事本的拷贝
  /*File file1=new File("f:\\a.jnt");//原图片
  File file2=new File("D:\\b.jnt");//拷贝到这个目录下，名字改成2.jpg*/
  //4.对歌曲的拷贝
  File file1=new File("f:\\tank.mp3");
        File file2=new File("D:\\b.mp3");
  try {
   FileInputStream fis = new FileInputStream(file1);
   FileOutputStream fos =new  FileOutputStream(file2);                                          
   byte[] b=new byte[1024];
   int len=0;
   while((len=fis.read(b))!=-1){  
    /*String str=new String(b,0,len);
    byte[] bt=str.getBytes();
    fos.write(bt, 0, bt.length);*/
    //上面三句跟这一句一样
    fos.write(b, 0, len);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  
 }
}