Java校招

努力打基础的博

已于 2024-04-02 11:10:23 修改

阅读量496

点赞数 11

文章标签： java 面试开发语言

于 2024-02-03 15:26:48 首次发布

本文链接：https://blog.csdn.net/m0_52606846/article/details/136005717

版权

校招

笔试
面试

笔试

Java

一、选择

同一个进程的多个线程堆栈共享状况哪个描述正确？（A）
A 堆共享，栈私有
B 堆私有，栈共享
C 堆共享，栈共享
D 堆私有，栈私有

解析：线程栈是线程私有的资源，而堆内存是进程内线程共享的资源。

关于 Socket 通信编程，以下描述错误的是：（D）
A 服务器端通过new ServerSocket()创建TCP连接对象
B 服务器端通过TCP连接对象调用accept()方法创建通信的Socket对象
C 客户端通过new Socket()方法创建通信的Socket对象
D 客户端通过new ServerSocket()创建TCP连接对象
下列关于HTTP长连接和短连接描述正确的是？(BCD)
A HTTP1.1默认是短连接
B HTTP1.1可以通过Connection: keep-alive指定长连接
C 短连接占用服务器内存资源较少
D 长连接适用于客户端和服务端频繁通信的场景
以下关于Java中集合类ArrayList、LinkedList、HashMap描述错误的是（C）
A HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
B ArrayList和LinkedList均实现了List接口
C 添加和删除元素时，ArrayList的表现更佳
D ArrayList的访问速度比LinkedList快
以下描述正确的是（B）
A Java支持多重继承，一个类可以实现多个接口；
B Java只支持单重继承，一个类可以实现多个接口；
C Java只支持单重继承，一个类只可以实现一个接口；
D Java支持多重继承，但一个类只可以实现一个接口。
JAVA中extends 与implements有啥区别？
- 在类的声明中，通过关键字extends来创建一个类的子类。一个类通过关键字implements声明自己使用一个或者多个接口。
  extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用
- extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了

比如：class A extends B implements C,D,E

二、简答

简述java线程池的作用和实现方式。
简述java虚拟机的垃圾回收（GC）机制。

JavaWeb

关于Redis的持久化，下列描述错误的是：（C）
A RDB是以快照的形式，将内存中的数据整体拷贝到硬盘上。
B 执行RDB存储时会产生阻塞，因此RDB不适合实时备份，而适合定时备份。
C AOF是以日志形式，将内存中的数据整体拷贝到硬盘上。
D AOF操作的实时性好，但是产生的数据体积大，数据的恢复速度慢。

MySQL

一、选择

二、简答

以MySQL为例，请说出两种常见的数据库引擎。

Linux

Linux 中有一个文件夹为 work，修改它及它的子文件的权限为 755，下列命令正确的是（A）
A chmod -R 755 work
B chmod 755 work
C chmod -f 755 work
D chmod -v 755 work

操作系统

下列哪些情况下会导致线程中断或停止运行（B）
A InterruptedException异常被捕获
B 线程调用了wait方法
C 当前线程创建了一个新的线程
D 高优先级线程进入就绪状态

解析：
A，异常被捕获后不会导致线程中断，异常抛出才会
B，线程使用了wait方法，会强行打断当前操作，进入阻塞（暂停）状态，然后需要notify()方法或notifyAll()方法才能进入就绪状态
C，新创建的线程不会抢占时间片，只有等当前线程把时间片用完，其他线程才有资格拿到时间片去执行。
D，调度算法未必是剥夺式的，而准备就绪但是还没有获得CPU，它的权限更高只能说明它获得CPU被执行的几率更大而已

下列有可能导致一进程从运行变为就绪的事件是(D)
A 一次I/O操作结束
B 运行进程需作I/O操作
C 运行进程结束
D 出现了比现运行进程优先权更高的进程

友塔笔试

