面试专题之Java基础（三）

最新推荐文章于 2024-04-27 04:08:30 发布
最新推荐文章于 2024-04-27 04:08:30 发布
阅读量156 收藏
点赞数
分类专栏： 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_zero/article/details/105240164
版权

题目

  1. 类 ExampleA 继承 Exception，类 ExampleB 继承ExampleA。
  2. Java 中如何实现序列化，有什么意义？
  3. Java 中有几种类型的流？
  4. 写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。
  5. 如何用 Java 代码列出一个目录下所有的文件？
  6. 简述正则表达式及其用途。
  7. Java 中是如何支持正则表达式操作的？
  8. 获得一个类的类对象有哪些方式？
  9. 如何通过反射创建对象？
  10. 如何通过反射调用对象的方法？
  11. 简述一下面向对象的”六原则一法则”。
  12. 什么是 UML？
  13. UML 中有哪些常用的图？
  14. 用 Java 写一个冒泡排序。
  15. 用 Java 写一个折半查找。
  16. 什么是不可变对象（immutable object）？Java 中怎么创建一个不可变对象？
  17. 我们能创建一个包含可变对象的不可变对象吗？
  18. Java 中应该使用什么数据类型来代表价格？
  19. 怎么将 byte 转换为 String？
  20. Java 中怎样将bytes[] 转换为 long 类型？
  21. 我们能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围，将会出现什么现象？

答案

  1. 类 ExampleA 继承 Exception，类 ExampleB 继承ExampleA。

有如下代码片断：

try {
	throw new ExampleB("b")
}catch（ExampleA e）{
	System.out.println("ExampleA");
}catch（Exception e）{
	System.out.println("Exception");
}

请问执行此段代码的输出是什么？
答：

输出：ExampleA。（根据里氏代换原则[能使用父类型的地方一定能使用子类型]，抓取 ExampleA 类型异常的 catch 块能够抓住 try 块中抛出的 ExampleB 类型的异常）

面试题 - 说出下面代码的运行结果。（此题的出处是《Java 编程思想》一书）

/**
 * @Auther: 洺润Star
 * @Date: 2020/4/1 10:53
 * @Description:
 */
class Annoyance extends Exception {}
class Sneeze extends Annoyance {}
class Human {
    public static void main(String[] args)
            throws Exception {
        try {
            try {
                throw new Sneeze();
            }
            catch ( Annoyance a ) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        }
        catch ( Sneeze s ) {
            System.out.println("Caught Sneeze");
            return ;
        }
        finally {
            System.out.println("Hello World!");
        }
        /**
         * Caught Annoyance
         * Caught Sneeze
         * Hello World!
         */
    }}
  1. Java 中如何实现序列化，有什么意义？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题（如果不进行序列化可能会存在数据乱序的问题）。要实现序列化，需要让一个类实现 Serializable 接口，该接口是一个标识性接口，标注该类对象是可被序列化的，然后使用一个输出流来构造一个对象输出流并通过 writeObject(Object)方法就可以将实现对象写出（即保存其状态）；如果需要反序列化则可以用一个输入流建立对象输入流，然后通过 readObject 方法从流中读取对象。序列化除了能够实现对象的持久化之外，还能够用于对象的深度克隆（可以参考第 29 题）。

  1. Java 中有几种类型的流？
    字节流和字符流。字节流继承于 InputStream、OutputStream，字符流继承于Reader、Writer。在 java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。关于 Java 的 I/O 需要注意的有两点：一是两种对称性（输入和输出的对称性，字节和字符的对称性）；二是两种设计模式（适配器模式和装潢模式）。另外 Java 中的流不同于 C#的是它只有一个维度一个方向。

  2. 写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。
    代码如下：

