Day_Java

一.File类

I/O流可以对文件的内容进行操作，但对文件本身的一些常规操作无法通过I/O流实现，如文件的创建、删除、重命名等操作，判断硬盘上某个文件是否存在等操作，为此JDK在java.io包下提供了一个FIle类，该类封装了一个路径，并提供了一系列方法：
1.常用构造方法

File file = new File("File.txt");//相对路径（相对于当前module）
System.out.println(file);//File.txt
File file1 = new File("E:\java\javaSenior\Day_08\hello.txt");//绝对路径：从计算机盘符开始
System.out.println(file1);//E:javajavaSeniorDay_08hello.txt
File file2 = new File("E:\java\javaSenior", "Day_08");
System.out.println(file2);//E:javajavaSeniorDay_08
File file3 = new File(file2, "java.txt");
System.out.println(file3);//E:javajavaSeniorDay_08java.txt

路径分隔符：在java中" “需要转译，因此java程序中表示路径会多出来一个” "。

2.常用方法
（1）File类的获取功能

@Test
//File类的获取功能--->常见方法
public void test01(){
    File file = new File("hello.txt");
    File file1 = new File("E:\java\javaSenior\he.txt");
    System.out.println(file.getAbsoluteFile());//public String getAbsoluteFile()：获取绝对名称
    System.out.println(file.getAbsolutePath());//public String getAbsolutePath()：获取绝对路径
    System.out.println(file.getPath());//public String getPath()：获取相对路径
    System.out.println(file.getParent());//public String getParent()：获取上层目录路径，若无，返回null
    System.out.println(file.getName());//public String getName()：获取名称
    System.out.println(new Date(file.lastModified()));//public long lastModified()：获取最近修改的时间
    System.out.println(file.length());//public long length()：获取文件长度（返回字节数)
    System.out.println("**********************************");
    System.out.println(file1.getAbsoluteFile());//public String getAbsoluteFile()：获取绝对名称
    System.out.println(file1.getAbsolutePath());//public String getAbsolutePath()：获取绝对路径
    System.out.println(file1.getPath());//public String getPath()：获取相对路径
    System.out.println(file1.getParent());//public String getParent()：获取上层目录路径，若无，返回null
    System.out.println(file1.getName());//public String getName()：获取名称
    System.out.println(new Date(file1.lastModified()));//public long lastModified()：获取最近修改的时间
    System.out.println(file1.length());//public long length()：获取文件长度（返回字节数)
    File file2 = new File("E:\java\javaSenior");
    String[] list = file2.list();//public String[] list：获取指定目录下的所有文件或者文件目录的名称数组
    for(String s : list){
        System.out.println(s);
    }
    System.out.println("---------------------------------");
    File[] files = file2.listFiles();//public File[] listFiles：获取指定目录下的所有文件或者文件目录的File数组
    for(File f : files){
        System.out.println(f);
    }
}

（2）File的重命名功能

@Test
//File的重命名功能，执行完以后，dest文件被创建，内容是file文件的内容，file文件本身被删除
public void test02(){
    File file = new File("E:\java\javaSenior\hello.txt");
    File file1 = new File("E:\JAVA EE\java.txt");
    //public boolean renameTo(File dest)：把文件重命名为指定的文件路径，想返回true，文件fiel存在，dest文件不存在
    boolean b = file.renameTo(file1);
    System.out.println(b);
}

（3）File的判断功能

@Test
//File类的判断功能
public void test03(){
    File file = new File("E:\JAVA EE\java.txt");
    System.out.println(file.exists());//public boolean exits()：文件/目录是否存在
    System.out.println(file.isFile());//public boolean isFile()：文件/目录是否是文件
    System.out.println(file.isDirectory());//public boolean isDirectory()：文件/目录是否是目录
    System.out.println(file.canRead());//public boolean canRead()：文件/目录是否可读
    System.out.println(file.canWrite());//public boolean canWrite()：文件/目录是否可写
    System.out.println(file.isHidden());//public boolean isHidden()：文件/目录是否隐藏
}

（4）File类的创建、删除功能

