JAVA面试基础「建议收藏」

全栈程序员站长

发布于 2022-09-08 10:50:59

9610

发布于 2022-09-08 10:50:59

文章被收录于专栏：全栈程序员必看

大家好，又见面了，我是你们的朋友全栈君。

JAVA面试部分重点内容

五、输入输出流IO流

1.File类的常用方法?

java.io.File，使用该类的构造函数就可以创建文件对象，将硬盘中的一个具体的文件以 Java 对象的形式来表示。

方法	描述
public File(String pathname)	根据路径创建对象（是绝对路径）
public String getName()	获取文件名
public String getParent()	获取文件所在的目录
public File getParentFile()	获取文件所在目录对应的File对象
public String getPath()	获取文件路径
public boolean exists()	判断文件是否存在
public boolean isDirectory()	判断对象是否为目录
public boolean isFile()	判断对象是否为文件
public long length()	获取文件的大小
public boolean createNewFile()	根据当前对象创建新文件
public boolean delete()	删除对象
public boolean mkdir()	根据当前对象创建目录
public boolean renameTo(File file)	为已存在的对象重命名

2.说说IO流?

Input 输入流（将外部文件读入到 Java 程序中）

Output 输出流（将 Java 程序中的数据输出到外部）

Java 中的流有很多种不同的分类。

按照方向分，输入流和输出流
按照单位分，可以分为字节流和 字符流（字节流是指每次处理数据以字节为单位，字符流是指每次处理数据以字符为单位）
按照功能分，可以分为节点流（字节流）和处理流(对节点流进行处理，生成其他类型的流）。

方法定义时的异常如果直接继承自 Exception，实际调用的时候需要手动处理（捕获异常/丢给虚拟机去处理)；方法定义时的异常如果继承自 RuntimeException，调用的时候不需要处理。

3.字节流的常用方法?

InputStream 的常用方法

方法	描述
int read()	以字节为单位读取数据
int read(byte b[])	将数据存入 byte 类型的数组中，返回数组中有效数据的长度
int read(byte b[],int off,int len)	将数据存入 byte 数组的指定区间内，返回数组长度
byte[ ] readAllBytes()	将所有数据存入 byte 数组并返回
int available()	返回当前数据流未读取的数据个数
void close()	关闭数据流

FileInputStream是抽象类InputStream的实现类，构造函数可以接受File实例对象，但要保证文件存在。

OutputStream的常用方法

方法	描述
void write(int b)	以字节为单位输出数据
void write(byte b[ ])	将byte数组中的数据输出
void write(byte b[ ],int off,int len)	将byte数组中指定区间的数据输出
void close()	关闭数据流
void flush()	将缓冲流中的数据同步到输出流中

FileOutputStream是抽象类OutputStream的实现类，构造方法可以接受File实例对象，文件不存在时，会创建文件。

4.说说字符流?

字节流是单位时间内处理一个字节的数据（输入+输出）

字符流是单位时间内处理一个字符的数据（输入+输出）

字符流：

输入字符流 Reader
输出字符流 Writer

Reader是一个抽象类

Closeable接口的作用:及时关闭资源，而不是让GC回收

Readable 接口的作用:可以将数据以字符的形式读入到缓冲区 InputStream(字节输入流) —> Reader（字符输入流）

InputStreamReader 的功能是将字节输入流转换为字符输入流，是处理流

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStream;
import java.io.Reader;

public class Test { 
   
    public static void main(String[] args) throws Exception { 
   
        //字符流
        Reader reader = new FileReader("/Users/southwind/Desktop/test.txt");
        int temp = 0;
        System.out.println("*******字符流读取********");
        while ((temp = reader.read())!=-1){ 
   
            System.out.println(temp);
        }
        reader.close();

        //字节流
        InputStream inputStream = new FileInputStream("/Users/southwind/Desktop/test.txt");
        temp = 0;
        System.out.println("*******字节流读取********");
        while ((temp = inputStream.read())!=-1){ 
   
            System.out.println(temp);
        }
        inputStream.close();
    }
}

import java.io.FileReader;
import java.io.Reader;

public class Test2 { 
   
    public static void main(String[] args) throws Exception { 
   
        Reader reader = new FileReader("/Users/southwind/Desktop/test.txt");
        char[] chars = new char[8];
        int length = reader.read(chars);
        System.out.println("数据流的长度是"+length);
        System.out.println("遍历数组");
        for (char aChar : chars) { 
   
            System.out.println(aChar);
        }

    }
}

read() 返回的是 int ，直接将字符转成字节（1-1，1-3），每次读一个字节。

read(char[ ] chars) 返回的是 char 数组，直接就返回字符个数，不会转成字节的。

read(char[ ] chars, int off, int len)：读len个字符，放到chars数组中off处。

5.说说缓冲流?

论是字节流还是字符流，使用的时候都会频繁访问硬盘，对硬盘是一种损伤，同时效率不高，如何解决？可以使用缓冲流，缓冲流自带缓冲区，可以一次性从硬盘中读取部分数据存入缓冲区，再写入内存，这样就可以有效减少对硬盘的直接访问。

缓冲流属于处理流，如何来区分节点流和处理流？

1、节点流使用的时候可以直接对接到文件对象 File

2、处理流使用的时候不可以直接对接到文件对象 File，必须要建立在字节流的基础上才能创建。

缓冲流又可以分为字节缓冲流和字符缓冲流，按照方向再细分，又可以分为字节输入缓冲流和字节输出缓冲流，以及字符输入缓冲流和字符输出缓冲流。

