求解一种简便的方法！

Question

有一数组dataArray={A1,A2,A3,A4,A5,A6,A1_001,A5_003,A6_002}.
 数据之间有联系，前六种（称为基础数据），后三种（称为复合数据）。复合数据是由前基础数据中的任意数+下划线+任意数字组成。dataArray中的数据没有明 排列顺序。
 现在要得到这样的数据dataArray={A2,A3,A4,A1_001,A5_003,A6_002}.即是：如果复合数据中下划线前数据等于基础数据，那么把此基础数据去掉。  各位有上面好的方法？尽量占用少的内存，尽量简洁的方式！
 

Answer 1

        String[] dataArray = new String[]{"A1", "A2", "A3", "A4", "A5", "A6", "A1_001", "A5_003", "A6_002"};
        String[] bs = new String[6];
        for (int i = 0, bp = 0; i < 6; i++) {
            boolean flag = true;
            for (int j = 6; j < 9; j++) {
                if (dataArray[j].contains(dataArray[i])) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                bs[bp++] = dataArray[i];
            }
        }
        System.arraycopy(dataArray, 6, bs, 3, 3);
        for(String s:bs){//输出
            System.out.println(s);
        }

Answer 2

        static void Main(string[] args)
        {
            string[] dataArray = { "A1", "A2", "A3", "A4", "A5", "A6", "A1_001", "A5_003", "A6_002" };
            string[] baseData = (from data in dataArray where data.Length == 2 select data).ToArray();
            for (int i = baseData.Length; i < dataArray.Length; i++)
            {
                string prefix = dataArray[i].Substring(0, 2);
                for (int j = 0; j < baseData.Length; j++)
                {
                    if (baseData[j] == prefix)
                    {
                        dataArray[j] = "-1";
                    }
                }            }
            foreach (var item in dataArray)
            {
                if ("-1" != item)
                    Console.WriteLine(item);
            }
        }

Answer 3

首先感谢这位老兄，问下你跑过吗？呵呵  下面这句什么意思。
string[] baseData = (from data in dataArray where data.Length == 2 select data).ToArray();

Answer 4

首先感谢这位老兄，问下你跑过吗？呵呵 下面这句什么意思。
string[] baseData = (from data in dataArray where data.Length == 2 select data).ToArray();貌似 从 data 表中查询数据....c#的语法吧

Answer 5

    String[] dataArray = new String[]{"A1", "A2", "A3", "A4", "A5", "A6", "A1_001", "A5_003", "A6_002"};
        String[] bs = new String[6];
        for (int i = 0, bp = 0; i < 6; i++) {
            boolean flag = true;
            for (int j = 6; j < 9; j++) {
                if (dataArray[j].contains(dataArray[i])) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                bs[bp++] = dataArray[i];
            }
        }
        System.arraycopy(dataArray, 6, bs, 3, 3);
        for(String s:bs){//输出
            System.out.println(s);
        }

Answer 6

你看这样行吗
String[] data=new String[]{"A1","A2","A3","A4","A5","A6","A1_001","A5_003","A6_002"};
for(int i=0;i<data.length;i++){
if(data[i].length()>2){
for(int j=0;j<data.length;j++){
if(data[j]!=null&&data[j].equals(data[i].substring(0,2))){
data[j]=null;
break;
}
}
}
}
for(int i=0;i<data.length;i++){
if(data[i]!=null){
System.out.print("  "+data[i]);
}
} }

Answer 7

先贴下我的吧，感觉很麻烦的， public static List operData(String[] dataArray){
     long start = System.currentTimeMillis();
//在添加的数据中，原始功能点不能和原始功能点的可编辑功能点共存，如果则可编辑覆盖原始的。
//1.提取出基础数据
List<String>  interList = new ArrayList<String>() ;
List<String>  baseList = new ArrayList<String>();
List<String> list = new ArrayList<String>();
for(int i=0;i<dataArray.length;i++){
String interStr = dataArray[i];
list.add(interStr);
 //1.1 根据下划线得到所有的复合数据
if(interStr.indexOf("_")>0){
interList.add(interStr);
//1.3 剔除复合数据
list.remove(interStr);
//1.2 并得到所包含的基础数据
baseList.add(interStr.split("_")[0]);
}
}
//2.剔除无效基础数据
for(int i=0;i<baseList.size();i++){
String aa = baseList.get(i);
    list.remove(aa);
}
interList.addAll(list);

long end = System.currentTimeMillis();

System.out.println(start);
System.out.println(end);
System.out.println(end-start);
//3.合并得到有效数据
for(int i=0;i<interList.size();i++){
System.out.println(interList.get(i));
}
return null;
}