共四个题，依次15、25、35、45分，第三题没搞明白，忘了题目了（原题目都是各种较长情景，核心就是我下面精简的内容）

给定任意格式的俩个日期，判断两个日期间隔的天数（注：不允许使用系统自带的data库）

//我当时的思路：
public class DateDifferenceCalculator {

    public static void main(String[] args) {
        // Scanner方法以接收两个字符串格式的日期
        
        // 计算两个日期间隔的天数
        int daysBetween = calculateDaysBetween(dateString1, dateString2);

        // 输出结果
        System.out.println("日期 " + dateString1 + " 和日期 " + dateString2 + " 之间的天数差是: " + daysBetween);
    }

    /**
     * 计算两个日期之间的天数差
     * @param dateString1 第一个日期字符串
     * @param dateString2 第二个日期字符串
     * @return 两个日期间隔的天数
     */
    public static int calculateDaysBetween(String dateString1, String dateString2) {
        String[] parts1 = dateString1.split("-");
        String[] parts2 = dateString2.split("-");

        int year1 = Integer.parseInt(parts1[0]);
        int month1 = Integer.parseInt(parts1[1]);
        int day1 = Integer.parseInt(parts1[2]);

        int year2 = Integer.parseInt(parts2[0]);
        int month2 = Integer.parseInt(parts2[1]);
        int day2 = Integer.parseInt(parts2[2]);

        // 将日期转换为天数
        int days1 = yearToDays(year1) + monthToDays(year1, month1) + day1;
        int days2 = yearToDays(year2) + monthToDays(year2, month2) + day2;

        // 计算天数差
        return Math.abs(days2 - days1);
    }

    /**
     * 将年份转换为天数
     * @param year 年份
     * @return 该年份对应的天数
     */
    private static int yearToDays(int year) {
        // 假设每年都是365天，不考虑闰年
        return year * 365;
    }

    /**
     * 将年份和月份转换为天数
     * @param year 年份
     * @param month 月份
     * @return 该年份和月份对应的天数
     */
    private static int monthToDays(int year, int month) {
        // 每个月的天数，注意二月份需要根据是否是闰年进行调整
        int[] daysInMonth = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

        // 如果是闰年，二月份有29天
        if (month == 2 && isLeapYear(year)) {
            daysInMonth[1] = 29;
        }

        // 计算总天数
        int totalDays = 0;
        for (int i = 0; i < month - 1; i++) {
            totalDays += daysInMonth[i];
        }

        return totalDays;
    }

    /**
     * 判断是否为闰年
     * @param year 年份
     * @return 如果是闰年返回true，否则返回false
     */
    private static boolean isLeapYear(int year) {
        return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    }
}

//完整的实现
int y;
	int m;
	int d;

	public test2(int y,int m,int d ){
		this.y=y;
		this.m=m;
		this.d=d;
	}
	public int sum(test2 d){
		int day=0;
		int[] x={0,31,28,31,30,31,30,31,31,30,31,30,31};
		for(int i=1;i<d.y;i++){
			if(i%4==0&& i%100!=0 || i%400==0){
				day+=366;
			}else{
				day+=365;
			}
		}
		if(d.y%4==0&& d.y%100!=0 || d.y%400==0){
			x[2]=29;
		}
		for(int i=1;i<d.m;i++){

			day+=x[i];	
		}
		day+=d.d;
		System.out.println(day);
		return day;

	}
	public int DiffDays(test2 d){//计算两个日期之间的相距天数的成员方法 
		int s1=sum(this);
		int s2=sum(d);
		if(s1>s2){
			return s1-s2;
		}else{
			return s2-s1;
		}
	}
	public static void main(String args[]){ 
		int a,b,c; 
		test2 d1,d2; 
		try{ 
			d1=new test2(2020,02,03); 
			d2=new test2(2025,03,02); 
			System.out.println("相差的天数:"+d1.DiffDays(d2)); 
		}catch(Exception e){ 
			System.out.println("error"); 
		} 
	}

