Java 数组的困难

我有点困了，所以如果有人有空的话，这对我来说是一个很大的帮助。我正在使用eclipse，程序正在编译和运行。但是有一个运行时错误。 在数组{2,1,1,2,3,3,2,2,2,1}中，我想打印{2,2,2}，这是数组中重复次数最高的数字。我得到的是： 0 1. 0 0 3. 0 2. 2. 0

谢谢你们，这是我的密码

public class SameIndexInArray
{
    public static void main(String[] args) 
    {
        int[] array = {2, 1, 1, 2, 3, 3, 2, 2, 2, 1};
        int[] subarray = new int[array.length]; //store the values should be {2, 2, 2}

        int max = 1;
        int total = 1;

        for(int i=0; i<array.length-1; i++)
        {
            if(array[i] != array[i + 1])
            {
                max = 1;
            }
            else if(array[i] == array[i + 1])
            {
                max++;
                total = max;
                subarray[i] = array[i]; // here is the issue
            }
            System.out.println(subarray[i]);
        }
        //System.out.println(total);
    }
}

公共类SameIndexInArray
{
公共静态void main（字符串[]args）
{
int[]数组={2,1,1,2,3,3,2,2,2,1}；
int[]subarray=newint[array.length]；//存储值应为{2,2,2}
int max=1；
整数合计=1；
对于（int i=0；i您只将临时存储到子数组中，因此您应该为子数组索引计数定义一个单独的计数器（假设为j），并假设子数组[j++]=array[i]。而且，您不应该为数组的每个索引输出子数组，因此将println移到第二个if子句中。
您只将临时存储到子数组中，因此您应该为子数组索引计数定义一个单独的计数器（假设为j），并说subarray[j++]=array[i]。并且，您不应该为数组的每个索引输出子数组，因此将println移到第二个if子句中。
您需要使用除“i”之外的另一个索引
您不能关联到具有相同索引的两个数组
您需要使用除“i”之外的另一个索引
您无法关联具有相同索引的2个数组。您的问题是子数组中的所有值都初始化为0，并且您仅在存在实际序列时才编辑这些值，从第二个元素开始

不需要整个子数组。只需保存开始索引和子查询的长度；）

我的意思是这样的：

int[] array = {2, 1, 1, 2, 3, 3, 2, 2, 2, 1};

int startIndex = 0;
int length = 0;

int longestIndex = 0;
int longestLength = 0;

for(int i=0; i<array.length-1; i++)
{
    if(array[i] != array[i + 1])
    {
        if (length > longestLength) {
            longestLength = length;
            longestIndex = startIndex;
        }
        startIndex = i;
        length = 1;
    }
    else if(array[i] == array[i + 1])
    {
        length++;
    }
}

if (length > longestLength) {
    longestLength = length;
    longestIndex = startIndex;
}

int[]数组={2,1,1,2,3,3,2,2,2,1}；
int startIndex=0；
整数长度=0；
int longestIndex=0；
int longestLength=0；
for（int i=0；i最长长度）{
最长长度=长度；
longestIndex=startIndex；
}
startIndex=i；
长度=1；
}
else if（数组[i]==数组[i+1]）
{
长度++；
}
}
如果（长度>最长长度）{
最长长度=长度；
longestIndex=startIndex；
}

现在您知道了最长序列的起始位置和长度，可以构建新阵列了：

int[] sequence = new int[longestLength];
for (int i = 0; i < longestLength; i++) {
    sequence[i] = array[i + startIndex];
}

int[]序列=新的int[longestLength]；
for（int i=0；i
您的问题是子数组中的所有值都初始化为0，并且您仅在存在实际序列时编辑值，从第二个元素开始

整个子阵列是不必要的。只需保存开始索引和子查询的长度；）

我的意思是这样的：

int[] array = {2, 1, 1, 2, 3, 3, 2, 2, 2, 1};

int startIndex = 0;
int length = 0;

int longestIndex = 0;
int longestLength = 0;

for(int i=0; i<array.length-1; i++)
{
    if(array[i] != array[i + 1])
    {
        if (length > longestLength) {
            longestLength = length;
            longestIndex = startIndex;
        }
        startIndex = i;
        length = 1;
    }
    else if(array[i] == array[i + 1])
    {
        length++;
    }
}

if (length > longestLength) {
    longestLength = length;
    longestIndex = startIndex;
}

int[]数组={2,1,1,2,3,3,2,2,2,1}；
int startIndex=0；
整数长度=0；
int longestIndex=0；
int longestLength=0；
for（int i=0；i最长长度）{
最长长度=长度；
longestIndex=startIndex；
}
startIndex=i；
长度=1；
}
else if（数组[i]==数组[i+1]）
{
长度++；
}
}
如果（长度>最长长度）{
最长长度=长度；
longestIndex=startIndex；
}