@Test//文件的创建和删除
public void test04() throws IOException {
    File file = new File("E:\JAVA EE\java_EE.txt");
    if(file.exists()){
        file.delete();//public boolean delete()：删除文件（不经过回收站）
        System.out.println("创建时文件存在，已被删除...");
    }else{
        file.createNewFile();//public boolean createNewFile()：创建文件
        System.out.println("创建时文件不存在，现已创建...");
    }
}

@Test//创建文件目录
public void test05(){
    File file = new File("E:\JAVA EE\IeaProjeect\11\22");
    boolean mkdir = file.mkdir();//public boolean mkdir()：创建单层文件目录（只创建一层情况）
    if(mkdir){
        System.out.println("mkdir创建成功...");
    }
    boolean mkdirs = file.mkdirs();//public boolean mkdirs()：创建多层文件目录
    if(mkdirs){
        System.out.println("mkdirs创建成功...");
    }
}

注意：创建时文件的路径会因为是单元测试（以当前module为准）或main()方法（以project为准）而不同。

public class FileReaderTest {
    public static void main(String[] args) {//main()方法是相对于整个项目而言的
        File file = new File("Day_09\Hello.txt");//
        System.out.println(file.getAbsolutePath());//E:javajavaSeniorDay_09Hello.txt
        File file1 = new File("Hello.txt");
        System.out.println(file1.getAbsolutePath());//E:javajavaSeniorHello.txt
    }
    @Test
    public void test01(){//单元测试是相对于module而言的
        File file = new File("Hello.txt");
        System.out.println(file.getAbsolutePath());
    }
}

二.I/O流

I/O流（Input/Output）流，即输入输出流，是Java中输入输出的基础，用于处理设备之间的数据传输。如：读/写文件，网络通讯等。

对于文本文件（.txt，.java，.c，.cpp等），使用字符流处理。文本文件的复制也可使用字节流。
对于非文本文件（.jpg，.mp3 ，.mp4，.avi，.doc , .ppt等），使用字节流处理。

三.字符流的使用

1.FileReader字符流读入数据
读入时的目标文件必须创建，不存在时会报错。

