因为这是家庭作业（或类似的），所以我不打算给出代码。
但是，我的方法是扫描较长的列表，并在一个列表中记录每个数字的位置 Map<Integer, Set<Integer>> .
然后遍历较短的列表，从Map集中的索引开始查找相同的序列。
这样做会带来很好的时间复杂性，

将int值处理为 codePoints :
[1] 将列表2转换为str2
[2] 将list1转换为str1，去掉左侧所有int值（不在list2中）
[3] 将str1移到str2上，记住str1位于str2上的最长序列

ArrayList<int[]> results = new ArrayList<>();

String str2 = new String(
            new int[] { 1, 8, 3, 10, 13, 14, 8, 10, 14, 6, 11 }, 0, 11 ); //[1]
int[] tmp = new int[] { 8, 9, 10, 11, 12, 8, 10, 13, 14, 15 };
int[] arr1 = IntStream.of( tmp ).dropWhile(
    c -> str2.indexOf( c ) < 0 ).toArray();      //[2]
String str1 = new String( arr1, 0, arr1.length );
for( int i = str1.length() - 2; i >= 0; i-- ) {  //[3]
  int[] rslt = new int[0];
  for( int j = 0; j < str2.length() - 2; j++ ) {
    int[] idx2 = new int[] { j };
    rslt = str1.substring( i ).codePoints().takeWhile(
        c -> c == (int)str2.charAt( idx2[0]++ ) ).toArray();
    if( rslt.length >= 2 ) {
      results.add( rslt );
    }
  }
}

results.forEach(a -> System.out.println( Arrays.toString( a ) ));

得到： [13, 14] , [10, 13, 14] , [8, 10]

我不太清楚你想做什么，但如果我做的是普通序列，我会创建子列表并比较它们：

public static Set<List<Integer>> findCommonSequence(List<Integer> source, List<Integer> target, int startLength) {
        Set<List<Integer>> sequences = new LinkedHashSet<>();

        // algorithm works in this way:
        // we prepare all possible sublists of source list that are at least startLength length
        // and then we check every of those sublists against the target list to see if it contains any

        // length is from startLength to maxSize, to check all sublists with that length
        // ie if startLength is 2 and source is 10, it will be 2 - 10 and thus it will check all sublist sizes
        for (int length = startLength; length < source.size(); length++) {
            // startIndex will move from 0 to original_list - length, so if length is 2, it will generate sublists
            // with indexes 0,1; 1,2; 2,3 ... 8,9
            for (int startIndex = 0; startIndex+length < source.size(); startIndex++) {
                // creates lightweight sublist that shares the data
                List<Integer> sublist = source.subList(startIndex, startIndex+length);
                // add all found subsequences into the set
                sequences.addAll(findSequenceIn(target, sublist));
            }
        }

        return sequences;
    }

    // Returns all subsequences that are inside the target list
    private static Set<List<Integer>> findSequenceIn(List<Integer> target, List<Integer> sublist) {
        Set<List<Integer>> subsequences = new LinkedHashSet<>();

        // simply do the same process as in first method but with fixed length to the length of sublist
        for (int i=0; i<target.size() - sublist.size(); i++) {
            // create another sublist, this time from target (again, share data)
            List<Integer> testSublist = target.subList(i, i+sublist.size());

            // compare two sublists, if they are equal, that means target list contains sublist from original list
            if (testSublist.equals(sublist)) {
                // add it to the set
                subsequences.add(new ArrayList<>(sublist));
            }
        }

        return subsequences;
    }

然后，您可以优化算法，通过发送索引而不是子列表来执行检查，并手动执行比较。该算法的复杂度应该在o（n3）到o（n4）之间。可能是o（n4），因为我们做了n2个子列表，然后将其中的n个操作与列表2中的n个子列表进行比较，但可能是n3，因为比较较小，不知道在数学上它与n3或n4有多接近。
当然，还有另一个n与子列表的副本，但你可以优化这一个了。