爪哇2博客
爪哇2博客

爪哇面试问题5年经验

爪哇面试问题5年经验

在这篇文章中,我们将看到 爪哇面试题 5至6年的经验。
当你有5年的经验 爪哇 开发人员,您需要对 馆藏, 多线程 概念。

如果您正在寻找以下查询,那么这篇文章也将为您提供帮助。

  • 爪哇面试题 4年经验
  • 爪哇面试问题6年经验
  • 爪哇面试问题7年的经验

这是5年Java程序员经验中最常问到的一些问题。您可能会发现一些问题很容易,但是我相信大多数开发人员都无法回答这些问题。

1.猜测以下程序的输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
组织.Arpit.爪哇2blog;
A
{
    虚空 m1()
    {
        系统..打印(“在m1 A中”);
    }
}
B 延伸 A
{
    虚空 m1()
    {
        系统..打印(“在m1 B中”);
    }
    虚空 m2()
    {
        系统..打印(“在平方米B中”);
    }
}
上市 测试 {
 
    上市 静态的 虚空 主要([] args) {
        A a= B();
        a.m2();
    }
}
 

输出是什么?
A.在平方米B
B.编译时错误
C.运行时错误

进一步阅读:
爪哇抽象
爪哇中的多态

2.猜测以下程序的输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
组织.Arpit.爪哇2blog;
 
A
{
    虚空 m1() 抛出 ArrayIndexOutOfBoundsException
    {
        系统..打印(“在m1 A中”);
    }
}
B 延伸 A
{
    虚空 m1() 抛出 IndexOutOfBoundsException
    {
        系统..打印(“在m1 B中”);
    }
}
上市 测试 {
 
    上市 静态的 虚空 主要([] args) {
        A a= B();
        a.m1();
    }
}
 

输出是什么?
A.在m1 B
B.编译时错误
C.运行时错误

3.猜测以下程序的输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.io.IOException;
 
A
{
    虚空 m1() 抛出 IOException
    {
        系统..打印(“在m1 A中”);
    }
}
B 延伸 A
{
    虚空 m1() 抛出 例外
    {
        系统..打印(“在m1 B中”);
    }
}
上市 测试 {
 
    上市 静态的 虚空 主要([] args) {
        A a= B();
        尝试 {
            a.m1();
        } 抓住 (IOException e) {
            e.printStackTrace();
        }
    }
}
 

输出是什么?
A.在m1 B
B.编译时错误
C.运行时错误

4.如果出现以下程序,将会怎样?

1
2
3
4
5
6
7
8
9
10
11
12
13
 
A
{
    已同步 虚空 m1()
    {
        系统..打印(“在m1 A中”);
    }
    虚空 m2()
    {
        系统..打印(“以平方米为单位”);
    }
}
 

有两个线程T1和T2。 T1正在访问m1方法。 T2可以同时在同一实例上访问m2方法吗?

进一步阅读: 对象级锁定和类级锁定

5.如果出现以下程序,将会怎样?

1
2
3
4
5
6
7
8
9
10
11
12
13
 
A
{
    已同步 虚空 m1()
    {
        系统..打印(“在m1 A中”);
    }
    已同步 虚空 m2()
    {
        系统..打印(“以平方米为单位”);
    }
}
 

有两个线程T1和T2。 T1正在访问m1方法。 T2可以同时在同一实例上访问m2方法吗?

进一步阅读: 对象级锁定和类级锁定

6.如果出现以下程序,将会怎样?

1
2
3
4
5
6
7
8
9
10
11
12
13
 
A
{
    已同步 静态的 虚空 m1()
    {
        系统..打印(“在m1 A中”);
    }
    已同步 虚空 m2()
    {
        系统..打印(“以平方米为单位”);
    }
}
 

有两个线程T1和T2。 T1正在访问m1方法。 T2可以同时在同一实例上访问m2方法吗?

7.猜测以下程序的输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.哈希集;
 
