1.File类:

java.io.File
文件和目录路径名的抽象表示形式,与系统无关,任何系统都可以使用
file:文件
directory:文件夹/目录
path:路径

static String File.pathSeparator 与系统有关的路径分隔符
static String File.separator 与系统有关默认名称分隔符

操作系统:路径不能写死
"C:/a/a.txt"
"C:"+File.separator+"a"+File.separator+"a.txt"

绝对路径:一个完整的路径(以盘符开始)
相对路径:一个简化的路径(相对于当前项目的根目录)

构造方法:

  a.File(Sring pathname)  通过将给定路径名字符串转换为抽象字符串名创建一个File实例
  b.File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 

File实例

常用方法:

      a.public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串 
      b.public String getPath()         返回构造方法中传递的路径
      c.public String getName()         返回构造方法传递的文件或目录的名字
      d.public long length()            返回构造方法中文件的大小,以字节展示

判断功能的方法:
a.public boolean exists() 表示构造方法中的文件目录是否真实存在
b.public boolean isDirectory() 判断是否为目录
c.public boolean isFile() 判断是否为文件

创建删除功能的方法:

  a.public boolean creatNewFile() 当具有该名称的文件不存在时,自动创建新文件
  b.public boolean delete()       删除由此flie表示的文件目录
  c.public boolean mkdir()        创建由file表示的目录
  d.public boolean mkdir()        创建由file表示的目录,包括任何必须但不存在的子目录

遍历目录的方法:
a.public String[] list() 返回一个String数组,表示该file目录中的文件目录
b.public File[] listFiles() 返回一个File数组,表示该File目录中的文件和目录(带路径)

2.递归

指在当前方法中调用自己的现象
直接递归:方法自身调用自己
间接递归:A方法调用B方法,B方法调用C方法,C方法调用A方法

注意事项:
递归要有一定的条件限制,保证递归能停止下来,否则会发生栈内存溢出
递归次数不能太多,否则会发生栈内存溢出
构造方法禁止递归操作

使用递归计算阶乘:

  public class DemoResouris1 {
    public static void main(String[] args) {
        int s = sum(5);
        System.out.println(s);
    }

    private static int sum(int n) {
        if (n==1)
        {
            return 1;
        }
        return n * sum(n-1);
    }
  }

使用递归遍历文件夹:

  import java.io.File;
  public class DemoResouris2 {
    public static void main(String[] args) {
        File f = new File("E:\\abc");//想要遍历的主目录
        a(f);
    }

    private static void a(File f) {
        File[] fi = f.listFiles();
        for (File file:fi
             ) {
            if (file.isDirectory()==true)
            {
                a(file);
            }
            System.out.println(file);
        }
    }
  }

3.FileFilter过滤器

java.io.FileFilter接口:用于抽象路径名的过滤器
作用:用于过滤文件
方法:boolean accept(File pathname) 测试指定抽象路径是否包含在某个路径名列表中
java.io.FilenameFilter接口:用于过滤文件名称
方法:boolean accept (File directory,String name) 测试指定文件是否在文件列表中
注意:过滤器均无实现类需要自己写
例:

      public class DemoResouris2 {
        public static void main(String[] args) {
            File f = new File("E:\\abc");//想要遍历的主目录
            a(f);
        }

    private static void a(File f) {
        File[] fi = f.listFiles((File dir,String name)->{
            return new File(dir,name).isDirectory()||new File(dir,name ).getName().toLowerCase().endsWith("");
        });
        for (File file:fi
             ) {
            if (file.isDirectory() == true) {
                a(file);
            } else {
                System.out.println(file);
            }
        }
    }
  }

4.IO字节流

流数据(字符,字节) 1个字符=2个字节 1个字节=8个二进制

字节流:输入流:InputStream 输出流:OutputStream
一切文件都是字节组成的
字符流:输入流:Reader 输出流:Writer

java.io.OutputStream:此抽象类是表示输出字节流的所有类的超类
public void close() 关闭此输出并释放与此流相关联的任何系统资源
public void flush() 刷新此输出流并强制任何缓冲的输出字符被写出
public void write(byte[] b) 将b.length字节从指定的字节数组写入此输出流
public void write(byte[] b,int off,int len)从指定的字节数组写入len字节,从偏移量off开始输出到此输出流
public abstract void write(int b) 将指定的字节输出流