import java.io.BufferedReader;
import java.io.FileReader;
public final class MyUtil {
	// 工具类中的方法都是静态方式访问的因此将构造器私有不允许创建对象(绝对好习惯)
	private MyUtil() {
		throw new AssertionError();
	}
	/**
* 统计给定文件中给定字符串的出现次数
*
* @param filename 文件名
* @param word 字符串
* @return 字符串在文件中出现的次数
*/
	public static int countWordInFile(String filename, String word) {
		int counter = 0;
		try (FileReader fr = new FileReader(filename)) {
			try (BufferedReader br = new BufferedReader(fr)) {
				String line = null;
				while ((line = br.readLine()) != null) {
					int index = -1;
					while (line.length() >= word.length() && (index =
					line.indexOf(word)) >= 0) {
						counter++;
						line = line.substring(index + word.length());
					}
				}
			}
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
		return counter;
	}}
  1. 如何用 Java 代码列出一个目录下所有的文件？
    如果只要求列出当前文件夹下的文件，代码如下所示：
import java.io.File;class Test12 {
	public static void main(String[] args) {
		File f = new File("/Users/Hao/Downloads");
		for (File temp : f.listFiles()) {
			if(temp.isFile()) {
				System.out.println(temp.getName());
			}
		}
	}}

如果需要对文件夹继续展开，代码如下所示：

import java.io.File;
/**
 * @Auther: 洺润Star
 * @Date: 2020/4/1 11:22
 * @Description:
 */
class Test12 {
    public static void main(String[] args) {
        showDirectory(new File("/Users/Hao/Downloads"));
    }
    public static void showDirectory(File f) {
        _walkDirectory(f, 0);
    }
    private static void _walkDirectory(File f, int level) {
        if(f.isDirectory()) {
            for (File temp : f.listFiles()) {
                _walkDirectory(temp, level + 1);
            }
        } else {
            for (int i = 0; i < level - 1; i++) {
                System.out.print("t");
            }
            System.out.println(f.getName());
        }
    }
}

在 Java 7 中可以使用 NIO.2 的 API 来做同样的事情，代码如下所示：

class ShowFileTest {
	public static void main(String[] args) throws IOException {
		Path initPath = Paths.get("/Users/Hao/Downloads");
		Files.walkFileTree(initPath, new SimpleFileVisitor<Path>() {
			@Override
			public FileVisitResult visitFile(Path file, BasicFileAttributes
			attrs)
			throws IOException {
				System.out.println(file.getFileName().toString());
				return FileVisitResult.CONTINUE;
			}
		}
		);
	}}

  1. 简述正则表达式及其用途。
    在编写处理字符串的程序时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。
    说明：计算机诞生初期处理的信息几乎都是数值，但是时过境迁，今天我们使用计算机处理的信息更多的时候不是数值而是字符串，正则表达式就是在进行字符串匹配和处理的时候最为强大的工具，绝大多数语言都提供了对正则表达式的支持。

  2. Java 中是如何支持正则表达式操作的？

Java 中的 String 类提供了支持正则表达式操作的方法，包括：matches()、replaceAll()、replaceFirst()、split()。此外，Java 中可以用 Pattern 类表示正则表达式对象，它提供了丰富的 API 进行各种正则表达式操作。
面试题：- 如果要从字符串中截取第一个英文左括号之前的字符串，例如：北京市(朝阳区)(西城区)(海淀区)，截取结果为：北京市，那么正则表达式怎么写？

import java.util.regex.Matcher;import java.util.regex.Pattern;class RegExpTest {
	public static void main(String[] args) {
		String str = "北京市(朝阳区)(西城区)(海淀区)";
		Pattern p = Pattern.compile(".*?(?=\()");
		Matcher m = p.matcher(str);
		if(m.find()) {
			System.out.println(m.group());
		}
	}}
  1. 获得一个类的类对象有哪些方式？

（1）方法 1：类型.class，例如：String.class

（2）方法 2：对象.getClass()，例如：”hello”.getClass()

（3）方法 3：Class.forName()，例如：Class.forName(“java.lang.String”)

  1. 如何通过反射创建对象？

方法 1：通过类对象调用 newInstance()方法，例如：String.class.newInstance()

方法 2：通过类对象的 getConstructor()或 getDeclaredConstructor()方法获得构造器（Constructor）对象并调用其 newInstance()方法创建对象，例如：String.class.getConstructor(String.class).newInstance(“Hello”);

