Java 从2D Arraylist获取相同元素的最长序列

方法public List horizontalSequences（）返回水平行中相同元素的最长序列的列表。例如，如果我有

ArrayList<ArrayList<String>> list = [. . . c c . 

                                     a a a a . . 

                                     b b b b b b 

                                     z z . c c c 
                                                ]

然后，该方法应该只返回第一次出现的元素，即列表中的第一个元素，即

[c]

。 提前谢谢

public List<String> gorizontalSequence(ArrayList<ArrayList<String>> list){
     ArrayList<String> list = new ArrayList<String>();
     int currentCount = 0;
     int max = 0;

     for(int i = 0; i < list.size(); i++){
         for(int j = 0; j < list.get(i).size() - 2;){

             if(list.get(i).get(j).equals(list.get(i).get(j-1)) 
                     && (!(list.get(i).get(j).equals("."))) 
                             && (!(list.get(i).get(j-1).equals(".")))){


                 currentCount+=2;
                 if(currentCount > max){
                     max = currentCount;
                 }

                 //list.clear();
                 list.add(list.get(i).get(j-1));
                 list.add(list.get(i).get(j));
                 j+=2;

             }

             else{
             list.add(list.get(i).get(j-1));
             currentCount++;
             if(currentCount > max){
                 max = currentCount;
            } 
                 j++;
         }
     }

public List gorizontalSequence（数组列表）{
ArrayList=新建ArrayList（）；
int currentCount=0；
int max=0；
对于（int i=0；i最大值）{
最大值=当前计数；
}
//list.clear（）；
list.add（list.get（i.get（j-1））；
list.add（list.get（i.get（j））；
j+=2；
}
否则{
list.add（list.get（i.get（j-1））；
currentCount++；
如果（当前计数>最大值）{
最大值=当前计数；
} 
j++；
}
}

所以你的意思是-你想找到一个字母出现的最大顺序。我不会为你写整个程序，但有一种方法可以在一次迭代中完成：

方法 我们将在遍历列表时，将当前字母的值保存在一个临时变量中。然后我们将查看下一个字母是否也是临时变量。如果是这样，我们将递增到一个临时变量，该临时变量包含连续字母的数量。如果不是这样，我们将检查该临时变量是否大于最大值序列（存储在另一个变量中）。如果是，我们覆盖max并将temp变量设置为0，如果不是，我们只需将其设置为0并重新开始

伪码

//我现在假设它是一个数组
char currentChar=列表[0]
int maxSeq，maxIndex
int curSeq
for（int i=0；imaxSeq//仅当它更大时。如果它等于，则我们将得到最后一个序列max
maxSeq=curSeq
maxIndex=i
curSeq=0
其他的
curSeq=0
//现在有了它开始的索引和序列的长度

希望您能理解。

这应该可以：

public ArrayList<String> horizontalSequence(ArrayList<ArrayList<String>> list)
{
    String maxString = "";
    int currentCount;
    int max = 0;

    for(int i = 0; i < list.size(); i++)
    {
        currentCount = 1;
        for(int j = 0; j < list.get(i).size() - 1; j++)
        {
            if(list.get(i).get(j).equals("."))
            {
                currentCount = 1;
                continue;
            }

            if(list.get(i).get(j).equals(list.get(i).get(j+1)))
            {
                currentCount++;
            }

            if( max <currentCount ) {
                max = currentCount;
                maxString = list.get(i).get(j);
            }
        }
    }

    return new ArrayList<>(Collections.nCopies(max, maxString));
}

public ArrayList horizontalSequence（ArrayList列表）
{
字符串maxString=“”；
int电流计数；
int max=0；
对于（int i=0；i如果（max如果我理解问题的正确性，它是“给定一个列表，在任何一个列表中找到相等元素的最长连续序列”。也就是说，连续序列不能在列表中拆分

如果是这种情况，则可以分两步进行：

对于每个列表，减少到该列表中最长的序列
找到那些列表中最长的
第一个问题是给出一个元素列表，这个列表中最长的连续序列是什么

private static <E> List<E> longestConsecutiveSequence(List<E> list) {
    List<E> longestSequence = new ArrayList<>();
    List<E> currentSequence = new ArrayList<>();
    for (E el: list) {
        if (!currentSequence.isEmpty() && !e.equals(currentSequence.get(0)))
            currentSequence = new ArrayList<>();
        currentSequence.add(e);
        if (currentSequence.size() > longestSequence.size())
            longestSequence = currentSequence;
    }
    return longestSequence;
}

第一种方法也可以通过流来实现，但这有点棘手，因为Java流用于独立处理项目，因此检查序列非常重要。请告诉我您是否希望我发布该方法，或者该方法是否太详细。
创建一个与列表大小相同的int数组，以保存元素的“点”。
如果当前元素等于上一个元素，则其点为上一个元素点加1。
得到最大点加1，我们有最大范围大小

    List<String> list = Arrays.asList("v", "a", "a", "a", "a", "a", "a", "b", "a", "a", "a", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "a", "a", "a");
    int[] points = new int[list.size()];
    int maxPos = 0;

    for (int i = 1; i < list.size(); i++) {
        if (list.get(i).equals(list.get(i - 1)))
            points[i] = points[i - 1] + 1;
        if (points[i] > points[maxPos])
            maxPos = i;
    }

    System.out.println(Arrays.toString(points));
    System.out.println("Max range size: " + (points[maxPos] + 1));
    System.out.println("With element: " + list.get(maxPos));

List List=数组。asList（“v”、“a”、“a”、“a”、“a”、“a”、“a”、“b”、“a”、“a”、“a”、“c”、“c”、“c”、“c”、“c”、“c”、“c”、“c”、“a”、“a”、“a”）；
int[]points=新int[list.size（）]；
int-maxPos=0；
对于（int i=1；i点[maxPos]）
maxPos=i；
}
System.out.println（array.toString（points））；
System.out.println（“最大范围大小：+（点[maxPos]+1））；
System.out.println（“带元素：+list.get（maxPos））；

现在，您可以创建一个大小为
点[maxPos]+1的数组列表，并添加
列表的元素。get（maxPos）
内部列表中的所有元素是否都表示一个字符（如示例数据所示）？也就是说，你能用
列表
对数据建模吗？@Mick助记符，它可以是任何类型的字符串-任何长度。但目标是返回列表中同一元素的最长序列。我明白了，但是用一个循环做2d Arraylist可以吗@OneRaynyDay@john不是，但我不知道是2d。没问题，只是如果你想知道每行中的最大序列，请对每行应用相同的算法。如果你想知道最大序列行，请在外部for循环中测试它。希望这有帮助！
private static <E> List<E> longestConsecutiveSequence(List<E> list) {
    List<E> longestSequence = new ArrayList<>();
    List<E> currentSequence = new ArrayList<>();
    for (E el: list) {
        if (!currentSequence.isEmpty() && !e.equals(currentSequence.get(0)))
            currentSequence = new ArrayList<>();
        currentSequence.add(e);
        if (currentSequence.size() > longestSequence.size())
            longestSequence = currentSequence;
    }
    return longestSequence;
}

public static <E> List<E> longestConsecutiveSequence(List<List<E>> listOfLists) {
    List<E> longestSequence = null;
    for (List<E> list: listOfLists) {
        List<E> sequence = longestConsecutiveSequence(list);
        if (longestSequence == null || sequence.size() > longestSequence.size())
            longestSequence = sequence;
    }
    return longestSequence;
}

return listOfList.stream()
    .map(this::longestConsecutiveSequence)
    .max(Comparator.comparingInt(List::size));

    List<String> list = Arrays.asList("v", "a", "a", "a", "a", "a", "a", "b", "a", "a", "a", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "c", "a", "a", "a");
    int[] points = new int[list.size()];
    int maxPos = 0;

    for (int i = 1; i < list.size(); i++) {
        if (list.get(i).equals(list.get(i - 1)))
            points[i] = points[i - 1] + 1;
        if (points[i] > points[maxPos])
            maxPos = i;
    }

    System.out.println(Arrays.toString(points));
    System.out.println("Max range size: " + (points[maxPos] + 1));
    System.out.println("With element: " + list.get(maxPos));