Java开发面经成长经历

Java开发面经

最近实习找工作,记录一下面试经历,趁机再抱一下佛脚,不定时更新

2021/8/19

一. Javascript部分

1. 定义变量的方法有哪些，全局变量如何定义

答:
1.定义变量的方式有:var,let,const
2.全局变量:const

2. ==和===的区别

答：
===比较类型和值，==只比较值。

3. for/i , for/in , for/of 的区别

答

1. for/i 用来遍历数组,i代表数组下标
2. for…in 循环用来遍历json对象：只能获得对象的键名，不能获得键值
3. for…of 循环：允许遍历获得键值

4. 邮箱正则表达式

答:
/^ [A-Za-zd0-9]+([-_.][A-Za-zd]+)*@([A-Za-zd]+[-.])+[A-Za-zd]{2,5}$/;

5. IP地址正则表达式

答:
/^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5]).(\d{1,2}|1\d\d|2[0-4]\d|25[0-5]).(\d{1,2}|1\d\d|2[0-4]\d|25[0-5]).(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/

6. 用正则提取题干中的数字(有整数,小数)

答:

var str = '123.456sdfsdf456.789'
var numArr = str.match(/(\d+\.)?\d+/g)
console.log(numArr) / /=> ["123.456", "456.789"]
输出：["123.456", "456.789"]

二. Java部分

1. Map或者HasMap的存储结构

答:
HashMap是由数组+链表组成。寻址easy，插入和删除easy。（存储单元数组Entry[]，数组里面包括链表）
https://blog.csdn.net/fsfsfsdfsdfdr/article/details/82876165
https://blog.csdn.net/shshaashsh/article/details/99311888

2. 数组和链表的区别和是适用场景

答:
https://blog.csdn.net/weixin_45151960/article/details/102757001

3. Switch是否可用在byte,long,char

答:
switch可作用于char byte short int
switch可作用于char byte short int对应的包装类
switch不可作用于long double float boolean，包括他们的包装类
switch中可以是字符串类型,String(JDK1.7之后才可以作用在string上)
switch中可以是枚举类型(JDK1.5之后)

4. ==和equal的区别

答:
==:
== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。
1、比较的是操作符两端的操作数是否是同一个对象。
2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：
int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。
equals：
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

5. 重载和重写的区别?是否可以根据返回值判断是否是重载?类中是否所有方法都可以重载

答:

1. 重载发生在一个类中，同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者两者都不同)则视为重载；重写发生在子类和父类之间，重新要求子类被重写方法和父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常(里氏替换原则)。
2. 重载对返回类型没有特殊要求。不能根据返回类型判断是否是重载
3. 静态方法和父类的私有方法都是不可以重载的。

6. 打开一个文件的字节输入流

答: https://blog.csdn.net/weixin_45747080/article/details/106747110

public class TestIO {
    public static void main(String[] args) {
        //1、指定我们想要读取的文件（源）
        File file = new File("TEST_JAVA.iml");
        //2、创建字节数组用来存储读取到的数据，字节数组长度为100
        byte[] bytes = new byte[100];
        try {
            //3、给file类对象创建输入流
            FileInputStream in = new FileInputStream(file);
            if (in.read(bytes)!=-1){//4、用read(bytes)方法将读取到的数据输入到bytes里
                //5、用String构造方法创建字节数组bytes的String对象，方便我们输出
                String string = new String(bytes);
                //6、输出bytes的String对象
                System.out.println(string);
            }
            //7、关闭输入流
            in.close();
        } catch (IOException e) {//8、捕获异常
            e.printStackTrace();
        }
    }
}

7. 打开一个文件的字符输入流

答:
FileReader reader = new FileReader(“1.txt”);
8. 创建多线程任务
答: https://www.cnblogs.com/mujingyu/p/7856344.html

public class MyThread1 extends Thread {
    public MyThread1(String name) {
        this.setName(name);
    }
    public void run() {
        for(int i=20;i<=100;i++) {
            System.out.println(getName()+"..."+i);
        }
    }
}