Answer 8

  //测试用
  public void testFilterArray() {
      String[] srcArray = new String[]{"A1","A2","A3","A4","A5","A6","A1_001","A5_003","A6_002"};
      String[] filterArray = getFilterArray(srcArray);
      for (String str : filterArray) {
          System.out.println(str);
      }  }  //处理后的数组取得
  public String[] getFilterArray(String[] srcArr) {
      //复合数据的正则表达
      String regexMultiData = "^([A-Z]){1}([0-9])+_([0-9])+$";
      Pattern ptnMulti = Pattern.compile(regexMultiData);
      List<String> deleteKeysLst = new ArrayList<String>();
      List<String> srcArrToList = new ArrayList<String>();      //符合数据的基本数据需要删除
      for (String currentData:srcArr) {
          if (ptnMulti.matcher(currentData).matches()) {
                String[] splitData = currentData.split("_");
                deleteKeysLst.add(splitData[0]);
          }
          srcArrToList.add(currentData);
      }      //复合数据的基本数据删除
      for (String baseData:deleteKeysLst) {
         if (srcArrToList.contains(baseData)) {
             srcArrToList.remove(baseData);
         }
      }
      String[] rtnArray = new String[srcArrToList.size()];
      return srcArrToList.toArray(rtnArray);
  }
打印结果
 A2
 A3
 A4
 A1_001
 A5_003
 A6_002

Answer 9

public static void main(String[] args) {
String[] dataArray = new String[]{"A1_2", "A2", "A3_5", "A4", "A5", "A6", "A1", "A5_003", "A6_002"};
List l=new ArrayList();
boolean b=true;
for (int i = 0; i < dataArray.length; i++) {
b=true;
if(null != dataArray[i]){
  if(dataArray[i].indexOf("_")>=0){
  l.add(dataArray[i]);
  for (int j = i+1; j < dataArray.length; j++) {
  if(null !=dataArray[j]&&dataArray[i].indexOf(dataArray[j])>=0){
  //l.add(dataArray[j]);
  dataArray[j]=null;
 // continue;
  }
  }
  }else{
  for (int j = i+1; j < dataArray.length; j++) {
  if(null !=dataArray[j]&&dataArray[j].indexOf(dataArray[i])>=0){
  l.add(dataArray[j]);
  dataArray[j]=null;
  b=false;
  }
  }
  if(b){
  l.add(dataArray[i]);
  }
  }
}
}
String[]s = new String[l.size()];
l.toArray(s);
for (int i = 0; i < s.length; i++) {
System.out.println(s[i]);
}
}

Answer 10

public static void main(String[] args) {
String[] dataArray = new String[]{"A1_2", "A2", "A3_5", "A4", "A5", "A6", "A1", "A5_003", "A6_002"};
List l=new ArrayList();
boolean b=true;
for (int i = 0; i < dataArray.length; i++) {
b=true;
if(null != dataArray[i]){
  //先遇到有下划线的,直接添加到list
  //清除数组后面没有下划线的选项
  if(dataArray[i].indexOf("_")>=0){
  l.add(dataArray[i]);
  for (int j = i+1; j < dataArray.length; j++) {
  if(null !=dataArray[j]&&dataArray[i].indexOf(dataArray[j])>=0){
  dataArray[j]=null;
  }
  }
  //先遇到无下划线的,向后查找是否有带下划线的选项
  //没有则添加本身,有则添加到list后置空
  }else{
  for (int j = i+1; j < dataArray.length; j++) {
  if(null !=dataArray[j]&&dataArray[j].indexOf(dataArray[i])>=0){
  l.add(dataArray[j]);
  dataArray[j]=null;
  b=false;
  }
  }
  if(b){
  l.add(dataArray[i]);
  }
  }
}
}
//将list转换为数组
String[]s = new String[l.size()];
l.toArray(s);
for (int i = 0; i < s.length; i++) {
System.out.println(s[i]);
}
}

Answer 11

这个做法有可能会出空指针错误，楼主要注意。
因为是乱序，很有可能被删除的数据再次被调用。
用这种方法的时候加上 data[i] ！＝ null的判断
个人不赞成用双重循环处理同一个数据集合

Answer 12

先谢谢楼主大哥，另外还可以利用集合来处理，例如String[] data=new String[]{"A1","A2","A3","A4","A5","A6","A1_001","A5_003","A6_002","A1"};
int N=6;//基本数据的个数
Set<String> set=new HashSet<String>();//记录数组中复合数据所包含的基本数据
List<String> list=new ArrayList<String>();
for(int i=0;i<data.length;i++){
list.add(data[i]);
//如果set的长度等于基本数据个数，说明所有基本数据都被用到，则不必再往set中添加数据
if(set.size()<N&&data[i].indexOf('_')!=-1){
set.add(data[i].split("_")[0]);
}
}
list.removeAll(set);
for(String s:list){
System.out.print("  "+s);
}

Answer 13

原因很简单因为你要顾虑本层的处理是否会对下一层处理造成影响。
添加，修改，删除数据时会有相互作用。所以不赞成。
因为一不留神就会种下一个不定时炸弹，就像这次的这个逻辑。
这次的这个bug根数组里的排序有关联，就是说这个bug是不定的，不一定什么时候会出现。
这样的bug在测试中最难被测出，一旦交给客户这种bug发生时会造成或小或大的损失。

Answer 14

removeAll我还真没用过，但是22楼想法跟我基本一致。
第一次循环找出要删除的数据
第二次循环删除数据(用removeAll就不用循环了，ArrayList给你做了);
这个方法不知道是不是最好但是应该没什么问题。两个数据集合我的代码      //复合数据的基本数据删除
      for (String baseData:deleteKeysLst) {
         if (srcArrToList.contains(baseData)) {
             srcArrToList.remove(baseData);
         }
      }换成      srcArrToList.removeAll(deleteKeysLst);