IO流

最新推荐文章于 2022-05-20 15:06:06 发布

weixin_30338481

最新推荐文章于 2022-05-20 15:06:06 发布

阅读量63

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/lcj12121/p/11331104.html

版权

File file = new File("e:\\a.txt");

主要分类为：增、删、查、判断

增：

1. file.CreatNewFile(); 创建文件

2. file.mkdir();创建一级目录

3. file.mkdirs();创建多级目录

删：

1. file.delete();删除文件，如果删除文件夹必须里面是空的

2. file.deleteOnExit(); 关闭虚拟机时强制删除

查：

file.getAbsoloteFile(); 获取当前文件
file.getAbsolotePath(); 获取文件名字符串
file.getParentFile(); 获取父文件
file.getParent(); 获取父文件路径字符串
file.getName(); 获取名字

等等...........................................

判断：

是否可读
是否可写
是否可以执行
是否是文件
是否是绝对路径
是否是隐藏
等等..........

        System.out.println("--------过滤list----------");

        String[] list2=mydir.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                if(name.endsWith(".png")) {
                    return true;
                }
                return  false;
            }
        });
        for (String s : list2) {
            System.out.println(s.toString());
        }

import java.io.File;

public class Demo2 {
    public static void main(String[] args) {
//        listDir(new File("d:\\aaa"),0);
        deleteFile(new File("c:\\"));
    }
    //练习1：递归遍历文件夹
    public static void listDir(File dir,int level){
        System.out.println(getSeparator(level)+dir.toString());
        File[] files = dir.listFiles();
        level++;
        if(files!=null&&files.length>0){
            for (File file : files) {
                if(file.isDirectory()){
                    listDir(file,level);
                }else{
                    System.out.println(getSeparator(level)+file.toString());
                }
            }
        }
    }
    public static String getSeparator(int level){ //0 1
        StringBuilder sb=new StringBuilder();
        sb.append("|");
        for(int i=0;i<level;i++){
            sb.append("_____");
        }
        return sb.toString();
    }

    //案例2递归删除文件夹
    public static void deleteFile(File dir){
        File[] files = dir.listFiles();
        if(files!=null&&files.length>0){
            //删除文件
            for (File file : files) {
                if(file.isDirectory()){
                    deleteFile(file);
                }else{
                    System.out.println(file.toString()+":"+file.delete());
                }
            }
            //把文件夹删除
            System.out.println(dir.toString()+":"+dir.delete());
        }

    }

}

IO 流：

流的定义：在工作中经常读取、写入的操作从内存到外部设备传输需要媒介或者管道，而这个媒介或管道就是IO流

流的作用及原理：流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，

根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

输入：读取

输出：写入

流的分类：

根据流的流向分类：输入流输出流

根据数据单元分类：字节流字符流

根据功能分类：节点流处理流

一 InputStream(输入流、抽象) 和 OutputStream（输出流、抽象）-----------------------字节

InputStream 的方法： 1.void close(); 2. int read(); 3. int read(bytes);

OutputStream的方法： 1.void close(); 2. void writer() 3.void flush()

二 FileInputStream() 和 FileOutputStream() ---------------------------------字节

此二类目前没有任何特别突出的，多是作为InputStream和OutputStram 的实现类使用

即 FilexxxxStream(file);,

三（字符） Reader 和 Writer

都是抽象类，不能实例化，可以使用它们的子类 FileReader 和 FileWriter

四（字符）FileReader 和 FileWriter

五：转环流

InputStreamReader :字节流转成字符流

InputStreamReader isr=new InputStreamReader(fis, "utf-8"); 此处的编码格式根据文件的编码而定

OutputStreamWriter: 字符流转成字节流

FileOutputStream fos=new FileOutputStream("e:\\a.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos, "utf-8"); 此处编码自定义，此处些什么，文件格式是什么

六：缓冲流 : 主要是为了增强基础流的功能而存在的，提高了流的工作效率【读写效率】

注意：如果使用记事本创建的文件，文件是utf‐8或者unicode编码，文件的前面有一个BOM（Byte Order Mark）

头,BOM作用指定文件使用的编码类型。GBK编码没有添加bom头。

utf‐8:EF BB BF

unicode 小端: FF FE 66 00

unicode 大端：FE FF 00 66

BufferedInputStream:

//实例化一个File对象

File file = new File("file/test22.txt");

//实例化一个缓冲字节输入流的对象

BufferedInputStream input = new BufferedInputStream(new FileInputStream(file));

BufffferedOutputStream:

File file = new File("test33.txt");

BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(file));

七： BufferdReader 和 BufferedWriter

八：ByteArrayInputStream 和 ByteArrayOutputStream

字符数组输入流 : ByteArrayInputStream

字符数组输出流：ByteArrayOutputStream

九：标准输入输出流 System.in 和 System.out

System.in 通过控制台输入

System.out 通过显示器输入然后打印

十：对象流 ObjectInputStream(对象输入流) 和 ObjectOutputStream(对象输出流)

1.序列化：将一个对象存到本地文件中，称为序列化

2.反序列化：将本地对象读取出来，被称为反序列化

