请教下以下代码为何运行出来达不到效果，自定义了一个list

我写了一串代码，首先自定义了一个E类型的list，然后写了如下方法，目的是想删除list里出现过三次大元素，代码如下：

public class ArraySubList<E> implements Cloneable {
private E[] data;
private int manyItems;
private String[] data2;


public ArraySubList()
{
final int INITIAL_CAPACITY = 10;
manyItems = 0;
data = (E[]) new Object[INITIAL_CAPACITY];
data2=new String[INITIAL_CAPACITY];
}


public ArraySubList(int initialCapacity){
if (initialCapacity < 0)
throw new IllegalArgumentException("The initialCapacity is negative: " + initialCapacity);
data=(E[])new Object[initialCapacity];
manyItems=0;
data2=new String[initialCapacity];
}


出问题的方法
public int removeItemAppearThree(){
int index;
int indexInner;
int indexStore[]=new int[3]; //储存出现过恰好3次元素的index
int targetCount[]={1,1,1,1,1,1,1,1}; //计算不同元素出现的次数，初始值为1
for(index=0;index<manyItems;index++){
for(indexInner=1;indexInner<manyItems;indexInner++){
if(data[index]==data[indexInner]){ //如果两个元素相等
targetCount[index]=targetCount[index]+1; //次数加1
if(targetCount[index]==2){ 
indexStore[0]=index;
indexStore[1]=indexInner;
}
else if(targetCount[index]==3){
indexStore[2]=indexInner;
}
}
}if(targetCount[index]==3){ //如果出现三次，则把三个元素删除，通过自减的方法
data[indexStore[0]] =data[manyItems--]; //manyItems是在list里的总个数
data[indexStore[1]] =data[manyItems--];
data[indexStore[2]] =data[manyItems--];
}
} 

return manyItems; //返回list还剩下的个数
}

测试代码：
public class ArraySubListTest {
public static void main(String[]args){
String[] a={"a","a","b","c","d","e","a","a","e"};
ArraySubList<String> sublist=new ArraySubList<>();
sublist.addMany(a);
System.out.println(sublist.removeItemAppearThree());
}
}

结果为6，但正确的应该是9，因为没有元素出现恰好三次，可是如果我把测试元素改为：
String[] a={"a","a","b","c","d","e","a","a"};即只有元素出现三次或一次，输出结果就正常了为8.
就是当一个元素出现了两次的时候，结果就会不如预期，这是为啥呢？

错误在于最后一个，删除的不是a,而是e。你自己试着算把最后一个e带进去试试。可以用debug来弄。最后一个e进去，他初始值就是1了（你的targetCount[]有八个一，但我估计是你第二组测试用例的时候删的，不然会数组越界）。然后你的循环并不会跳过自己本身，所以遇到第一个e之后，他就是2了，在遇到自己就是3了，满足条件就删除了三次。

我有一个排序后删除出现三次的元素的方法

package org.bg.jms;

import java.util.Arrays;

public class ArraySubList implements Cloneable {
    public String[] data = {"a", "b", "b", "b", "b", "c", "c", "c", "d", "e", "a", "e"};

    public ArraySubList() {
    }

    public String[] removeItemAppearThree() {
        // 排序
        Arrays.sort(data);
        // 标记出现三次的元素位置
        String current = data[0];
        int count = 1;
        int stay = data.length;
        for (int i = 0; i < data.length; i++) {
            if (data[i].equals(current) && i != 0) {
                count++;
                if ((count == 3 && (i + 1 < data.length) && (!data[i + 1].equals(current)))) {
                    data[i - 2] = null;
                    data[i - 1] = null;
                    data[i] = null;
                    stay = stay - 3;
                }
            } else {
                count = 1;
                current = data[i];
            }
        }
        // 删除空元素
        String[] tmp = new String[stay];
        int offset = 0;
        for (int i = 0; i < data.length; i++) {
            if (null != data[i]) {
                tmp[i - offset] = data[i];
            } else {
                offset++;
            }
        }
        System.out.println(Arrays.asList(tmp));
        return tmp;
    }

    public static void main(String[] args) {
        new ArraySubList().removeItemAppearThree();
    }
}

你这个思路吧，首先就有点误区，你可以把数组进行排序，然后你只要判断当前的数和它后面的两位是否相同就可以了，然后你想怎么处理就简单多了。