现在您知道了最长序列的起始位置和长度，可以构建新阵列了：

int[] sequence = new int[longestLength];
for (int i = 0; i < longestLength; i++) {
    sequence[i] = array[i + startIndex];
}

int[]序列=新的int[longestLength]；
for（int i=0；i
这是因为您正在将索引位置“i”插入子数组。
例如
第二次循环运行时

array[1]==array[2]
为true且

subarray[i] = array[i]; 

跑步。所以此时子数组的内容是{0,1,0,0,0,0,0,0,0}。请注意，默认情况下数组初始化为0

这就是你能做到的

int[] array = {2, 1, 1, 2, 3, 3, 2, 2, 2, 1};
         //store the values should be {2, 2, 2}

        int max = 1;
        int total = 1;
        int value = 0;
        for(int i=0; i<array.length-1; i++)
        {
            if(array[i] != array[i + 1])
            {
                max = 1;
            }
            else if(array[i] == array[i + 1])
            {
                max++;
                total = max;
                value = array[i];
            }

        }
        int[] subarray = new int[total];
        for(int i=0; i<total; i++)
            subarray[i] = value;

int[]数组={2,1,1,2,3,3,2,2,2,1}；
//存储值应为{2,2,2}
int max=1；
整数合计=1；
int值=0；
对于（inti=0；i，这是因为在子数组的索引位置“i”插入。
例如
第二次循环运行时

array[1]==array[2]
为true且

subarray[i] = array[i]; 

因此，此时子数组的内容是{0,1,0,0,0,0,0,0}。请注意，默认情况下数组初始化为0

这就是你能做到的

int[] array = {2, 1, 1, 2, 3, 3, 2, 2, 2, 1};
         //store the values should be {2, 2, 2}

        int max = 1;
        int total = 1;
        int value = 0;
        for(int i=0; i<array.length-1; i++)
        {
            if(array[i] != array[i + 1])
            {
                max = 1;
            }
            else if(array[i] == array[i + 1])
            {
                max++;
                total = max;
                value = array[i];
            }

        }
        int[] subarray = new int[total];
        for(int i=0; i<total; i++)
            subarray[i] = value;

int[]数组={2,1,1,2,3,3,2,2,2,1}；
//存储值应为{2,2,2}
int max=1；
整数合计=1；
int值=0；
对于（inti=0；i看看这是否有效

    int[] array = {2, 1, 1, 2, 3, 3, 2, 2, 2, 1};

    int frequency = 0;
    int num = 0;

    for(int i=0; i<array.length-1; i++)
    {
        int lfreq = 1;
        int lnum = array[i];
        while(array[i] == array[i+1]){
            lfreq++;
            i++;
        }
        if(lfreq >= frequency){
            frequency = lfreq;
            num = lnum;
        }

    }
    int[] subarray = new int[frequency];
    for(int i=0; i < frequency; i++)
        subarray[i] = num;

    System.out.println(Arrays.toString(subarray));

int[]数组={2,1,1,2,3,3,2,2,2,1}；
整数频率=0；
int num=0；
对于（int i=0；i=频率）{
频率=lfreq；
num=lnum；
}
}
int[]子数组=新int[频率]；
对于（int i=0；i
看看这是否有效

    int[] array = {2, 1, 1, 2, 3, 3, 2, 2, 2, 1};

    int frequency = 0;
    int num = 0;

    for(int i=0; i<array.length-1; i++)
    {
        int lfreq = 1;
        int lnum = array[i];
        while(array[i] == array[i+1]){
            lfreq++;
            i++;
        }
        if(lfreq >= frequency){
            frequency = lfreq;
            num = lnum;
        }

    }
    int[] subarray = new int[frequency];
    for(int i=0; i < frequency; i++)
        subarray[i] = num;

    System.out.println(Arrays.toString(subarray));

int[]数组={2,1,1,2,3,3,2,2,2,1}；
整数频率=0；
int num=0；
对于（int i=0；i=频率）{
频率=lfreq；
num=lnum；
}
}
int[]子数组=新int[频率]；
对于（int i=0；i
公共静态void main（字符串[]args）{

int[]ar={2,1,1,2,3,3,2,2,2,1}；
int max=0，
maxStart=0，
计数=1；
对于（int i=1；i max）{
最大值=计数；
maxStart=i-count+1；
}
}否则{
计数=1；
}
}
System.out.println（“子数组从“+maxStart”开始）；
对于（int i=maxStart；i
公共静态void main（字符串[]args）{

int[]ar={2,1,1,2,3,3,2,2,2,1}；
int max=0，
maxStart=0，
库伊