面试复盘（事成）

已于 2024-09-20 10:00:06 修改
阅读量869 收藏 25
点赞数 12
分类专栏： 面试经历 文章标签： 面试
于 2024-09-18 18:25:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42592739/article/details/142331712
版权

1.深拷贝和浅拷贝

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

以下例子，Student对象里面有个Person对象，调用clone之后，克隆对象和原对象的Person引用的是同一个 对象，这就是浅拷贝。

public class Student implements Cloneable {
    private Person person;
    private String grade;
    //内部类
    static class Person {

        private String name;

        Person(String name){
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
    //重写克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public Person getPerson() {
        return person;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Student student = new Student();
        Person person = new Person("名字");
        student.person = person;
        Student Student2 = (Student)student.clone();
        person.setName("新名字");
        System.out.println(Student2.getPerson().getName());
    }
}
//输出：新名字

深拷贝：拷贝对象和原始对象的引用类型引用不同的对象。

深克隆的实现方法有很多，比如以下几个：

  1. 所有引用属性都实现克隆，整个对象就变成了深克隆。
  2. 使用 JDK 自带的字节流序列化和反序列化对象实现深克隆。
  3. 使用第三方工具实现深克隆，比如 Apache Commons Lang。
  4. 使用 JSON 工具，如 GSON、FastJSON、Jackson 序列化和反序列化对象实现深克隆。

以下例子，在clone函数中不仅调用了super.clone，而且调用Person对象的clone方法（Person也要实 现Cloneable接口并重写clone方法），从而实现了深拷贝。可以看到，拷贝对象的值不会受到原对象的 影响。

public class Student implements Cloneable {
    private Person person;
    private String grade;
    static class Person implements Cloneable{

        private String name;

        Person(String name){
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    //重写克隆方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student student = null;
        student = (Student) super.clone();
        student.person = (Person) person.clone();//拷贝Person对象
        return student;
    }

    public Person getPerson() {
        return person;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Student student = new Student();
        Person person = new Person("名字");
        student.person = person;
        Student Student2 = (Student)student.clone();
        person.setName("新名字");
        System.out.println(Student2.getPerson().getName());
    }
}
//输出：名字

 深克隆还可以通过利用序列化和反序列化(简单方便)

import java.io.*;

public class Student implements Serializable {
    private Person person;
    private String grade;
    static class Person implements Serializable {

        private String name;