//启动
MyThread1 myThread = new MyThread1("新线程");
myThread.start();

9. 乐观锁和悲观锁

答:
https://blog.csdn.net/qq_34337272/article/details/81072874
https://www.jianshu.com/p/d2ac26ca6525
a.悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
b. 乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

10. &和&&

答:
https://www.cnblogs.com/hongten/p/hongten_java_yu.html
https://blog.csdn.net/ShyTan/article/details/81609983
&&: 短路与
&: 逻辑与
对于：& – > 只要左右两边有一个为false，则为false；只有全部都为true的时候，结果为true
对于：&& – > 只要符号左边为false，则结果为false；当左边为true，同时右边也为true，则结果为true

三. Mysql部分(只记得这些了)

1. 一条sql执行过长的时间，你如何优化，从哪些方面？

答:
https://www.cnblogs.com/waitmoon/p/13799887.html
https://www.cnblogs.com/zhaoyan001/p/9981539.html
简单回答：执行计划调优、语句调优、索引调优、设计调优、业务调优。
中级回答：时间有限，回答得不全面。
1.执行计划调优
熟读执行计划，十大参数。
2.语句调优
尽量全值匹配。
范围条件放最后。
Null/Not 有影响。
3.索引调优
最佳左前缀法则。
不在索引列上做任何操作。
覆盖索引尽量用。
不等于要甚用。
Like查询要当心。
字符类型加引号。
OR改UNION效率高。
4.设计调优
数据量大，可以分库分表。
并行执行多条sql。比如查询多个表的数据总条数，可以优化成并行执行。
主从同步，读写分离。
5.业务调优
调整业务。比如分页，以前可以指定页数区查询，可以改成下拉形式。
返回大数据量，应该考虑需求是否合理。

2. 查询姓名是”徐”开头的数据

答:

select * from v_user where nickName like CONCAT('','徐','%')
select * from v_user where nickName like '徐%'

3. 三个表,用户表(user),用户角色关系表(User_role_relation),角色表(role),查询用户名为”admin”的所有角色信息

写法1:
select r.* from role r where r.role_id in (
	select ur.role_id from User_role_relation ur where ur.user_id in (
		select u.user_id from user u where u.userName = 'admin'
	)
)
写法2:
select r.* from role left join User_role_relation ur on ur.role_id = r.role_id 
left join user u on u.user_id = ur.user_id where u.userName = 'admin' 

性能比较:
https://blog.csdn.net/weixin_35743986/article/details/113292854

四.Vue部分(记忆很模糊,复原不出来原题并省略一些题)

1. 生命周期有哪些

答:
https://www.jianshu.com/p/410b6099be69
vue每个组件都是独立的，每个组件都有一个属于它的生命周期，从一个组件创建、数据初始化、挂载、更新、销毁，这就是一个组件所谓的生命周期。在组件中具体的方法有:
beforeCreate
created
beforeMount
mounted
beforeUpdate
updated
beforeDestroy
destroyed

2. 如何父子组件传递值和事件

答:https://www.cnblogs.com/jiujiu-blog/p/13916210.html
传递数据:
父组件绑定数据: <child :msg=“msg” @envent=“click”>
子组件:
接收数据: props:{
msg:{
type:String,
default:’’
}
}
子组件事件传递到父组件
this.$emit(‘click’,data);

3. axios接口请求返回的对象是什么对象(外层那个)

答: Promise

4. axios如何做到请求按顺序执行

答:https://www.jianshu.com/p/115b4c79a75d

五.Springboot部分

1. 常用的注解有哪些

答:
@SpringBootApplication,@Service,@RestController,@ResponseBody,@Component,@ComponentScan,@Configuration,@Bean,@AutoWired,@Resource(name=“name”,type=“type”)…

2. 接收参数的注解有哪些

答:
RequestBody,RequestParam,PathVariable…

…还有忘记题目是啥了