随机给n个整数，判断这些数字能否通过去掉其中的一些位上的数（不能全去掉），使其被8整除（注：不能重新排列数字的顺序）
重要思路：“被8整除的数，后三位也可以被8整除”，用个三层嵌套的for循环，表示三位数就行，注意可能两位数或一位数

Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
//提取后三位
int lastThreeDigits = num % 1000;

if(lastThreeDigits % 8 == 0){
}

给出一个矩形的四个顶点坐标及一个圆的圆心坐标和半径，判断这个矩形和这个圆能否相交或相切，若不相切，写出圆与矩形之间最近的距离

public class ShapeIntersection {

    // 计算两点之间的距离
    private static double distance(double x1, double y1, double x2, double y2) {
        return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
    }

    // 判断矩形和圆是否相交或相切
    public static boolean doIntersect(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4,double cx, double cy, double radius) {
        // 计算矩形的中心点
        double rectCenterX = (x1 + x2 + x3 + x4) / 4.0;
        double rectCenterY = (y1 + y2 + y3 + y4) / 4.0;

        // 计算矩形中心到圆心的距离
        double rectCenterToCircleDistance = distance(rectCenterX, rectCenterY, cx, cy);

        // 如果矩形中心到圆心的距离小于等于半径，则矩形和圆相交或相切
        if (rectCenterToCircleDistance <= radius) {
            return true;
        }

        // 计算矩形的每条边到圆心的距离
        double edgeDistances[] = {
                distance(cx, cy, (x1 + x2) / 2, (y1 + y2) / 2), // 上边
                distance(cx, cy, (x2 + x3) / 2, (y2 + y3) / 2), // 右边
                distance(cx, cy, (x3 + x4) / 2, (y3 + y4) / 2), // 下边
                distance(cx, cy, (x4 + x1) / 2, (y4 + y1) / 2)  // 左边
        };

        // 如果任何一条边的距离小于等于半径，则矩形和圆相交或相切
        for (double distance : edgeDistances) {
            if (distance <= radius) {
                return true;
            }
        }

        // 如果没有相交或相切的情况，返回false
        return false;
    }

    public static void main(String[] args) {
//Scanner方法接收所有的参数

        // 判断矩形和圆是否相交或相切
        boolean intersects = doIntersect(x1, y1, x2, y2, x3, y3, x4, y4, cx, cy, radius);
        System.out.println("The rectangle and the circle do not intersect or touch"));
    }
}

管培生

我的了解：在基地“集训”几个月，然后根据你的培训内容和表现给你“定岗”，工作地点是和公司商量着选合适的，不同公司的业务不一样，你的岗位职责是跟着公司走的，大部分员工是公司需要什么，你就学什么做什么，公司搞考研教育的，你要去整理资料和拉人这样。且管培生大都是需要”轮岗“的，就是哪里缺人你就顶上，包括但不限于加班、代同事的班、收集资料啥的，而且这些其实就是你的一部分工作内容；定岗后就在分部先干着，干个1-3年看业绩，业绩好了留下来，继续干有机会“晋升”；干的不太好就调你到发展好的地方让你去学东西提高自己。综合来说是一路伴随竞争的、需要做事能力强的、很吃业绩和机遇的职业。（引号引起来的就是HR说的术语，无贬义）

面试

项目是重中之重

Java常见和基础问题

1. Java中的引用数据类型有哪些？

其实只要不是基本数据类型就都是引用数据类型，有类、接口和数组

它们与基本数据类型的区别？
（1）从内存的构建方面来说(内存中,有堆内存和栈内存两者)
1、基本数据类型:被创建时,在栈内存中会被划分出一定的内存,并将数值存储在该内存中.
2、引用数据类型:被创建时,首先会在栈内存中分配一块空间,然后在堆内存中也会分配一块具体的空间用来存储数据的具体信息,即hash值,然后由栈中引用指向堆中的对象地址.
（2）从使用方面来说
1、基本数据类型:判断数据是否相等，用= =和 != 判断；
2、引用数据类型:判断数据是否相等，用equals()方法；

