【笔记】每天一个面试题
本帖最后由 小白不怂 于 2021-4-26 21:51 编辑做一下笔记，面试题来源与网络，主要来源于牛客网，侵权删除
### 4.11
有这样一段程序
```java
public class Test{
public static void main(String [] args){
List list=new ArrayList();
list.add("a");
list.add("b");
list.add("a");
Set set=new HashSet();
set.add("a");
set.add("b");
set.add("a");
System.out.println(list.size()+","+set.size());
}
}
```
请问运行主要的程序会打印出的是什么（）(刮一刮出答案)
<font color=#fff >3,2</font>
解析：
**list有序可重复，set无序不可重复，list可以插入多个null元素，而set只允许插入一个null元素**
### 4.12
指出接下来程序运行的结果
```java
public class Example{
String str = new String("good");
char[] ch ={'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
str = "test ok";
ch = 'g';
}
}
```
<font color=#fff >good and gbc</font>
个人理解，欢迎纠错补充
实参和形参的问题。
String类型的`str`是值传递，在调用`change()` 方法时，改变的指是`change()` 方法中的形参，并未真正修改实参`str`
而方法中`ch`是引用传递，也称传地址，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。
**涉及知识点**
1. java中传递参数的两种方式
1. 值传递：传递值的数据类型，八种基本数据类型和String(事实上String也是传递的地址,只是string对象和其他对象是不同的，string对象是不能被改变的，内容改变就会产生新对象。那么StringBuffer就可以改变值，但只是改变其内容。不能改变外部变量所指向的内存地址)。
2. 引用传递：传递地址值的数据类型：除String以外的所有复合数据类型，包括数组、类和接口
2. java中形参，实参，成员变量，局部变量，构造方法的作用和区别
1. 形参：**用来接受实参中传过来的值**，对与基本数据类型和string，形参的改变不影响实际参数，对引用类型，形参的改变直接影响实际参数
2. 实参：实际参数
3. 局部变量：
1. 也称内部变量，是指在一个方法内部、方法声明上或复合语句内部定义的变量（方法和函数只是叫法不同）
2. 没有默认的初始化值，必须先定义，赋值，才能使用
3. 内存位置：栈内存
4. 生命周期：随着方法的调用而存在，随着方法的调用完毕而消失。
4. 全局变量：既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是**可以被本程序所有对象或函数引用**。
5. 成员变量：
1. 位置：类中方法外
2. 内存位置：堆内存
3. 生命周期：随着对象的存在而存在，随着对象的消失而消失
6. 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则
7. Java构造函数，也叫构造方法，是JAVA中一种特殊的函数。与函数名相同，无返回值
3. 基本类型
1. 整数型：byte、short、int、long
1. byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间
2. short：16位，最大数据存储量是65536，数据范围是-32768~32767之间
3. int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1
4. long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1
2. 浮动型：float、double
1. float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F
2. double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加
3. 字符型：char 存储Unicode码，用单引号赋值
4. 布尔型：boolean 只有true和false两个取值
### 4.13
A 是抽象父类或接口， B ， C 派生自 A ，或实现 A ，现在 Java 源代码中有如下声明：
>1. A a0=new A();
>
>2. A a1 =new B();
>
>3. A a2=new C();
问以下哪个说法是正确的？（ ）
>A.第1行不能通过编译
>
>B.第1、2行能通过编译，但第3行编译出错
>
>C.第1、2、3行能通过编译，但第2、3行运行时出错
>
>D.第1行、第2行和第3行的声明都是正确的
答案：<font color=#fff >**A**</font>
解析：**抽象类和接口不能实例化！**
### 4.14
以下JAVA程序代码的输出是
```java
public static void main(String args[]) {
System.out.println(17^5);
}
```
>A.12 B.22 C.20 D.1419857
解析：(主要来自于`牛客网-XUYINGJIE-`)
按位异或(^)运算是一个二进制运算：两者相同为0，两者不同为1
17^5: 分别将17、5转为二进制，然后从后向前比较 ，相同为0，不同为1
17 = 10001
5 = 101
17^5 = 10100
10100 转为10进制为：20
**知识点**
1. 异或运算的一些性质
. a^0=a
2. a^a=0
3. 在数学中的运算符未`⊕`
4. 满足交换律和结婚律 a⊕b⊕a = (a⊕a)⊕b = 0⊕b = b
2. 使用异或运算交换2个数值
```java
a=11, b=9.
a = a^b = 1011^1001 = 0010;
b = b^a = 1001^0010 = 1011;
a = a^b = 0010^1011 = 1001;
//经运算后，此时：a = 9,b = 11;
```
3. 位运算
1. 按位与(**&**) 同时为1，则为1 否则为0 例：a = 2; b = 3; a & b => 10 & 11 => 10
2. 按位或(**|**) 有一个为1，则为1，否则为0 例：a = 2; b = 3; a | b => 10 | 11 => 11
3. 按位异或(**^**) 不同为1，相同为0 例：a = 2; b = 3; a ^ b => 10 ^ 11 => 01
4. 按位取反(**~**) 二进制数在内存中是以补码的形式存在的，我们要得到补码然后取按位取反
原码->反码->补码 列:a = 2;二进制原码 => 10 反码 => 010 ,前面补零（多1位符号位）其中最左面的是符号位，0为正，1为负。正数原反补一样，负数是原码(符号位不变 取反) -> 反码(反码+1) -> 补码。010是正数，补码为 010 ， 对补码按位取反101，把按位取反后的二进制数101转为补码，101是负数，101 => 110 => 111 = > -0b11 => -3 公式 ~x = -(x+1)
5. 按位左移 (**<<**) 按位左移，左移n位相当于乘以2的n次方 例：a = 2; a << 3 => 16
6. 按位右移 (**>>**) 按位右移，左移n位相当于除以2的n次方 例：a = 2; a >> 3 => 0
### 4.15
#### 1、A,B,C,D 中哪些是 setvar的重载？(多选)
```java
public class methodover
{
public void setVar(int a, int b, float c) {}
}
```
> A.private void setVar(int a， float c， int b){}
>
> B.protected void setVar(int a， int b， float c){}
>
> C.public int setVar(int a， float c， int b){return a;}
>
> D.public int setVar(int a， float c){return a;}
答案：ACD
解析：
**重载是在同一个类中，有多个方法名相同，参数列表不同(参数个数不同，参数类型不同，顺序不同),与方法的返回值无关，与权限修饰符无关**，B中的参数列表和题目的方法完全一样了。
#### 2、下列关于while循环、do-while循环和for循环说法错误的是(多选)
>A.while循环先执行条件判断，do-while循环执行循环体
>B.do-while循环结束的条件是关键字while后的条件表达式成立
>C.for循环结构中的3个表达式缺一不可
>D.while循环能够实现的操作，for循环也能实现
答案：BC
解析：
A while只有在满足条件时执行，而do-while会先执行一次 再看条件是否满足 满足再次循环 不满足跳出
B 说的是do-while的**循环结束**的条件，自然是条件不成立才结束，所以B错误
Cfor循环中的"单次表达式"、"条件表达式"和"循环体语句"都是选择项, 即可以缺省成只剩下`;`的空语句，`;`不能 缺省的原因是编译格式如此，缺省了[编译器](https://baike.sogou.com/lemma/ShowInnerLink.htm?lemmaId=106869&ss_c=ssc.citiao.link)不认识而会报错。
省略了用来初始化的单次表达式时, 表示不对循环[控制变量](https://baike.sogou.com/lemma/ShowInnerLink.htm?lemmaId=7623797&ss_c=ssc.citiao.link)赋初值。
省略了条件表达式, 若不做其它处理则成为死循环。
省略了所有循环体， 则for语句不被其它形式处理时不产生任何作用。
D while与for是可以实现的，do-while就不对了
###4.16下列方法中哪个是执行线程的方法？ （）
>run（）
>start（）
>sleep（）
>suspend（）
答案：run()
解析：
run()方法用来执行线程体中具体的内容
start()方法用来启动线程对象，使其进入就绪状态
sleep()方法用来使线程进入睡眠状态
suspend()方法用来使线程挂起，要通过resume()方法使其重新启动
### 4.17 jvm中垃圾回收分为scanvenge gc和full GC，其中full GC触发的条件可能有哪些
>A.栈空间满
>B.年轻代空间满
>C.老年代满
>D.持久代满
>E.ystem.gc()
答案：CDE
解析：
垃圾收集机制：新生代、老年代、持久代
!(https://uploadfiles.nowcoder.com/images/20180411/7172803_1523440475066_2AA6D19E6A170E0E245A561A593D035E)
1，新生代：（1）所有对象创建在新生代的Eden区，当Eden区满后触发新生代的Minor GC，将Eden区和非空闲Survivor区存活的对象复制到另外一个空闲的Survivor区中。（2）保证一个Survivor区是空的，新生代Minor GC就是在两个Survivor区之间相互复制存活对象，直到Survivor区满为止。
2，老年代：当Survivor区也满了之后就通过Minor GC将对象复制到老年代。老年代也满了的话，就将触发Full GC，针对整个堆（包括新生代、老年代、持久代）进行垃圾回收。
3，持久代：持久代如果满了，将触发Full GC。
System.gc是有可能触发full gc的。这个方法的调用是建议jvm进行full gc，虽然只是建议而非一定，但很多情况下会触发full gc，从而增加了full gc的频率，但弊端是增加了间歇性停顿的次数，不建议使用。
### 4.19
#### 以下类定义中的错误是什么？（）
```java
abstract class xy
{
abstract sum (int x, int y) { }
}
```
>A.没有错误
>B.类标题未正确定义
>C.方法没有正确定义
>D.没有定义构造函数
答案：C.方法没有正确定义
解析
1、抽象方法不能有方法体，只能声明
2、该方法缺少返回值，只有构造没有返回值
#### ArrayList list = new ArrayList(20);中的list扩充几次
A.0
B.1
C.2
D.3
答案 A
解析
Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8，如果新创建的集合有带初始值，默认就是传入的大小，也就不会扩容
### 4.22
#### 假设一个 list初始化为{2，9，5，4，8，1}。 在第一轮冒泡排序后，list变成了（）?
>2, 9, 5, 4, 8, 1
>2, 9, 5, 4, 1, 8
>2, 5, 9, 4, 8, 1
>2, 5, 4, 8, 1, 9
答案：2, 5, 4, 8, 1, 9
解析：
冒泡排序：相邻之间两两交换，将最大值放到末尾，一直缩小范围到第一位
```java
package chaopst_work3;
import java.util.Arrays;
public class Test3 {
public static void main(String[] args) {
//定义数组
int [] arr = new int[] {19,25,1,58,30,46,97,34,62,92};
//冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr>arr) {
int temp=arr;
arr=arr;
arr=temp;
}
}
}
//展示
for (int i = 0; i < arr.length; i++) {
System.out.print(arr + "\t");
}
System.out.println();
//最小值
System.out.println("最小值为："+arr);
}
}
```
#### 下列代码的执行结果是：（ ）
```java
public class Test3{
public static void main(String args[]){
System.out.println(100%3);
System.out.println(100%3.0);
}
}
```
>1和1
>1和1.0
>1.0和1
>1.0和1.0
答案：1和1.0
解析：
关于基本数据类型之间的互相转换：转换规则
1. 八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以互相转換
2. 小容量向大容量转换，称为自动类型转换，容量从小到大排序
byte< short< int < long < float < double < char
注：任何浮点类型不管占用多少个字节，都比整数型容量大
所以100%3.0会自动转换为double类型，Java小数默认类型为double
### 4.23
#### 一个以". java"为后缀的源文件，哪些说法是正确的？
>只能包含一个类，类名必须与文件名相同
>只能包含与文件名相同的类，以及其中的内部类
>只能有一个与文件名相同的类，可以包含其他类
>可以包含任意类
答案：只能有一个与文件名相同的类，可以包含其他类
解析：
当编写一个java源代码文件时，此文件通常被称为编译单元（有时也被称为转译单元）。每个编译单元都必须有一个后缀名.java，而在编译单元内则可以有一个public类，该类的名称必须与文件的名称相同（包括大小写，但不包括文件的后缀名.java）。每个编译单元只能有一个public类，否则编译器就不会接受。如果在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看见这些类的，这是因为它们不是public类，而且它们主要用来为主public类提供支持。 -------《Java 编程思想》
#### 下面属于java合法变量定义的是？
>final
>1var1
>_var2
>var3&
答案：_var2
解析：
==标识符可以包括这4种字符：字母、下划线、$、数字；开头不能是数字；不能是关键字==
#### 字符界面下接受用户从键盘输入，需要import的包是：（ ）
>java.lang包
>java.awt包
>java.io包
>java.applet包
答案：java.io包
解析：
这个问题的前题是：字符界面下
字符界面就是操作系统或应用软件的界面,和操作都是字符实现,没有图形.dos系统就是典型的字符界面.
与之相对的就是图形界面.也是界面和操作运用了图形.windows就是典型的图形界面
==字符流的传输，需要导入java.io包，而java.util中的Scanner则是获取控制台的输入。==
#### / * .................. * /中可以嵌套//注释，也能嵌套/ * .......... * /注释。
>正确
>错误
答案：错误
解析：在Java中规定，多行注释可以嵌套单行注释，但是不能嵌套多行注释。 而且这样嵌套根本没意义啊
#### DBMS 中实现事务持久性的子系统是()
>安全性管理子系统
>完整性管理子系统
>并发控制子系统
>恢复管理子系统
答案：恢复管理子系统
解析:
链接：https://www.nowcoder.com/questionTerminal/9b1fef54196f4d1e881804bb235fcd2c
来源：牛客网
**DBMS：**数据库管理系统(Database ManagementSystem)是一种操纵和管理数据库的大型软件，用于建立、使用和维护数据库，简称DBMS。
DBMS中事务有四个特性：
==原子性-事务管理子系统。一致性-完整子系统。隔离性-并发控制子系统。持久性-恢复管理子系统==
#### 以下哪些方法是Object类中的方法
>clone()
>toString()
>wait()
>finalize()
答案：以上都是
解析：
Object是所有类的父类，任何类都默认继承Object，Object实现了以下方法
1．clone方法
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
2．getClass方法
final方法，获得运行时类型。
3．toString方法
该方法用得比较多，一般子类都有覆盖。
4．finalize方法
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
5．equals方法
该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
6．hashCode方法
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
一般必须满足obj1.equals(obj2)== true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
7．wait方法
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
8．notify方法
该方法唤醒在该对象上等待的某个线程。
9．notifyAll方法
该方法唤醒在该对象上等待的所有线程。
### 4.24
#### 有一个源代码，只包含import java.util.* ; 这一个import语句，下面叙述正确的是？( )
>只能写在源代码的第一句
>可以访问java/util目录下及其子目录下的所有类
>能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
>编译错误
答案：能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
解析：
导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，应该使用哪个a类呢。所以也应该选C
#### ResultSet中记录行的第一列索引为？
>-1
>0
>1
>以上都不是
答案：1
解析：
结果集(ResultSet)，通常通过执行查询数据库的语句生成，是数据中查询结果返回的一种对象，可以说结果集是一个存储查询结果的对象，但是结果集并不仅仅具有存储的功能，他同时还具有操纵数据的功能，可以完成对数据的更新等。
1 、读取方法1 – 通过索引来遍历读取
```java
while(rs.next()){
int id = rs.getInt(1);
String name = rs.getString(2);
String gender = rs.getString(3);
System.out.println("学号:"+id+" 姓名："+name+" 性别："+gender);
}
```
2 、读取方法2 – 通过字段名称来读取
```java
while(rs.next()){
int id = rs.getInt("id");
String name = rs.getString("name");
String gender = rs.getString("gender");
System.out.println("学号:"+id+" 姓名："+name+" 性别："+gender);
}
```
强调一下，这个传入的字段名称可以不区分大小写，因为在mysql中就是不区分的
#### 说明输出结果。
```java
package test;
import java.util.Date;
public class SuperTest extends Date{
private static final long serialVersionUID = 1L;
private void test(){
System.out.println(super.getClass().getName());
}
public static void main(String[]args){
new SuperTest().test();
}
}
```
>SuperTest
>SuperTest.class
>test.SuperTest
>test.SuperTest.class
答案：test.SuperTest
解析：
1、super.getClass()的意思是调用的是父类即Date类的方法，而不是对父类执行getClass()方法； super就是父类的意思
2、父类的getClass方法继承自Object类，且该方法是final的，不能被修改；
3、Object中的getClass()返回的是当前运行的类，即SuperTest;
4、Class中的getName()方法针对引用类型的返回的是包名+类名，即test.SuperTest;
5、如果想要返回父类，即Date的名称，可以使用super.getClass().getSuperClass().getName();
6、此处super还是this，亦或直接getClass().getName()，结果都是一样的；
### 4.25
#### 对于java类型变量char c,short s,float f,double d,表达式c*s+f+d的结果类型为（）
>float
>char
>short
>double
答案：double
解析：
考察的是数据类型的转换
小容量向大容量转换，称为自动类型转换，容量从小到大排序
byte< short < char < int < long < float < double
#### Java 语言用以下哪个类来把基本类型数据封装为对象（）
>包装类
>Class
>Math
>Object
答案：包装类
解析：
java的数据类型分为两大类：基本类型和引用类型；
基本类型只能保存一些常量数据，引用类型除了可以保存数据，还能提供操作这些数据的功能；
为了操作基本类型的数据，java也对它们进行了封装， 得到八个类，就是java中的基本类型的封装类；他们分别是：
八种基本类型： byte short int long float double char boolean
对应的包装类 ： Byte Short Integer Long Float Double Character Boolean
答案:A
### 4.26
#### Java 源程序文件的扩展名为（）
>.java
>.class
>.exe
>.jar
答案：.java
解析
java中源文件的后缀为.java，经过javac.exe编译后生成字节码文件，后缀为.class，再经过java.exe编译为可执行文件，后缀为.exe。
.jsp：是Java 服务器页面技术，支持Java代码的***页；
.xml：可拓展文本标记语言，一种文本格式，常用来做配置文件；
.jar：一种压缩包格式，常用来打包 Java 类库。
#### 下列正确的是
>形式参数可被字段修饰符修饰
>形式参数不可以是对象
>形式参数为方法被调用时真正被传递的参数
>形式参数可被视为local variable
答案：形式参数可被视为local variable
解析：
A：形式参数只能被final修饰
B：形式参数可以是对象
C：形式参数被调用时被传递的是实际参数的拷贝
D：local variable：局部变量
#### 类所实现的接口以及修饰不可以是（）。
>void
>public
>abstract
>final
答案：final
解析
final可以修饰方法，属性，类，就是不能修饰接口，因为final修饰表示不能被继承，接口就是用来给别人继承实现的，接口不能被继承了还有什么意义呢
#### 下列不属于算法结构的是（）
>输入数据
>处理数据
>存储数据
>输出结果
答案：存储数据
解析：
算法包括0个或多个输入，1个或多个输出，中间有穷个处理过程。
存储结构不属于算法结构
一个算法应该具有以下五个重要的特征：
##### 有穷性
（Finiteness）
算法的有穷性是指算法必须能在执行有限个步骤之后终止；
##### 确切性
(Definiteness)
算法的每一步骤必须有确切的定义；
##### 输入项
(Input)
一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；
##### 输出项
(Output)
一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；
##### 可行性
(Effectiveness)
算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。
#### 关于下列代码的正确的是
```java
byte b1=1,b2=2,b3,b6;
final byte b4=4,b5=6;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);
```
>输出结果：13
>语句：b6=b4+b5编译出错
>语句：b3=b1+b2编译出错
>运行期抛出异常
答案：语句：b3=b1+b2编译出错
解析：
被final修饰的变量是常量，所以`b6=b4+b5; `的计算过程中并不会转换为int类型，
而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。
Java中的byte，short，char进行计算时都会提升为int类型。
list有序可重复，set无序不可重复，list可以插入多个null元素，而set只允许插入一个null元素 类似于tuple
页:
[1]