java的流类（简单理解）

java的流类（简单理解）

I/O流

 java把文件信息与数据流的方式在内存中移动的操作  

• I: input 输入——表示流动的方向
• O: output 输出——表示流动方向

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

/**
 * I/O——文件列表
 */
public class Test02 {
    public static void main(String[] args) {
//        method01();
        method02();
    }

    /**
     * list
     */
    public static void method01(){
        String str="F:/file2/100txt";
        File f=new File(str);

        //获取该路径下所有的文件/路径的名称
        String names[]=f.list();


        //获取该路径下被过滤过的文件名称，如字母开头
        String fns[]=f.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                String regex="[a-z]+.+";
                return name.matches(regex);
            }
        });
        for(String name:fns){
            System.out.println(name+",");
        }
    }

    public static void method02(){
        String str="F:/file2/100txt";
        File f=new File(str);

        //获取该路径下的所有文件
        File fa[]=f.listFiles();
        for(File fl:fa){
            boolean b=fl.isFile();
            System.out.println((b?"文件":"路径")+"文件名："+fl.getName()+"，父路径："+fl.getParent());
        }
        File fs[]=f.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                String regex=".+\\.txt";

                return file.isFile()&&file.getName().matches(regex);
            }
        });
    }
}

文件类File

File类——包含表示文件地址的路径与存储内容的文件
 路径：绝对路径与相对路径
 绝对路径：出现盘符的地址表示
 相对路径：有一个相对参照物的地址表示
 文件：一个存在后缀名，存储信息的

import java.io.File;

/**
 * java的File类
 */
public class Test01 {
    public static void main(String[] args) {
        method01();
    }

    /**
     * File
     */
    public static void method01(){
        String path="F:/file/";
        File f=new File(path);
        //判断路径是否存在
        boolean b=f.exists();//true存在，false不存在
       String absPath= f.getAbsolutePath();//获取绝对路径
        b=f.isAbsolute(); //判断路径是否存在
        File f1=new File("abc.txt");//通过文件名创建文件夹

        File f2=new File(f,"exg.txt");//绝对路径的文件

        if (!f.exists()){
            //创建路径（创建文件夹）
//            f.mkdir();//创建一层路径
            f.mkdirs();//创建一层或者多层路径

            System.out.println("mkdir路径创建："+(b?"成功":"失败"));
        }

        //删除路径
       b= f.delete();//只有该路径下的内容为空的才能删除

        System.out.println("路径删除："+(b?"成功":"失败"));

        try {

                //创建新文件
               b= f2.createNewFile();

            System.out.println("文件创建"+(b?"成功":"失败"));

        }catch (Exception e){
            e.printStackTrace();
        }

        //判断s是否是路径文件
        b=f.isFile();//是否是文件
        b=f.isDirectory();//是否为路径

        f.isHidden();
        f.canRead();//是否可读取
        f.setReadOnly();//设置为只读

        //重命名
        File f4=new File(f,"123.txt");
        f2.renameTo(f4);
    }
}

对应练习

File类对应练习

文件流Stream

字节流

字节输入流/输出流

• 字节流（8位）
• InputStream
• OutputStream

文件字节流输入/输出流

• FileInputStream
• FileOutputStream

import java.io.*;

/**
 * 文件字节输出流
 */
public class Test01 {
    public static void main(String[] args) {
        File file = new File("F:/file/001.txt");
        fileInput(file);
//        fileOutput(file);
    }