2. final有哪些用法?

被final修饰的类不可以被继承. 被final修饰的方法不可以被重写.
被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.
被final修饰的方法,JVM会尝试将其内联,以提高运行效率.
被final修饰的常量,在编译阶段会存入常量池中.

3. static用法

静态变量和静态方法，类实例所共享

4. 为什么有些java类要实现Serializable接口

为了网络进行传输或者持久化

5. 什么是序列化

将对象的状态信息转换为可以存储或传输的形式的过程

6. 常见的五种运行时异常：

ClassCastException （类转换异常）
IndexOutOfBoundsException （数组越界）
NullPointerException （空指针异常）
ArrayStoreException （数据存储异常，操作数组是类型不一致）
BufferOverflowException

7. 简述反射

定义：反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意个对象，都能够调用它的任意一个方法。在java中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制

8. String str="i"与 String str=new String(“i”)一样吗？

不一样，因为内存的分配方式不一样。String str="i"的方式，Java 虚拟机会将其分配到常量池中；而String str=new String(“i”) 则会被分到堆内存中。

9. Java如何实现跨平台？

我们编写的Java代码经javac编译后生成字节码文件（.class文件），再通过JVM（Java虚拟机）将字节码文件根据不同平台翻译成各自平台下的机器码文件。不同平台下编译生成的字节码是一样的，但是由JVM翻译成的机器码却不一样。

10. Java 与 C++ 的区别？

Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 兼容 C ，不但支持面向对象也支持面向过程。
Java 通过虚拟机从而实现跨平台特性， C++ 依赖于特定的平台。
Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
Java 支持自动垃圾回收，而 C++ 需要手动回收。
Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承

11. JDK、JRE、JVM，他们三者的关系？

JRE = JVM + Java 核心类库，它是Java运行时环境，只能运行class而没有编译的功能
JDK = JRE + Java工具 + 编译器 + 调试器，它是Java开发工具包

12. 面向对象有哪些特性？

面向对象四大特性：封装，继承，多态，抽象

1、封装就是将类的信息隐藏在类内部，不允许外部程序直接访问，而是通过该类的方法实现对隐藏信息的操作和访问。良好的封装能够减少耦合。
2、继承是从已有的类中派生出新的类，新的类继承父类的属性和方法，并能扩展新的能力，大大增加程序的重用性和易维护性。在Java中是单继承的，也就是说一个子类只有一个父类。
3、多态是同一个行为具有多个不同表现形式的能力。在不修改程序代码的情况下改变程序运行时绑定的代码。实现多态的三要素：继承、重写、父类引用指向子类对象。
静态多态性：通过重载实现，相同的方法有不同的參数列表，可以根据参数的不同，做出不同的处理。
动态多态性：在子类中重写父类的方法。运行期间判断所引用对象的实际类型，根据其实际类型调用相应的方法。

4、抽象。把客观事物用代码抽象出来。

13. 面向对象编程的六大原则?

单一职责：对象设计要求独立，不能设计万能对象。
开闭原则：对象修改最小化。
里式替换：程序扩展中抽象被具体可以替换（接口、父类、可以被实现类对象、子类替换对象）
迪米特：高内聚，低耦合。尽量不要依赖细节。
依赖倒置：面向抽象编程。也就是参数传递，或者返回值，可以使用父类类型或者接口类型。从广义上讲：基于接口编程，提前设计好接口框架。
接口隔离：接口设计大小要适中。过大导致污染，过小，导致调用麻烦。

14. 了解Java的包装类型吗？为什么需要包装类？

