【2021Java后端面试题整理】JVM面试题+面经答案

最新推荐文章于 2024-03-06 16:35:42 发布
最新推荐文章于 2024-03-06 16:35:42 发布
阅读量1.2k 收藏 9
点赞数
分类专栏： 大厂面试题 面试题笔记 文章标签： JVM Java 后端 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41522089/article/details/115354562
版权

目录

链接一下目录方便查找

菜鸡的2021春招实习之旅（面经+自己总结的笔记）

JVM

1.JVM体系结构

背烂了

2.什么是垃圾？如何判断一个对象是否可以回收？

简单来说就是内存汇中已经不再使用到的空间就是垃圾

使用标记算法:

标记算法有两种,一种引用计数器算法,另一种是可达性分析算法

引用计数器算法就是如果A对象被引用,则给计数器加1,如果引用接触则减去1,下次垃圾回收的时候如果计数器为0则表示为垃圾,但是存在严重的问题,就是如果存在循环引用,会引发内存泄露

可达性分析,就是使用GCRoot作为起点,用引用链能够找到的对象就是可达的,如果不可达就是不可用

使用可达性分析，通过GCRoot为起点，如果一个对象到GC Root没有任何引用链相连，说明此对象不可用

2.5什么时候触发垃圾回收,什么时候放入老年代?

1.eden区满了,触发young gc,触发复制算法,将存活的对象放到s1区;如果eden区再次满了,再次触发young gc,将s1和eden区存活对象放到s2区;

如果超过15次阈值还是长期存活就直接转移到老年代;或者s1区过小,eden区转移不到s区,直接放入老年代 ;或者当前文件过大,直接就转移到老年代

2.老年代垃圾回收

对老年代而言,垃圾没那么多,以前是使用标记-清理算法,但是会有内存碎片,没有连续可用的空间;后续使用标记-整理算法

3.哪些对象可以作为GC Roots

  1. 虚拟机栈（栈帧中的局部变量）中引用的对象。
  2. 本地方法栈（native）中引用的对象。
  3. 方法区中常量引用的对象。
  4. 方法区中类静态属性引用的对象。
  5. 所有被同步锁synchronized持有的对象
  6. Java虚拟机内部的引用：基本数据类型对应的Class对象，一些常驻的异常对象（如： NullPointerException、OutOfMemoryError） ，系统类加载器。
  7. 反映java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。

4.垃圾回收算法

https://blog.csdn.net/qq_41522089/article/details/107801105

5.System.gc()或者Runtime.getRuntime().gc()的调用会怎么样

在默认情况下，通过System.gc()或者Runtime.getRuntime().gc()的调用，会显式触发Full GC，同时对老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。

然而System.gc()调用附带一个免责声明，无法保证对垃圾收集器的调用(无法保证马上触发GC)。

垃圾回收是自动进行的,无序手动

6.OutOfMemoryError

内存溢出和内存泄露

内存溢出就是内存在GC完毕的情况下或者有大文件GC知道自己无法进行清理,就会存在内存溢出

内存泄露就是本来不应该可达的对象,竟然可达了,就是还有引用在上面.说明存在泄露,比如ThreadLocal里面的变量就是一个非常典型的例子

StackOverflowError

栈满会抛出该错误。无限递归就会导致StackOverflowError，是java.lang.Throwable→java.lang.Error→java.lang.VirtualMachineError下的错误。

OOM—Java heap space

堆满会抛出该错误。

OOM—GC overhead limit exceeded

这个错误是指：GC的时候会有“Stop the World"，STW越小越好，正常情况是GC只会占到很少一部分时间。但是如果用超过98%的时间来做GC，而且收效甚微，就会被JVM叫停。下例中，执行了多次Full GC，但是内存回收很少，最后抛出了OOM:GC overhead limit exceeded错误。详见GCOverheadDemo。

[GC (Allocation Failure) [PSYoungGen: 2048K->496K(2560K)] 2048K->960K(9728K), 0.0036555 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2544K->489K(2560K)] 3008K->2689K(9728K), 0.0060306 secs] [Times: user=0.08 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 2537K->512K(2560K)] 4737K->4565K(9728K), 0.0050620 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2560K->496K(2560K)] 6613K->6638K(9728K), 0.0064025 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 

