微软Java面试问题

对于Java面试，微软询问关于数据结构、算法、概念等方面的问题。面试官从不问只与Java有关的问题。面试官也可以问问题数组，链表，堆栈，队列，字符串，模式,二叉树等。面试也可以问一些软件设计和测试方面的问题。

对于Java Microsoft面试，我们还应该对我们以前工作过的项目有适当的了解。您应该了解代码的流程、数据库如何与项目连接、表结构、主键、外键等。微软Java面试的前30个问题如下:

1)如何检查二叉树是否是BST ?

为了检查二叉树是否为BST，我们只需检查左子节点是否小于当前节点。我们还检查右子节点是否大于当前节点。对于BST二叉树，左子结点的值应该更小，而右子结点的值应该更大。

2)如何在无限大小的排序数组中找到一个元素?

为了从一个无限排序的数组中找到一个元素，我们将下标设置在位置100。如果我们需要找到的元素小于索引，则对最后100项执行二进制搜索。否则，我们将索引设置在位置200。我们将索引设置为100，直到项目更大。

3)编写一个程序，找到最长的子字符串，不重复字符。

LongestSubString.java

           //导入所需的类和包importjava.util.LinkedHashMap;importjava.util.Scanner;publicclassLongestSubString {staticvoidlongestSubString(String str){//将用户输入的字符串转换为字符数组使用toCharArray() char[] charArray = str.toCharArray();//初始化变量存储最长字符串和长度Int length = 0;//创建LinkedHashMap，键为字符类型，值为整型。//值是字符的位置。LinkedHashMap<Character, Integer>positionMap = newLinkedHashMap<Character, Integer>();//通过字符数组迭代字符串(inti = 0; i<charArray.length; i++) { char c = charArray[i]; //if the character is not in present in positionMapkeySet, add c as a new key along with its position as values if(!positionMap.containsKey(c)) { positionMap.put(c, i); } //if character c is already present in positionMap, repositioning the cursor i to the position of c and clear the positionMap. else { i = positionMap.get(c); positionMap.clear(); } //update subStr and length if(positionMap.size() > length) { length = positionMap.size(); subStr = positionMap.keySet().toString(); } } System.out.println("The longest substring is "+subStr+" with length "+length+"."); } publicstaticvoidmain(String[] args) { String inputString; Scanner sc= newScanner(System.in); System.out.print("Enter a string: "); inputString = sc.nextLine(); sc.close(); longestSubString(inputString); } }
          

输出:

4)如何反转大小为n的链表?

链表的每个元素都存储下一个元素或节点的地址。为了反转链表，我们需要在链表的每个节点中存储上一个节点的地址。我们可以通过使用递归或迭代来反转链表。我们使用以下步骤来反转一个链表:

我们首先存储头部。下一个临时指针ptr。
之后，我们打电话reverseLL (head.next)方法。
存储返回的指针reverseLL (head.next)在临时变量中临时．
我们设置了Next = head（ptr中反向列表的最后一个节点临时）.
的临时变量指向反向链表的第一个节点。

5)如何从字符串中删除重复项?

有多种方法可以从字符串中删除重复项。我们可以通过简单地在字符数组中只添加不同的字符来做到这一点，使用BST，通过使用排序，通过使用哈希，通过使用unordered_map STL方法，用法indexOf ()方法。下面是一个从字符串中删除重复项的简单示例。

RemoveDuplicates.java

           packagejavaTpoint.MicrosoftJava;importjava.util。*;//创建类removeduplicate用于删除重复字符publicclassremoveduplicate{//创建removecars()方法，返回不同的字符串static string removecars (charcharArray[]， int length){//设置索引为0 int pos = 0;//对charArray执行迭代(inti = 0;我<长度;i++){//检查当前字符是否存在于字符串之前。//如果它存在，我们跳过它，否则我们将它添加到结果int j;For (j = 0;<我;j++) {if (charArray[i] == charArray[j]) {break; } } if (j == i) { charArray[pos++] = charArray[i]; } } returnString.valueOf(Arrays.copyOf(charArray, pos)); } // Driver code publicstaticvoidmain(String[] args) { String inputString; Scanner sc= newScanner(System.in); System.out.print("Enter a string: "); inputString = sc.nextLine(); sc.close(); charcharArray[] = inputString.toCharArray(); System.out.println("The string after removing duplicates is: "+removeChars(charArray, charArray.length)); } }
          

输出:

6)如何合并两个未排序的数组?

有两种方法可以将两个未排序的数组以排序的方式合并。在第一种方法中，我们简单地连接两个数组，然后使用任何排序技术对它们进行排序。第二种方法，我们对两个数组排序，然后合并它们。让我们来理解合并两个未排序数组的第一种方法:

