java 同名类加载如何设置优先级 java类同名方法

转载

mob64ca1401b651 2024-06-12 11:44:19

文章标签 java 同名类加载如何设置优先级 java 面试 jvm 开发语言 文章分类 Java 后端开发

Java基础面试题（3）

填空题

有如下程序代码：

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是 ——————子类。
Reader对象是——————（接口/类/抽象类）。

判断题

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

简答题

什么是序列化，什么是反序列表，为什么有时要用到序列化？
简述TreeSet集合和TreeMap集合特点？

程序题

编程程序实现使用io流，在本地建立一个文本文件(user.txt)，文件内容是5000行字符英文字符串，每行有3-15 随机字母组成的词汇，第一个词汇首字母大写，每个词汇之间用空格隔开，最后一个词汇尾部加上点。
内容形式如下：
Aus xxy pawfa.
Xua yes user mi ya xya.
定义一个Book类（id,书名，作者，价格），使用ArrayList集合，在类main方法加载运行时添加10本书，书籍具有id,书名、作者、价格三个属性，在main函数中通过键盘录入一个书名时，查询出该书籍的详细信息
编写程序，实现统计某目录的所有文件类型的个数，也包括子目录。输入结果如下：
Jpg 6
Gif 1
Png 33
Java 5
Unknow 3
编程实现统计一个文本文件中，字母出现的次数或单词出现的次数
实现字符串分组 [“ate”,”att”,”test”,”ttes”,”tae”] 分组结果是
[[“ate”,”tae”],[“test”,”ttes],[“att”]]

答案

填空题

没有 ex finally
Map 或 Map<K,V>
字节流字符流
read 或 read() 或 read(buf) 输入流数据读完了
InputStreamReader
抽象类

判断题

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

简答题

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

程序题

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

package cn.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Random;
public class Ex1 {
    public static void main(String[] args) {
        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 = "abcdefhijklmnopqrstuvwxyz";
        String s2 = "abcdefhijklmnopqrstuvwxyz".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();
    }
}

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

package cn.io;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Book {
    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;
	getter setter….
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public static void main(String[] args) {
        //图书初始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){
                if(b.getName().contains(n)){
                    System.out.println(b);
                }
            }
            System.out.println();
        }

    }


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

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

package cn.webrx;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class Ex3 {
    static Map<String, Integer> map = new HashMap<>();

    public static void main(String[] args) {
        //要统计的路径
        //String path = "D:\\源码\\dormitory";

        //count(new File(path));
        count(new File("D:\\"));

        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 = "unknow";
                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、编程实现统计一个文本文件中，字母出现的次数或单词出现的次数

package cn.webrx;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Ex4 {
    public static void main(String[] args) {
      try(FileReader reader = new FileReader("u.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);
      }
    }
}

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

public static void main(String[] args) {
        String[] ls = new String[]{"age", "eat", "tea", "tan", "ate", "nat", "bat", "book", "bkoo"};
        System.out.println(Arrays.toString(ls));
        for (int n = 0; n < ls.length; n++) {
            String t = ls[n];
            if ("-".equals(t)) continue;
            for (int i = n + 1; i < ls.length; i++) {
                if (is(t, ls[i])) {
                    ls[n] += "-" + ls[i];
                    ls[i] = "";
                }
            }
        }
        

        System.out.println(Arrays.deepToString(ls));

        String ok = "";
        for (String t : ls) {
            if ("".equals(t) || "-".equals(t)) continue;
            ok += "," + t;
        }
        String[] oo = ok.substring(1).split(",");
        System.out.println(Arrays.toString(oo));

        StringBuilder su = new StringBuilder("[");
        for(String s : oo){
            String[] t = s.split("-");
            su.append(Arrays.toString(t)+",");
        }
        su.replace(su.lastIndexOf(","),su.lastIndexOf(",")+1,"]");
        System.out.println(su);

    }


    public static boolean is(String a, String b) {
        boolean f = false;
        if (a.length() == b.length()) {
            var aa = a.toCharArray();
            Arrays.sort(aa);
            var bb = b.toCharArray();
            Arrays.sort(bb);
            f = new String(aa).equalsIgnoreCase(new String(bb));
        }
        return f;
    }

    public static boolean isSame(String a, String b) {
        boolean f = true;
        if (a.length() == b.length()) {
            for (int i = 0; i < a.length(); i++) {
                if (b.indexOf(a.charAt(i)) == -1) {
                    f = false;
                    break;
                }
            }

            for (int i = 0; i < a.length(); i++) {
                if (a.indexOf(b.charAt(i)) == -1) {
                    f = false;
                    break;
                }
            }
        }
        return f;
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。