爪哇2博客
关
爪哇2博客

爪哇面试者程序

爪哇面试程序

在本教程中，我们将看到Java面试程序的入门知识。该面试程序将帮助新生破解Java面试。

以下是针对大一新生的十大Java采访程序列表。

问题1：检查数字是奇数还是偶数？

回答：

这是一个非常基本的问题。将数字除以2时，需要检查余数。如果为1，则为奇数，否则为偶数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
包 com.Arpit.爪哇2blog;
 
上市 类 OddEvenCheckMain {
 
    上市 静态的 虚空 主要(串[] args) {
          整型 数=27;
 
          如果 ( 数 % 2 == 0 )
          {
              //如果余数为0，则为偶数
             系统.出.打印(“数字是偶数”);
           }
          其他
          {
              //如果余数为1，则为奇数
             系统.出.打印(“数字很奇怪。”);
          }
    }
}
 

当您运行上述程序时，将获得以下输出：

数字是奇数。

问题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;
 
上市 类 PrimeNumberMain {
 
上市 静态的 虚空 主要(串[] args) {
 
  系统.出.打印(“ 17是素数？：”+是Prime(17));
  系统.出.打印(“ 2是素数？：”+是Prime(2));
  系统.出.打印(“ 91是质数？：”+是Prime(91));
  系统.出.打印(“ 29是素数？：”+是Prime(29));
  系统.出.打印(“ 81是素数？：”+是Prime(81));
}
 
上市 静态的 布尔值 是Prime(整型 数)
{
  对于 (整型 i = 2; i <=数学.sqrt(数); i++) {
   如果(数%i==0)
    返回 假;
  }
  返回 真正;
}
 
}
 

当您运行上述程序时，将获得以下输出：

17是质数？：是
2是素数？：是
91是素数？：假
29是质数？：是
81是质数？：否

如果可以通过 检查是否 数字是主要的详细信息。

问题3：反转字符串：

回答：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
包 com.Arpit.爪哇2blog;
类 ReverseStringForMain
{
上市 静态的 虚空 主要(串[] args)
{
  串 力量=“快乐”;
  串 逆转=”;
  对于(整型 i=力量.长度()-1;i>=0;i-)
  {
   逆转=逆转+力量.字符(i);
  }
  系统.出.打印(“快乐的反面是：”+逆转);
}
}
 

当您运行上述程序时，将获得以下输出：

快乐的反面是：yppaH
 You can go through 如何反转字符串 了解更多方法。

问题4：检查String是否是回文。

回答：
反转字符串，并使用输入字符串检查它。

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
 
包 组织.Arpit.爪哇2blog;
进口 爪哇.实用程序.扫描器;
 
上市 类 串FullLoop回文 {
 
上市 静态的 虚空 主要(串[] args) {
 
  扫描器 扫描器 = 新 扫描器(系统.在 );
  系统.出.打印(“输入字符串：”);
 
  串 力量 = 扫描器.下一页Line();
  串 逆转Str = ”;
 
  对于(整型 i = 力量.长度() - 1; i >= 0; i-){
   逆转Str = 逆转Str + 力量.字符(i);
  }
 
  如果(力量.等于(逆转Str)){
   系统.出.打印(“字符串是回文”);
  } 其他 {
   系统.出.打印(“字符串不是回文”);
  }
}
}
 

当您在程序上方运行时，将获得以下输出：

输入字符串：12121
字符串是回文
输入字符串：Apple
字符串不是回文

你可以经历 检查字符串是否是回文 更多细节。

问题5：在o（登录）时间中按排序数组搜索数字？

回答：
您需要使用 二进制搜索 在o（logn）时间中搜索数组中的元素。
二进制搜索代码

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
 
包 组织.Arpit.爪哇2blog.线;
 
上市 类 BinarySerarchMain {
 
上市  静态的 整型 binarySearch(整型[] sortedArray, 整型 elementToBeSearched) {
  整型 第一 = 0;
        整型 持续 = sortedArray.长度 - 1;
 
      而 (第一 < 持续) {
 
          整型 中 = (第一 + 持续) / 2;  //计算中点。
 
          如果 (elementToBeSearched < sortedArray[中]) { 持续 = 中; //在上半年重复搜索。 }否则，如果（elementToBeSearched> sortedArray[mid]) {
              第一 = 中 + 1;  //在后半部分重复sortedArray。
          } 其他 {
              返回 中;     // 找到了。返回位置
          }
      }
 
      返回 -1;    //找不到元素
  }
 
上市 静态的 虚空 主要(串[] args)
{
 
  整型[] sortedArray={2,6,67,96,107,119,128,453};
  整型 在 dexOfElementToBeSearched=binarySearch(sortedArray,67);
  系统.出.打印(“数组中的74的索引是：” +在 dexOfElementToBeSearched);
 
  整型 在 dexOfElementToBeSearchedNotFound =binarySearch(sortedArray,7);
  系统.出.打印(“数组中的索引7为：” +在 dexOfElementToBeSearchedNotFound );
}
 
}
 