MergeUnsortedArrays.java

           packagejavaTpoint.MicrosoftJava;importjava.util。*;//创建类MergeUnsortedArrays，将它们以排序的方式合并为一个数组publicclassMergeUnsortedArrays{//创建mergeAndSort()方法，返回已排序的归并数组publicstaticvoidmergeAndSort(int array1[]， int array2[]， intresArray[]){//计算两个数组的长度int len1 = array1.length;Int len2 = array2.length;//合并两个数组int I = 0, j = 0, k = 0;while (i< len1) {resArray[k] = array1[i];我+ +;k + +;} while (j < len2) {resArray[k] = array2[j];+ +; k++; } // perform sorting on resArray Arrays.sort(resArray); System.out.print("Sorted merge array: "); for (int p = 0; p < len1 + len2; p++) System.out.print(" " + resArray[p]); } // main() method start publicstaticvoidmain(String[] args) { int[] array1 = newint[5]; int[] array2 = newint[5]; Scanner sc = newScanner(System.in); System.out.println("Enter the elements in the first array: "); for(inti = 0; i< array1.length; i++) { array1[i] = sc.nextInt(); } System.out.println("Enter the elements in the second array: "); for(int j = 0; j < array2.length; j++) { array2[j] = sc.nextInt(); } sc.close(); intresArray[]=newint[array1.length + array2.length]; // call mergeAndSort() method mergeAndSort(array1, array2, resArray); } }
          

输出:

7)我们有两个链表，基本上代表两个大数字。编写一个函数，查找两个数字的和并将其存储到第三个列表中。

           节点组合列表(节点第一个节点，节点第二个节点){节点头= null;节点prev = null;节点tmp = null;Int c = 0;/ /携带intsum;//使用while循环执行操作直到firstNode和secondNode不等于null while (firstNode != null || secondNode != null) {sum = c + (firstNode != null ?firstNode。data: 0) + (secondNode != null ?secondNode。数据:0);//对于下一次计算，c的更新值c = (sum >= 10) ?1: 0; // if value of sum is greater than 10, update value of sum sum = sum % 10; // creating new node and set sum as data tmp = new Node(sum); if (head == null) { head = tmp; } else { prev.next = tmp; } // Set prev for next insertion prev = tmp; if (firstNode != null) { firstNode = firstNode.next; } if (secondNode != null) { secondNode = secondNode.next; } } if (c> 0) { tmp.next = new Node(c); } return head; }
          

8)编写一个算法，从给定的中序和前序遍历构建树。

我们首先从预订遍历并增加索引变量，以便在下一个递归调用中选择下一个元素。
从选中的元素中，我们创建一个新的树节点N。
现在，我们从给定值中得到了所选元素的下标有条不紊地进行并将其存储在变量pos中。
我们为pos之前可用的所有元素调用constructTree()方法，并创建一棵树作为节点N的左子树。
我们为pos之后可用的所有元素调用constructTree()方法，并创建一棵树作为节点N的右子树。
最后，返回节点N。

9)编写逻辑，从一个由连续字符组成的字符串中找到最长字符串的长度。

FinalConsSubString.java

           packagejavaTpoint.MicrosoftJava;importjava.util.Scanner;//创建类findconsubstring查找最长子串的长度，该子串由连续字符组成classfindconsubstring{//创建getLastIndex()获取从索引i开始的最大有效子串的最后一个索引staticintgetLastIndex(String str, int n, inti) {i++;while (i< n) {charcurr = str.charAt(i);charprev = str.charAt(i - 1);如果((咕咕叫= = ' a '上一页= = ' z ') | |(咕咕叫- prev = = 1)){我+ +;}else {break;}} return - 1;} //创建getLength()方法获取连续字符最长子字符串的长度staticintgetLength(String inputStr, int length) {intlen = 0;Int I = 0; while (i< length) { // call getLastIndex() method to get last index because valid sub-string exists from index i to last int last = getLastIndex(inputStr, length, i); len = Math.max(last - i + 1, len); i = last + 1; } returnlen; } // Driver code publicstaticvoidmain(String args[]) { String inputString; Scanner sc= newScanner(System.in); System.out.print("Enter a string: "); inputString = sc.nextLine(); sc.close(); System.out.print(getLength(inputString, inputString.length())); } }
          

输出:

10)数组中除了两个元素外，每个元素都有一个副本。写逻辑找到这两个元素。

我们可以很容易地从数组中找到这两个元素，使用for循环迭代它，并检查是否elementE是否显示在数组的其余元素中。如果未找到该元素，则简单地将其存储在另一个数组中并在屏幕上显示。

让我们实现上述理论的逻辑。