java.io.FileOutputStream extends OutputStream
文件字节输出流
作用:把内存中的数据写入到硬盘文件中
构造方法:
FileOutputStream(Sring name)创建一个向具有指定名称的文件中写入数据的文件流
FileOutputStream(File file)创建一个向指定文件中写入数据的文件流
参数:写入数据的目的
String name:目的地是一个文件的路径
File file:目的地是一个文件

写入数据的原理(内存-->硬盘)
java程序-->JVM(Java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中

字节输出流的使用步骤:
a.创建一个FileOutputStream对象,构造方法中传入写入数据的目的
b.调用write方法,把数据写入到文件中
c.释放资源
写多个字节的方法;
public void write(byte[] b):将b.length字节从指定数组写入到输出流
如果第一个字节是正数,那么显示的时候会查询ASCII表
如果第一个字节是负数,那第一个字节和第二个字节组成一个中文显示
写入字符的方法:使用string类中的方法把字符串转换为字节数组
byte [] getBytes() 把字符串转换为字符数组
追加续写:使用两个参数的构造方法
FileOutputStream(String name,boolean append) 创建一个向具有指定名称的文件中写入数据的文件流
FileOutputStream(File file,boolean append) 创建一个向指定文件中写入数据的文件流
参数:boolean append:追加写开关
true:不会覆盖原文件,在末尾追加
false:创建一个新文件,覆盖原文件
例:

import java.io.FileOutputStream;
import java.io.IOException;
public class FileWriteDemo {
public static void main(String[] args) throws IOException {
FileOutputStream file = new FileOutputStream("E://abc.txt",false);
file.write(48);
file.write("Java,我爱你".getBytes());
file.close();
}
}

java.io.InputStream:字节输入流
int read()从输入流中读取数据的下一个字节
int read(byte [] b)从输入流中读取一定数量的字节,并将其储存在缓冲区数组B中
void close()关闭此输入流并释放与其关联的所有系统资源
java.io.FileInputStream extends InputStream
把硬盘文件中的数据,读取到内存中使用
构造方法:
FileInputStream(String name)
FileInputStream(File file)
读取数据的原理(硬盘-->内存)
java程序-->JVM-->OS-->OS读取数据的方法-->读取文件

   使用步骤:
   创建一个FileInputStream对象,绑定数据源
   使用FileInputStream对象中的read方法读取文件
   释放资源

   read()一次只能读取一个字节,读取到末尾是输出-1

使用read一次读取多个字节
byte [] b将多个字节储存到字节数组中

例:

  import java.io.FileInputStream;
  import java.io.IOException;
  import java.util.Arrays;
  public class ReadFileDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream file = new FileInputStream("E://abc.txt");
        //一次读取一个字节
        int i = file.read();
        System.out.println(i);
        //一次读取多个字节
        byte [] bytes = new byte [2];
        int read = file.read(bytes);
        System.out.println(Arrays.toString(bytes));
        //释放资源
        file.close();
    }
  }

文件复制:一读一写
例:

  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  public class FileCopyDemo {

    public static void main(String[] args) throws IOException {
        //创建一个输入流对象
        FileInputStream fls = new FileInputStream("C:\\Users\\双g\\Downloads\\gost.jpg");
        //创建一个输出流对象
        FileOutputStream file = new FileOutputStream("E:\\gost.jpg");
        int len = 0;
        //创建循环条件
        while ((len=fls.read())!=-1)
        {
            //写入数据
            file.write(len);
        }
        //关闭资源(写入先关闭,读取后关闭)
        file.close();
        fls.close();

        //使用byte优化速度
        //毫秒时间
        long s = System.currentTimeMillis();
        //创建一个输入对象
        FileInputStream file1 = new FileInputStream("C:\\Users\\双g\\Downloads\\ChromeSetup.exe");
        //创建一个输出对象
        FileOutputStream file2 = new FileOutputStream("E:\\ChromeSetup.exe");
        int len1 = 0;
        //初始化数组
        byte [] bytes = new byte[10000];
        while ((len=file1.read(bytes))!=-1){
            //写入数据
            file2.write(bytes);
        }
        //释放资源
        file2.close();
        file1.close();
        long e = System.currentTimeMillis();
        System.out.println("复制文件用时:"+(e-s)+"毫秒");
    }
  }

5.IO字符流

字符输入流Reader
int read()读取单个字符并返回
int read(char [] c)一次读取多个字符并存入数组
void close() 释放资源

java.io.FileReader extends InputStreamReader extends Reader
把硬盘中的数据以字符的方式读取到内存中
构造方法:
FileReader(String filename)
FileReader(File file)