Java 是一种面向对象语言，很多地方都需要使用对象而不是基本数据类型。比如，在集合类中，我们是无法将 int 、double
等类型放进去的。因为集合的容器要求元素是 Object
类型。为了让基本类型也具有对象的特征，就出现了包装类型。相当于将基本类型包装起来，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

（1）在Java中，有时我们可能需要使用对象而不是原始数据类型。

例如，在使用集合时：

ArrayList<int> list = new ArrayList<>();// 错误

//正常运行
ArrayList<Integer> list = new ArrayList<>();

在这种情况下，包装器类可以帮助我们将原始数据类型用作对象。

例如，我们可以将空值存储在包装对象中：

int a = null;//将生成一个错误

// 正常运行
Integer a = null;

（2）使用包装类：

int a = 5;
//转换为包装对象
Integer aObj = Integer.valueOf(a);
//也可以直接转：Integer aObj = a;

15. 自动装箱和拆箱

（1）Java中基础数据类型与它们对应的包装类见下表：
原始类型包装类型
boolean Boolean
byte Byte
char Character
float Float
int Integer（-128 ~ 127）
long Long
short Short
double Double

装箱：将基础类型转化为包装类型。
拆箱：将包装类型转化为基础类型。
（2）当基础类型与它们的包装类有如下几种情况时，编译器会自动帮我们进行装箱或拆箱：
赋值操作（装箱或拆箱）
进行加减乘除混合运算（拆箱）
进行>,<,==比较运算（拆箱）
调用equals进行比较（装箱）
ArrayList、HashMap等集合类添加基础类型数据时（装箱）

16. String 为什么不可变？

String对象其实在内部就是一个个字符，存储在一个value数组里面。String类内部所有的字段都是私有的，也就是被private修饰。而且String没有对外提供修改内部状态的方法。

17. String, StringBuffer 和 StringBuilder区别

可变性： String 不可变
StringBuffer 和 StringBuilder 可变
线程安全： String 不可变，因此是线程安全的
StringBuilder 不是线程安全的
StringBuffer 是线程安全的，内部使用 synchronized 进行同步

18. String 类的常用方法有哪些？

String最大长度：2^31 -1
indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的byte类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

19. 什么是字符串常量池？

字符串常量池（StringPool）保存着所有字符串字面量，类似于缓冲区。这些字面量在编译时期就确定。字符串常量池位于堆内存中，专门用来存储字符串常量。在创建字符串时，JVM首先会检查字符串常量池，如果该字符串已经存在池中，则返回其引用，如果不存在，则创建此字符串并放入池中，并返回其引用。

20. Object常用方法有哪些？

toString：输出对象地址。
equals：比较两个引用变量是否指向同一个对象（内存地址）。
hashCode：将与对象相关的信息映射成一个哈希值，默认的实现hashCode值是根据内存地址换算出来。
clone：Java赋值是复制对象引用，如果我们想要得到一个对象的副本，使用赋值操作是无法达到目的的。Object对象有个clone()方法，实现了对象中各个属性的复制，但它的可见范围是protected的。

21. 深拷贝和浅拷贝？

浅拷贝：拷⻉对象和原始对象的引⽤类型引用同⼀个对象。
深拷贝：拷贝对象和原始对象的引用类型引用不同的对象。

22. equals与hashcode的关系：

hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

如果两个对象调用equals比较返回true，那么它们的hashCode值一定要相同；
如果两个对象的hashCode相同，它们并不一定相同。

23. Java创建对象有几种方式？

用new语句创建对象。
使用反射，使用Class.newInstance()创建对象。
调用对象的clone()方法。
运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法。

24. Java中类实例化顺序：

静态属性，静态代码块。
普通属性，普通代码块。
构造方法。

25. 方法重载和重写的区别？

重载：同个类中的多个方法可以有相同的方法名称，但是有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同），这就称为方法重载。
重写：方法的重写描述的是父类和子类之间的。当父类的功能无法满足子类的需求，可以在子类对方法进行重写。方法重写时，方法名、返回类型与形参列表必须一致，且访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)

