Java高级部分--文件与流（序列化）（3）

一.文件管理

1.Java中的对文件的管理，通过java.io包中的File类实现。

2.File类的方法及含义

boolean createNewFile() 当且仅当不存在具有此抽象路径名指定的名称的文件时，原子地创建由此抽象路径名指定的一个新的空文件。

static File createTempFile(String prefix,String suffix) 在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。

static File createTempFile(String prefix,Stirng suffix,File directory) 在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。

boolean exists( ) 测试此抽象路径名表示的文件或目录是否存在。

boolean delete( ) 删除此抽象路径名表示的文件或目录。

boolean equals(Object obj) 测试此抽象路径名与给定对象是否相等。

boolean canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。

boolean canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。

String[] list( )  返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。

String getAbsolutePath( ) 返回抽象路径名的绝对路径名字符串。

String getName( ) 返回由此抽象路径名表示的文件或目录的名称，不包括路径名称。

String getPath( ) 将此抽象路径名转换为一个路径名字符串。

File[] listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。

boolean renameTo(File dest ) 重新命名此抽象路径名表示的文件。

long length( ) 返回由此抽象路径名表示的文件的大小，以byte为单位。

boolean mkdir( ) 创建此抽象路径名指定的目录。

boolean mkdirs( ) 创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。注意，如果此操作失败，可能已成功创建了一些必需的父目录。

 •需求：桌面（C:/Users/Administrator/Desktop）路径下创建test文件夹，test文件夹下创建abc.txt。

package io;

import java.io.File;  
import java.io.IOException;

public class File1 {
 
    public static void main(String[] args) throws IOException {
            
           File   f3=new File("C:/Users/Administrator/Desktop/test");
           File   f4=new File(f3, "abc.txt");
             
           f3.mkdirs();             //创建文件夹，联通父目录一起创建
           f4.createNewFile(); //创建文件
           
           System.out.println(f4.exists());   //判断是否存在该文件
      //  f4.delete();   //删除文件
           System.out.println(f4.canRead());   //是否可以读取该文件中的内容
           System.out.println(f4.canWrite());   //是否该文件可修改
           
           System.out.println("------------------------------------------------");
           String   str[]=f3.list();   //获取该文件夹中的所有文件名
           for(int i=0;i<str.length;i++){
               System.out.print(str[i]+"    ");
           }
           System.out.println();     //换行
           
           File  f[]=f3.listFiles();    //获得该文件加下的所有文件对象
           for(int i=0;i<f.length;i++){
               System.out.print(f[i]+"    ");
           }
           
           
           System.out.println();   //换行
           System.out.println("执行成功");  
           
        
    }

}

•需求:删除test文件夹下所有名字包含a的文件

package io;

import java.io.File;

public class File2 {

    
    public static void main(String[] args) {
        File f1 = new File("C:/Users/Administrator/Desktop/test");
        File files[] = f1.listFiles();
        for (int i = 0; i < files.length; i++) {
            String   name=files[i].getName();
            if (files[i].isFile() && name.substring(0, name.lastIndexOf(".")).contains("a")) {
                files[i].delete();
            }
        }
        System.out.println("删除成功");

    }
}

二.流

流的作用：数据传递

分类：

1.按方向分：

               输入流  in

               输出流  out

2.根据操作的数据分：

                          字节流（节点流） stream

                          字符流  reader writer

3.按功能分:

              节点流（基础流）

              处理流（过滤流） buffered

流使用的步骤:

                   1指定文件（数据源    数据宿）

                   2架设节点流的管道，架设处理流的管道

                   3调用读取或写入方法

                   4（在写入流中用flush刷新缓冲区）关闭流

字节输入流:

              fileinputstream

              字节 空格 符号

字节输出流:

               fileOutputstream

               字节 空格 符号

字符输入流:

              字节 空格 符号

字符输出流 (flush刷新缓冲区):

                                      字符串 空格 符号

处理流(输入输出字节处理流):

                                    Bufferedinputstream  

                                    Bufferedoutputstream 

 输入输出字符处理流:

                           Bufferedreader- - 读行

                           Bufferedwriter- - 换行写入

•需求：桌面（C:/Users/Administrator/Desktop）路径下创建a.txt，a.txt下写入Pioneer.HengYu

package io;

import java.io.BufferedReader;
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 BufferReader1 {

    
    public static void main(String[] args) throws IOException {
        

        File f1 = new File("C:/Users/Administrator/Desktop/a.txt");
        FileWriter fWriter = new FileWriter(f1);
        BufferedWriter bWriter = new BufferedWriter(fWriter);
        bWriter.write("Pioneer.HengYu");
        bWriter.flush();    //刷新过滤流的缓冲区(写入)
        fWriter.close();
        bWriter.close();
        System.out.println("执行成功");

    }

}

mark：标记

         有两个或多个标记同时存在时，按照代码执行顺序，最后执行的标记生效

skip：跳过字符

        skip在mark前执行，然后reset到mark上时，两次都跳过字符

        skip在mark后执行，然后reset到mark上时，当次跳过字符

reset：重置到最新标记的位置上