字节输⼊缓冲流

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;

public class Test { 
   
    public static void main(String[] args) throws Exception { 
   
        //1、创建节点流
        InputStream inputStream = new FileInputStream("/Users/southwind/Desktop/test.txt");
        //2、创建缓冲流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
// int temp = 0;
// while ((temp = bufferedInputStream.read())!=-1){ 
   
// System.out.println(temp);
// }

        byte[] bytes = new byte[1024];
        int length = bufferedInputStream.read(bytes,10,10);
        System.out.println(length);
        for (byte aByte : bytes) { 
   
            System.out.println(aByte);
        }

        bufferedInputStream.close();
        inputStream.close();
    }
}

字符输⼊缓冲流 readLine ⽅法

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.Reader;字节输出缓冲流
public class Test2 { 
   
 public static void main(String[] args) throws
Exception { 
   
 //1、创建字符流（节点流）
 Reader reader = new
FileReader("/Users/southwind/Desktop/test.txt");
 //2、创建缓冲流（处理流）
 BufferedReader bufferedReader = new
BufferedReader(reader);
 String str = null;
 int num = 0;
 System.out.println("***start***");
 while ((str =
bufferedReader.readLine())!=null){ 
   
 System.out.println(str);
 num++;
 }
 System.out.println("***end***,共读取
了"+num+"次");
 bufferedReader.close();
 reader.close();
 }
}

字节输出缓冲流

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;字符输出缓冲流
public class Test { 
   
 public static void main(String[] args) throws
Exception { 
   
 OutputStream outputStream = new
FileOutputStream("/Users/southwind/Desktop/test2.txt
");
 BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(outputStream);
 String str = "由于在开发Oak语⾔时，尚且不存在运⾏
字节码的硬件平台，所以为了在开发时可以对这种语⾔进⾏实验研究，
他们就在已有的硬件和软件平台基础上，按照⾃⼰所指定的规范，⽤软
件建设了⼀个运⾏平台，整个系统除了⽐C++更加简单之外，没有什么
⼤的区别。";
 byte[] bytes = str.getBytes();
// for (byte aByte : bytes) { 
   
// bufferedOutputStream.write(aByte);
// }
 bufferedOutputStream.write(bytes,9,9);
 bufferedOutputStream.flush();
 bufferedOutputStream.close();
 outputStream.close();
 }
}

字符节输出缓冲流

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;
public class Test2 { 
   输⼊流没有 flush ⽅法，但不代表它没有缓冲流，输出流是有 flush
⽅法的，实际开发中在关闭输出缓冲流之前，需要调⽤ flush ⽅
法。
序列化和反序列化
序列化就是将内存中的对象输出到硬盘⽂件中保存。
反序列化就是相反的操作，从⽂件中读取数据并还原成内存中的对
象。
序列化
 public static void main(String[] args) throws
Exception { 
   
 Writer writer = new
FileWriter("/Users/southwind/Desktop/test2.txt");
 BufferedWriter bufferedWriter = new
BufferedWriter(writer);
// String str = "由于在开发语⾔时尚且不存在运⾏字节
码的硬件平台，所以为了在开发时可以对这种语⾔进⾏实验研究，他们
就在已有的硬件和软件平台基础上，按照⾃⼰所指定的规范，⽤软件建
设了⼀个运⾏平台，整个系统除了⽐C++更加简单之外，没有什么⼤的
区别。";
// bufferedWriter.write(str,5,10);
 char[] chars = { 
   'J','a','v','a'};
// bufferedWriter.write(chars,2,1);
 bufferedWriter.write(22902);
 bufferedWriter.flush();
 bufferedWriter.close();
 writer.close();
 }
}

输入流没有 flush 方法，但不代表它没有缓冲流，输出流是有 flush 方法的，实际开发中在关闭输出缓冲流之前，需要调用 flush 方法。

6.说说序列化和反序列化?

序列化就是将内存中的对象输出到硬盘文件中保存。
反序列化就是相反的操作，从文件中读取数据并还原成内存中的对象。

1、实体类需要实现序列化接口，Serializable

import java.io.Serializable;

public class User implements Serializable { 
   
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() { 
   
        return id;
    }

    public void setId(Integer id) { 
   
        this.id = id;
    }

    public String getName() { 
   
        return name;
    }

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

    public Integer getAge() { 
   
        return age;
    }

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

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

    public User(Integer id, String name, Integer age) { 
   
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

2、实体类对象进行序列化处理，通过数据流写入到文件中，ObjectOutputStream。

import com.southwind.entity.User;

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class Test { 
   
    public static void main(String[] args) throws Exception { 
   
        User user = new User(1,"张三",22);
        OutputStream outputStream = new FileOutputStream("/Users/southwind/Desktop/obj.txt");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(user);
        objectOutputStream.flush();
        objectOutputStream.close();
        outputStream.close();
    }
}

3、反序列化

import com.southwind.entity.User;

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;

public class Test2 { 
   
    public static void main(String[] args) throws Exception { 
   
        InputStream inputStream = new FileInputStream("/Users/southwind/Desktop/obj.txt");
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        User user = (User) objectInputStream.readObject();
        System.out.println(user);
        objectInputStream.close();
        inputStream.close();
    }
}

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/156507.html原文链接：https://javaforall.cn

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

如有侵权请联系 cloudcommunity@tencent.com 删除

文件存储