java-删除字符串列表中的子字符串

考虑字符串列表的情况 示例：list=['apple'、'bat'、'cow'、'dog'、'applebat'、'cowbat'、'dogbark'、'help']

java代码必须检查字符串的任何元素是否是另一个元素的子集，如果是，则必须删除较大的字符串元素

因此，在本例中，字符串“applebat”、“cowbat”、“dogbark”被删除

我所采取的方法是选取两个列表，并以以下方式对其进行迭代

ArrayList<String> list1 = new ArrayList<String>(strings);
ArrayList<String> list2 = new ArrayList<String>(strings);
for(int i = 0; i<list1.size();i++)
    {
        String curr1 = list1.get(i);

        for(int j = 0;j<list2.size();j++)
        {
            String curr2 = list2.get(j);

            if(curr2.contains(curr1)&&!curr2.equals(curr1))
            {
                list2.remove(j);
                j--;
        }
        }
    }

ArrayList list1=新的ArrayList（字符串）；
ArrayList list2=新的ArrayList（字符串）；
对于（int i=0；i
import java.util.ArrayList；
导入java.util.*；
//我们的主类变成了一个文件，但主方法仍然存在
公共类HelloWorld
{
公共静态void main（字符串[]args）
{
String[]strings={“苹果”、“蝙蝠”、“牛”、“狗”、“苹果树”、“牛蝙蝠”、“狗吠”、“帮助”}；
ArrayList list1=新的ArrayList（Arrays.asList（strings））；
ArrayList list2=新的ArrayList（Arrays.asList（strings））；
ArrayList结果=新的ArrayList（Arrays.asList（strings））；
对于（inti=0；i我想这里的set会更快。
使用java8流api可以很容易地做到这一点

试试看：

private Set<String> delete() {
        Set<String> startSet = new HashSet<>(Arrays.asList("a", "b", "c", "d", "ab", "bc", "ce", "fg"));
        Set<String> helperSet = new HashSet<>(startSet);

        helperSet.forEach(s1 -> helperSet.forEach(s2 -> {
            if (s2.contains(s1) && !s1.equals(s2)) {
                startSet.remove(s2);
            }
        }));

        return startSet;
    }

private Set delete（）{
Set startSet=新的HashSet（Arrays.asList（“a”、“b”、“c”、“d”、“ab”、“bc”、“ce”、“fg”）；
Set helperSet=newhashset（startSet）；
helperSet.forEach（s1->helperSet.forEach（s2->{
如果（s2.包含（s1）&&！s1.等于（s2））{
开始设置。移除（s2）；
}
}));
返回startSet；
}

不要从您要迭代的集合中删除任何元素，否则您将有ConcurrentModificationException。
为了充分提高大量单词列表的性能，我认为sort和a的组合，例如，是您所需要的，假设您愿意实现这样复杂的逻辑

首先，按长度对单词进行排序

然后按照单词长度顺序建立Aho–Corasick字典。对于每个单词，首先检查字典中是否存在子字符串。如果存在子字符串，则跳过该单词，否则将该单词添加到字典中

完成后，转储字典或并行维护列表（如果字典不容易/不可能转储）。
import java.util.ArrayList；
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Random;

public class SubStrRmove {
    public static List<String> randomList(int size) {
        final String BASE = "abcdefghijklmnopqrstuvwxyz";
        Random random = new Random();
        List<String> list = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            int length = random.nextInt(3) + 2;
            StringBuffer sb = new StringBuffer();
            for (int j = 0; j < length; j++) {
                int number = random.nextInt(BASE.length());
                sb.append(BASE.charAt(number));
            }
            list.add(sb.toString());
            sb.delete(0, sb.length());
        }
        return list;
    }

    public static List<String> removeListSubStr(List<String> args) {
        String[] input = args.toArray(new String[args.size()]);
        Arrays.parallelSort(input, (s1, s2) -> s1.length() - s2.length());
        List<String> result = new ArrayList<>(args.size());
        for (int i = 0; i < input.length; i++) {
            String temp = input[i];
            if (!result.stream().filter(s -> temp.indexOf(s) >= 0).findFirst().isPresent()) {
                result.add(input[i]);
            }
        }
        return result;
    }

    public static List<String> removeListSubStr2(List<String> args) {
        String[] input = args.toArray(new String[args.size()]);
        Arrays.parallelSort(input, (s1, s2) -> s1.length() - s2.length());
        List<String> result = new ArrayList<>(args.size());
        for (int i = 0; i < input.length; i++) {
            boolean isDiff = true;
            for (int j = 0; j < result.size(); j++) {
                if (input[i].indexOf(result.get(j)) >= 0) {
                    isDiff = false;
                    break;
                }
            }
            if (isDiff) {
                result.add(input[i]);
            }
        }
        return result;
    }

    public static void main(String[] args) throws InterruptedException {
        List<String> list = randomList(20000);
        Long start1 = new Date().getTime();
        List<String> listLambda = removeListSubStr(list);
        Long end1 = new Date().getTime();
        Long start2 = new Date().getTime();
        List<String> listFor = removeListSubStr2(list);
        Long end2 = new Date().getTime();
        System.out.println("mothod Labbda:" + (end1 - start1) + "ms");
        System.out.println("mothod simple:" + (end2 - start2) + "ms");
        System.out.println("" + listLambda.size() + listLambda);
        System.out.println("" + listFor.size() + listFor);

    }

}