26. 接口与抽象类的区别

接口：是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类
抽象类：Java中并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。（其实就是一个不能实例化对象的类）用abstract class 来定义抽象类。

相同点：都不能被实例化
不同点： 1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

27. Java支持多继承吗？

Java不支持多继承，指的是类不支持多继承。但Java接口可以通过继承多个父接口来实现多继承。

28. 黑盒测试和白盒测试

黑盒测试也称功能测试、数据驱动测试。
常用方法
　　等价类划分
　　边界值分析
　　因果图
　　决策表分析
白盒测试也称结构测试、逻辑驱动测试。
白盒测试逻辑驱动方法
　　语句覆盖
　　判定覆盖
　　条件覆盖
　　判定/条件覆盖
　　条件组合覆盖
　　路径覆盖

29. 反射

动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

反射的应用场景：
JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序

30. 泛型

31. 序列化和反序列化

当我们只在本地 JVM 里运行下 Java 实例，这个时候是不需要什么序列化和反序列化的，但当我们需要将内存中的对象持久化到磁盘，数据库中时，当我们需要与浏览器进行交互时，当我们需要实现 RPC 时，这个时候就需要序列化和反序列化 .实现序列化和反序列化要实现 Serializable 接口

只要我们对内存中的对象进行持久化或网络传输，这个时候都需要序列化和反序列化.

32. transient关键字的作用？

Java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。也就是说被transient修饰的成员变量，在序列化的时候其值会被忽略，在被反序列化后， transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。

Java web 面试

JSP九大内置对象
过滤器filter
监听器listener

谈谈自己的缺点

有什么想问的问题吗

这个问题根据是几面要问的问题不一样，例如一面时就不应该问什么薪资能给多少；例如二面时就不应该问贵公司是做什么的，我的发展前景怎么样（你一面和线下的时候干什么去了？这些不提前调查好就瞎投，hr给你发offer才怪）而且最好是思考一下，别急着说没有。但也有一些通用的问题：
eg: 问这场面试中自身有什么不足
对于我的表现有什么建议吗

中科创达-Java开发工程师

谈谈项目
项目有没有进行什么优化：数据库数据较多时；调取数据次数多时；
索引
Java的异常处理机制

Java所有异常类都是 Throwable的子类。
它包括Java异常处理的两个重要子类：Error和Exception

异常处理机制为：抛出异常，捕捉异常。
总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出。允许忽略不可查的RuntimeException和Error。

抛出异常的方法：throws和throw

throws：通常被用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔。throws关键字将异常抛给上一级，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

throw：通常用在方法体中或者用来抛出用户自定义异常，并且抛出一个异常对象。程序在执行到throw语句时立即停止，如果要捕捉throw抛出的异常，则必须使用try-catch语句块或者try-catch-finally语句。

对于try-catch-finally语句：先执行try 块中的代码，如果正常运行没有发生异常则执行完后执行finally 代码块中的代码；如若在try 中发生异常且被catch 捕捉到则执行catch 中的代码块，然后执行finally 块中的代码；

final和finally的区别

final是一个修饰符，可以用于类、方法和变量。当用于类时，表示该类不能被继承；当用于方法时，表示该方法不能被重写；当用于变量时，表示该变量只能被赋值一次，即为常量。
finally是一个关键字，用于结构化异常处理中的try-catch-finally块。
总之，final用于修饰类、方法和变量，用于实现不可变性；而finally用于结构化异常处理中的清理代码块，用于确保资源的正确释放。

说一下线程
是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。它负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。
Java 程序天生就是多线程程序，一个 Java 程序的运行是 main 线程和多个其他线程同时运行。

多进程：操作系统中同时运行的多个程序
多线程：在同一个进程中同时运行的多个任务

说一下集合

