Java 查找两个阵列列表之间的交集

查找两个字符串数组列表的交点

代码如下：

public ArrayList<String> intersection( ArrayList<String> AL1, ArrayList<String> AL2){   
    ArrayList<String> empty = new ArrayList<String>();
    ArrayList<String> empty1 = new ArrayList<String>();
    if (AL1.isEmpty()){
        return AL1;
    }
    else{
        String s = AL1.get(0);
        if(AL2.contains(s))
            empty.add(s);


            empty1.addAll(AL1.subList(1, AL1.size()));
            empty.addAll(intersection(empty1, AL2));
            return empty;
    }
}

---

上面的代码给了我这个输出，但我想知道如何使代码更容易理解。

您可以这样编写代码，使其更容易理解：

/**
 * Computes the intersection of two Lists of Strings, returning it as a new ArrayList of Strings
 *
 * @param list1 one of the Lists from which to compute an intersection
 * @param list2 one of the Lists from which to compute an intersection
 *
 * @return a new ArrayList of Strings containing the intersection of list1 and list2
 */
public ArrayList<String> intersection( List<String> list1, List<String> list2) {   
    ArrayList<String> result = new ArrayList<String>(list1);

    result.retainAll(list2);

    return result;
}

/**
*计算两个字符串列表的交集，并将其作为字符串的新ArrayList返回
*
*@param list1用于计算交点的列表之一
*@param list2用于计算交点的列表之一
*
*@返回包含list1和list2交叉点的字符串的新ArrayList
*/
公共阵列列表交叉点（列表列表1，列表列表2）{
ArrayList结果=新的ArrayList（列表1）；
结果：保留（列表2）；
返回结果；
}

您可以这样写，让它更容易理解：

/**
 * Computes the intersection of two Lists of Strings, returning it as a new ArrayList of Strings
 *
 * @param list1 one of the Lists from which to compute an intersection
 * @param list2 one of the Lists from which to compute an intersection
 *
 * @return a new ArrayList of Strings containing the intersection of list1 and list2
 */
public ArrayList<String> intersection( List<String> list1, List<String> list2) {   
    ArrayList<String> result = new ArrayList<String>(list1);

    result.retainAll(list2);

    return result;
}

/**
*计算两个字符串列表的交集，并将其作为字符串的新ArrayList返回
*
*@param list1用于计算交点的列表之一
*@param list2用于计算交点的列表之一
*
*@返回包含list1和list2交叉点的字符串的新ArrayList
*/
公共阵列列表交叉点（列表列表1，列表列表2）{
ArrayList结果=新的ArrayList（列表1）；
结果：保留（列表2）；
返回结果；
}

您可以这样写，让它更容易理解：

/**
 * Computes the intersection of two Lists of Strings, returning it as a new ArrayList of Strings
 *
 * @param list1 one of the Lists from which to compute an intersection
 * @param list2 one of the Lists from which to compute an intersection
 *
 * @return a new ArrayList of Strings containing the intersection of list1 and list2
 */
public ArrayList<String> intersection( List<String> list1, List<String> list2) {   
    ArrayList<String> result = new ArrayList<String>(list1);

    result.retainAll(list2);

    return result;
}

/**
*计算两个字符串列表的交集，并将其作为字符串的新ArrayList返回
*
*@param list1用于计算交点的列表之一
*@param list2用于计算交点的列表之一
*
*@返回包含list1和list2交叉点的字符串的新ArrayList
*/
公共阵列列表交叉点（列表列表1，列表列表2）{
ArrayList结果=新的ArrayList（列表1）；
结果：保留（列表2）；
返回结果；
}

您可以这样写，让它更容易理解：

/**
 * Computes the intersection of two Lists of Strings, returning it as a new ArrayList of Strings
 *
 * @param list1 one of the Lists from which to compute an intersection
 * @param list2 one of the Lists from which to compute an intersection
 *
 * @return a new ArrayList of Strings containing the intersection of list1 and list2
 */
public ArrayList<String> intersection( List<String> list1, List<String> list2) {   
    ArrayList<String> result = new ArrayList<String>(list1);

    result.retainAll(list2);

    return result;
}

/**
*计算两个字符串列表的交集，并将其作为字符串的新ArrayList返回
*
*@param list1用于计算交点的列表之一
*@param list2用于计算交点的列表之一
*
*@返回包含list1和list2交叉点的字符串的新ArrayList
*/
公共阵列列表交叉点（列表列表1，列表列表2）{
ArrayList结果=新的ArrayList（列表1）；
结果：保留（列表2）；
返回结果；
}

