经典面试题(1.2)

最新推荐文章于 2024-10-10 09:56:47 发布

_自有天意

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量191

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_58725148/article/details/127111372

版权

一、填空题（每空1分，共10分）

1）有如下程序代码：

public static void show() {
    try {
        int i = 3 / 0;
        System.out.println(i);
        return;
    } catch (Exception e) {
        System.out.println("ex");
        return;
    } finally {
        System.out.println("finally");
        return;
    }
}

，此方法_____(有/没有)语法的错误，如果没有错误，调用此方法程序输出内容顺序是（1）_______________ (2) _______________

HashMap集合工具类，是实现：_______________接口。
java io流操作体系中，流分_______________和 _______________ 。
FileInputStream输入流，使用_______________方法来读取内容，如果这个方法返回-1，代表_______________。
FileReader是_______________子类。
6）Reader对象是_______________（接口/类/抽象类）。

二、判断题（每题2分，共20分）

1）在类的定义中可以有两个同名方法，这种现象称为方法重写。（）
2）方法重写只能出现在一个类中，不能出现在有继承关系的父子类中。（）
3）接口声明中，不可以有实现方法。（）
4）java io流体系中，InputStream是个接口，FileInputStream是接口的实现类。（）
5）程序代码InputStream is = new InputStream(“f.txt”); 此行代码没有错误，功能是建立输入流。
6）HashSet集合对象的元素可以是重复的，并且是有序的。（）
7）如下代码 List<int[]> list = new ArrayList<int[]>(); 在程序语法上正确的。（）
8）如下代码 Map<int,Integer> m = new Hash<Integer,Integer>(); 在语法上是正确的。（）
9）在java io流体系中，File对象是一个流，使用完需要调用close() 方法关闭，释放其占用的内存资源。（）
10）集合TreeSet，是一个有序的集合，且内部的元素不能重复。（）

三、简答题（每题10分，共20分）

1）什么是序列化，什么是反序列表，为什么有时要用到序列化？

2）简述TreeSet集合和TreeMap集合特点？

四、程序题（每题10分，共50分）

1、编程程序实现使用io流，在本地建立一个文本文件(user.txt)，文件内容是5000行字符英文字符串，每行有3-15 随机字母组成的词汇，第一个词汇首字母大写，每个词汇之间用空格隔开，最后一个词汇尾部加上点。
内容形式如下：
Aus xxy pawfa.
Xua yes user mi ya xya.

2、定义一个Book类（id,书名，作者，价格），使用ArrayList集合，在类main方法加载运行时添加10本书，书籍具有id,书名、作者、价格三个属性，在main函数中通过键盘录入一个书名时，查询出该书籍的详细信息

3、编写程序，实现统计某目录的所有文件类型的个数，也包括子目录。输入结果如下：
Jpg 6
Gif 1
Png 33
Java 5
Unknow 3

4、编程实现统计一个文本文件中，字母出现的次数或单词出现的次数

5、实现字符串分组 [“ate”,”att”,”test”,”ttes”,”tae”] 分组结果是
[[“ate”,”tae”],[“test”,”ttes],[“att”]]

答案

一、填空题（每空1分，共10分）

1）没有 ex finally
2）Map 或 Map<K,V>
3）字节流、字符流
4）read 或 read() 或 read(buf)
5）InputStreamReader
6）抽象类

二、判断题（每空2分，共20分）

1.F 2.F 3.F 4.F 5.F 6.F 7.F 8.F 9.F 10.T

三、简答题（每空10分，共20分）

1）
① Java序列化就是指把Java对象转换为字节序列的过程。
Java反序列化就是指把字节序列恢复为Java对象的过程
② 序列化最重要的作用：在传递和保存对象时保证对象的完整性和可转递性。对象转换为有序字节流，以便在网络上传输或者保存在本地文件中。
反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。
总结：核心作用就是对象状态的保存和重建。（整个过程核心点就是字节流中所保存的对象状态及描述信息）
2）
相同点：
① 都是有序集合
② TreeMap时TreeSet的底层结构
③ 运行速度都比hash慢
区别：
① TreeSet指存储一个对象，而TreeMap存储两个对象Key和Value（仅仅key对象有序）
② TreeSet中不能有重复对象，而TreeMap中可以存在
③ TreeMap的底层采用红黑树的实现，完成数据有序的插入，排序。

四、程序题（每空10分，共50分）

public static void main(String[] args) {

        /*
        编程程序实现使用io流，在本地建立一个文本文件(user.txt)，文件内容是5000
        行字符英文字符串，每行有3-15 随机字母组成的词汇，第一个词汇首字母大写，每
        个词汇之间用空格隔开，最后一个词汇尾部加上点。
        */
        try {
            FileOutputStream fos = new FileOutputStream("user.txt",true);
            for (int i = 0; i < 100; i++) {
                fos.write(getStr(3,35).getBytes());
            }
        } catch (FileNotFoundException e){
            e.printStackTrace();
        } catch (IOException e){
            e.printStackTrace();
        }
    }

    public static String getStr(int a,int b){
        StringBuilder su = new StringBuilder();
        su.append(getStr(true) + "");
        Random rand = new Random();
        int len = rand.nextInt(b - a) + a;
        for (int i = 0; i < len; i++) {
            su.append(getStr() + " ");
        }
        return su.toString().trim().concat(".\n");
    }

    public static String getStr(){
        return getStr(false);
    }

    public static String getStr(boolean f){
        Random rand = new Random();
        String s1 = "abcdefghijklmnopqrstuvwxyz";
        String s2 = "abcdefghijklmnopqrstuvwxyz".toUpperCase();
        StringBuilder su = new StringBuilder();
        if (f){
            su.append(s2.charAt(rand.nextInt(s2.length())));
        }
        int len = rand.nextInt(5) + 2;
        for (int i = 0; i < len; i++) {
            su.append(s1.charAt(rand.nextInt(s2.length())));
        }
        return su.toString();
    }