注：(1)transient修饰的成员（2）静态成员（3）序列化版本id:判断序列化和反序列化是否是同一个类. （4）实现接口：Serializable

（5）一个对象流只能操作一个对象，如果操作多个会发生EOFException(文件以外到达文件末尾)

（6）如果向将多个对象序列化到本地，可以借助于集合，【思路：将多个对象添加到集合中，将集合的对象写入到本地文件中，再次读出来，获取到的仍然是集合对象，遍历集合】

package com.qf;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/*
 * 使用ObjectOutputStream实现序列化
 * 使用ObjectInputStreaam实现反序列化
 * Serializable
 * Deserializable
 */
public class Demo12 {
    public static void main(String[] args) throws Exception{
        //writeObject();
        readObject();
    }
    public static void writeObject() throws Exception{
        //1创建流
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("stu.bin"));
        //2序列化
        Student shaobo=new Student("少泊", 16, "北京");
        Student zhangsan=new Student("张三", 16, "北京");
        Student lisi=new Student("李四", 16, "北京");

        ArrayList<Student> list=new ArrayList<>();
        list.add(shaobo);
        list.add(zhangsan);
        list.add(lisi);


        oos.writeObject(list);

        //3关闭
        oos.close();
        System.out.println("序列化完毕");
    }

    public static void readObject() throws  Exception{
        //1创建流
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("stu.bin"));
        //2读取
//        Student stu1= (Student) ois.readObject();
//        Student stu2= (Student) ois.readObject();
//        Student stu3= (Student) ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        for (Student student : list) {
            System.out.println(student.toString());
        }



        //3关闭
        ois.close();
    }
}

*******************************************************************************************************************************************************************************

package com.qf;

import java.io.Serializable;

/*
 * 不能序列化:(1)transient修饰的成员（2）静态成员
 * 序列化版本id:判断序列化和反序列化是否是同一个类.
 */
public class Student implements Serializable {

//序列化版本id
 private static final long serialVersionUID=1000L;

private String name;
private transient int age; //transient:瞬间的
 private String address;
public static String country="中国";
//修改
 private String email;





public Student(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
 }
public Student() {

 }

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 getAddress() {
return address;
 }

public void setAddress(String address) {
this.address = address;
 }

public String getEmail() {
return email;
 }

public void setEmail(String email) {
this.email = email;
 }

@Override
 public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
 }
}

十一：RandomAccessFile(使用RandomAccessFile读写文件)

RandomAccessFile是用来访问那些保存数据记录的文件的，你就可以用seek(?)方法来访问记录，并进行读写了。

这些记录的大小不必相同；但是其大小和位置必须是可知的。但是该类仅限于操作文件。

import java.io.RandomAccessFile;

/*
 * 使用RandomAccessFile读写文件
 */
public class Demo1 {
    public static void main(String[] args) throws Exception{
        //write();
        read();
    }
    public static void write() throws Exception{
        //1创建对象
        RandomAccessFile raf=new RandomAccessFile("ran.txt", "rw");
        //2写入
        raf.writeUTF("张三");
        raf.writeInt(20);
        raf.writeDouble(170.5);
        raf.writeBoolean(true);
        raf.writeUTF("李四");
        raf.writeInt(22);
        raf.writeDouble(180.5);
        raf.writeBoolean(false);
        //3关闭
        raf.close();
        System.out.println("写入完毕");

    }

    public static void read() throws Exception{
        //1创建对象
        RandomAccessFile raf=new RandomAccessFile("ran.txt", "r");
        //设置跳过张三，设置读取指针的偏移量，从0开始
//        raf.seek(21);
//        raf.seek(21);
        //跳过21个字节，从当前位置
        raf.skipBytes(21);
        //raf.skipBytes(21);
        //2读取
        String name = raf.readUTF();
        int age = raf.readInt();
        double height = raf.readDouble();
        boolean b = raf.readBoolean();

        System.out.println(name+" "+age+" "+height+" "+b);

        //3关闭
        raf.close();

    }


}

十二： properties

package com.qf2;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintStream;
import java.util.Properties;
import java.util.Set;

/*
 * 使用Properties集合保存数据
 */
public class Demo2 {
    public static void main(String[] args) throws Exception{
        //创建集合
        Properties properties=new Properties();
        //1添加
        properties.setProperty("name", "少泊");
        properties.setProperty("age", "20");
        properties.setProperty("address", "北京");
        //2遍历
        Set<String> keyset = properties.stringPropertyNames();
        for (String key : keyset) {
            System.out.println(key+"===="+properties.getProperty(key));
        }
        //3和流有关的方法
        //3.1 list方法
        System.out.println("-----------list---------");
        properties.list(new PrintStream("prop.properties"));
        properties.list(System.out);
        //3.2load方法
        System.out.println("-----------load-----------------");
        Properties properties2=new Properties();
        properties2.load(new FileReader("prop2.properties"));
        properties2.list(System.out);
        //3.3store方法
        properties2.store(new FileWriter("prop3.properties"), "信息");

        //3.4System.getProperties();
        System.out.println("---------System.getProperties();----------");
        Properties sysprop = System.getProperties();
        sysprop.setProperty("myname", "hello");
        sysprop.list(System.out);


    }
}