爪哇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博客