实现效果：
在这里插入图片描述
2、定义一个Book类（id,书名，作者，价格），使用ArrayList集合，在类main方法加载运行时添加10本书，书籍具有书名、作者、价格三个属性，在main函数中通过键盘录入一个书名时，查询出该书籍的详细信息。

public class Book {
    public static void main(String[] args) {
        /*
            定义一个Book类（id,书名，作者，价格），使用ArrayList集合，在类main方法
            加载运行时添加10本书，书籍具有书名、作者、价格三个属性，在main函数中通
            过键盘录入一个书名时，查询出该书籍的详细信息。
        */

        // 图书初始10本
        Scanner sc = new Scanner(System.in);
        int i = 0;
        while (true) {
            i = list.size() + 1;
            System.out.printf("请输入第%d本书籍名称  作者  价格：", i);
            String n = sc.next();
            String a = sc.next();
            double p = sc.nextDouble();
            Book bk = new Book(i, n, a, p);
            list.add(bk);
            if (list.size() == 10){
                System.out.println("10书籍输入完成。进入程序查询");
                break;
            }
            System.out.println();
        }

        System.out.println("-----------------------------------------");

        while (true){
            System.out.print("请输入书籍名称（退出quit）：");
            String n = sc.nextLine();
            if ("quit".equalsIgnoreCase(n)) break;
            for (Book b : list){
                System.out.println(b);
            }
        }
        System.out.println();

    }

    private int id;
    private String name;
    private String author;
    private double price;

    public Book() {

    }

    static List<Book> list = new ArrayList<>();

    public Book(int id, String name, String author, double price) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

实现效果：

在这里插入图片描述
3、编写程序，实现统计某目录的所有文件类型的个数也包括子目录。输入结果如下：
Jpg 6
Gif 1
Png 33
Java 5
Unknow 3

public class WeekTest3 {

    static Map<String, Integer> map = new HashMap<>();

    public static void main(String[] args) {
        /*
            编写程序，实现统计某目录的所有文件类型的个数也包括子目录。输入结果如下：
            Jpg 6
            Gif 1
            Png 33
            Java 5
            Unknow 3
        */

        // 要统计的路径
        // String path = "g:/images/image";

        // count(new File(path));
        count(new File("g:\\images"));
        System.out.println(map);

    }

    public static void count(File dir) {
        for (File f : dir.listFiles()) {
            if (f.isDirectory()) {
                count(f);
            } else if (f.isFile()) {
                String filename = f.getName().toLowerCase();
                String ext = "jpg";
                try {
                    ext = filename.substring(filename.lastIndexOf("."));
                } catch (Exception e) {

                }
                if (map.containsKey(ext)) {
                    Integer t = map.get(ext);
                    map.put(ext, t + 1);
                } else {
                    map.put(ext, 1);
                }
            }
        }
    }

}

实现效果：

在这里插入图片描述

4、编程实现统计一个文本文件中，字母出现的次数或单词出现的次数

public class WeekTest4 {
    public static void main(String[] args) {

        // 编程实现统计一个文本文件中，字母出现的次数或单词出现的次数

        try {
            FileReader reader = new FileReader("user.txt");
            char[] buf = new char[1023];
            int len = 0;
            StringBuilder su = new StringBuilder();
            while ((len = reader.read(buf)) != -1) {
                su.append(new String(buf, 0, len));
            }
            char[] c1 = su.toString().toCharArray();
            Map<String, Integer> map = new HashMap<>();
            for (char c : c1) {
                if (c == '\r' || c == '\n' || c == ' ') continue;
                String k = String.valueOf(c);

                if (map.containsKey(k)) {
                    map.put(k, map.get(k) + 1);
                } else {
                    map.put(k, 1);
                }
            }
            List<Map.Entry<String,Integer>> list = new ArrayList<>(map.entrySet());
            list.sort((a,b) -> b.getValue() - a.getValue());
            System.out.println(list);

        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

实现效果：

在这里插入图片描述

5、实现字符串分组 [“ate”,”att”,”test”,”ttes”,”tae”] 分组结果是
[[“ate”,”tae”],[“test”,”ttes],[“att”]]

public class WeekTest5 {
    public static void main(String[] args) {
        /*
           实现字符串分组 ["ate","att","test","ttes","tae"] 分组结果是
           [[“ate”,”tae”],[“test”,”ttes],[“att”]]
        */

        String[] s = {"ate","att","test","ttes","tae"};
        System.out.println(new WeekTest5().stringGoup(s));

    }

    public List<List<String>> stringGoup(String[] strs){
        if (strs == null || strs.length == 0){
            return new ArrayList<>();
        }
        Arrays.sort(strs);
        Map<String,List<String>> map = new HashMap<>();
        for (String str : strs){
            char[] c = str.toCharArray();
            Arrays.sort(c);
            String s = String.valueOf(c);
            if (!map.containsKey(s))
                map.put(s,new ArrayList<>());
            map.get(s).add(str);
        }
        return new ArrayList<>(map.values());
    }
}

实现效果：
在这里插入图片描述