FindUniqueElements.java

           packagejavaTpoint.MicrosoftJava;importjava.util.Scanner;publicclassFindUniqueElements {publicstaticvoidgetUniqueElements(int array[]， int length) {for (int = 0;我<长度;i++) {int j;For (j = 0;J < length;j + +){如果(我! = j & &阵列[我]= = array [j]){打破;}} if (j == length) System.out.println(array[i]);}} publicstaticvoidmain(String[] args) {Scanner sc = newScanner(System.in); System.out.println("Enter size of the array"); int size = sc.nextInt(); int[] array = newint[size]; System.out.println("Enter the elements of the array: "); for(inti = 0; i<array.length; i++){ array[i] = sc.nextInt(); } sc.close(); getUniqueElements(array, size); } }
          

输出:

11)编写逻辑，从三个数组中找到公共元素。

FindCommonElements.java

           packagejavaTpoint.MicrosoftJava;importjava.util.Scanner;publicclassFindCommonElements {publicstaticvoidgetCommonElements(int array1[]， int array2[]， int array3[]， int length) {int i = 0, j = 0, k = 0;While (i< array1。长度&& j < array2。length && k < array3.length) {if (array1[i] == array2[j] && array2[j] == array3[k]) {System.out。print (array1[我]+ " ");我+ +;+ +;k + +;}elseif (array1[i] < array2[j]) {i++; }elseif (array2[j] < array3[k]) { j++; }else { k++; } } } publicstaticvoidmain(String[] args) { Scanner sc = newScanner(System.in); System.out.println("Enter size of the array"); int size = sc.nextInt(); int[] array1 = newint[size]; int[] array2 = newint[size]; int[] array3 = newint[size]; System.out.println("Enter the elements of the 1st array: "); for(inti = 0; i< array2.length; i++){ array1[i] = sc.nextInt(); } System.out.println("Enter the elements of the 2nd array: "); for(inti = 0; i< array2.length; i++){ array2[i] = sc.nextInt(); } System.out.println("Enter the elements of the 3rd array: "); for(inti = 0; i< array3.length; i++){ array3[i] = sc.nextInt(); } sc.close(); getCommonElements(array1, array2, array3, size); } }
          

输出:

12)像数据类型一样，我们可以对对象进行类型转换吗?解释一下。

是的，我们可以在Java中进行类型转换和对象。基本上有两种方法来类型转换一个对象，即，向上转型而且向下类型转换。

向上转型一种类型的对象类型转换在哪子类对象类型转换为父类对象。它也被称为泛化或不断扩大的．

语法:

向下类型转换是另一种类型的对象类型转换，其中父类引用对象赋给子类对象。在Java中，向下类型转换在有限的场景下是可能的。

语法:

要了解关于对象类型转换的更多信息，点击这里．

13)我们如何判断一个链表是否包含一个循环或循环?

我们使用两个指针，即，快而且慢在遍历链表时。慢指针和快指针在每次迭代中分别移动两个和一个节点。如果链表包含一个循环，两个指针将在迭代过程中在同一点相遇。

如果两个指针都指向null，则链表中不包含任何循环或循环。

14)在单例中什么是双重检查锁定?

Singleton的双重检查锁定是一种确保在应用程序生命周期中只创建Singleton类的单个实例的方法。双重检查锁定意味着代码在使用和不使用锁的情况下对Singleton类的现有实例进行两次检查，以确保创建的Singleton实例不超过一个。

15)我们在Java中使用瞬态变量的场景是什么?

瞬态变量是Java中一种特殊类型的变量，在反序列化过程中用默认值初始化。在序列化时，暂态变量的值未序列化。

为了防止任何对象被序列化，我们使用瞬态变量．方法可以轻松地创建瞬态变量瞬态关键字。

16)用Java解释volatile。

在Java中,挥发性是用于解决变量可见性问题的关键字。这是使类线程安全的另一种方式。线程安全意味着多个线程可以毫无问题地使用一个方法或一个类实例。

17)我们可以重写Java中的私有方法吗?

我们不能重写私有方法，因为我们不能像访问非私有方法那样访问私有方法。方法重写只能在子类中进行，我们不能访问子类中的私有方法。

18)用Java解释HashTable和HashMap的区别。

S.No。	哈希表	HashMap
1.	不是同步的。	它是同步的。
2.	它是线程安全的。	它不是线程安全的。
3.	它不包含任何空键或值。	它包含一个空键和多个空值。
4.	它很慢。	与Hashtable相比，它非常快。
5.	它继承Dictionary类。	它继承了AbstractMap类。

19)给出任意两个方法的名称，我们可以覆盖一个对象作为HashMap中的键。

equals()和hashcode()是我们可以覆盖的两个方法，用于将对象用作HashMap中的键。

20)在Java中区分LinkedList和ArrayList。

S.No。	LinkedList	ArrayList
1.	LinkedList内部使用双链表来存储元素。	ArrayList内部使用一个动态数组来存储元素。
2.	使用LinkedList操作更快，因为使用了双重链表。	由于内部使用数组，对ArrayList的操作很慢。
3.	与数组列表相比，它更快。	它只实现List接口，因此充当列表。
4.	它有利于数据的操作。	它可以有效地存储和访问数据。