上市 顾客 {
 
     名称;
    整型 年龄;
 
    顾客( 名称,整型 年龄)
    {
        这个.名称=名称;
        这个.年龄=年龄;
    }
    上市 静态的 虚空 主要([] args) {
 
        顾客 c1= 顾客(“约翰”,20);
        顾客 c2= 顾客(“约翰”,20);
 
        哈希集<顾客> 客户集= 哈希集<>();
        客户集.(c1);
        客户集.(c2);
        系统..打印(客户集.尺寸());
    }
 
    //获取器和设置器
}
 

8.猜测以下程序的输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
组织.Arpit.爪哇2blog;
 
上市 雇员 {
     名称;
    整型 年龄;
 
    上市 雇员( 名称,整型 年龄)
    {
        这个.名称=名称;
        这个.年龄=年龄;
    }
 
    @覆写
    上市 整型 hashCode() {
        最后 整型 主要 = 31;
        整型 结果 = 1;
        结果 = 主要 * 结果 + 年龄;
        结果 = 主要 * 结果 + ((名称 == 空值) ? 0 : 名称.hashCode());
        返回 结果;
    }
 
    @覆写
    上市 布尔值 等于(目的 对象) {
        如果 (这个 == 对象)
            返回 真正;
        如果 (对象 == 空值)
            返回 ;
        如果 (得到Class() != 对象.得到Class())
            返回 ;
        雇员 其他 = (雇员) 对象;
        如果 (年龄 != 其他.年龄)
            返回 ;
        如果 (名称 == 空值) {
            如果 (其他.名称 != 空值)
                返回 ;
        } 其他 如果 (!名称.等于(其他.名称))
            返回 ;
        返回 真正;
    }
 
    上市 得到Name() {
        返回 名称;
    }
    上市 虚空 setName( 名称) {
        这个.名称 = 名称;
    }
    上市 整型 得到Age() {
        返回 年龄;
    }
    上市 虚空 setAge(整型 年龄) {
        这个.年龄 = 年龄;
    }  
}
 

主班

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.地图;
 
上市 哈希图Main {
 
    上市 静态的 虚空 主要([] args) {
        雇员 emp1= 雇员(“马丁”,27);
        地图<雇员,> = 哈希图<雇员,>();
        .(emp1, “已验证”);
        emp1.setName(“约翰”);
        系统..打印(.得到(emp1));
    }
}
 

9.如何为您的应用程序确定年轻一代和老一代的大小?

这取决于应用程序的性质。
如果您有很多临时对象,那么会有很多次要gc。您可以提供参数XX:NewRatio = 1将50%分配给年轻一代,将50%分配给老年人。
默认情况下,NewRatio = 2,因此年轻的Generation是总堆的1/3。
同样,如果您有太多的长寿命对象,则可能需要通过设置高NewRatio值来增加保有权空间的大小。

10. 爪哇中的垃圾回收是什么?

垃圾收集 是识别Java堆上已使用和未使用的对象并从堆中删除未使用的对象的过程。
有生命的物体意味着 目的 仍被引用到程序的某些部分。未使用的对象表示该对象未被程序的任何部分引用,并且可以进行垃圾回收。
程序员不必像C或C ++那样进行手动垃圾收集。 爪哇负责

11. 爪哇中的垃圾收集器有哪些类型?

你可以看到一个 这里的详细答案.

12. Collection.synchronizedMap(map)和ConcurrentHashMap有什么区别?

当您使用Collection.synchronizedMap(map)使地图线程安全时,它会锁定整个地图对象,但是ConcurrentHashMap不会锁定整个地图对象,而只会锁定它的一部分(段)。
您可以阅读更多有关 并发哈希图在这里.

13.在代码下运行时会发生什么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.迭代器;
进口 爪哇.实用程序.地图.条目;
 
上市 IterateMapMain {
 
    上市 静态的 虚空 主要( args[])
    {
        //以国家/地区为键,资本为值的HashMap
        哈希图<,> 地图= 哈希图<,>();
        地图.(“印度”,“德里”);
        地图.(“日本”,“东京”);
        地图.(“法国”,“巴黎”);
        地图.(“俄国”,“莫斯科”);
 
        //迭代Java迭代器
        系统..打印(“迭代java迭代器”);
        迭代器<> countryKeySetIterator=地图.键集().迭代器();
        (countryKeySetIterator.hasNext()){
             countryKey=countryKeySetIterator.下一页();
            地图.(“尼泊尔”, “加德满都”);
            系统..打印(countryKey);
 
        }
        系统..打印(“ -----------------------------”);
    }
 
}
 

