Java 文本中间的交点

嗨，我想比较两个ArrayList。像这样：

public class intersection {
 public static void main(String... args) throws Exception {

    List<String> list1 = new ArrayList<String>(Arrays.asList("This is a test example to help me learn hashsets"));
    List<String> list2 = new ArrayList<String>(Arrays.asList("test example", "Not returned"));

    System.out.println(new intersection().intersection(list1, list2));

}


public <T> List<T> intersection(List<T> list1, List<T> list2) {
    List<T> list = new ArrayList<T>();

    for (T t : list1) {
        if(list2.contains(t)) {
            list.add(t);
        }
    }

    return list;
}
}

公共类交叉口{
公共静态void main（字符串…参数）引发异常{
List list1=newarraylist（Arrays.asList（“这是一个帮助我学习hashset的测试示例”）；
List list2=新的ArrayList（Arrays.asList（“测试示例”，“未返回”）；
System.out.println（new crossion（）.crossion（list1，list2））；
}
公共列表交叉点（列表1、列表2）{
列表=新的ArrayList（）；
for（T:list1）{
if（列表2.contains（t））{
列表。添加（t）；
}
}
退货清单；
}
}

我希望返回“测试示例”，因为它位于两个ArrayList中的某个位置。抱歉，忘了说ArrayList的内容无法更改。是否有这样做的必要？。谢谢

有个错误：

List<String> list1 = new ArrayList<String>(Arrays.asList("This is a test example to help me learn hashsets"));

List list1=newarraylist（Arrays.asList（“这是一个帮助我学习哈希集的测试示例”）；

这里列表只包含一个元素，因为“这是一个帮助我学习hashset的测试示例”是一个元素

将字符串除以，

 public class intersection {
   public static void main(String... args) throws Exception {

    List<String> list1 = new ArrayList<String>(Arrays.asList("This is a ","test example"," to help me learn hashsets"));
    List<String> list2 = new ArrayList<String>(Arrays.asList("test example", "Not returned"));

    System.out.println(new intersection().intersection(list1, list2));

  }


  public <T> List<T> intersection(List<T> list1, List<T> list2) {
    List<T> list = new ArrayList<T>();

    for (T t : list1) {
        if(list2.contains(t)) {
            list.add(t);
        }
    }

    return list;
  }
}

公共类交叉口{
公共静态void main（字符串…参数）引发异常{
List list1=新的ArrayList（Arrays.asList（“这是一个”，“测试示例”，“帮助我学习哈希集”）；
List list2=新的ArrayList（Arrays.asList（“测试示例”，“未返回”）；
System.out.println（new crossion（）.crossion（list1，list2））；
}
公共列表交叉点（列表1、列表2）{
列表=新的ArrayList（）；
for（T:list1）{
if（列表2.contains（t））{
列表。添加（t）；
}
}
退货清单；
}
}

或者将交叉点的逻辑更改为使用子字符串

编辑：

public <T> List<T> intersection(List<T> list1, List<T> list2) {
    List<T> list = new ArrayList<T>();

    for (T t : list2) {
        for(T l: list1){
            if(((String)l).contains((CharSequence)t)){
                list.add(t);
            }

        }
    }

    return list;
}

公共列表交叉点（列表1、列表2）{
列表=新的ArrayList（）；
for（T:list2）{
对于（TL:list1）{
if（（（字符串）l）.包含（（字符序列）t））{
列表。添加（t）；
}
}
}
退货清单；
}

您需要检查单个单词

public class intersection {

    public static void main(String... args) throws Exception {

        List<String> list1 = new ArrayList<String>(Arrays.asList("This is a test example to help me learn hashsets".split("\\s+")));
        List<String> list2 = new ArrayList<String>(Arrays.asList("test example Not returned".split("\\s+")));

        System.out.println(new intersection().check(list1, list2));

    }

    public <T> List<T> check(List<T> list1, List<T> list2) {
        List<T> list = new ArrayList<T>();

        for (T t : list1) {
            if (list2.contains(t)) {
                list.add(t);
            }
        }

        return list;
    }
}

公共类交叉口{
公共静态void main（字符串…参数）引发异常{
List list1=new ArrayList（Arrays.asList（“这是一个帮助我学习hashset.split（\\s+”）的测试示例））；
List list2=新的ArrayList（Arrays.asList（“未返回测试示例”）.split（\\s+））；
System.out.println（newintersection（）.check（list1，list2））；
}
公共列表检查（列表1、列表2）{
列表=新的ArrayList（）；
for（T:list1）{
if（列表2.contains（t））{
列表。添加（t）；
}
}
退货清单；
}
}

或者，您可以选择在整个字符串中搜索短语

公共类交叉口{

public static void main(String... args) throws Exception {

    String s1 = "This is a test example to help me learn hashsets";
    String[] s2 = new String[] { "test example", "Not returned" };

    System.out.println(new intersection().check(s1, s2));

}

public List<String> check(String s1, String[] s2) {
    List<String> list = new ArrayList<>();

    for (String s : s2) {
        if (s1.contains(s)) {
            list.add(s);
        }
    }

    return list;
}

publicstaticvoidmain（String…args）引发异常{
String s1=“这是一个帮助我学习哈希集的测试示例”；
字符串[]s2=新字符串[]{“测试示例”，“未返回”}；
System.out.println（新交叉点（）.check（s1，s2））；
}
公共列表检查（字符串s1，字符串[]s2）{
列表=新的ArrayList（）；
for（字符串s:s2）{
如果（s1.包含）{
列表。添加（s）；
}
}
退货清单；
}

}使用Java 8流：

public static <T> List<T> intersection(List<T> list1, List<T> list2) {
    List<T> list = new ArrayList<>();
    Predicate<? super T> con = (t) -> {
        Predicate<? super T> p = (u) -> u.toString().contains((CharSequence) t);
        return list1.stream().anyMatch(p);
    };
    list2.stream().filter(con).forEach(list::add);

    return list;
}

公共静态列表交叉点（列表1、列表2）{
列表=新的ArrayList（）；
如果你使用一个列表，你必须在单个单词上做它。否则考虑Strug.NoxOfFoad抱歉忘记说ARARYLIST不能被编辑，因为在较大的文件中，它们将是无法格式化的文本文件。。因此，如果两个单词之间存在更多的空格，它将忽略。例如“.split（\\s+”）第二种解决方案不会检查单个单词，因此我认为它的解决方案不正确。第二种解决方案很好，因为我正在检查字符串2中的整个短语是否在字符串1中的某个位置。我应该更清楚一些。谢谢你的帮助all@niks是的，第二个解决方案检查字符串中的短语。我很喜欢你在r上的建议埃格斯