List (对付顺序的好帮⼿)：存储的元素是有序可重复的。
Set (注重独⼀⽆⼆的性质): 存储的元素是⽆序不可重复的。
Map (⽤ Key 来搜索的专家): 使⽤键值对（kye-value）存储，Key 是⽆序的、不可重复的，value 是⽆序的、可重复的，每个键最多映射到⼀个值。

hashmap和hashtable区别

线程是否安全： HashMap 是⾮线程安全的，HashTable 是线程安全的（如果你要保证线程安全的话就使⽤ConcurrentHashMap ）；
效率：因为线程安全的问题，HashMap 要⽐ HashTable 效率⾼⼀点。
对 Null key 和 Null value 的⽀持： HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有⼀个，null 作为值可以有多个；HashTable 不允许有 null 键和 null 值，否则会抛出NullPointerException。
底层数据结构： HashMap 在解决哈希冲突时有了较⼤的变化，当链表⻓度⼤于阈值（默认为 8）（将链表转换成红⿊树前会判断，如果当前数组的⻓度⼩于64，那么会选择先进⾏数组扩容，⽽不是转换为红⿊树）时，将链表转化为红⿊树，以减少搜索时间。Hashtable 没有这样的机制。

servlet生命周期

Servlet 生命周期可被定义为从创建直到毁灭的整个过程。
三个步骤即：初始化------>处理请求------>销毁

创建Servlet对象后---------->
初始化（调用 init () 方法）--------->
处理/响应客户端的请求（调用service() 方法）--------->
销毁（调用 destroy() 方法，最后由 JVM 的垃圾回收器进行垃圾回收）

项目中有用到并发吗？对并发有什么了解
你的爱好
你对我们公司了解吗，你投了哪些岗位，现在手上有offer吗，期望薪资是多少？
这个系列问题真的是不能交心的谈，你必须表现出专业专一才行，

一定要提前查公司和你投的岗位（公司业务、发展前景、你的大致工作内容及职业规划）
千万别说自己在广投各个职位，这样显得你对自己没有定位，对他们公司也不够在意
手上有没有offer我也不知道该怎么回答，待更新
期望薪资其实也可以提前查一下，被问及时报个大概的要求。有些个公司真的是你说高了hr立马哑火了，有时候说的较高可能很容易被刷的

泛微-Java开发工程师

自己最熟悉的技术栈？
Spring Boot
Java异常框架知道哪些？
try、catch、finally、throw、throws
Throwable下的各种实现类
它有两个子类：Error 和Exception。Error用来处理程序运行环境方面的异常
cookie和session是什么？
Cookie实际上是一小段的文本信息。客户端请求服务器，如果服务器需要记录该用户状态，就使用response向客户端浏览器颁发一个Cookie。客户端会把Cookie保存起来。当浏览器再请求该网站时，浏览器把请求的网址连同该Cookie一同提交给服务器。服务器检查该Cookie，以此来辨认用户状态。服务器还可以根据需要修改Cookie的内容。

Session是另一种记录客户状态的机制，不同的是Cookie保存在客户端浏览器中，而Session保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上。这就是Session。客户端浏览器再次访问时只需要从该Session中查找该客户的状态就可以了。

值类型和引用类型的区别？

引用类型存储的是地址，它表示你操作的数据是同一个，也就是说当你传一个参数给另一个方法时，你在另一个方法中改变这个变量的值，那么调用这个方法是传入的变量的值也将改变。除了八种基本数据类型外，其他所有的类型都称为引用类型（数组、类、接口、字符串等）

值类型存储的是值，它表示复制一个当前变量传给方法，当你在这个方法中改变这个变量的值时，最初生命的变量的值不会变。byte、short、int、long、double、float、char、boolean

值类型和引用类型分别在JVM哪个区域？

引用类型放在堆中。
值类型一般在栈中，但也有特殊的，如数组里的基本类型就放在对应的堆内存中。

String是值类型吗？
不是，是引用类型，它的默认值是null(这是对象的默认值)
servlet生命周期？