  1. 如何通过反射获取和设置对象私有字段的值？
    可以通过类对象的 getDeclaredField()方法字段（Field）对象，然后再通过字段对象的 setAccessible(true)将其设置为可以访问，接下来就可以通过 get/set 方法来获取/设置字段的值了。下面的代码实现了一个反射的工具类，其中的两个静态方法分别用于获取和设置私有字段的值，字段可以是基本类型也可以是对象类型且支持多级对象操作。

  2. 如何通过反射调用对象的方法？
    请看下面的代码：

import java.lang.reflect.Method;class MethodInvokeTest {
	public static void main(String[] args) throws Exception {
		String str = "hello";
		Method m = str.getClass().getMethod("toUpperCase");
		System.out.println(m.invoke(str));
		// HELLO
	}}
  1. 简述一下面向对象的”六原则一法则”。

（1）单一职责原则：一个类只做它该做的事情。（单一职责原则想表达的就是”高内聚”，写代码最终极的原则只有六个字”高内聚、低耦合”，就如同葵花宝典或辟邪剑谱的中心思想就八个字”欲练此功必先自宫”，所谓的高内聚就是一个代码模块只完成一项功能，在面向对象中，如果只让一个类完成它该做的事，而不涉及与它无关的领域就是践行了高内聚的原则，这个类就只有单一职责。我们都知道一句话叫”因为专注，所以专业”，一个对象如果承担太多的职责，那么注定它什么都做不好。这个世界上任何好的东西都有两个特征，一个是功能单一，好的相机绝对不是电视购物里面卖的那种一个机器有一百多种功能的，它基本上只能照相；另一个是模块化，好的自行车是组装车，从减震叉、刹车到变速器，所有的部件都是可以拆卸和重新组装的，好的乒乓球拍也不是成品拍，一定是底板和胶皮可以拆分和自行组装的，一个好的软件系统，它里面的每个功能模块也应该是可以轻易的拿到其他系统中使用的，这样才能实现软件复用的目标。）

（2）开闭原则：软件实体应当对扩展开放，对修改关闭。（在理想的状态下，当我们需要为一个软件系统增加新功能时，只需要从原来的系统派生出一些新类就可以，不需要修改原来的任何一行代码。要做到开闭有两个要点：①抽象是关键，一个系统中如果没有抽象类或接口系统就没有扩展点；②封装可变性，将系统中的各种可变因素封装到一个继承结构中，如果多个可变因素混杂在一起，系统将变得复杂而换乱，如果不清楚如何封装可变性，可以参考《设计模式精解》一书中对桥梁模式的讲解的章节。）

（3）依赖倒转原则：面向接口编程。（该原则说得直白和具体一些就是声明方法的参数类型、方法的返回类型、变量的引用类型时，尽可能使用抽象类型而不用具体类型，因为抽象类型可以被它的任何一个子类型所替代，请参考下面的里氏替换原则。）

（4）里氏替换原则：任何时候都可以用子类型替换掉父类型。（关于里氏替换原则的描述，Barbara Liskov 女士的描述比这个要复杂得多，但简单的说就是能用父类型的地方就一定能使用子类型。里氏替换原则可以检查继承关系是否合理，如果一个继承关系违背了里氏替换原则，那么这个继承关系一定是错误的，需要对代码进行重构。例如让猫继承狗，或者狗继承猫，又或者让正方形继承长方形都是错误的继承关系，因为你很容易找到违反里氏替换原则的场景。需要注意的是：子类一定是增加父类的能力而不是减少父类的能力，因为子类比父类的能力更多，把能力多的对象当成能力少的对象来用当然没有任何问题。）

（5）接口隔离原则：接口要小而专，绝不能大而全。（臃肿的接口是对接口的污染，既然接口表示能力，那么一个接口只应该描述一种能力，接口也应该是高度内聚的。例如，琴棋书画就应该分别设计为四个接口，而不应设计成一个接口中的四个方法，因为如果设计成一个接口中的四个方法，那么这个接口很难用，毕竟琴棋书画四样都精通的人还是少数，而如果设计成四个接口，会几项就实现几个接口，这样的话每个接口被复用的可能性是很高的。Java 中的接口代表能力、代表约定、代表角色，能否正确的使用接口一定是编程水平高低的重要标识。）

（6）合成聚合复用原则：优先使用聚合或合成关系复用代码。（通过继承来复用代码是面向对象程序设计中被滥用得最多的东西，因为所有的教科书都无一例外的对继承进行了鼓吹从而误导了初学者，类与类之间简单的说有三种关系，Is-A 关系、Has-A 关系、Use-A 关系，分别代表继承、关联和依赖。其中，关联关系根据其关联的强度又可以进一步划分为关联、聚合和合成，但说白了都是Has-A 关系，合成聚合复用原则想表达的是优先考虑 Has-A 关系而不是 Is-A 关系复用代码，原因嘛可以自己从百度上找到一万个理由，需要说明的是，即使在Java 的 API 中也有不少滥用继承的例子，例如 Properties 类继承了 Hashtable类，Stack 类继承了 Vector 类，这些继承明显就是错误的，更好的做法是在Properties 类中放置一个 Hashtable 类型的成员并且将其键和值都设置为字符串来存储数据，而 Stack 类的设计也应该是在 Stack 类中放一个 Vector 对象来存储数据。记住：任何时候都不要继承工具类，工具是可以拥有并可以使用的，而不是拿来继承的。）

（7）迪米特法则：迪米特法则又叫最少知识原则，一个对象应当对其他对象有尽可能少的了解。（迪米特法则简单的说就是如何做到”低耦合”，门面模式和调停者模式就是对迪米特法则的践行。对于门面模式可以举一个简单的例子，你去一家公司洽谈业务，你不需要了解这个公司内部是如何运作的，你甚至可以对这个公司一无所知，去的时候只需要找到公司入口处的前台美女，告诉她们你要做什么，她们会找到合适的人跟你接洽，前台的美女就是公司这个系统的门面。再复杂的系统都可以为用户提供一个简单的门面，Java Web 开发中作为前端控制器的 Servlet 或 Filter 不就是一个门面吗，浏览器对服务器的运作方式一无所知，但是通过前端控制器就能够根据你的请求得到相应的服务。调停者模式也可以举一个简单的例子来说明，例如一台计算机，CPU、内存、硬盘、显卡、声卡各种设备需要相互配合才能很好的工作，但是如果这些东西都直接连接到一起，计算机的布线将异常复杂，在这种情况下，主板作为一个调停者的身份出现，它将各个设备连接在一起而不需要每个设备之间直接交换数据，这样就减小了系统的耦合度和复杂度，如下图所示。迪米特法则用通俗的话来将就是不要和陌生人打交道，如果真的需要，找一个自己的朋友，让他替你和陌生人打交道。）

img

img
12. 什么是 UML？

UML 是统一建模语言（Unified Modeling Language）的缩写，它发表于 1997年，综合了当时已经存在的面向对象的建模语言、方法和过程，是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持。使用 UML 可以帮助沟通与交流，辅助应用设计和文档的生成，还能够阐释系统的结构和行为。