当您运行上述程序时，将获得以下输出：

数组中的67的索引是：2
数组中的7的索引是：-1

问题6：在数组中查找缺失的数字。

回答：

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
 
包 组织.Arpit.爪哇2blog;
 
上市 类 MissingNumberMain {
 
上市 静态的 虚空 主要(串[] args) {
 
  整型[] rr1={7,5,6,1,4,2};
  系统.出.打印(“缺少数组arr1的数字：”+missingNumber(rr1));
  整型[] rr2={5,3,1,2};
  系统.出.打印(“数组arr2中缺少编号：”+missingNumber(rr2));
 
}
 
上市 静态的 整型 missingNumber(整型[] rr)
{
  整型 n=rr.长度+1;
  整型 和=n *(n+1)/2;
  整型 剩余总和=0;
  对于 (整型 i = 0; i < rr.长度; i++) {
   剩余总和+ =rr[i];
  }
  整型 missingNumber=和-剩余总和;
  返回 missingNumber;
}
}
 

当您运行上述程序时，将获得以下输出：

数组arr1缺少数字：3
数组arr2缺少数字：4

你可以经历 在数组中找到缺失的数字 更多细节。

问题7：Java程序在字符串中查找重复的字符？

回答：

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;
 
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.组;
 
上市 类 串FindDuplicatesMain {
 
上市 静态的 虚空 主要(串[] args) {
  串 力量 = “ 爪哇2blog.com”;
  哈希图 烧焦CountMap = 新 哈希图();
  对于 (整型 i = 0; i < 力量.长度(); i++)
{
      烧焦 c = 力量.字符(i);
      如果 (烧焦CountMap.containsKey(c))
      {
           烧焦CountMap.放(c, 烧焦CountMap.得到(c) + 1);
      } 其他 {
           烧焦CountMap.放(c, 1);
   }
}
对于 (字符 c : 烧焦CountMap.键集()) {
如果 (烧焦CountMap.得到(c) > 1)
    系统.出.打印(“重复字符：” + c + “ ======” + “数：” + 烧焦CountMap.得到(c));
  }
}
}
 

当您运行上述程序时，将获得以下输出：

1
2
3
4
 
重复 字符 : a ======  计数 : 2
重复 字符 : o ======  计数 : 2
 

你可以经历 在字符串中查找重复的字符 更多细节。

问题8：Java程序查找String中的单词数？

回答：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
包 com.Arpit.爪哇2blog;
 
类 数词
{
    上市 静态的 虚空 主要(串[] args)
    {
        串 力量=“我的名字是约翰”;
 
        串[] 话 = 力量.修剪().分裂(”);
 
        系统.出.打印(“字符串中的单词数=”+话.长度);
        系统.出.打印(“话是：”);
        对于 (整型 i = 0; i < 话.长度; i++) {
            系统.出.打印(话[i]);
        }
    }
}
 

当您在程序上方运行时，将获得以下输出：

字符串中的单词数= 4
的话是：
我的
名称
是
约翰

问题9：编写程序以查找阶乘？

回答：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
包 com.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.扫描器;
 
上市 类 阶乘{
    上市 静态的 虚空 主要(串[] args){
        扫描器 在 = 新 扫描器(系统.在 );
        系统.出.打印(“输入数字以计算阶乘：”);
        整型 n = 在 .下一页Int();
        整型 f =1;
        对于(整型 i=n; i>0; i-){
            f = F*i;
        }
        系统.出.打印(“的基础+n+“是”+f);
    }
}
 

当您运行上述程序时，将获得以下输出：

输入数字以计算阶乘：
5
5的阶乘为120

问题10：编写程序来打印斐波那契数列？

回答：

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.算法;
 
上市 类 FibonnacciIterativeMain
{
上市 静态的 虚空 主要(串[] args)
{
  系统.出.打印(“印刷斐波那契系列：”);
  //系列的前两个数字
  整型 上一页=0,下一页=1;
  //打印前两个元素
  系统.出.打印(上一页+”+下一页);
  //要打印的元素数
  整型 数OfElements=10;
  整型 和=0;
  对于(整型 i=2;i<数OfElements;i++)
  {
   和=上一页+下一页;
   系统.出.打印(”+和);
   上一页=下一页;
   下一页=和;
  }
}
}
 

当您运行上述程序时，将获得以下输出：

印刷斐波那契系列：
0 1 1 2 3 5 8 13 21 34

你可以经历 斐波那契系列程序 更多细节

那’有关面向新生的Java 面试程序的全部信息。

您可能还喜欢：

爪哇面试程序


导入联系人

您可能还喜欢：

分享这个

作者

关注作者

相关文章

Comments

发表评论

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

订阅我们的新闻

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


成为朋友

©2020 爪哇2博客