删除数组中的连续重复值-Arduino/Java

我正在使用Ardunio，但很高兴使用Java解决方案，因为这可以帮助我理解

我有一个长度为50的数组

stateX[]

，它将保存类似以下的值：

0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, -1, -1, 0, 1, 1......

我想知道如何从数组中删除彼此相邻的重复值。因此，输出将变成一个更小的数组，其中包含元素：

0, 1, 0, -1, 0, 1

很明显，这个较小的数组会改变大小，所以我不确定。以及如何检测重复值

感谢您的帮助

我不知道“系统化”的方法，但这里有一种方法可以做到：

int[] array = new int[]{1,0,0,1,1,1,-1,-1,1,-1};
List<Integer> lst = new ArrayList<Integer>();

lst.add(array[0]);

for(int i=1;i<array.length;i++)
{
    if(array[i]!=lst.get(lst.size()-1)) lst.add(array[i]);
}

int lstSize = lst.size();
int[] revisedArray = new int[lstSize];
for(int i = 0; i < lstSize; i++) revisedArray[i] = lst.get(i);

int[]数组=新的int[]{1,0,0,1,1,1,1，-1,1，-1}；
List lst=new ArrayList（）；
lst.add（数组[0]）；
对于（int i=1；i以下解决方案可以正常工作，并且不使用任何java列表，这两个特性都有助于移植到Arduino/C。它的复杂性为O（a.length）

请注意，由于未调整输入/输出数组的大小，并且删除了值，因此该数组最终太大。返回的值
newSize
指示解决方案的长度，即在调用该方法后，只有a中的第一个
newSize
值相关

public static int removeAdjacentDuplicates(int[] a) {
    int newSize = 1;
    for (int i = 1; i < a.length; i++) {
        // check if the current value differs from the preceding one
        if (a[i] != a[i - 1]) {
            a[newSize++] = a[i];
        }
    }
    return newSize;
}

公共静态int removeajacentduplicates（int[]a）{
int newSize=1；
for（int i=1；i
很抱歉，我不知道Ardunio，但我用Java编写了下面的类，非常简单，希望这可能会有所帮助，不要犹豫问任何问题！：

package test;

import java.util.ArrayList;
import java.util.Random;

public class Duplicates {

    static ArrayList<Integer> ints = new ArrayList<Integer>();

    public static void main(String[] args) 
    {

        //Creating an arrayList with random numbers from 0 to 5, note that it will work with any numbers.
        for(int index = 0 ;  index <= 1000 ; index++)
        {
            Random myRandom = new Random(); 
            int x = (int) (myRandom.nextDouble() * 5); 
            ints.add(x);

        }

        //Calling my method to remove dupliates next to another
        ArrayList<Integer> cleanedList = removeNextToAnotherDuplicates(ints);

        //Displaying it in the console
        System.out.println(cleanedList.toString());

    }

    public static  ArrayList<Integer> removeNextToAnotherDuplicates(ArrayList<Integer> list)
    {

        for(int i = 0 ; i < list.size() ; i++)
        {
            boolean continueFlag = true;

            // j = j because I do not want to always increment my position, since I would skip some due to the fact that I remove duplicates
            for( int j = i + 1; j < list.size() && continueFlag ; j = j)
            {
                //Showing each iterations.
                System.out.println("i("+ i +") :" + list.get(i).intValue() + "   j("+ j +") :" + list.get(j).intValue());

                if(list.get(i).intValue() == list.get(j).intValue())
                {
                    list.remove(j);
                }
                else
                {
                    continueFlag = false;
                    j++;
                }

                //Showing each iterations.
                System.out.println("flag: "+ continueFlag);
                System.out.println(list.toString());

            }
        }

        return list;
    }
}

封装测试；
导入java.util.ArrayList；
导入java.util.Random；
公共类副本{
静态ArrayList ints=新ArrayList（）；
公共静态void main（字符串[]args）
{
//创建随机数为0到5的arrayList时，请注意，它可以处理任何数字。
对于（int index=0；如上所述，只需使用循环在数组上迭代索引，然后在下一个值等于当前值（可以存储在最终数组中）时增加它