@Test
//FileReader读入数据
public void test01(){//单元测试是相对于module而言的
    //1.实例化需要操作的的文件对象
    File file = new File("Hello.txt");
    FileReader fileReader = null;
    try{//选择try-catch捕获异常而不是抛出异常，原因是若因为异常导致程序异常终止，文件相关的流操作没有关闭会浪费JVM内存资源
        //2.指定操作文件的流的实例化
        fileReader = new FileReader(file);
        //3.读入数据
        int len = 0;
        while ((len = fileReader.read())!=-1){//read()读取至数据末尾时返回-1
            System.out.print((char)len);
        }
    }catch (Exception e){
        System.out.println(e.getMessage());
    }finally {
        if(fileReader!=null){
            try {
                //4.关闭流
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

以上操作效率太低，对该方法改进如下：

@Test
//FileReader读入数据改进
public void test02() {
    File file = new File("Hello.txt");
    FileReader fileReader = null;
    try{//选择try-catch捕获异常而不是抛出异常，原因是若因为异常导致程序异常终止，文件相关的流操作没有关闭会浪费JVM内存资源
        fileReader = new FileReader(file);
        //read(char[] cbuff)：返回每次读入cbuff中的字符个数。
        char[] buffer = new char[1024];
        int len = 0;
        while((len=fileReader.read(buffer))!=-1){//read()读取至数据末尾时返回-1
            //方式1
            for(int i=0;i 
2.FileWirter字符流写出数据
 写出时的目标文件不存在也可以，会自动创建。 
@Test
public void test03(){
    //1.创建File对象指明要操作的文件
    File file = new File("HelloWorld.txt");
    //2.创建FileWriter对象
    FileWriter fileWriter = null;
    try{//选择try-catch捕获异常而不是抛出异常，原因是若因为异常导致程序异常终止，文件相关的流操作没有关闭会浪费JVM内存资源
        fileWriter = new FileWriter(file,true);//true表示追加操作，false表示覆盖
        //3.写入数据
        fileWriter.write("I have a dream!n");
        fileWriter.write(97);
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        //4.关闭流
        if(fileWriter!=null){
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 
3.FileWriter和FileReader实现文件的复制操作 
@Test
public void copytest(){
	//1.创建需要操作的文件
    File file = new File("HelloWorld.txt");
    File file1 = new File("copyHelloWorld.txt");
    //2.创建FileReader和FileWriter读写对象
    FileWriter fw = null;
    FileReader fr = null;
    try{
        fw = new FileWriter(file1);
        fr = new FileReader(file);
         //3.先读取数据，后写入数据
        char[] cbuffer = new char[1024];
        int len = 0;
        while((len = fr.read(cbuffer))!=-1){//read()读取至数据末尾时返回-1
            fw.write(cbuffer,0,len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
    //4.关闭对应的流（顺序不管）
        try{
            fw.close();
        }catch (IOException e){
            e.printStackTrace();
        }
//            finally//方式2：写在finally中也对
//            {
            try{
                fr.close();
            }catch (IOException e){
                e.printStackTrace();
            }
//            }
    }
}
 
四.字节流的使用 
使用FileInputStream和FileOutputStream实现非文本的复制： 
@Test
public void test03() {
    String file1 = "C:\Users\Administrator\Desktop\面向对象\代理模式.png";
    String file2 = "C:\Users\Administrator\Desktop\面向对象\代理模式1.png";
    long start = System.currentTimeMillis();
    InputOutputStreamCopy(file1,file2);
    long end = System.currentTimeMillis();
    System.out.println("复制用时："+(end-start));
}
//InputOutputStreamCopy(String file1, String file2)：文件的复制操作（可以是文本或非文本的文件）
public void InputOutputStreamCopy(String file1, String file2){
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try{
        fis = new FileInputStream(file1);
        fos = new FileOutputStream(file2);
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len=fis.read(bytes))!=-1){//read()读取至数据末尾时返回-1
            fos.write(bytes,0,len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        try{
            fos.close();
        }catch (IOException e){
            e.printStackTrace();
        }
        try{
            fis.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}
 
五.缓冲流的使用 

 
 字节流、字符流的操作效率不高，缓冲流可以提高对文件读取、写入的速度。
 原因：内部提供了一个缓冲区，大小为8192bit。
 BufferedOutputStream和BufferedWriter还有个flush()方法，执行此方法，缓冲区的内容将被清空。
 1.字节缓冲流实现文件的复制操作 
@Test
public void test03(){
    String file = "E:\java\javaSenior\Day_09\HelloWorld.txt";
    String file1 = "E:\java\javaSenior\Day_09\HelloWorld03.txt";
    long start = System.currentTimeMillis();
    copyWithBuffer(file,file1);
    long end = System.currentTimeMillis();
    System.out.println("复制用时："+(end-start));
}
public void copyWithBuffer(String file1, String file2){
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
    try{
        //2.创建流
        //2.1创建字节流
        FileInputStream fis  = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);
        //2.2创建缓冲流
        bis = new BufferedInputStream(fis);
        bos = new BufferedOutputStream(fos);
        //3.实现复制操作
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len=bis.read(bytes))!=-1){//read()读取至数据末尾时返回-1
            bos.write(bytes,0,len);
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {//关闭外层流时内层流也会默认关闭
        if(bos!=null){
            try{
                bos.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        if(bis!=null){
            try{
                bis.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}
 
2.字符缓冲流实现文件的复制
 里面有一个特有的readLine()方法（不换行），newline()可用于换行。 
@Test
//字符缓冲流实现文件的复制
public void test01(){
    BufferedReader br = null;
    BufferedWriter bw = null;
    try{
        br = new BufferedReader(new FileReader(new File("E:\java\javaSenior\Day_09\壁纸.jpg")));
        bw = new BufferedWriter(new FileWriter(new File("E:\java\javaSenior\Day_09\壁纸02.jpg")));
        int len = 0;
        //方式1：使用字符数组
//        char[] buffer = new char[1024];
//        while ((len = br.read(buffer))!=-1){//read()读取至数据末尾时返回-1
//            bw.write(buffer,0,len);
//        }
        //方式2：使用String
        String data;
        while ((data=br.readLine())!=null){//readLine()读到文件末尾时返回null,默认不换行输出
            bw.write(data+"n");//方式1换行
            bw.write(data);
//            bw.newline();//方式2换行
        }
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        if(bw!=null){
            try{
                bw.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        if(br!=null){
            try{
                bw.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}
 
六.转换流 

 
 转换流属于字符流。目的是提供字节流和字符流的转换。
 InputStreamReader：将一个字节输入流转换为字符输入流
 OutputStreamWriter：将一个字节输出流转换为字符输出流
 解码：字节、字节数组—>字符串、字符数组
 编码：字符串、字符数组—>字节、字节数组 
@Test
//字节的输入流转换为字符额输入流
public void test02(){
    //1.创建字节输入流对象
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(new File("E:\java\javaSenior\Day_09\Hello.txt"));
        //2.将字节输入流对象转换为字符输入流对象
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");//此时的编码格式是文件的格式，否则会乱码，在本次测试中，若使用gbk的编码格式，中文就会乱码
        char[] buffer = new char[1024];
        int len;
        while ((len=isr.read(buffer))!=-1){//read()读取至数据末尾时返回-1
            String str = new String(buffer,0,len);
            System.out.println(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fis!=null){
            try{
                fis.close();
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
} 
 
@Test
//转换流实现文件的复制
public void InputStreamReaderTest(){
    InputStreamReader isr = null;
    OutputStreamWriter osw = null;
    try {
        FileInputStream fis = new FileInputStream(new File("E:\java\javaSenior\Day_09\HelloWorld01.txt"));
        FileOutputStream fos = new FileOutputStream(new File("E:\java\javaSenior\Day_09\HelloWorld04.txt"));
        isr = new InputStreamReader(fis,"utf-8");
        osw = new OutputStreamWriter(fos,"utf-8");
        char[] buffer = new char[1024];
        int len ;
        while((len=isr.read(buffer))!=-1){//read()读取至数据末尾时返回-1
            osw.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        if(isr!=null){
            try {
                isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(osw!=null){
            try {
                osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 
七.扩展的I/O流（了解） 
1.标准的输入、输出流
 
 
  
//例题：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。
public class SystemInOutTest {
    public static void main(String[] args) {
        //方式1：使用System.in--->转换流--->BufferedReader的readLine()方法
        
        //方式二：使用Scanner(System.in)
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入字符串：");
            String s = sc.nextLine();
            if("e".equalsIgnoreCase(s) || "exit".equalsIgnoreCase(s)){
                System.out.println("程序运行结束...");
                break;
            }
            String s1 = s.toUpperCase();
            System.out.println(s1);
        }
    }
}
 

 2.打印流（了解）
  
//使用打印流将ASCII码打印在指定的文件中
public class PrintStreamTest {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream(new File("E:\java\javaSenior\Day_09\print.txt"));//文件可以不存在，但是目录必须存在
            PrintStream ps = new PrintStream(fos, true);//创建打印输出流，设置为自动刷新模式
            if(ps!=null){
                System.setOut(ps);//指定打印流
            }
            for(int i = 0; i< 255;i++){
                System.out.print((char)i);//输出ASCII码
                if(i%50==0){
                    System.out.println();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 
3.数据流
 
 作用：用于读取或写出基本数据类型的变量或字符串。 
public class DataOutputTest {
    public static void main(String[] args) {
        //将内存中的数据写入到文件中(此时直接查看会乱码)
        DataOutputStream dos =null;
        try {
            dos = new DataOutputStream(new FileOutputStream("E:\java\javaSenior\Day_09\text.txt"));
            dos.write(25);
            dos.flush();//刷新缓存
            dos.writeBoolean(true);
            dos.flush();
            dos.writeUTF("数据结构");
            dos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //将文件中存储的基本数据类型和字符串赋值给变量并输出
    @Test
    public void test01(){
        DataInputStream dis = null;
        try {
            dis = new DataInputStream(new FileInputStream("E:\java\javaSenior\Day_09\text.txt"));
            int age = dis.read();//读取的顺序和存储的顺序一致，否则会报错
            boolean b = dis.readBoolean();
            String name = dis.readUTF();
            System.out.println(age);
            System.out.println(b);
            System.out.println(name);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(dis!=null){
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
 
编码表

Day

Java相关栏目本月热门文章