  1. UML 中有哪些常用的图？

UML 定义了多种图形化的符号来描述软件系统部分或全部的静态结构和动态结构，包括：用例图（use case diagram）、类图（class diagram）、时序图（sequencediagram）、协作图（collaboration diagram）、状态图（statechart diagram）、活动图（activity diagram）、构件图（component diagram）、部署图（deploymentdiagram）等。在这些图形化符号中，有三种图最为重要，分别是：用例图（用来捕获需求，描述系统的功能，通过该图可以迅速的了解系统的功能模块及其关系）、类图（描述类以及类与类之间的关系，通过该图可以快速了解系统）、时序图（描述执行特定任务时对象之间的交互关系以及执行顺序，通过该图可以了解对象能接收的消息也就是说对象能够向外界提供的服务）。用例图：

类图：

img

时序图：

img

  1. 用 Java 写一个冒泡排序。
    冒泡排序几乎是个程序员都写得出来，但是面试的时候如何写一个逼格高的冒泡排序却不是每个人都能做到，下面提供一个参考代码：
import java.util.Comparator;
/**
* 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可
以相互替换)
* @author 骆昊
*
*/public interface Sorter {
	/**
* 排序
* @param list 待排序的数组
*/
	public <T extends Comparable<T>> void sort(T[] list);
	/**
* 排序
* @param list 待排序的数组
* @param comp 比较两个对象的比较器
*/
	public <T> void sort(T[] list, Comparator<T> comp);}import java.util.Comparator;/**
* 冒泡排序
*
* @author 骆昊
*
*/public class BubbleSorter implements Sorter {
	@Override
	public <T extends Comparable<T>> void sort(T[] list) {
		Boolean swapped = true;
		for (int i = 1, len = list.length; i < len && swapped; ++i) {
			swapped = false;
			for (int j = 0; j < len - i; ++j) {
				if (list[j].compareTo(list[j + 1]) > 0) {
					T temp = list[j];
					list[j] = list[j + 1];
					list[j + 1] = temp;
					swapped = true;
				}
			}
		}
	}
	@Override
	public <T> void sort(T[] list, Comparator<T> comp) {
		Boolean swapped = true;
		for (int i = 1, len = list.length; i < len && swapped; ++i) {
			swapped = false;
			for (int j = 0; j < len - i; ++j) {
				if (comp.compare(list[j], list[j + 1]) > 0) {
					T temp = list[j];
					list[j] = list[j + 1];
					list[j + 1] = temp;
					swapped = true;
				}
			}
		}
	}}
  1. 用 Java 写一个折半查找。
    折半查找，也称二分查找、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组已经为空，则表示找不到指定的元素。这种搜索算法每一次比较都使搜索范围缩小一半，其时间复杂度是 O(logN)。
import java.util.Comparator;
public class MyUtil {
	public static <T extends Comparable<T>> int binarySearch(T[] x, T
	key) {
		return binarySearch(x, 0, x.length- 1, key);
	}
	// 使用循环实现的二分查找
	public static <T> int binarySearch(T[] x, T key, Comparator<T> comp)
	{
		int low = 0;
		int high = x.length - 1;
		while (low <= high) {
			int mid = (low + high) >>> 1;
			int cmp = comp.compare(x[mid], key);
			if (cmp < 0) {
				low= mid + 1;
			} else if (cmp > 0) {
				high= mid - 1;
			} else {
				return mid;
			}
		}
		return -1;
	}
	// 使用递归实现的二分查找
	private static<T extends Comparable<T>> int binarySearch(T[] x, int
	low, int high, T key) {
		if(low <= high) {
			int mid = low + ((high -low) >> 1);
			if(key.compareTo(x[mid])== 0) {
				return mid;
			} else if(key.compareTo(x[mid])< 0) {
				return binarySearch(x,low, mid - 1, key);
			} else {
				return binarySearch(x,mid + 1, high, key);
			}
		}
		return -1;
	}}

说明：上面的代码中给出了折半查找的两个版本，一个用递归实现，一个用循环实现。需要注意的是计算中间位置时不应该使用(high+ low) / 2 的方式，因为加法运算可能导致整数越界，这里应该使用以下三种方式之一：low + (high - low)/ 2 或 low + (high – low) >> 1 或(low + high) >>> 1（>>>是逻辑右移，是不带符号位的右移）

