Java基础 – IO机制

//查找当前file的所有父目录
File file = new File("D:\\test\\bbb\\inner\\InnerTest.txt");
File pfile = file.getParentFile();
while(pfile!=null){
    System.out.println(pfile.getAbsolutePath());
    pfile = pfile.getParentFile();//再找一遍
}

//设计一个方法  用来展示(遍历)文件夹,参数-->file(代表文件或文件夹)
public void showFile(File file){
    //获取file的子元素
    //files==null是个文件
    //files!=null是个文件夹
    //files.length!=0是一个带元素的文件夹
    File[] files = file.listFiles();//test文件夹所有子元素
    if(files!=null && files.length!=0){
        for(File f:files){
            this.showFile(f);
        }
    }
    //做自己的显示(file是文件或file是一个空的文件夹)
    System.out.println(file.getAbsolutePath());
}

//设计一个方法 删除文件夹,参数 file
public void deleteFile(File file){
    //判断file不是空文件夹
    File[] files = file.listFiles();
    if(files!=null && files.length!=0){
        for(File f:files){
            this.deleteFile(f);
        }
    }
    //删除file (file是个文件或file是一个空文件夹)
    file.delete();
}

public void copyFile(File file, String path) {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //创建输入流读取信息
        fis = new FileInputStream(file);
        //创建一个新的File对象
        File newFile = new File(path +"\\"+ file.getName());//"E:\\test\\test.txt"
        //创建一个输出流
        fos = new FileOutputStream(newFile);
        byte[] b = new byte[1024];//通常1kb-8kb之间
        int count = fis.read(b);
        while(count != -1) {
            fos.write(b, 0, count);//将读取到的有效字节写入
            fos.flush();
            count = fis.read(b);
        }
        System.out.println("复制完毕！");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //关闭
        if(fis!=null) {
            try { fis.close(); }
            catch (IOException e) {e.printStackTrace();}
        }
        if(fos!=null) {
            try {fos.close();}
            catch (IOException e) {e.printStackTrace();}
        }
    }
}

File file = new File("F://test//Test.txt");
try {
    FileReader fr = new FileReader(file);
    // int code = fr.read();
    // System.out.println(code);
    char[] c = new char[1024];
    int count = fr.read(c);
    while(count!=-1) {
        System.out.println(new String(c, 0, count));
        count = fr.read(c);
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

//设计一个方法，用来用户登录认证
public String login(String username, String password) {
    try {
        BufferedReader br = new BufferedReader(new FileReader("F://test//User.txt"));
        //User.txt每行存储格式：张三-123
        String user = br.readLine();//user表示一行记录，记录账号密码
        while(user!=null) {
            //将user信息拆分，分别与参数比较
            String[] value = user.split("-");//value[0]账号，value[1]密码
            System.out.println(value[0]);
            if(value[0].equals(username)) {
                if(value[1].equals(password)) {
                    return "登录成功";
                }
            }
            user = br.readLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return "账号或密码错误！";
}

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

public class ReaderDemo2 {
   public static void main(String[] args) throws IOException {
    // 定义文件路径,文件为gbk编码
       String FileName = "E:\\file_gbk.txt";
    // 创建流对象,默认UTF8编码
       InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
    // 创建流对象,指定GBK编码
       InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
// 定义变量,保存字符
       int read;
    // 使用默认编码字符流读取,乱码
       while ((read = isr.read()) != -1) {
           System.out.print((char)read); // ��Һ�
      }
       isr.close();
    // 使用指定编码字符流读取,正常解析
       while ((read = isr2.read()) != -1) {
           System.out.print((char)read);// 大家好
      }
       isr2.close();
  }
}

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

public class OutputDemo {
   public static void main(String[] args) throws IOException {
    // 定义文件路径
       String FileName = "E:\\out.txt";
    // 创建流对象,默认UTF8编码
       OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(FileName));
       // 写出数据
    osw.write("你好"); // 保存为6个字节
       osw.close();
// 定义文件路径
String FileName2 = "E:\\out2.txt";
    // 创建流对象,指定GBK编码
       OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(FileName2),"GBK");
       // 写出数据
    osw2.write("你好");// 保存为4个字节
       osw2.close();
  }
}

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

//满足两个条件
public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int age; // transient瞬态修饰成员,不会被序列化
   public void addressCheck() {
    System.out.println("Address check : " + name + " -- " + address);
  }
}
//写出对象方法
public class SerializeDemo{
  public static void main(String [] args)   {
  Employee e = new Employee();
  e.name = "zhangsan";
  e.address = "beiqinglu";
  e.age = 20; 
  try {
    // 创建序列化流对象
         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
      // 写出对象
      out.writeObject(e);
      // 释放资源
      out.close();
      fileOut.close();
      System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
      } catch(IOException i)   {
           i.printStackTrace();
      }
  }
}
//输出结果：
//Serialized data is saved

public class DeserializeDemo {
  public static void main(String [] args)   {
       Employee e = null;
       try {
            // 创建反序列化流
            FileInputStream fileIn = new FileInputStream("employee.txt");
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // 读取一个对象
            e = (Employee) in.readObject();
            // 释放资源
            in.close();
            fileIn.close();
      }catch(IOException i) {
            // 捕获其他异常
            i.printStackTrace();
            return;
      }catch(ClassNotFoundException c) {
      // 捕获类找不到异常
            System.out.println("Employee class not found");
            c.printStackTrace();
            return;
      }
       // 无异常,直接打印输出
       System.out.println("Name: " + e.name);// zhangsan
       System.out.println("Address: " + e.address); // beiqinglu
       System.out.println("age: " + e.age); // 0
  }
}

public class Employee implements java.io.Serializable {
    // 加入序列版本号
    private static final long serialVersionUID = 1L;
    public String name;
    public String address;
    // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
    public int eid; 

    public void addressCheck() {
        System.out.println("Address check : " + name + " -- " + address);
    }
}

PrintStream ps = new PrintStream("ps.txt")；

public class PrintDemo {
    public static void main(String[] args) throws IOException {
        // 调用系统的打印流,控制台直接输出97
        System.out.println(97);
        // 创建打印流,指定文件的名称
        PrintStream ps = new PrintStream("ps.txt");
        // 设置系统的打印流流向,输出到ps.txt
        System.setOut(ps);
        // 调用系统的打印流,ps.txt中输出97
        System.out.println(97);
    }
}