公共ArrayList交叉点（ArrayList AL1，ArrayList AL2）{
ArrayList returnArrayList=新建ArrayList（）；
用于（字符串测试：AL1）
{
如果（！returnArrayList.contains（测试））
{
if（AL2.包含（测试））
{
returnArrayList.add（测试）；
}
}
}
返回数组列表；
}

您可以使用循环而不是递归。

公共ArrayList交叉点（ArrayList AL1，ArrayList AL2）{
ArrayList returnArrayList=新建ArrayList（）；
用于（字符串测试：AL1）
{
如果（！returnArrayList.contains（测试））
{
if（AL2.包含（测试））
{
returnArrayList.add（测试）；
}
}
}
返回数组列表；
}

您可以使用循环而不是递归。

公共ArrayList交叉点（ArrayList AL1，ArrayList AL2）{
ArrayList returnArrayList=新建ArrayList（）；
用于（字符串测试：AL1）
{
如果（！returnArrayList.contains（测试））
{
if（AL2.包含（测试））
{
returnArrayList.add（测试）；
}
}
}
返回数组列表；
}

您可以使用循环而不是递归。

公共ArrayList交叉点（ArrayList AL1，ArrayList AL2）{
ArrayList returnArrayList=新建ArrayList（）；
用于（字符串测试：AL1）
{
如果（！returnArrayList.contains（测试））
{
if（AL2.包含（测试））
{
returnArrayList.add（测试）；
}
}
}
返回数组列表；
}

---

您可以使用循环而不是递归。

Java集合已经通过调用

retainAll

支持循环。交集不会返回新的集合，而是就地发生，这就是为什么如果要保留原始列表1，必须创建新的ArrayList的原因<如果调用对象被修改，则code>retainAll返回布尔值

ArrayList<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
list1.add("C");
ArrayList<String> list2 = new ArrayList<String>();
list2.add("D");
list2.add("B");
list2.add("C");
ArrayList<String> intersection = new ArrayList<String>(list1);
intersection.retainAll(list2);
for(String s: intersection){
    System.out.println(s);
}

---

Java集合已经通过

retainAll

调用对此提供了支持。交集不会返回新的集合，而是就地发生，这就是为什么如果要保留原始列表1，必须创建新的ArrayList的原因<如果调用对象被修改，则code>retainAll返回布尔值

ArrayList<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
list1.add("C");
ArrayList<String> list2 = new ArrayList<String>();
list2.add("D");
list2.add("B");
list2.add("C");
ArrayList<String> intersection = new ArrayList<String>(list1);
intersection.retainAll(list2);
for(String s: intersection){
    System.out.println(s);
}

---

Java集合已经通过

retainAll

调用对此提供了支持。交集不会返回新的集合，而是就地发生，这就是为什么如果要保留原始列表1，必须创建新的ArrayList的原因<如果调用对象被修改，则code>retainAll返回布尔值

ArrayList<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
list1.add("C");
ArrayList<String> list2 = new ArrayList<String>();
list2.add("D");
list2.add("B");
list2.add("C");
ArrayList<String> intersection = new ArrayList<String>(list1);
intersection.retainAll(list2);
for(String s: intersection){
    System.out.println(s);
}

---

Java集合已经通过

retainAll

调用对此提供了支持。交集不会返回新的集合，而是就地发生，这就是为什么如果要保留原始列表1，必须创建新的ArrayList的原因<如果调用对象被修改，则code>retainAll返回布尔值

ArrayList<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
list1.add("C");
ArrayList<String> list2 = new ArrayList<String>();
list2.add("D");
list2.add("B");
list2.add("C");
ArrayList<String> intersection = new ArrayList<String>(list1);
intersection.retainAll(list2);
for(String s: intersection){
    System.out.println(s);
}

---

如果您对依赖项没有意见，我建议您看看apachecommons集合（）

---

对于您的特定用途，它将是CollectionUtils（）的方法交集。

如果您对依赖关系没有异议，我建议您查看apache commons collections（）

---

对于您的特定用途，它将是CollectionUtils（）的方法交集。

如果您对依赖关系没有异议，我建议您查看apache commons collections（）

为了你的朋友