  1. 什么是不可变对象（immutable object）？Java 中怎么创建一个不可变对象？
    不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer 及其它包装类。推荐阅读

  2. 我们能创建一个包含可变对象的不可变对象吗？
    是的，我们是可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的引用就可以了，如果需要变化时，就返回原对象的一个拷贝。最常见的例子就是对象中包含一个日期对象的引用。

  3. Java 中应该使用什么数据类型来代表价格？
    如果不是特别关心内存和性能的话，使用 BigDecimal，否则使用预定义精度的double 类型。

  4. 怎么将 byte 转换为 String？
    可以使用 String 接收 byte[] 参数的构造器来进行转换，需要注意的点是要使用的正确的编码，否则会使用平台默认编码，这个编码可能跟原来的编码相同，也可能不同。

  5. Java 中怎样将bytes[] 转换为 long 类型？
    bytes[] 到数字类型的转换是个经常用到的代码,解决方式也不止一种。

java代码实现

如果不想借助任何已经有的类，完全可以自己实现这段代码，如下：

/**
* 将字节数组转为long<br>
* 如果input为null,或offset指定的剩余数组长度不足8字节则抛出异常
* @param input
* @param offset 起始偏移量
* @param littleEndian 输入数组是否小端模式
* @return
*/
public static long longFrom8Bytes(byte[] input, int offset, Boolean littleEndian){
	long value=0;
	// 循环读取每个字节通过移位运算完成long的8个字节拼装
	for (int  count=0;count<8;++count){
		int shift=(littleEndian?count:(7-count))<<3;
		value |=((long)0xff<< shift) & ((long)input[offset+count] << shift);
	}	
	return value;
}

借助java.nio.ByteBuffer实现

java.nio.ByteBuffer 本身就有getLong,getInt,getFloat….方法,只要将byte[]转换为ByteBuffer就可以实现所有primitive类型的数据读取,参见javadoc。

/**
     * 利用 {@link java.nio.ByteBuffer}实现byte[]转long
     * @param input
     * @param offset
     * @param littleEndian 输入数组是否小端模式
     * @return
     */public static long bytesTolong(byte[] input, int offset, Boolean littleEndian) {
	// 将byte[] 封装为 ByteBuffer
	ByteBuffer buffer = ByteBuffer.wrap(input,offset,8);
	if(littleEndian){
		// ByteBuffer.order(ByteOrder) 方法指定字节序,即大小端模式(BIG_ENDIAN/LITTLE_ENDIAN)
		// ByteBuffer 默认为大端(BIG_ENDIAN)模式
		buffer.order(ByteOrder.LITTLE_ENDIAN);
	}
	return buffer.getlong();}

借助java.io.DataInputStream实现

java.io.DataInputStream 同样提供了readLong,readLong,readLong….方法,只要将byte[]转换为DataInputStream就可以实现所有primitive类型的数据读取,参见javadoc。

