最近我被要求为一份工作编写3个测试程序。这些程序将只使用核心的Java API和我选择的任何测试框架。应在适当的位置实现单元测试。
虽然我没有收到任何反馈，但我认为他们不喜欢我的解决方案（否则我会从他们那里听到），所以我决定在这里展示我的程序，并问这个实现是否可以被认为是好的，如果不是，那么为什么？
为了避免混淆，我现在只问了第一个问题。
实现一个函数，在更大的另一个数组中找到一个数组。 它应该接受两个数组作为参数，并返回第二个数组首次完全出现在第一个数组中的索引。例如，findArray([2,3,7,1,20], [7,1]) 应该返回 2。
我没有尝试寻找任何现有的解决方案，而是想自己做。
可能的原因： 1. 应该是静态的。 2. 应该使用行注释而不是块注释。 3. 没有先检查空值（我知道，太晚发现了）。 4. ？
更新:
很多原因已经被提出，很难选择一个答案，因为许多答案都有好的解决方案。正如@adietrich提到的那样，我倾向于相信他们想让我展示核心API的知识（他们甚至要求编写函数，而不是编写算法）。
我认为保住这份工作最好的方法是提供尽可能多的解决方案，包括： 1. 使用Collections.indexOfSubList()方法实现，以显示我对核心集合API的了解。 2. 实现一种蛮力方法，但提供更优雅的解决方案。 3. 使用搜索算法实现，例如Boyer-Moore。 4. 使用System.arraycopy()和Arrays.equal()的组合来实现。虽然不是性能最佳的解决方案，但它将展示我对标准数组例程的了解。
感谢大家的答案！
更新结束。
以下是我编写的程序:
package com.example.common.utils;
/**
* This class contains functions for array manipulations.
*
* @author Roman
*
*/
public class ArrayUtils {
/**
* Finds a sub array in a large array
*
* @param largeArray
* @param subArray
* @return index of sub array
*/
public int findArray(int[] largeArray, int[] subArray) {
/* If any of the arrays is empty then not found */
if (largeArray.length == 0 || subArray.length == 0) {
return -1;
}
/* If subarray is larger than large array then not found */
if (subArray.length > largeArray.length) {
return -1;
}
for (int i = 0; i < largeArray.length; i++) {
/* Check if the next element of large array is the same as the first element of subarray */
if (largeArray[i] == subArray[0]) {
boolean subArrayFound = true;
for (int j = 0; j < subArray.length; j++) {
/* If outside of large array or elements not equal then leave the loop */
if (largeArray.length <= i+j || subArray[j] != largeArray[i+j]) {
subArrayFound = false;
break;
}
}
/* Sub array found - return its index */
if (subArrayFound) {
return i;
}
}
}
/* Return default value */
return -1;
}
}
测试代码：
package com.example.common.utils;
import com.example.common.utils.ArrayUtils;
import junit.framework.TestCase;
public class ArrayUtilsTest extends TestCase {
private ArrayUtils arrayUtils = new ArrayUtils();
public void testFindArrayDoesntExist() {
int[] largeArray = {1,2,3,4,5,6,7};
int[] subArray = {8,9,10};
int expected = -1;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArrayExistSimple() {
int[] largeArray = {1,2,3,4,5,6,7};
int[] subArray = {3,4,5};
int expected = 2;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArrayExistFirstPosition() {
int[] largeArray = {1,2,3,4,5,6,7};
int[] subArray = {1,2,3};
int expected = 0;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArrayExistLastPosition() {
int[] largeArray = {1,2,3,4,5,6,7};
int[] subArray = {5,6,7};
int expected = 4;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArrayDoesntExistPartiallyEqual() {
int[] largeArray = {1,2,3,4,5,6,7};
int[] subArray = {6,7,8};
int expected = -1;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArrayExistPartiallyEqual() {
int[] largeArray = {1,2,3,1,2,3,4,5,6,7};
int[] subArray = {1,2,3,4};
int expected = 3;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArraySubArrayEmpty() {
int[] largeArray = {1,2,3,4,5,6,7};
int[] subArray = {};
int expected = -1;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArraySubArrayLargerThanArray() {
int[] largeArray = {1,2,3,4,5,6,7};
int[] subArray = {4,5,6,7,8,9,10,11};
int expected = -1;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
public void testFindArrayExistsVeryComplex() {
int[] largeArray = {1234, 56, -345, 789, 23456, 6745};
int[] subArray = {56, -345, 789};
int expected = 1;
int actual = arrayUtils.findArray(largeArray, subArray);
assertEquals(expected, actual);
}
}