14.编写程序以按顺序使用线程打印奇数?

这是程序 按顺序使用线程打印奇数和偶数.

15.您在项目中使用了哪种设计模式?

您可以命名一些设计模式,例如 辛格尔顿, 观察者 等,您可能已在项目中使用过。

16.单例设计模式中的双层锁定是什么?

双重锁定 单例设计模式  用于使其成为线程安全的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
上市 静态的 辛格尔顿 得到Instance()
    {
        如果 (_instance == 空值) { //单选
            已同步 (辛格尔顿.)
            {
                如果 (_instance == 空值)//再次检查
 
                {
                    _instance = 辛格尔顿();
                }
            }
        } 返回 _instance;
    }
 

让’假设两个线程(T1和T2)检查是否为空,并且两个线程都在同步(Singleton.class)时到达。 T1获取锁并创建Singleton实例并返回。现在T2进入了一个同步块,因为我们再次检查了null,所以它将不再创建对象。

17.编写一个程序来使用BlockingQueue实现生产者-消费者问题?

你可以找到 详细的答案在这里

18.您从事过Java 8吗?您可以分享Java 8的主要变化吗?

如果您从事过 爪哇 8,您可以共享诸如Stream, lambda表达式, 接口中的defaults方法 等等

19.您是否从事序列化工作?您能分辨出Serializable和Externalizable之间的区别吗?

你可以找到 详细的答案在这里

20.如何检测应用程序中的内存泄漏?

这个问题没有简单的答案。您可以通过JVisualVM进行线程转储,并在其中进行分析 蚀内存分析器工具.

您可能还喜欢:

那’具有5至6年经验的Java面试问题。

分享这个

作者

关注作者

相关文章

  • 爪哇面试题
    22 May

    爪哇面试题

    我写了很多Java面试问题,这是所有Java面试问题的索引。我将继续在此帖子中添加更多面试问题。核心Java核心Java面试问题此列表包括前50个核心Java面试问题。无论您是新手还是经验丰富的程序员,此面试问题都将[…]

  • 爪哇中的扎实原则
    11月9日

    爪哇中的SOLID原理

    在这篇文章中,我们将看到Java中的5条SOLID原则。罗伯特·C·马丁(Robert C. Martin)提出了五项面向对象的设计原则,并使用了缩写S.O.L.I.D。该首字母缩写词的每个字母都讨论Java的原理。当您结合使用S.O.L.I.D的所有原理时,对您来说会变得更加容易[…]

  • 爪哇面试问题2年经验
    11月8日

    爪哇面试问题2年经验

    在本文中,我们将看到2到3年的Java面试问题。这些是新生(0-3年的经验)最常被问到的面试问题。这个问题清单将帮助您破解Java面试。在此之前,我已经分享了详细的答案,您可能会发现它也很有帮助。一世 […]

  • 爪哇棘手的面试题
    9月11日

    爪哇技术面试题

    在这篇文章中,我们将看到Core 爪哇访谈中要求的顶级Java技术面试。我涵盖了很多关于Java编程的面试问题。这是您可能会发现有用的其他Java面试问题的列表。核心Java面试题Java 馆藏面试题Java 串面试题OOPs 爪哇中的面试题[…]

  • 春季靴面试问题
    8月06

    春季靴面试的前15个问题

    在这篇文章中,我们将看到15个有关Spring Boot面试的热门问题及其答案。如果您想了解更多有关Spring Boot的信息,可以阅读Spring Boot教程。如果您正在寻找以下查询,那么这篇文章也将为您提供帮助。 春季靴面试问题3年的经验Spring Boot面试[…]

  • 爪哇面试程序
    6月10日

    爪哇面试者程序

    在本教程中,我们将看到Java面试程序的入门知识。该面试程序将帮助新生破解Java面试。以下是针对大一新生的十大Java采访程序列表。问题1:检查数字是奇数还是偶数?答:这是一个非常基本的问题。您需要检查余数[…]

Comments

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让’s be Friends

©2020 爪哇2博客