Servlet 初始化后调用 init () 方法。
Servlet 调用 service() 方法来处理客户端的请求。

service() 方法是执行实际任务的主要方法。Servlet 容器（即 Web 服务器）调用 service() 方法来处理来自客户端（浏览器）的请求，并把格式化的响应写回给客户端。每次服务器接收到一个 Servlet 请求时，服务器会产生一个新的线程并调用服务。service() 方法检查 HTTP 请求类型（GET、POST、PUT、DELETE等），并在适当的时候调用 doGet、doPost、doPut，doDelete 等方法。

Servlet 销毁前调用 destroy() 方法。
最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

事务的隔离级别有了解吗？
事务具有原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）四个特性，简称 ACID。

SQL 标准定义了四个隔离级别：
READ-UNCOMMITTED(读取未提交)：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。
READ-COMMITTED(读取已提交)：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生。
REPEATABLE-READ(可重复读)：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
SERIALIZABLE(可串行化)：最高的隔离级别，完全服从ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。

mysql里面用什么关键字进行分页？
LIMIT分页查询
MySQL默认隔离级别
MySQL默认支持的隔离级别是 REPEATABLE-READ（可重读）。
static局部变量与全局变量的区别，编译后映射文件是否包含此类变量的地址?

局部变量局部有效;编译后不产生变量地址。
全局变量在整个程序运行中有效;编译后产生变量地址。

请论述Vector和ArrayList的区别。

Vecotor线程安全，ArrayList线程不安全，由于线程的同步必然要影响性能，所以ArrayList的性能比Vector好，当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

String str="i"与 String str=new String(“i”)一样吗？

不一样，因为内存的分配方式不一样。String str="i"的方式，Java 虚拟机会将i值存在常量池，地址赋给str1。假设再写一个String str2=“i”，则会把i的地址赋给str2，但是i对象不会重新创建，他们引用的是同一个地址值，共享同一个i内存。；而String str=new String(“i”) 则会创建一个i对象，然后将对象的地址值放到堆内存中。

拓展：
堆内存用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。

String 类的常用方法都有那些？

String最大长度：2^31 -1
indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的byte类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

java 中 IO 流分为几种？
springboot项目里常用的注解
1、@SpringBootApplication：放在启动类上，标注一个Spring Boot应用
2、@RequestMapping ：用于将任意HTTP 请求映射到控制器方法上

  @RequestMapping("/user/login")  
    public String login() {
        return "user login";
    }

3、@RestController：

JDK 和 JRE 有什么区别？

JRE = JVM + Java 核心类库(java.lang、java.io)，它是Java运行时环境，只能运行class而没有编译的功能
JDK = JRE + Java工具(javac(编译用的)、java) + 编译器 + 调试器，它是Java开发工具包

final 在 java 中有什么作用？

凡是引用final关键字的地方皆不可修改！
(1)修饰类：表示该类不能被继承；
(2)修饰方法：表示方法不能被重写；
(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）
(4)修饰常量：在编译阶段会存入常量池中.

相信大家都具备基本的常识: 被final修饰的变量是不能够被改变的. 但是这里的"不能够被改变"对于不同的数据类型是有不同的含义的.
当final修饰的是一个基本数据类型数据时, 这个数据的值在初始化后将不能被改变; 当final修饰的是一个引用类型数据时,也就是修饰一个对象时, 引用在初始化后将永远指向一个内存地址, 不可修改. 但是该内存地址中保存的对象信息, 是可以进行修改的.

new String(“a”) + new String(“b”) 会创建几个对象？

对象1： new StringBuilder()
对象2： new String(“a”)
对象3：常量池中的"a"
对象4： newString(“b”)
对象5：常量池中的"b"
对象6 ：new String(“ab”)

接口和抽象类有什么区别？

相同点：都不能被实例化
不同点：（1）接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。
（2）实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
（3）接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。