字符输入流使用步骤
创建FileReader对象,绑定数据源
使用read方法读取文件
释放资源

例:

    import java.io.FileReader;
    import java.io.IOException;
    public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建一个数据源
        FileReader f = new FileReader("E:\\abc.txt");
        //read方法读取一个字符
        int len = 0;
        while ((len=f.read())!=-1){
            System.out.print((char)len);
        }
        //释放资源
        //read方法读取多个字符
        char [] c = new char[1024];
        int len1 = 0;
        while ((len1 = f.read(c))!=-1){
            /*
            String(char[] value)将字符数组转换为字符串
            String(char[] value ,开始位置,有效个数)
             */
            System.out.print(new String(c,0,len1));
        }
        f.close();
    }
   }

字符输出流Writer
void close() 关闭流,先刷新。
void flush() 刷新流
void write(char[] cbuf) 写入一个字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String str) 写一个字符串
void write(String str, int off, int len) 写一个字符串的一部分。

java.io.FileWriter extends OutputStreamWriter extends Writer
把内存中的字符写入到文件中
使用步骤:
创建FileWriter对象,绑定目的地
使用writer方法,把数据写入到内存缓冲区
使用flush方法把缓冲区的数据刷新到文件中(close方法也能实现)
close()把数据刷新到文件并释放资源

  追加续写:与字节流一样
  换行符号:
       Windows:\r\n
       Linux:/n
       mac:/r 

例:

import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
    FileWriter writer = new FileWriter("E:\\bcd.txt",true);
    writer.write("\r\n"+"内蒙古农业大学!");
    writer.close();
}
}

使用try catch处理异常

  import java.io.IOException;
  import java.io.FileWriter;
  public class FileWriterDemo {
    public static void main(String[] args){
        FileWriter writer = null;
        try {
            writer= new FileWriter("E:\\bcd.txt",true);
            writer.write("\r\n"+"内蒙古农业大学!");

        }catch (IOException e){
            System.out.println(e);
        }finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
  }

6.Properties集合存储数据
java.util.properties extends Hashtable<k,v> implements Map<k,v>
Properties集合是一个唯一与IO流结合的集合
Properties集合是一个双列集合,key和value默认都是字符串
特有方法:
Object setProperty(String key,String value)调用Hashtable方法put
String getProperty(String key)通过key找到value值,相当于Map集合的get(key).
Set stringPropertyNames()返回此属性列表里的键值,其中该键和对应值是字符串,相当于Map集合的get集合中KeySet方法

使用store方法,把集合中的临时数据,持久化写入到硬盘储存中。
void store(OutputStream out,String comments)
void store(Writer write,String comments)
参数:
OutputStream out:字节输出流,不能写入中文
Writer write:字符输出流,可以写中文
String comments:注释,用来解释说明保存的文件是做什么用的,不能使用中文
使用步骤:
创建Properties集合对象,添加数据
创建字节输出流/字符输出流对象,构造方法中绑定输出的目的地
使用Properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘储存中
释放资源
例:

  import java.io.IOException;
  import java.util.Properties;
  import java.io.FileWriter;
  public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        show();
    }

    private static void show() throws IOException {
        Properties pro = new Properties();
        pro.setProperty("zhangwuji","12");
        pro.setProperty("zhaomin", "13");
        pro.setProperty("zhouzhiruo", "14");

        FileWriter fw = new FileWriter("D:\\IntelliJ IDEA 2019.1.3\\Code\\Java_Code\\src\\com\\company\\FileAndIO\\pro.txt");

        pro.store(fw,"save date");
    }
  }  

使用load方法,把键盘中的保存的文件(键对值),读取到集合中使用
void load(Reader reader)字符输入流能读取中文
void load(InputStream inStream)字节输入流不能读取中文
注意:键值对文件,键与值默认连接符号可以用'='或空格
键值对文件,可以使用#号进行注释,不会对读取
键值对文件,键与值都是字符串不需要引号
使用步骤:
创建Properties集合对象
使用load方法读取文件
遍历Properties集合
例:

  import java.io.FileReader;
  import java.io.IOException;
  import java.util.Properties;
  import java.util.Set;
  public class LoadDemo {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();

        properties.load(new FileReader("D:\\IntelliJ IDEA 2019.1.3\\Code\\Java_Code\\src\\com\\company\\FileAndIO\\pro.txt"));

        Set<String> set = properties.stringPropertyNames();

        for (String key : set) {
            String s = properties.getProperty(key);
            System.out.println(key+"="+s);
        }
    }
  }

7.Buffered缓冲流