    /**
     * 文件字节输入
     * 从存储设备到流程
     * @param f
     */
    public static void fileInput(File f){

        //声明输入流
        InputStream is = null;
        try {
            is = new FileInputStream(f);
            int i = 0;//记录保存每次读取到的内容长度
            byte bs[] = new byte[1024];//存储每次读取到的内容
            while ((i = is.read(bs))!=-1){
                //把字节数组转换为可以输出的字符串
                String str = new String(bs,0,i);
                //str = new String(str.getBytes("ios-8859-1","utf-8"));//文件内容出现乱码可用
                System.out.println(str);
            }
            if(is != null){
                is.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

//输出到文件001.txt
    public static void fileOutput(File f){

        System.out.println("执行输出。。。。。");
        OutputStream os = null;
        try {
            os = new FileOutputStream(f,true);//默认是覆盖，true——说明是追加

            String str = "\n这里是要输出的内容，1234,hellh!";

            os.write(str.getBytes());
            if (os != null){
                os.close();
            }
            System.out.println("执行输出。。。。。");

        }catch (Exception e){e.printStackTrace();}
    }
}

字符流

字符输入流/输出流

• 字符流（ 16位）
• File、Object
• reader、writer

文件字符流输入/输出流

• FileReader、BufferReader
• FileWriter、BufferWriter

import java.io.*;

/**
 * 字符的输入输出流
 */
public class Test02 {
    public static void main(String[] args) {
        File file = new File("F:/file/001.txt");
//        fileReader(file);
        fileWriter(file);
    }

    /**
     * 文件读取流
     */
    public static void fileReader(File file){
        FileReader fr = null;
        //缓冲流
        BufferedReader br = null;

        try {
           fr = new FileReader(file);
           br = new BufferedReader(fr);

           String str = "";
           while ((str = br.readLine()) != null){
               System.out.println(str);
           }

           if (br != null)br.close();
           if (fr != null)fr.close();
        }catch (Exception e){e.printStackTrace();}
    }

    /**
     * 文件字符写入流
     * @param file
     */
    public static void fileWriter(File file){
        System.out.println("开始写入！");
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw = new FileWriter(file,true);
            bw = new BufferedWriter(fw);
            String str = "hjksahh b";

            bw.newLine();//写入新的一行
            bw.write(str);
            bw.flush();//刷新,回到新的状态


            if (bw!=null)bw.close();
            if (fw!=null)fw.close();

            System.out.println("输出完成！");
        }catch (Exception e){e.printStackTrace();}
    }
}

字节流与字符流区别

• 1、读写单位的不同：字节流以字节（8bit）为单位，字符流与字符（16bit）为单位。
• 2、处理对象不同：字节流所有数据都可以处理（图片，视频，音频）（只要不输出） 字符流只能处理字符类数据（txt）(读取文本快，不易产生乱码)
• 3、处理数据大小：字节8位二进制，字符流16位二进制

对象流

就是一个对对象序列化与反序列化的过程

  序列化：把对象转换为字节序列的过程
      1）、持久化（内存转换到硬盘）
      2）、网络传输
      3）、writeObject
  反序列化：把字节序列转换成对象的过程
      1）、对象输入流
      2）、readObject

对象字节输入/输出流

• ObjectInputStream
• ObjectOutputStream

import java.io.*;
import java.util.LinkedList;
import java.util.List;

/**
 * java的IO 对象流输入输出流
 */
public class Test01 {
    public static void main(String[] args) throws Exception{
        String path="F:/file/student.txt";
        File file = new File(path);

        method(file);
        Thread.sleep(1000);
        method01(file);
    }

    /**
     * ObjectOutputStream
     * FileOutputStream
     */
    public static void method(File file){
        System.out.println("开始执行。。。。");
        ObjectOutputStream oos = null;
        OutputStream os = null;
        try {
            os = new FileOutputStream(file,false);
            oos = new ObjectOutputStream(os);

            Student s = new Student("sad",45,'男');
            Student s1 = new Student("sad1",4,'女');
            Student s2 = new Student("sad2",43,'女');
            Student s3 = new Student("sad3",445,'男');
            List<Student> list = new LinkedList<>();
            list.add(s);list.add(s1);list.add(s2);list.add(s3);
            oos.writeObject(list);
            oos.flush();
            if (oos != null)oos.close();
            if(os != null)os.close();

            System.out.println("执行完成、、、、");
        }catch (Exception e){e.printStackTrace();}
    }

    /**
     * ObjectInoutStream
     * InputStream
     */
    public static void method01(File file){
        ObjectInputStream ois = null;
        InputStream is = null;
        try {
            is = new FileInputStream(file);
            ois = new ObjectInputStream(is);

           List<Student> s = ( List<Student>) ois.readObject();
           for(Student student : s ){
               System.out.println("反序列化内容！"+student);

           }

            if (ois != null)ois.close();
            if (is != null)is.close();
        }catch (Exception e){e.printStackTrace();}
    }
}
class Student implements Serializable {
    //序列化ID
    private static final long serialVersionUID = -123456789;
    private String name;
    private int age;
    private char sex;

    public Student() {}

    public Student(String name, int age, char 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 char getSex() {
        return sex;
    }

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

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

属性类properties

该类主要是用于对配置文件的读取，与键值对的方式存在，类似于Map集合（name-String，value-String）

    properties类是继承Hashtable
       1.getProperty(String name):通过名称获取对应的value
       2.load(InputStream inStream),从输入流中读取属性列表
       3.setProperty(String name,String value) 通过name设置value
       4.store(OutputStream out,String comments)把属性列表写出到properties
         文件中，comments表示文件注解#
       5.clear() 清除所有装载的数据

import Util.FileUtil;

import java.io.*;
import java.util.Properties;

/*
java的属性类Properties
 */
public class Test02 {

    public static void main(String[] args) throws InterruptedException {
        method01();
    }
    public static void method01() throws InterruptedException {

        String str = "F:/file3/test.properties";
        File f = new File(str);
        FileUtil.createFile(f);

        Properties pro = new Properties();

        //键值对的方式进行赋值
        pro.setProperty("url","jdbc:mysql:/localhost:3306/xx");
        pro.setProperty("driver","jdbc.mysql.sj");
        pro.setProperty("username","root");
        pro.setProperty("password","root");
        storePro(f,pro);

        Thread.sleep(1000);
        pro = loadPro(f);

        //取值,keySet中是Object类型
        for (Object key : pro.keySet()){
            Object value = pro.get(key);
            String val = pro.getProperty(key + "");
            System.out.println("name = " + key + ",value=" + value);
        }
    }

    /**
     * 输出属性内容
     * @param file
     * @param properties
     */

    public static void storePro(File file,Properties properties){
        System.out.println("属性内容执行--------");
        OutputStream os = null;
        try {
            os = new FileOutputStream(file,false);

            properties.store(os,"mysql connection");

            if (os != null) os.close();
            System.out.println("完成属性内容的输出--------");

        }catch (Exception e){e.printStackTrace();}
    }

    /**
     * 读取属性文件
     * @param file
     * @return
     */
    public static Properties loadPro(File file){
        InputStream is = null;
        try {
            is = new FileInputStream(file);

            Properties properties = new Properties();
            properties.load(is);


            if (is != null) is.close();

            return  properties;
        }catch (Exception e){e.printStackTrace();}

        return null;
    }

    public static void  method202(){
        //框架中读取方式
       InputStream in = Test02.class.getResourceAsStream("F:/file3/test.properties");
    }
}