导入java.util.array；
导入java.util.Date；
导入java.util.List；
导入java.util.Random；
公共类子类移动{
公共静态列表随机列表（整数大小）{
最终字符串BASE=“abcdefghijklmnopqrstuvxyz”；
随机=新随机（）；
列表=新的ArrayList（）；
对于（int i=0；is1.length（）-s2.length（））；
列表结果=新的ArrayList（args.size（））；
for（int i=0；itemp.indexOf>=0.findFirst（）.isPresent（））{
结果。添加（输入[i]）；
}
}
返回结果；
}
公共静态列表removeListSubStr2（列表参数）{
字符串[]输入=args.toArray（新字符串[args.size（）]）；
parallelSort（输入，（s1，s2）->s1.length（）-s2.length（））；
列表结果=新的ArrayList（args.size（））；
for（int i=0；i=0）{
isDiff=假；
打破
}
}
如果（isDiff）{
结果。添加（输入[i]）；
}
}
返回结果；
}
公共静态void main（字符串[]args）引发InterruptedException{
列表=随机列表（20000）；
Long start1=new Date（）.getTime（）；
List listLambda=removeListSubStr（列表）；
Long end1=新日期（）.getTime（）；
Long start2=新日期（）.getTime（）；
List listFor=removeListSubStr2（列表）；
Long end2=新日期（）.getTime（）；
System.out.println（“方法Labbda:”+（end1-start1）+“ms”）；
System.out.println（“方法简单：”+（end2-start2）+“ms”）；
System.out.println（“+listLambda.size（）+listLambda”）；
System.out.println（“+listFor.size（）+listFor”）；
}
}
我已经在小数据上对它进行了测试，希望它能帮助您找到解决方案

import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args){
        String []list = {"apple","bat","cow","dog","applebat","cowbat","dogbark","help","helpless","cows"};
        System.out.println(Arrays.toString(list));
        int prelenght = 0;
        int prolenght = 0;
        long pretime = System.nanoTime();
        for(int i=0;i<list.length;i++){
            String x = list[i];
            prelenght = list[i].length();
            for(int j=i+1;j<list.length;j++){               
                String y = list[j];
                if(y.equals(x)){
                    list[j] = "0";
                }else if(y.contains(x)||x.contains(y)){
                    prolenght = list[j].length();                   
                    if(prelenght<prolenght){
                        list[j] = "0";
                    }                       
                    if(prelenght>prolenght){
                        list[i] = "0";
                        break;
                    }
                }
            }
        }       
        long protime = System.nanoTime();
        long time = (protime - pretime);
        System.out.println(time + "ns");
        UpdateArray(list);      
    }

    public static void UpdateArray(String[] list){
        ArrayList<String> arrayList = new ArrayList<>();
        for(int i=0;i<list.length;i++){
            if(!list[i].equals("0")){
                arrayList.add(list[i]);
            }
        }
        System.out.println(arrayList.toString());
    }
}

我认为您不能在迭代时简单地删除它们。您可以做的是接受一个否定条件，然后将其添加到另一个数组中。请尝试
HashSet
，并检查
contains
，然后使用
remove
方法删除它们。
Set
将为我们提供
O（1）
（假设）运行时。我试过一小组字符串，代码很好，但是当列表变得很大时，它需要花费大量的时间来处理，我不想在两个列表上重复n次幂n次。我想动态地减少两个列表，这样我可以删除很多比较。检查这个，解释会更好我已经检查了neg假设条件，即它是否等于或是否不包含任何子字符串标志将变为1。在一次迭代后，我们将其添加到结果中。最后，您可以删除list1和list2对象
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args){
        String []list = {"apple","bat","cow","dog","applebat","cowbat","dogbark","help","helpless","cows"};
        System.out.println(Arrays.toString(list));
        int prelenght = 0;
        int prolenght = 0;
        long pretime = System.nanoTime();
        for(int i=0;i<list.length;i++){
            String x = list[i];
            prelenght = list[i].length();
            for(int j=i+1;j<list.length;j++){               
                String y = list[j];
                if(y.equals(x)){
                    list[j] = "0";
                }else if(y.contains(x)||x.contains(y)){
                    prolenght = list[j].length();                   
                    if(prelenght<prolenght){
                        list[j] = "0";
                    }                       
                    if(prelenght>prolenght){
                        list[i] = "0";
                        break;
                    }
                }
            }
        }       
        long protime = System.nanoTime();
        long time = (protime - pretime);
        System.out.println(time + "ns");
        UpdateArray(list);      
    }

    public static void UpdateArray(String[] list){
        ArrayList<String> arrayList = new ArrayList<>();
        for(int i=0;i<list.length;i++){
            if(!list[i].equals("0")){
                arrayList.add(list[i]);
            }
        }
        System.out.println(arrayList.toString());
    }
}

[apple, bat, cow, dog, applebat, cowbat, dogbark, help, helpless, cows]
time elapsed : 47393ns
[apple, bat, cow, dog, help]