作用:提升读写速率
原理:把内容存入数组,通过数组进行传递
字节缓冲输出流:
java.io.BufferedOutputStream extends OutputStream
继承父类的所有方法
构造方法:
BufferedOutputStream(outStream out)创建一个新的缓冲输出流,将数据写入底层输出流
BufferedOutputStream(outStream out,int size)创建一个新的缓冲输出流,将具有指定缓存大小的数据写入指定的底层输出流
参数:
OutputStream out:字节输出流
int size:指定缓冲流内部缓冲区的大小,不指定默认
使用步骤:
创建一个FileOutputStream对象,构造方法绑定输出目的
创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象,提高FileOutputStream对消效率
使用BufferedOutputStream对象中方法write,把数据写入内部缓冲区
使用BufferedOutputStream对象中方法flush,把内部缓冲区中的数据,刷新到文件中
释放资源(先调用flush,再调用close)
例:

  import java.io.BufferedOutputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  public class BufferedDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream file = new FileOutputStream("D:\\IntelliJ IDEA 2019.1.3\\Code\\Java_Code\\src\\cc\\sgee\\FileAndIO\\buffer.txt");

        BufferedOutputStream bf = new BufferedOutputStream(file);

        bf.write(97);

        bf.close();
    }
  }

字节缓冲输入流:

java.io.BufferedInputStream extends InputStream
继承父类所有方法
构造方法:
BufferedInputStream(InputStream in)创建一个BufferedInputStream并保存参数in
BufferedInputStream(InputStream in,int size)创建指定缓冲区大小的BufferedInputStream
参数:
InputStream in:字节输入流
我们可以传递FileInputStream,缓冲流会给FileInputStream增加一个缓冲区,提高读取效率
int size:指定缓冲流内部缓冲区的大小
使用步骤:
创建FileInputStream对象,构造方法中指定要读取的数据源
创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高读取效率
使用方法read,读取文件
释放资源
例:

  import java.io.BufferedInputStream;
  import java.io.FileInputStream;
  import java.io.IOException;
  public class BufferedInputStreamDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fl = new FileInputStream("D:\\IntelliJ IDEA 2019.1.3\\Code\\Java_Code\\src\\cc\\sgee\\FileAndIO\\buffer.txt");

        BufferedInputStream bis = new BufferedInputStream(fl);

        int i = bis.read();

        System.out.println(i);

        fl.close();
    }
  }

字符缓冲输出流:

java.io.BufferedWriter extends Writer
继承父类的所有方法
构造方法:
BufferedWriter(Writer out)创建一个使用默认大小输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out,int size)创建一个使用给定大小输出缓冲区的新缓冲字符输出流
参数:
writer out:字符输出流
int size:指定缓冲区大小,不写默认大小
void newLine()换行符号
使用步骤:
创建字符输出流对象,构造方法中传递字符输出流
调用方法write,把数据写入内存缓存区
调用flush方法,把数据刷新到文件中
释放资源
例:

  import java.io.FileWriter;
  import java.io.BufferedWriter;
  import java.io.IOException;
  public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        BufferedWriter bf =new BufferedWriter(new FileWriter("D:\\IntelliJ IDEA 2019.1.3\\Code\\Java_Code\\src\\cc\\sgee\\FileAndIO\\Writer.txt"));
        for (int i = 0; i <10 ; i++) {
            bf.write("Java,我爱你!");
            bf.newLine();
        }
        bf.close();
    }
  }

字符缓冲输入流:

java.io.BufferedReader extends Reader
继承父类所有方法
构造方法:
BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz)创建使用指定大小的输入缓冲区的缓冲字符输入流。
特有的成员方法:
String readLine()读取一个文本行,读取一行数据
行的终止符号:读一行文字。 一行被视为由换行符('\ n'),回车符('\ r')中的任何一个或随后的换行符终止。
返回值:
包含行的内容的字符串,不包括任何行终止字符,如果已达到流的末尾,则为null
使用步骤:
创建字符缓冲输入流对象,构造方法中传递字符输入流
使用read或readLine读取文本
释放资源
例:

  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.IOException;
  public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new FileReader("D:\\IntelliJ IDEA 2019.1.3\\Code\\Java_Code\\src\\cc\\sgee\\FileAndIO\\Writer.txt"));

        String s;
        while ((s=bf.readLine())!=null){
            System.out.println(s);
        }

    }
  }
Last modification:May 29th, 2020 at 01:42 pm
如果觉得我的文章对你有用,请随意赞赏