[Full GC (Ergonomics) [PSYoungGen: 2048K->860K(2560K)] [ParOldGen: 6264K->7008K(7168K)] 8312K->7869K(9728K), [Metaspace: 3223K->3223K(1056768K)], 0.1674947 secs] [Times: user=0.63 sys=0.00, real=0.17 secs] 
[Full GC (Ergonomics) [PSYoungGen: 2048K->2006K(2560K)] [ParOldGen: 7008K->7008K(7168K)] 9056K->9015K(9728K), [Metaspace: 3224K->3224K(1056768K)], 0.1048666 secs] [Times: user=0.45 sys=0.00, real=0.10 secs] 
[Full GC (Ergonomics) [PSYoungGen: 2047K->2047K(2560K)] [ParOldGen: 7082K->7082K(7168K)] 9130K->9130K(9728K), [Metaspace: 3313K->3313K(1056768K)], 0.0742516 secs] [Times: user=0.28 sys=0.00, real=0.07 secs] 

·······

[Full GC (Ergonomics) [PSYoungGen: 2047K->2047K(2560K)] [ParOldGen: 7084K->7084K(7168K)] 9132K->9132K(9728K), [Metaspace: 3313K->3313K(1056768K)], 0.0738461 secs] [Times: user=0.36 sys=0.02, real=0.07 secs] 

Exception in thread "main" [Full GC (Ergonomics) [PSYoungGen: 2047K->0K(2560K)] [ParOldGen: 7119K->647K(7168K)] 9167K->647K(9728K), [Metaspace: 3360K->3360K(1056768K)], 0.0129597 secs] [Times: user=0.11 sys=0.00, real=0.01 secs] 
java.lang.OutOfMemoryError: GC overhead limit exceeded
	at java.lang.Integer.toString(Integer.java:401)
	at java.lang.String.valueOf(String.java:3099)
	at jvm.GCOverheadDemo.main(GCOverheadDemo.java:12)
OOM—GC Direct buffer memory

在写NIO程序的时候，会用到ByteBuffer来读取和存入数据。与Java堆的数据不一样，ByteBuffer使用native方法，直接在堆外分配内存。当堆外内存（也即本地物理内存）不够时，就会抛出这个异常。

OOM—unable to create new native thread

在高并发应用场景时，如果创建超过了系统默认的最大线程数，就会抛出该异常。Linux单个进程默认不能超过1024个线程。解决方法要么降低程序线程数，要么修改系统最大线程数vim /etc/security/limits.d/90-nproc.conf。

OOM—Metaspace

使用静态类,将元空间装满了,元空间满了就会抛出这个异常。

7.什么是STW

Stop-the-World，简称STW，指的是GC事件发生过程中，会产生应用程序（对应进程）的停顿。

可达性分析算法中枚举根节点（GC Roots）会导致所有Java执行线程停顿.

1.STW事件和采用哪款GC无关，所有的GC都有这个事件。
2.哪怕是G1也不能完全避免Stop-the-world情况发生，只能说垃圾回收器越来越优秀，回收效率越来越高，尽可能地缩短了暂停时间。
3.STW是JVM在后台自动发起和自动完成的。在用户不可见的情况下，把用户正常的工作线程全部停掉。
4.开发中尽量不要采用System.gc()；会导致Stop-the-world的发生。

8.四大引用

强引用:只要有引用,就不回收,一般是new

软引用:在内存足够的情况下不回收,如果内存不够就进行回收,如果内存还不够就OOM

弱引用:只要垃圾回收器一运作就回收

虚引用:形同虚设,get方法为null,一般机制被引用队列锁使用

public class PhantomReferenceDemo {
    public static void main(String[] args) throws InterruptedException {
        Object o1 = new Object();
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
        PhantomReference phantomReference = new PhantomReference(o1, referenceQueue);
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());

        System.out.println("===========");

        o1 = null;
        System.gc();
        Thread.sleep(500);
        System.out.println(o1);
        System.out.println(phantomReference.get());
        System.out.println(referenceQueue.poll());//GC后将对象放到引用队列中了
    }
}