package io;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReader2 {

    
    public static void main(String[] args) throws IOException {  
        
        //   BufferedReader  bf2=new BufferedReader(new FileReader("d:/a/b/c/test/a.txt"));  
        
           File    file=new File("C:/Users/Administrator/Desktop/a.txt");
           FileReader   fReader=new FileReader(file);
           BufferedReader   bReader=new BufferedReader(fReader);
           
              //一次读3行  
            for(int i=0;i<3;i++){
                System.out.println(bReader.readLine());  
            }
          
           bReader.skip(1);    //跳过字符
           bReader.mark(2);    //第二次标记    
            //暂停下载            
            for(int i=0;i<3;i++){
                System.out.println(bReader.readLine());  
            }
            
                  
            for(int i=0;i<3;i++){
                System.out.println(bReader.readLine());  
            }

            bReader.reset();      //重置到最新标记的位置上
            for(int i=0;i<3;i++){
                System.out.println(bReader.readLine());  
            }
           
           
    
           

    }

}

执行结果

•需求：模拟服务器返回一个网页(传递的是浏览器能够解析的代码)

package io;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriter1 {


    public static void main(String[] args) throws IOException {
            
        File  f1=new File("d:/a.html");  //d盘下创建a.html
        f1.createNewFile();
        FileWriter   fw1=new FileWriter(f1);
        PrintWriter   pWriter=new PrintWriter(fw1);
        pWriter.println("<html>");
        pWriter.println("<head>");
        pWriter.println("</head>");
        pWriter.println("<body>");
        pWriter.println("<h1>服务器端传递给客户端的网页数据</h1>");
        pWriter.println("</body>");
        pWriter.println("</html>");
        pWriter.flush();
        fw1.close();
        pWriter.close();
        
    
        System.out.println("执行成功"); 

    }

}

•需求：更改输出设备不在控制台输出信息，将输出设备更改到指定的文件上（日志）

package io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class PrintStream1 {

    
    public static void main(String[] args) throws IOException {  
        
        File file = new File("d:/a/b/c/test/a.txt");
        FileOutputStream fos = new FileOutputStream(file, true);  //ture的话，原有数据不会被清空掉，可以继续追加信息
        PrintStream ps = new PrintStream(fos);
        
        System.setOut(ps);
        System.out.println("123");  
        
        
        System.setErr(ps);
        System.out.println("输出设备更改到指定的文件上");
        
        fos.close();
        ps.close();

    }

}

•需求：C盘图片复制到G盘（可改图片名）

package io;

import java.awt.Image;
import java.awt.image.RenderedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

public class ImageIo1 {

    
    public static void main(String[] args) throws IOException {

        File  f1=new File("C:/Users/Administrator/Desktop/1.png");    //1.png是电脑中已有图片
         Image  img=ImageIO.read(f1);  //向上转型      读取源文件
     
       ImageIO.write((RenderedImage)img, "png", new File("g:/2.png"));   //将读取的源文件写入目标位置
         
         System.out.println("执行成功");  
         
          }
}

*对象在流中不能直接传递，需要先将对象序列化，再进行传递，对象(Object)序列化是指将对象转换为字节序列的过程

序列化：通过使用ObjectInputStream和ObjectOutputStream类保存和读取对象的机制叫做序列化

          ObjectOutputStream类：ObjectOutputStream类继承OutputStream类，并实现了ObjectOutput接口。它负责向流写入对象

                                 主要方法：writeObject(Object obj) 向指定的OutputStream中写入对象obj

 　　　  ObjectInputStream类 ：ObjectInputStream类继承InputStream类，并实现了ObjectInput接口。它负责从流中读取对象

                                 主要方法：readObject(Object obj) 从指定的InputStream中读取对象

序列化类的步骤：  （自动将对象转换成byte序列   ----可以在流传递-----  操作系统会将字节序列转换成对象）

（1）创建Person类，实现序列化接口，声明属性，提供构造方法和set、get方法（ObjectOutputStream1中主要运用get方法取值）

（2）实现序列化接口--->Person implements  Serializable   

（3）在ObjectOutputStream1类中先运用ObjectOutputStream类（它负责向流写入对象）、writeObject方法将对象写入一个文件夹中，再通过ObjectInputStream类（它负责从流中读取对象）、readObject方法读取出来

（4）建议所有可序列化类都显式声明 serialVersionUID 值（static final long serialVersionUID = 42L;）

（5）transient关键字：transient修饰的属性不进行序列化的操作，起到一定消息屏蔽的效果

person类

package io;

import java.io.Serializable;

public class Person implements  Serializable {   
    
    static final long serialVersionUID = 42L;   

       
            String   name;
          transient  String   password;     //屏蔽写入到磁盘文件上的属性
            int   age;
            String   sex;
            
            public Person(String name, int age, String sex) {
                
                this.name = name;
                this.age = age;
                this.sex = sex;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public String getSex() {
                return sex;
            }

            public void setSex(String sex) {
                this.sex = sex;
            }

}

ObjectOutputStream1类（主方法）

package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectOutputStream1 {

    /**
     *   将创建的person对象写入a文件中
     */
    public static void main(String[] args) throws Exception {
        
        File file = new File("d:/a.txt");
        FileOutputStream   fos=new FileOutputStream(file);
        ObjectOutputStream   oos=new ObjectOutputStream(fos);//处理流，过滤流
        Person   p1=new Person("Pioneer.HengYu", 23, "男");
        oos.writeObject(p1);   
        oos.flush();
        fos.close();         //关闭基础流
        oos.close();        //关闭过滤流
        System.out.println("执行成功");
        
        
        FileInputStream   fis=new FileInputStream(file);
        ObjectInputStream   ois=new ObjectInputStream(fis);
        Person   p=(Person)ois.readObject();   //向下转型（强转）
        System.out.println(p.getName());
        System.out.println(p.getAge());
        System.out.println(p.getSex());
        fis.close();
        ois.close();
          
        

    }

}