优化ArrayList的条件

Question

我在数组列表中的一些值，我不得不删除基于conditions.I一些特定值使用IF的条件，但也有很多条件比较，所以我需要优化时间。对于例如比较我我的名单是

Msisdn_array = {45,85,79,60,502}

，如果条件匹配，则删除该条目。

下面是条件下，是否有优化这个条件任何可能的方式。

if(Msisdn_array.contains("60") && Msisdn_array.contains("910")) 
{ 
Msisdn_array.remove("60"); 
Msisdn_array.remove("910"); 
} 

if(Msisdn_array.contains("75") && Msisdn_array.contains("500")) 
{ 
Msisdn_array.remove("75"); 
Msisdn_array.remove("500"); 
} 

if(Msisdn_array.contains("76") && Msisdn_array.contains("502")) 
{ 
Msisdn_array.remove("76"); 
Msisdn_array.remove("502"); 
} 

if(Msisdn_array.contains("61") && Msisdn_array.contains("911")) 
{ 
Msisdn_array.remove("61"); 
Msisdn_array.remove("911"); 
} 

if(Msisdn_array.contains("77") && Msisdn_array.contains("503")) 
{ 
Msisdn_array.remove("77"); 
Msisdn_array.remove("503"); 
} 

if(Msisdn_array.contains("78") && Msisdn_array.contains("505")) 
{ 
Msisdn_array.remove("78"); 
Msisdn_array.remove("505"); 
} 

if(Msisdn_array.contains("79") && Msisdn_array.contains("507")) 
{ 
Msisdn_array.remove("79"); 
Msisdn_array.remove("507"); 
} 

if(Msisdn_array.contains("62") && Msisdn_array.contains("912")) 
{ 
Msisdn_array.remove("62"); 
Msisdn_array.remove("912"); 
} 

if(Msisdn_array.contains("63") && Msisdn_array.contains("913")) 
{ 
Msisdn_array.remove("63"); 
Msisdn_array.remove("913"); 
} 

if(Msisdn_array.contains("64") && Msisdn_array.contains("914")) 
{ 
Msisdn_array.remove("64"); 
Msisdn_array.remove("914"); 
} 

if(Msisdn_array.contains("65") && Msisdn_array.contains("915")) 
{ 
Msisdn_array.remove("65"); 
Msisdn_array.remove("915"); 
} 

if(Msisdn_array.contains("66") && Msisdn_array.contains("916")) 
{ 
Msisdn_array.remove("66"); 
Msisdn_array.remove("916"); 
} 

if(Msisdn_array.contains("67") && Msisdn_array.contains("917")) 
{ 
Msisdn_array.remove("67"); 
Msisdn_array.remove("917"); 
} 

if(Msisdn_array.contains("68") && Msisdn_array.contains("918")) 
{ 
Msisdn_array.remove("68"); 
Msisdn_array.remove("918"); 
} 

if(Msisdn_array.contains("69") && Msisdn_array.contains("919")) 
{ 
Msisdn_array.remove("69"); 
Msisdn_array.remove("919"); 
} 

if(Msisdn_array.contains("70") && Msisdn_array.contains("920")) 
{ 
Msisdn_array.remove("70"); 
Msisdn_array.remove("920"); 
} 

if(Msisdn_array.contains("71") && Msisdn_array.contains("921")) 
{ 
Msisdn_array.remove("71"); 
Msisdn_array.remove("921"); 
} 

if(Msisdn_array.contains("72") && Msisdn_array.contains("922")) 
{ 
Msisdn_array.remove("72"); 
Msisdn_array.remove("922"); 
} 

if(Msisdn_array.contains("73") && Msisdn_array.contains("923")) 
{ 
Msisdn_array.remove("73"); 
Msisdn_array.remove("923"); 
} 

if(Msisdn_array.contains("74") && Msisdn_array.contains("924")) 
{ 
Msisdn_array.remove("74"); 
Msisdn_array.remove("924"); 
} 

if(Msisdn_array.contains("80") && Msisdn_array.contains("926")) 
{ 
Msisdn_array.remove("80"); 
Msisdn_array.remove("926"); 
} 

if(Msisdn_array.contains("81") && Msisdn_array.contains("927")) 
{ 
Msisdn_array.remove("81"); 
Msisdn_array.remove("927"); 
} 

if(Msisdn_array.contains("82") && Msisdn_array.contains("928")) 
{ 
Msisdn_array.remove("82"); 
Msisdn_array.remove("928"); 
} 

Answer 1