  1. 我们能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围，将会出现什么现象？
    是的，我们可以做强制转换，但是 Java 中 int 是 32 位的，而 byte 是 8 位的，所以，如果强制转化是，int 类型的高 24 位将会被丢弃，byte 类型的范围是从 -128 到 127。
洺润
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《面试专题-----经典高频面试题收集一》解锁 Java 面试的关键：深度解析常见高频经典面试题（第一篇）
weixin_44976692的博客
12-22 6万+
大家好，我是码农阿豪，一位热爱 Java 编程的程序员。今天我想和大家分享一些常见的 Java 面试题，通过收集解析这些问题，希望能够帮助大家更好地准备面试，突破技术瓶颈。
Java基础面试专题1
08-03
【Java基础面试专题1】 Java 是一种面向对象的编程语言，其核心概念包括封装、继承和多态。封装是将数据和操作数据的方法绑定在一起，保护数据不被随意访问；继承则是子类继承父类的属性和方法，使得代码复用更加...
从字符串中截取第一个英文左括号之前的字符串
黄昏的大树
05-14 7013
从字符串中截取第一个英文左括号之前的字符串
（1/100）
weixin_44351047的博客
11-16 283
学习思路如下： 一、JavaSE部分 ❤1、Java基础——题目 1、为什么重写equals还要重写hashcode 2、说一下map的分类和常见的情况 3、Object若不重写hashCode()的话，hashCode()如何计算出来的？ 4、==比较的是什么？ 5、若对一个类不重写，它的equals()方法是如何比较的？ 6、java8新特性 7、说说Lamda表达式的优缺点。 8、一个十进...
写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数
weixin_44540416的博客
10-26 462
只提拱自己参考 import java.io.BufferedReader; import java.io.FileReader; public final class MyUtil { private MyUtil() { throw new AssertionError(); } /** * 统计给定文件中给定字符串的出现次数 * * @param filename 文件名 * @param word 字符串 .
【面试专题】Java核心基础篇①
Javascript_tsj的博客
08-12 3310
Java数据类型包括基本数据类型和引用数据类型两大类。基本数据类型有8个，可以分为4个小类，分别是整数类型（byte/short/int/long）、浮点类型（float/double）、字符类型（char）、布尔类型（boolean）。其中，4个整数类型中，int类型最为常用。2个浮点类型中，double最为常用。另外，在这8个基本类型当中，除了布尔类型之外的其他7个类型，都可以看做是数字类型，它们相互之间可以进行类型转换。
面试java基础题，lombok插件
2401_84009597的博客
04-19 1008
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
尼恩Java面试宝典
热门推荐
架构师尼恩
05-15 1万+
加架构师 尼恩 免费领！ 专题01：JVM面试题（卷王专供 + 史上最全 + 2022面试必备）-V2 专题02：Java算法面试题（卷王专供 + 史上最全 + 2022面试必备）-V2 专题03：Java基础面试题（卷王专供+ 史上最全 + 2022面试必备）-V2 专题04：架构设计面试题（卷王专供+ 史上最全 + 2022面试必备）-V2 专题05：Spring面试题__专题06：SpringMVC__专题07：Tomcat面试题（卷王专供+ 史上最全 + 2022面试必备）-V2 专题0
一名北漂三年的Java程序员的面试经历和题库总结！
2401_84024576的博客
04-27 1000
即使是面试跳槽，那也是一个学习的过程。只有全面的复习，才能让我们更好的充实自己，武装自己，为自己的面试之路不再坎坷！今天就给大家分享一个Github上全面的Java面试题大全，就是这份面试大全助我拿下大厂Offer，月薪提至30K！我也是第一时间分享出来给大家，希望可以帮助大家都能去往自己心仪的大厂！为金三银四做准备！
黑马Java常见面试题基础（一）
dengfengling999的博客
10-31 1199
每次对 String 的操作相当于生成一个新的 String 对象，而对 StringBuffer 和 StringBuilder 的操作是对对象本身的操作，而不会生成新的对象， 所以对于频繁改变内容的字符串避免使用 String，因为频繁的生成对象将会对 系统性能产生影响。类加载器的特点： 动态加载，无需在程序一开始运行的时候加载，而是在程序运行的过程中，动态按 需加载，字节码的来源也很多，压缩包 jar、war 中，网络中，本地文件等。”里面的对象“会在原来的对象和它的副本之间共享。
大厂面试真题Java语法基础面试专题及答案
04-28
大厂面试真题Java语法基础面试专题及答案提取方式是百度网盘分享地址
Java语法基础-面试专题及答案
01-28
11.Java 面向对象编程三大特性: 封装 继承 多态 关于继承的3点 12.String StringBuffer 和 StringBuilder 的区别是什么 String 为什么是不可变的 可变性、线程安全性的研究 13.自动装箱与拆箱 14.在一个静态方法内...
面试专题--基础篇资料
09-12
本面试专题涵盖了Java编程语言的基础知识，旨在帮助求职者在面试中展现出扎实的编程功底。以下将详细介绍Java语言的一些核心概念和关键知识点。 1. **Java简介**：Java是一种面向对象的、跨平台的编程语言，由Sun ...
Java基础知识点面试专题.pdf
01-04
总的来说，理解和掌握这些Java基础知识点对于进行面试和实际开发都是非常重要的。它们涵盖了对象的比较、数据类型的存储、多态的概念、字符串操作以及类的组织结构等多个方面，这些都是Java程序员必须熟练掌握的基础...
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx
07-17
2024年欧洲铝桁架市场主要企业市场占有率及排名.docx
torchaudio-0.13.1+cpu-cp39-cp39-win_amd64.whl
最新发布
07-17
torchaudio软件包，直接下载下来，通过命令窗口输入：pip install torchaudio-xxx.whl安装就行，再也不怕pip安装timeout了
出入库存盘点表-图表分析-分类查询-Excel模板
07-17
【作品名称】：出入库存盘点表-图表分析-分类查询-Excel模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
torchaudio-0.12.1+cpu-cp37-cp37m-win_amd64.whl
07-17
torchaudio软件包，直接下载下来，通过命令窗口输入：pip install torchaudio-xxx.whl安装就行，再也不怕pip安装timeout了
2023年互联网大厂Java面试专题汇总文档
05-23
为什么说简历很重要？ 一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。 在不夸大自己能力的情况下， 写出一份好的简历也是一项很棒的能力。为什么说简历很重要呢? 先从面试来说 假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会 决定你这一关是Fail还是Pass。 假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。 另外，就算你通过了筛选，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多 时间去面试。 所以，简历就像是我们的一个门面一样，它在很大程度上决定了你能否进入到下一轮的面试中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值