详解可以见我的博客[https://blog.csdn.net/qq_41522089/article/details/107850681](

9.垃圾收集器

详解可见https://blog.csdn.net/qq_41522089/article/details/107871181

Java 8可以将垃圾收集器分为四类。

串行收集器Serial

为单线程环境设计且只使用一个线程进行GC，会暂停所有用户线程，不适用于服务器。就像去餐厅吃饭，只有一个清洁工在打扫。

并行收集器Parrallel

使用多个线程并行地进行GC，会暂停所有用户线程，适用于科学计算、大数据后台，交互性不敏感的场合。多个清洁工同时在打扫。

并发收集器CMS

用户线程和GC线程同时执行（不一定是并行，交替执行），GC时不需要停顿用户线程，互联网公司多用，适用对响应时间有要求的场合。清洁工打扫的时候，也可以就餐。

G1收集器

对内存的划分与前面3种很大不同，将堆内存分割成不同的区域，然后并发地进行垃圾回收。
在这里插入图片描述

CMS与serial old GC是备选，就是如果无法用原有搭配就使用备选搭配

红线在JDK8以后弃用，9直接remove

绿线在jdk14弃用

CMS在JDK14删除

  • 两个收集器间有连线，表明它们可以搭配使用： Serial/Serial Old、Serial/CMS、 ParNew/Serial Old、ParNew/CMS、 Parallel Scavenge/Serial Old、Parallel Scavenge/Parallel Old、G1；
  • 其中Serial Old作为CMS 出现"Concurrent Mode Failure"失败的后备预案。
  • （红色虚线）由于维护和兼容性测试的成本，在JDK 8时将Serial+CMS、 ParNew+Serial Old这两个组合声明为废弃（JEP 173） ，并在JDK 9中完全取消了这些组合的支持（JEP214），即：移除。
  • （绿色虚线）JDK 14中：弃用Parallel Scavenge和SerialOld GC组合（JEP366 ）
  • （青色虚线）JDK 14中：删除CMS垃圾回收器 （JEP 363）
Serial收集器

年代最久远，是Client VM模式下的默认新生代收集器，使用复制算法。优点：单个线程收集，没有线程切换开销，拥有最高的单线程GC效率。缺点：收集的时候会暂停用户线程。

使用-XX:+UseSerialGC可以显式开启，开启后默认使用Serial+SerialOld的组合。

在这里插入图片描述

ParNew收集器

也就是Serial的多线程版本，GC的时候不再是一个线程，而是多个，是Server VM模式下的默认新生代收集器，采用复制算法。

使用-XX:+UseParNewGC可以显式开启，开启后默认使用ParNew+SerialOld的组合。但是由于SerialOld已经过时，所以建议配合CMS使用。
在这里插入图片描述

Parallel Scavenge收集器

ParNew收集器仅在新生代使用多线程收集，老年代默认是SerialOld，所以是单线程收集。而Parallel Scavenge在新、老两代都采用多线程收集。Parallel Scavenge还有一个特点就是吞吐量优先收集器，可以通过自适应调节，保证最大吞吐量。采用复制算法。

使用-XX:+UseParallelGC可以开启， 同时也会使用ParallelOld收集老年代。其它参数，比如-XX:ParallelGCThreads=N可以选择N个线程进行GC，-XX:+UseAdaptiveSizePolicy使用自适应调节策略。

在这里插入图片描述

SerialOld收集器

Serial的老年代版本，采用标整算法。JDK1.5之前跟Parallel Scavenge配合使用，现在已经不了，作为CMS的后备收集器。

ParallelOld收集器

Parallel的老年代版本，JDK1.6之前，新生代用Parallel而老年代用SerialOld，只能保证新生代的吞吐量。JDK1.8后，老年代改用ParallelOld。

使用-XX:+UseParallelOldGC可以开启， 同时也会使用Parallel收集新生代。

CMS收集器

并发标记清除收集器，是一种以获得最短GC停顿为目标的收集器。适用在互联网或者B/S系统的服务器上，这类应用尤其重视服务器的响应速度，希望停顿时间最短。是G1收集器出来之前的首选收集器。使用标清算法。在GC的时候，会与用户线程并发执行，不会停顿用户线程。但是在标记的时候，仍然会STW。

使用-XX:+UseConcMarkSweepGC开启。开启过后，新生代默认使用ParNew，同时老年代使用SerialOld作为备用。

在这里插入图片描述

过程
  1. 初始标记：只是标记一下GC Roots能直接关联的对象，速度很快，需要STW。
  2. 并发标记：主要标记过程，标记全部对象，和用户线程一起工作，不需要STW。
  3. 重新标记：修正在并发标记阶段出现的变动，需要STW。
  4. 并发清除：和用户线程一起，清除垃圾，不需要STW。
优缺点

优点：停顿时间少，响应速度快，用户体验好。

缺点：

  1. 对CPU资源非常敏感：由于需要并发工作，多少会占用系统线程资源。
  2. 无法处理浮动垃圾：由于标记垃圾的时候，用户进程仍然在运行，无法有效处理新产生的垃圾。到达阈值会使用full GC
  3. 产生内存碎片：由于使用标清算法，会产生内存碎片。
GC的选择

组合的选择

  • 单CPU或小内存,单机程序
    -XX: +UseSerialGC
  • 多CPU ,需要最大吞吐量,如后台计算型应用
    -XX: +UseParallelGC或者
    -XX: +UseParallelOldGC
  • 多CPU ,追求低停顿时间,需快速响应如互联网应用
    -XX: +UseConcMarkSweepGC
    -XX:+ParNewGC

在这里插入图片描述

G1收集器

G1收集器与之前垃圾收集器的一个显著区别就是——之前收集器都有三个区域，新、老两代和元空间。而G1收集器只有G1区和元空间。而G1区，不像之前的收集器，分为新、老两代，而是一个一个Region，每个Region既可能包含新生代，也可能包含老年代。

G1收集器既可以提高吞吐量，又可以减少GC时间。最重要的是STW可控，增加了预测机制，让用户指定停顿时间。

使用-XX:+UseG1GC开启，还有-XX:G1HeapRegionSize=n、-XX:MaxGCPauseMillis=n等参数可调。

在这里插入图片描述

特点
  1. 并行和并发：充分利用多核、多线程CPU，尽量缩短STW。
  2. 分代收集：虽然还保留着新、老两代的概念，但物理上不再隔离，而是融合在Region中。
  3. 空间整合：G1整体上看是标整算法，在局部看又是复制算法，不会产生内存碎片。
  4. 可预测停顿：用户可以指定一个GC停顿时间，G1收集器会尽量满足。
过程

与CMS类似。

  1. 初始标记。
  2. 并发标记。
  3. 最终标记。
  4. 筛选回收。

10.JVM参数

1.JVM参数类型

标配参数

比如-version、-help、-showversion等，几乎不会改变。

X参数

用得不多，比如-Xint，解释执行模式；-Xcomp，编译模式；-Xmixed，开启混合模式（默认）。

在这里插入图片描述

XX参数

重要，用于JVM调优。

查询

jps -l 查询正在运行的Java程序

jinfo -flag 属性名 进程号

布尔类型

公式：-XX:+某个属性、-XX:-某个属性，开启或关闭某个功能。比如-XX:+PrintGCDetails，开启GC详细信息。

KV键值类型

公式：-XX:属性key=值value。比如-XX:Metaspace=128m、-XX:MaxTenuringThreshold=15。

-xms/-xmx参数

-Xms和-Xmx十分常见，用于设置初始堆大小和最大堆大小。第一眼看上去，既不像X参数，也不像XX参数。实际上-Xms等价于-XX:InitialHeapSize，-Xmx等价于-XX:MaxHeapSize。所以-Xms和-Xmx属于XX参数。

查看参数盘点家底

查看默认初始值：java -XX:+PrintFlagsInitial

查看修改后参数

-XX:+PrintFlagsFinal

= 是默认参数，:=是修改后的参数

可以用-XX:+PrintCommandLineFlags查看常用参数。

JVM 常用参数

-Xmx/-Xms

最大和初始堆大小。最大默认为物理内存的1/4，初始默认为物理内存的1/64。

-Xss

等价于-XX:ThresholdStackSize。用于设置单个栈的大小，系统默认值是0，不代表栈大小为0。而是使用默认值,根据操作系统的不同，有不同的值。比如64位的Linux系统是1024K，而Windows系统依赖于虚拟内存。

-Xmn

新生代大小，一般不调。

-XX:MetaspaceSize

设置元空间大小。

-XX:+PrintGCDetails

输出GC收集信息，包含GC和Full GC信息。

-XX:SurvivorRatio

新生代中，Eden区和两个Survivor区的比例，默认是8:1:1。通过-XX:SurvivorRatio=4改成4:1:1

-XX:NewRatio

老生代和新年代的比列，默认是2，即老年代占2，新生代占1。如果改成-XX:NewRatio=4，则老年代占4，新生代占1。

-XX:MaxTenuringThreshold

新生代设置进入老年代的时间，默认是新生代逃过15次GC后，进入老年代。如果改成0，那么对象不会在新生代分配，直接进入老年代。

https://blog.csdn.net/qq_41522089/article/details/107850681)

-XX: +PrintGC 输出Gc日志。类似： -verbose: gc

只会显示总的GC堆的变化

-XX: +PrintGCDetails 输出GC的详细日志

详细显示GC使用情况，收集多少垃圾，内存变化，花费时间等

-XX: +PrintGCTimeStamps 输出GC的时间戳（以基准时间的形式）

显示启动以来花费的时间

-XX: +PrintGCDateStamps输出GC的时间戳（以日期的形式 ）

以yyyy-MM-dd HH:mm:ss的形式输出启动以来的时间

-XX: +PrintHeapAtGC 在进行GC的前后打印出堆的信息
-Xloggc:. . /logs/gc. log日志文件的输出路径

11.JVMGC + SpringBoot微服务的生产部署和调参优化

实际工作中，如何结合spr ingboot进行调优?

JVMGC -->>调优–>> spr ingboot微服务的生产部
署和调参优化
1 IDEA开发完微服务工程
2 maven进行clean package
3要求微服务启动的时候，同时配置我们的JVM/GC的调优参数
3.1内
3.2外===>重点
4公式
java -server jvm的各种参数 -jar 第一步上面的jar/war包名字

12.栈帧的里面具体有什么

https://blog.csdn.net/qq_41522089/article/details/107596640

13.栈和堆的区别

一、堆栈空间分配区别：
　　1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；
　　2、堆（操作系统）： 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。
　　二、堆栈缓存方式区别：
　　1、栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；
　　2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。
　　三、堆栈数据结构区别：
　　堆（数据结构）：堆可以被看成是一棵树，如：堆排序；
　　栈（数据结构）：一种先进后出的数据结构。

14.线程上下文加载器打破双亲委派机制

线程上下文加载器的重要性：
SPI (Service Provider Interface)
父ClassLoader可以使用当前线程Thread.currentThread().getContextClassLoader()所指定的classloader加载的类。
这就改变了父ClassLoader不能使用子ClassLoader或是其他没有直接父子关系的CLassLoader加载的类的情况，即改变了
双亲委托模型。

线程上下文加载器就是当前线程的Current ClassLoader
在双亲委托模型下，类加载器由下至上的，即下层的类加载器会委托上层进行加载。但是对于SPI来说，有些接口是java
核心库所提供的，而java核心库是由启动类加载器来加载的，而这些接口的实现来自于不同的jar包（厂商提供），java
的启动类加载器是不会加载其他来源的jar包，这样传统的双亲委托模型就无法满足SPI的要求，而通过给当前线程设置上下文加载器
就可以设置上下文类加载器来实现对于接口实现类的加载。

如果没有通过与setContextClassLoader(ClassLoader classloader)进行设置的话，线程将继承其父线程的上下文类加载器。
Java应用运行时的初始线程的上下文加载器是系统类加载器，在线程中运行的代码可以通过该类加载器来加载类与资源

15.new一个对象的过程

img

Java new一个对象有以下几步:

1.首先查看常量池,看看有没有该类的符号引用,如果没有符号引用的话就会触发创建对象,总体又分为这个类加载过程和对象内存分配的过程

2.首先是触发类加载机制,加载链接初始化;将字节码文件使用类加载器进行加载,然后链接分为验证,准备和解析,验证就是验证字节码文件的安全性,准备就是将对应的类成员变量进行赋默认值,常量直接赋值,解析就是将符号引用转换成直接引用,经过初始化过程,就是调用方法进行初始化,为静态变量赋值,执行静态代码块

3.之后就是进行对象内存分配;如果已经有过符号引用可以省去第二步类加载过程.首先在堆中分配一块内存,如果说是连续空间的话,就是用指针碰撞在空闲的位置开辟一块空间;如果是空闲列表,就是找一块足够大的空间存储内存.然后设置对象头;在之后是调用对象的初始化方法;最后在栈中引用新对象

如果经过逃逸分析以后,对象不发生逃逸,那么可以分配到栈上,如果不可以,尝试使用TLAB进行分配,再不行就进行堆内存,指针碰撞和空闲列表的方式,如果eden内存不够则分给老年代

叶落雨飘
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java经典编程题（附答案）
01-05
几十个Java示例程序，搞懂了考试不成问题 【程序1】 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一 对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析： 兔子的规律为数列1,1,2,3,5,8,13,21.... 【程序2】 题目：判断101-200之间有多少个素数，并输出所有素数。 1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。 【程序3】 题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如： 153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。 1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。 【程序4】 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。 程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成： (1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。 (2)如果nk，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。 (3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。 【程序5】 题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下 的用C表示。 1.程序分析：(a>b)?a:b这是条件运算符的基本例子。 【程序6】 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。 1.程序分析：利用辗除法。 【程序7】 题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。 1.程序分析：利用while语句,条件为输入的字符不为'\n'. 【程序8】 题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)， 几个数相加有键盘控制。 1.程序分析：关键是计算出每一项的值。 【程序9】 题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程 找出1000以内的所有完 数。 【程序10】 题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多 少米？第10次反弹多高？ 【程序11】 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 1.程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。 【程序12】 题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万 元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部 分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可 提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？ 1.程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型。 【程序13】 题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？ 1.程序分析：在10万以内判断，先将该数加上100后再开方，再将该数加上268后再开方，如果开方后的结果满足 如下条件，即是结果。请看具体分析： 【程序14】 题目：输入某年某月某日，判断这一天是这一年的第几天？ 1.程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且 输入月份大于3时需考虑多加一天。 【程序15】 题目：输入三个整数x,y,z，请把这三个数由小到大输出。 1.程序分析：我们想办法把最小的数放到x上，先将x与y进行比较，如果x>y则将x与y的值进行交换，然后再用x 与z进行比较，如果x>z则将x与z的值进行交换，这样能使x最小。 【程序16】 题目：输出9*9口诀。 1.程序分析：分行与列考虑，共9行9列，i控制行，j控制列。
面试官：我就问了一个JVM，没想到他能吹半个小时
banzhuanhu的博客
08-30 1万+
前言： 作为 Java 的从业者，在找工作的时候，一定会被问及关于 JVM 相关的知识。 JVM知识的掌握程度，在很多面试官眼里是候选人技术深度的一个重要评判标准。 在这里我们将详细的整理常见的 JVM 面试题目，并给出标准答案，提供给大家学习参考。等大家面试的时候，希望能对面试官吹个半个小时，如果真是这样，我想说：牛皮啊！ 另外本人整理收藏了20年多家公司面试知识点整理 ，以及各种Java核心知识点免费分享给大家，想要资料的话请点1065653031暗号CSDN。 目录前言：1、内存模型以及分区，需
Java面试篇【JVM】常见面试题（2024最新）
最新发布
系统看你学习很认真，随机送了一个月会员！
03-06 1475
线程私有：程序计数器，虚拟机栈，本地方法栈线程共享的：堆，方法区，直接内存。
面试最常被问的 Java 后端题目及参考答案
a6636656的博客
07-06 7581
一、Java 基础篇1. Object 有哪些常用方法？大致说一下每个方法的含义2. Java 创建对象有几种方式？3. 获取一个类对象的方式有哪些？4. ArrayList 和 LinkedList 的区别有哪些？5. 用过 ArrayList 吗？说一下它有什么特点？6. 有数组了为什么还要搞个 ArrayList 呢？7. 说说什么是 fail-fast？8. Hashtable 与 HashMap 的区别9. HashMap 中的 key 我们可以使用任何类作为 key 吗？10. HashMap
Java后端真实面试题大全(有详细答案)--高频/真题
热门推荐
IT利刃出鞘的博客
11-24 11万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
16道JVM面试题
2301_78021017的博客
06-12 2676
1.程序计数器：当前线程正在执行的字节码的行号指示器，线程私有，唯一一个没有规定任何内存溢出错误的情况的区域。 2.Java虚拟机栈：线程私有，描述Java方法执行的内存模型，每个方法运行时都会创建一个栈帧，存放局部变量表、操作数栈、动态链接、方法出口等信息，每个方法的运行到结束对应一个栈帧的入栈和出栈。会有StackOverFlowError异常（申请的栈深度大于虚拟机所允许深度）和OutOfMemoryError异常（线程无法申请到足够内存）。 3.本地方法栈：功能与Java虚拟机栈相同，不过是为Nat
java后端面试题.zip
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
JAVA面试手册、Java面经+Java后端开发+实习+应届生求职面试
06-26
资源概要：Java八股文+Java核心知识点+Java集合+计算机网络+MySQL数据库+Java并发编程+Redis+JVM面试八股文+Spring+系统设计题+大厂面经及答案等相关技术问题+程序员简历制作
Java后端的面试题.zip
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
java后端实习面试题练习.zip
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
Java后端开发面试题2023，基于JavaGuide
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多...
Java——《面试题——JVM篇》
行秋的博客
05-23 3085
JVM定义了不同运行时数据区，他们是用来执行应用程序的。某些区域随着JVM启动及销毁，另外一 些区域的数据是线程性独立的，随着线程创建和销毁。jvm内存模型总体架构图如下：（摘自oracle 官方网站）JVM在执行Java程序时，会把它管理的内存划分为若干个的区域，每个区域都有自己的用途和创建 销毁时间。如下图所示，可以分为两大部分，线程私有区和共享区。下图是根据自己理解画的一个 JVM内存模型架构图：JVM内存分为线程私有区和线程共享区线程私有区1、程序计数器。
JVM常见面试题
给自己一个smile
05-01 1万+
JVM场景面试
JVM常见面试题解析
wanghao112956的博客
07-24 8727
前言 总结了JVM一些经典面试题，分享出我自己的解题思路，希望对大家有帮助，有哪里你觉得不正确的话，欢迎指出，后续有空会更新。 （想自学习编程的小伙伴请搜索圈T社区，更多行业相关资讯更有行业相关免费视频教程。完全免费哦!） 1.什么情况下会发生栈内存溢出。 思路： 描述栈定义，再描述为什么会溢出，再说明一下相关配置参数，OK的话可以给面试官手写是一个栈溢出的demo。 我的答案： 栈是线程私有的...
java面试 描述jvm_面试必学JVM面试题（附答案）
weixin_42398843的博客
02-24 478
Java语言区别于其他计算机语言的最大特点就是面向对象性，也被称为与平台无关的编程语言，java能实现这样的特点，就是因为JVM虚拟机的作用，因此关于JVM的知识点都是需要大家掌握的。下面整理了10道JVM面试题，是在java面试中考察几率最大的题目，一起来学习吧。1、什么情况下会发生栈内存溢出?答：(1)栈是线程私有的，他的生命周期与线程相同，每个方法在执行的时候都会创建一个栈帧，用来存储局部变...
java后端面试题总结（内容无先后顺序，持续更新中）
qq_41027095的博客
05-19 1万+
本文中的内容并非完全原创，很大一部分参考了其他博主写得比较优秀的内容，会标注好出处。本篇文章旨在记录一下网上所看到的面试常考问题，欢迎大家一起学习交流。
【Java面试题汇总】JVM篇（2023版）
vincewm的博客
04-20 8618
JVM内存模型、双亲委派模型、类加载机制、内存溢出、垃圾回收机制、内存泄漏、垃圾回收流程、垃圾回收器、G1、CMS、JVM调优
java面试必问的80道JVM面试题
qq_51861525的博客
07-22 527
引用计数法，被引用就加一，为0的就是没有引用的，就可以被回收，但是会有循环引用的问题科可达性分析，与根没有关系的就是可以回收的。==============================executor和executors的区别======================================cms问题=======================================守护线程和用户线程========================守护线程thread。...
Java-JVM-面试题
weixin_42460596的博客
03-31 1196
加载: 将字节码文件中的.class文件,通过类加载器,加载进运行时数据区的方法区内,并创建一个大的Class对象链接:(验证、准备、解析)① 验证(比如说验证字节码文件开头是CAFFBABA,版本号等)② 准备(为类变量赋予默认的初始化值, 使用static+final修饰, 且显示赋值不涉及到方法或者构造器调用的基本数据类型或者String类型的显示赋值都在准备阶段)③ 解析:将类中的符号引用变成直接引用(符号引号在字节码文件的常量池中)
百度java后端面试题
02-19
我不清楚百度java后端面试题，但是我可以给你一些建议：1.准备好Java基础知识，包括Java语法和数据结构；2.了解JVM，比如类加载机制，内存管理和垃圾收集；3.熟悉Java Web开发技术，如Servlet，JSP，XML，Web Services等；4.了解不同类型的框架，如Spring，Hibernate，Struts等；5.了解数据库编程，如SQL，JDBC，Hibernate等；6.熟悉操作系统原理；7.熟悉计算机网络，知道HTTP，TCP / IP协议的基本原理；8.了解数据库管理系统，如MySQL，Oracle，SQLServer等；9.了解软件工程原理，版本控制等；10.熟悉软件开发流程，如软件需求分析，设计，实现，测试，部署等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值