一个潜在的优化是，你可以不需要检查第二个项目是否在列表中。而只是试图删除它。如果它被删除，remove方法will return true，您也可以删除第一个项目。

if(Msisdn_array.contains("60") && Msisdn_array.remove("910")){ 
    Msisdn_array.remove("60"); 
} 

如果你不想写出来的每一个if语句，你可以存储组的地图，与第一项作为重点，并作为值的第二个项目。

Map<String, String> rules = new HashMap<>(); 
rules.put("60", "910"); 
rules.put("75", "500"); 
rules.put("76", "502"); 
... 
... 
for(Entry entry : rules.values()) { 
    if(Msisdn_array.contains(entry.getKey()) && Msisdn_array.remove(entry.getValue())){ 
     Msisdn_array.remove(entry.getKey()); 
    } 
} 

Answer 2

如果您不经常遍历列表，我建议您使用Set。 在这个集合中搜索速度很快。

Answer 3

contains是O（n）的操作。遍历列表直到找到元素。所以每次你打电话给contains你都可能遍历整个列表。

的优化可能是一次遍历列表，手动，并检查元素存在，然后事后做你移除了，一些额外的内存的成本来存储布尔变量：

boolean exists_72 = false; 
boolean exists_922 = false; 

for(String element : Msisdn_array) { 
    if(element.equals("72")) { 
     exists_72 = true; 
    } else if(element.equals("922")) { 
     exists_922 = true; 
    } 
} 

if(exists_72 && exists_922) } 
    Msisdn_array.remove("72"); 
    Msisdn_array.remove("922"); 
} 

Answer 4

为删除返回boolean被成功地删除，你可以做

if (list.remove ("60") && list.remove ("90")) 
{ 
    // everything ok 
} 
else { 
    // put back "60" 
    list.add ("60"); 
} 

但我个人会去可读性只需创建一个方法

removeBoth (String one, String two) { 
    if(list.contains(one) && list.contains(two)) 
    { 
    list.remove(one); 
    list.remove(two); 
    } 
} 

Answer 5

我想你只需要提取方法来检查是否所有的一组值的列表中存在，然后删除所有。例如：

private void removeIfAllExist(List<String> list, String[] values) { 
    for (String v : values) { 
     if (!list.contains(v)) { 
      return; 
     } 
    } 
    list.removeAll(Arrays.asList(values)); 
} 

public void yourLogic() { 
    List<String> list = new ArrayList<>(Arrays.asList("45", "85", "79", "60", "502")); 
    String[][] conditions = new String[][]{ 
      new String[]{"60", "910"}, 
      new String[]{"75", "500"}, 
      new String[]{"76", "502"}, 
      new String[]{"61", "911"}, 
      new String[]{"77", "503"}, 
      // more conditions 
    }; 
    for (String[] values : conditions) { 
     removeIfAllExist(list, values); 
    } 
} 

Answer 6

它很慢，因为List.contains速度缓慢，也因为List.remove是更慢（因为它必须与移动更大的索引的所有要素，以填补缺口）。由于代码重复，这很丑陋。

Msisdn_array是违反Java的命名约定，它不是数组，所以我们称它为inputList。我们使用HashSet进行查找，另一个用于跟踪应该删除的内容。

class Worker { 
    private final Set<String> inputListAsSet = new HashSet<>(); 
    private final Set<String> removals = new HashSet<>(); 

    public static void process(List<String> inputList) { 
     final Worker worker = new Worker(inputList); 
     worker.removeIfBothPresent("60", "910"); 
     worker.removeIfBothPresent("75", "500"); 
     worker.removeIfBothPresent("76", "502"); 
     worker.removeIfBothPresent("61", "911"); 
     worker.removeIfBothPresent("72", "922"); 
     worker.removeIfBothPresent("73", "923"); 
     worker.removeIfBothPresent("74", "924"); 
     worker.removeIfBothPresent("80", "926"); 
     worker.removeIfBothPresent("81", "927"); 
     worker.removeIfBothPresent("82", "928"); 
     inputList.removeAll(worker.removals); 
    } 

    private Worker(List<String> inputList) { 
     inputListAsSet.addAll(inputList); 
    } 

    private void removeIfBothPresent(String first, String second) { 
     if (inputListAsSet.contains(first) && inputListAsSet.contains(second)) { 
      removals.add(first); 
      removals.add(second); 
     } 
    } 
} 

而不是使用类实例，该集可以作为参数传递，但创建一个工作者似乎更干净。请注意，尽管进行了优化，但我的代码比原始代码短。如果重复，则不完全相同。