        Person(String name){
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
    public Student myClone(){
        Student student = null;
        try {
            //将对象序列化到流里
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(os);
            oos.writeObject(this);
            //将流反序列化成对象
            ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(is);
            student = (Student) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return student;
    }

    public Person getPerson() {
        return person;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Student student = new Student();
        Person person = new Person("名字");
        student.person = person;
        Student Student2 = (Student)student.myClone();
        person.setName("新名字");
        System.out.println(Student2.getPerson().getName());
    }
}

2.关于并发用过哪些

使用锁机制：锁机制是一种用于控制多个线程对共享资源进行访问的机制。在 Java 中，锁机制主要有两种：synchronized 关键字和 Lock 接口。synchronized 关键字是 Java 中最基本的锁机制，它可以用来修饰方法或代码块，以实现对共享资源的互斥访问。而 Lock 接口是 Java5 中新增的一种锁机制，它提供了比 synchronized 更强大、更灵活的锁定机制，例如可重入锁、读写锁等；

使用线程安全的容器：如 ConcurrentHashMap、Hashtable、Vector。需要注意的是，线程安全的容器底层通常也是使用锁机制实现的；

使用本地变量：线程本地变量是一种特殊的变量，它只能被同一个线程访问。在 Java 中，线程本地变量可以通过 ThreadLocal 类来实现。每个 ThreadLocal 对象都可以存储一个线程本地变量，而且每个线程都有自己的一份线程本地变量副本，因此不同的线程之间互不干扰。

volatile 关键字，用于保证多线程情况下共享变量的可见性。当一个变量被声明为 volatile 时，每个线程在访问该变量时都会立即刷新其本地内存（工作内存）中该变量的值，确保所有线程都能读到最新的值。并且使用 volatile 可以禁止指令重排序，这样就能有效的预防，因为指令优化（重排序）而导致的线程安全问题。volatile 有两个主要功能：保证内存可见性和禁止指令重排序。

synchronized 是 Java 中最基本的锁机制，使用它可以实现对共享资源的互斥访问。当一个线程访问被 synchronized 修饰的方法或代码块时，它会自动获取锁，其他线程只能排队等待该线程释放锁。

sping的声明式事务 @Transactional来开启线程。

当声明式事务 @Transactional 遇到以下场景时，事务会失效：

  1. 非 public 修饰的方法；
  2. timeout 设置过小；
  3. 代码中使用 try/catch 处理异常；
  4. 调用类内部 @Transactional 方法；
  5. 数据库不支持事务。

ThreadLocal 线程本地变量，每个线程都拥有一份该变量的独立副本，即使是在多线程环境下，每个线程也只能修改和访问自己的那份副本，从而避免了线程安全问题，实现了线程间的隔离。

3.值传递和引用传递

值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中,而并不是将这个值直接传递给函数

引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，而传递过来的地址还是与之前的地址指向同一个值，那么要是修改了这个参数，就会影响这个值的改变。

先是基础数据类型，应该没有疑问是值传递，在方法中修改值的大小不会影响原有值。

public class Test {
    public static void main(String[] args) {
        int value = 1;
        setValue(value);
        System.out.println("修改后值为："+ value);
    }
    
    public static void setValue(int value) {
        value = 2;
        System.out.println("修改值为：" + value);
    }
}

//修改值为：2
//修改后值为：1

然后是引用数据类型，在方法中修改值的大小也不会影响原有值。

public class Test {
    public static void main(String[] args) {
        String value = "1";
        setValue(value);
        System.out.println("修改后值为："+ value);
    }

    public static void setValue(String value) {
        value = "2";
        System.out.println("修改值为：" + value);
    }
}
//修改值为：2
//修改后值为：1

自定义类，在方法中修改值的大小也不会影响原有值。

public class Test {
    public static void main(String[] args) {
        Person value = new Person("1");
        setValue(value);
        System.out.println("修改后值为："+ value.getName());
    }

    public static void setValue(Person value) {
        value = new Person("2");
        System.out.println("修改值为：" + value.getName());
    }
    static class Person {
        private String name;
        
        Person(String name){
            this.name = name;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
}
//修改值为：2
//修改后值为：1

但是对于对象的值，

JVM虚拟机分为堆和栈，堆中存储对象实例和数组，它是所有线程共享的，对象在堆中通过引用进行访问。栈是为每个线程分配的内存区域，用于存储方法调用和局部变量等信息，方法的参数、局部变量和返回值都存储在栈帧中。

对于上述的例子，Person对象的实力存储在堆中，栈中有两块，一块是main方法栈里面有value引用，另一个块是一块是setValue方法栈里面也有value引用。

如果java是引用传递，那么两个栈用Value的引用应该指向的是堆中的同一块地址。

public class Test {
    public static void main(String[] args) {
        Person value = new Person("1");
        System.out.println("main中value修改后的引用地址"+value.toString());
        setValue(value);
        System.out.println("修改后值为："+ value.getName());
        System.out.println("main中value修改后的引用地址"+value.toString());
        value = new Person("2");
        System.out.println("修改后值为："+ value.getName());
        System.out.println("main中value修改后的引用地址2:"+value.toString());
    }

    public static void setValue(Person value) {
        System.out.println("setValue中value的引用地址"+value.toString());
        value = new Person("2");
        System.out.println("修改值为：" + value.getName());
        System.out.println("setValue中value修改后的引用地址"+value.toString());
    }
    static class Person {
        private String name;

        Person(String name){
            this.name = name;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
}
//        main中value修改后的引用地址Test$Person@135fbaa4
//        setValue中value的引用地址Test$Person@135fbaa4
//        修改值为：2
//        setValue中value修改后的引用地址Test$Person@45ee12a7
//        修改后值为：1
//        main中value修改后的引用地址Test$Person@135fbaa4
//        修改后值为：2
//        main中value修改后的引用地址2:Test$Person@330bedb4

从上述代码可以看到setvalue中value的引用地址没修改前是和mian中value的引用地址是相同的。如果说是值传递 那么setvalue中value的引用地址没修改前是和mian中value的引用地址不应该相同吧，但如果是引用传递，那么在setvalue中对value的修改也应该会同步影响到main方法中的value啊，这又与事实不符。看到一种说法是对象类型的值是对象引用，那么就是值传递，但是传递的是引用地址，这就可以解释为什么setvalue中value的引用地址没修改前是和mian中value的引用地址是相同的。那么对于第二个疑问，也就是setvalue中value的引用地址相当于重新赋值了一个新的对象引用，也算合理。

对象类型的值是对象引用的理论也可以解释单独set属性值时，main中的value也会有影响。

public class Test {
    public static void main(String[] args) {
        Person value = new Person("1");
        System.out.println("main中value修改后的引用地址"+value.toString());
        setValue(value);
        System.out.println("修改后值为："+ value.getName());
        System.out.println("main中value修改后的引用地址"+value.toString());
    }

    public static void setValue(Person value) {
        System.out.println("setValue中value的引用地址"+value.toString());
        value.setName("2");
        System.out.println("修改值为：" + value.getName());
        System.out.println("setValue中value修改后的引用地址"+value.toString());
    }
    static class Person {
        private String name;

        Person(String name){
            this.name = name;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
}
//        main中value修改后的引用地址Test$Person@135fbaa4
//        setValue中value的引用地址Test$Person@135fbaa4
//        修改值为：2
//        setValue中value修改后的引用地址Test$Person@135fbaa4
//        修改后值为：2
//        main中value修改后的引用地址Test$Person@135fbaa4

4.函数式编程

Lambda 表达式是 Java 8 引入的一种简洁的表示匿名方法的方式，使用它可以用于替代某些匿名内部类对象，从而让程序更简洁，可读性更好。

Lambda 表达式主要用于执行函数式接口（Function Interface），即只有一个抽象方法的接口。常见的函数式接口包括 java.util.function 包下的 Predicate、Function、Consumer 等。

Lambda 底层运行原理如下：

  1. 在程序运行时，会在类中生成一个匿名内部类，匿名内部类会实现接口，并重写接口中的抽象方法。
  2. 类中会生成一个静态方法，静态方法中的代码就是 Lambda 表达式中的代码。
  3. 匿名内部类重写的抽象方法，会调用上一步的静态方法，从而实现 Lambda 代码的执行。

5.stream流

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

  • stream() − 为集合创建串行流。

  • parallelStream() − 为集合创建并行流。

  • forEach() Stream 提供了新的方法 forEach来迭代流中的每个数据。

  • map() map 方法用于映射每个元素到对应的结果

  • filter() filter 方法用于通过设置的条件过滤出元素。

  • limit() limit 方法用于获取指定数量的流。

  • sorted() sorted 方法用于对流进行排序。

  • parallelStream() parallelStream 是流并行处理程序的代替方法。

  • Collectors() Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。

6.过滤器和拦截器有什么区别

  • 出身不同：过滤器来自于 Servlet，而拦截器来自于 Spring 框架；

  • 触发时机不同：请求的执行顺序是：请求进入容器 > 进入过滤器 > 进入 Servlet > 进入拦截器 > 执行控制器（Controller），所以过滤器和拦截器的执行时机，是过滤器会先执行，然后才会执行拦截器，最后才会进入真正的要调用的方法；

  • 底层实现不同：过滤器是基于方法回调实现的，拦截器是基于动态代理（底层是反射）实现的；

  • 支持的项目类型不同：过滤器是 Servlet 规范中定义的，所以过滤器要依赖 Servlet 容器，它只能用在 Web 项目中；而拦截器是 Spring 中的一个组件，因此拦截器既可以用在 Web 项目中，同时还可以用在 Application 或 Swing 程序中；

  • 使用的场景不同：因为拦截器更接近业务系统，所以拦截器主要用来实现项目中的业务判断的，比如：登录判断、权限判断、日志记录等业务；而过滤器通常是用来实现通用功能过滤的，比如：敏感词过滤、字符集编码设置、响应数据压缩等功能。

7.怎么让自己的类可以像Lambda表达式一样创建

Lambda 底层运行原理如下：

  1. 在程序运行时，会在类中生成一个匿名内部类，匿名内部类会实现接口，并重写接口中的抽象方法。

  2. 类中会生成一个静态方法，静态方法中的代码就是 Lambda 表达式中的代码。

  3. 匿名内部类重写的抽象方法，会调用上一步的静态方法，从而实现 Lambda 代码的执行。

在自己定义的接口上加@FunctionalInterface注解， 它是 Java 8 引入的一个注解，它用于标记一个接口为函数式接口。

@FunctionalInterface 注解的作用如下：

  1. 编译时检查：当一个接口被标记为 @FunctionalInterface 时，编译器会检查该接口是否只有一个抽象方法。如果不符合函数式接口的定义（即存在多个抽象方法），编译器会报错，提醒开发者修正。这为开发者提供了明确的编译时保障，确保所标记的接口确实符合函数式接口的要求。

  2. 代码明确性：即使不加 @FunctionalInterface 注解，只要接口符合函数式接口的定义，它仍然可以被视为函数式接口。但注解的存在增加了代码的明确性和可读性，使得其他开发者更容易理解该接口的设计意图。

  3. 支持 Lambda 表达式：函数式接口的主要目的是为了支持 Lambda 表达式。通过 Lambda 表达式，开发者可以以更简洁的方式实现函数式接口的抽象方法，从而减少模板代码，使代码更加简洁和易于理解。由于 Lambda 表达式本身不包含类型信息，Java 编译器需要一种机制来确定 Lambda 表达式对应的目标类型。函数式接口就扮演了这一角色——Lambda 表达式可以被赋值给任何兼容的函数式接口类型，编译器会依据接口的唯一抽象方法来推断 Lambda 表达式的参数类型和返回类型。

在 Java 标准库中，有许多使用 @FunctionalInterface 注解的接口，如 java.util.function 包下的 Function、Predicate、Consumer 等，这些接口都是函数式接口，广泛用于数据处理、过滤、转换等操作。此外，在 Spring Boot 框架中，也经常使用函数式接口来定义事件监听器、回调函数等。

7.1 可能是怎么实现链式调用？

  1. Setter 原生方式

  2. Lombok @Accessors 注解方式

  3. Lombok @Builder 注解方式

  4. Hutool GenericBuilder 方式

8.mybatis用过吗，了解mybatis的插件吗

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生 SQL 查询，将接口和 Java 的实体类映射成数据库中的记录。

PageHelper分页插件。

9.mybatisplus用过吗，了解mybatisplus的插件吗

MyBatis-Plus可以简化CRUD操作，通过继承BaseMapper类，对于简单的CRUD操作可以直接使用，而不需要再自己写sql。

插件主体 | MyBatis-Plus (baomidou.com)

10.一张表 有两个字段值重复了，删除除了id最小的数据（笔试）

delete  from person where id not in (
select a.* from (
SELECT min(id) from person GROUP BY address,name
) a
)

11.递归实现斐波那契数列（笔试）

非递归实现。

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        String num = "100";
        math(num);
    }

    private static void math(String num) {
        ArrayList<Integer> arr = new ArrayList<Integer>();
        arr.add(1);
        arr.add(1);
        for (; Integer.valueOf(num)>arr.get(arr.size()-1)+arr.get(arr.size()-2) ;) {
            arr.add(arr.get(arr.size()-1)+arr.get(arr.size()-2));
        }
        System.out.println(arr.toString());
    }
}

递归实现。

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        String num = "100";
        ArrayList<Integer> arr = new ArrayList<Integer>();
        arr.add(1);
        arr.add(1);
        math(arr,num);
        System.out.println(arr.toString());
    }

    private static void math(ArrayList<Integer> arr,String num) {
        if(Integer.valueOf(num)>arr.get(arr.size()-1)+arr.get(arr.size()-2)){
            arr.add(arr.get(arr.size()-1)+arr.get(arr.size()-2));
            math(arr,num);
        }else {
            return;
        }
    }
}

乌桕wujiu
关注
专栏目录
17 | 如何做好面试复盘？将经验提升为能力
小Y的博客
01-25 1455
面试复盘至关重要
面试复盘（数据分析）
happylls666的博客
01-15 1261
数据分析面试复盘
面试复盘整理
你知道的越多，你不知道的越多
01-28 3310
面试复盘 总结： ​ 面试了将近一个月，大厂基本上都面过了，大厂技术栈基本上都是springcloud+mysql+redis+kafka，一面基本上都是自我介绍，问问kafka问问redis问问mysql问问并发。问题基本上都很简单，虽然说都是八股文背一背就行了，不过最好还是有自己的理解，不然稍微厉害的面试官会考察你的思路根据你的理解出场景题，如果只是背诵问两个问题就能发现你根本不理解。简历上写的技术一定要重点准备。 ​ 面试碰到不会的场景题目没关系，跟面试官表达出自己的思考过程，面试官一般也会提点下。
软件测试面试复盘
m0_65683419的博客
09-26 352
③抽象类中的成员权限可以是public、默认、protected（抽象类中抽象方法就是为了重写，所以不能被private修饰),而接口中的成员只能是public(方法默认:pubic abstrat、成员变量默认:public static final)重写发生在父类子类之间，方法名必须相同，返回值类型必须相同，参数列表必须相同，访问权限不能比父类中被重写的方法的访问权限更低。②隔离性：事物间是互相隔离的，每个事务对其他事务的操作都是透明的，可以防止并发执行的事务之间产生脏读、不可重复读、幻读等问题。
C#开发工程师最终面试复盘
yannsann的博客
07-09 1170
软件开发工程师面经
3.11面试复盘
热门推荐
逾越的博客
03-13 1万+
Spring事务异常一定会回滚吗？什么情况事务会失效？ 1、事务失效的7种情况 1.1、未启用spring事务管理功能 1.2、方法不是public类型的 @Transaction 可以用在类上、接口上、public方法上，如果将@Trasaction用在了非public方法上，事务将无效。 1.3、数据源未配置事务管理器 spring是通过事务管理器了来管理事务的，一定不要忘记配置事务管理器了，要注意为每个数据源配置一个事务管理器： 1.4、自身调用问题 spring是通过aop的方式，对需要spring
硬件工程师面试复盘
weixin_53143085的博客
10-13 531
硬件工程师面试复盘前言一、BOSS直聘关键词二、关于要工资面试问题 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、BOSS直聘关键词 BOSS直聘上通常都会有各种关键词，通常来说硬件工程师可以分为两种，分别是需要Layout和不需要Layout，对于一些规模大一点的公司通常上是不需要Layout的，更多的是指导EDA工程师进行La
数字马力笔试面试复盘
weixin_48137421的博客
11-10 1万+
http缓存问题？有哪些？然后我自己介绍了自己项目中的一些个人觉得相对具有挑战性的点我做的是商城的项目，对当时的我来说，完成项目的时候确实存在一些具有挑战性的点，现在呢我通过学习和实践已经可以熟练的解决相似的问题。axios二次封装NextTick()导航守卫Vuex。
产品实习面试复盘记录
weixin_65931068的博客
06-16 436
一些产品面试复盘记录
面试复盘
qq_43422296的博客
03-12 357
面试复盘（阿里一面） 阿里的一面难度并不是很大，但是感觉自己的表现特别差。 第一道题目是你了解Hash吗 hash，一般翻译为散列、杂凑，或者音译为哈希，是把任意长度的输入（又叫做预映射pre-image）通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间。 它其实就是一个算法，最简单的算法就是加减乘除，比方，我设计个数字算法，输...
软件实施工程师面试复盘
10-13
面试复盘
面试复盘.md
10-30
面试复盘.md
Angular面试题五
笃励的博客
09-19 1147
除了内置管道外，Angular还允许开发者创建自定义管道。自定义管道是一个实现了接口的类，该接口要求实现一个transform方法，该方法定义了数据的转换逻辑。通过Angular CLI，可以方便地生成自定义管道的模板代码，并在应用中注册和使用自定义管道。Angular管道是处理和转换模板中数据的重要工具，通过内置的管道和自定义管道，可以轻松地实现复杂的数据格式化逻辑，并将处理后的数据呈现给用户。在开发过程中，合理使用管道可以提高代码的可读性和可维护性。
面试金典题2.5
m0_73096516的博客
09-22 212
(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295。(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295。直接计算求和，用一个变量存储进位，就可以算出链表的和。给定两个用链表表示的整数，每个节点包含一个数位。编写函数对这两个整数求和，并用链表形式返回结果。这些数位是反向存放的，也就是个位排在链表首部。2 -> 1 -> 9，即912。9 -> 1 -> 2，即912。leetcode代码。
产品经理面试整理-了解公司和产品
不务正业的猿
09-22 138
查阅用户评论和评价（如App Store, Google Play, Trustpilot等）以了解用户对产品的看法、赞赏的地方和需要改进的地方。：研究公司服务的客户类型和主要的用户群体（B2B, B2C, B2G等），以及他们的需求和行为特点。通过以上的准备，你将能全面了解公司和产品，在面试中更自信地展示你的洞察力和适应能力。：熟悉公司的主要产品和服务，包括它们的核心功能、目标用户、使用场景和价值主张。：关注公司在社交媒体上的表现和用户反馈，加入相关论坛，了解社区和用户的讨论。
刷题训练之栈
AAlykk的博客
09-21 1222
最早博主续写了牛客网130道题，这块的刷题是让同学们快速进入C语言，而我们学习c++已经有一段时间了，知识储备已经足够了但缺少了实战，面对这块短板博主续写刷题训练，针对性学习，把相似的题目归类，系统的刷题，而我们刷题的官网可以参考：​​​​​​力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台牛客网 - 找工作神器|笔试题库|面试经验|实习招聘内推，求职就业一站解决_牛客网⭐知识讲解采用模拟。
Java面试篇-AOP专题（什么是AOP、AOP的几个核心概念、AOP的常用场景、使用AOP记录操作日志、Spring中的事务是如何实现的）
聂可以的博客
09-21 1237
Java面试篇-AOP专题（什么是AOP、AOP的几个核心概念、AOP的常用场景、使用AOP记录操作日志、Spring中的事务是如何实现的）
[leetcode刷题]面试经典150题之6轮转数字（简单）
最新发布
m0_63680328的博客
09-23 399
将数组中的元素向右轮转。
产品经理面试整理-准备个人案例
不务正业的猿
09-22 224
挑选那些你认为对你的职业生涯影响最大的项目，尤其是你在其中扮演了重要角色或产生了显著影响的项目。通过这些准备，你将能够在面试中有条理地展示你的经验和能力，让面试官对你的产品管理能力留下深刻印象。例如：“经过三个月的调整，我们的用户留存率提升了15%，并成功重新激活了20%的流失用户。：展示你如何与其他团队（如技术团队、设计团队、市场团队等）合作，说明你在团队中的角色和贡献。：用具体的数字和数据来说明你的贡献和项目成果，例如用户增长率、收入增加、用户满意度提升等。：详细描述你采取的行动步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值