计算 Java 中两个数组中匹配的字符串数

Question

给定两个字符串数组 a 和 b，每个都按字母顺序排列，我想return计算两个数组中匹配的字符串的数量。

public int countMatch(String[] a, String[] b) {

}

我的目标是能够调用如下方法；

countMatch({"apple", "banana", "xylophone"}, {"banana", "carrot", "dog", "xray", "xylophone"});

这应该 return int 值 2，因为有两个字符串匹配每个数组（"banana" 和 "xylophone"）。

可能重要的是要注意，数组将始终按字母顺序排列，如果这有助于解决问题的话。

Answer 1

一旦对这些数组进行排序，您就可以执行以下操作：

您将有两个变量：i 和 j。 First 将遍历第一个数组，second 遍历第二个。

然后你比较a[i]和b[j]。如果它们相等，则匹配，并且您可以提高两个索引。如果它们不相等，那么 advance index 是 word 中较小的（if a[i] < b[j] advance i else j）。

Answer 2

试试这个

public final class StringArrayMatcher{

    public int findMatchCount(final String [] a,final String [] b){
        /*
            If a has more than one entries that matches to a string in b, it's also considered as accountable.
        */
            int matchCount = 0;

            for(String x_element : a){
                for(String y_element : b){
                    if(x_element.equals(y_element)) ++matchCount;                       
                }
            }
            return matchCount;
    }
    public static void main(String[] args) {
        System.out.format("Total matches = %d",new StringArrayMatcher().findMatchCount(new String[]{"apple", "banana", "xylophone"}, new String[]{"banana", "carrot", "dog", "xray", "xylophone"}));
    }
}

Answer 3

除非最终性能是一个问题，否则请忽略它们已排序的事实。将 a[] 中的所有值放入 HashSet。循环 b[] 并计算集合中包含的数量。

Answer 4

您可以创建一个简单的方法，例如：

public int countMatch(String[] a, String[] b) {
    List<String> list1 = new ArrayList(Arrays.asList(a));
    List<String> list2 = Arrays.asList(b);
    list1.retainAll(list2);
    return list1.size();
}

Answer 5

如果你想把两个匹配的词恰好数一次，不管它们是否出现，就像你说的；试试这个代码

import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;
import java.util.List;

public final class StringArrayMatcher{

    public int findMatchCount(final String [] a,final String [] b){

        int matchCount = 0;

        Set<String> setA = new HashSet<>(Arrays.asList(a));
        List<String> setB = Arrays.asList(b);

        for(String value1 : setA){
            for(String value2 : setB){
                if(value1.equals(value2)){ ++matchCount; break; }
            }
        }
            return matchCount;
    }
    public static void main(String[] args) {
        System.out.format("Total matches = %d",new StringArrayMatcher().findMatchCount(new String[]{"apple"}, new String[]{"apple","apple"}));
    }
}

*Set 的使用会自动删除数组中的重复单词。

Answer 6

如果你完全不关心字母顺序。那么就很简单了，你需要两个循环来完成这项工作，即你需要比较所有可能的对。在您的示例中，您需要进行 3*5 次比较才能得出结论。

public int countMatch(String[] a, String[] b) {

        int count = 0;
        for(int i=0; i<a.length; i++){
            for(int j=0; j<b.length; i++){
                if(a[i].equals(b[i])){
                    count++;
                    break;
                }
            }
        }
        return count;
    }

但是如果考虑到字母顺序，可以简单的改进一下

public int countMatch1(String[] a, String[] b) {

        int count = 0;
        int cursor = 0;
        for(int i=0; i<a.length; i++){
            for(int j=cursor; j<b.length; i++){
                if(a[i].equals(b[i])){
                    count++;
                    cursor = j;
                    break;
                }
            }
        }
        return count;
    }

在这种情况下，您可以使用变量游标来记住上次搜索数组 a[i] 时停止的位置，然后在下一次搜索 a[i+1] 时，您可以简单地从游标开始，而不是从游标开始重新开始，因为光标之前的所有先前的肯定不能匹配 a[i+1]。

Answer 7

我的代码如下：

public class Test {

public static int findMatchCount(final String [] a,final String [] b){
    int matchCount = 0;

    for(int i = 0, j = 0;i < a.length && j < b.length;){
        int res = a[i].compareTo(b[j]);
        if(res == 0){
            matchCount++;
            i++;
            j++;
        }else if(res < 0){
            i++;
        }else{
            j++;
        }
    }
    return matchCount;
}

public static void main(String[] args){ 
    String[] a = {"apple", "apple"};
    String[] b = {"apple", "apple"};
    System.out.println(findMatchCount(a,b));

}
}

Answer 8

您可以使用 for 循环比较这些数组，并将第一个数组的第一个索引与所有第二个数组索引进行比较，然后继续与其他第一个数组索引进行比较。像这样：

public class Ber {
    public static void main( String[] arg){

       String[] abc1 = {"1", "7", "j", "kolo", "7", "1"};
       String[] abc2 = {"2", "n", "m", "2", "n", "kolo"};

       for (int i = 0, j = 0; j < abc2.length; i++) {
          if (abc1[i].equals(abc2[j])){
            System.out.println("found first index: "+i+" second index: "+j);
            break;
          } else if (i == abc1.length-1) {
            i = 0;
            j++;
          } 

          System.out.println("searching... "+i+" "+j);
      }
   }
}

你可能会看到这样的东西：

searching... 0 0
searching... 1 0
searching... 2 0
searching... 3 0
searching... 4 0
searching... 0 1
searching... 1 1
searching... 2 1
searching... 3 1
searching... 4 1
searching... 0 2
searching... 1 2
searching... 2 2
searching... 3 2
searching... 4 2
searching... 0 3
searching... 1 3
searching... 2 3
searching... 3 3
searching... 4 3
searching... 0 4
searching... 1 4
searching... 2 4
searching... 3 4
searching... 4 4
searching... 0 5
searching... 1 5
searching... 2 5
found first index: 3 second index: 5

Answer 9

使用集合和列表执行此操作的好方法。如果您迟早要使用 java，无论如何您都会开始使用它们，最好尽快开始，稍后再研究它们的工作原理。

import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;
public final class Match{


    public int countMatch( String [] a, String [] b){
            Set<String> set = new HashSet<>(Arrays.asList(a));
            set.retainAll(Arrays.asList(b));
            System.out.println("The number of matches is " + set.size());

            return set.hashCode();
}


    public static void main(String[] args) {

        String[] a = {"apple", "banana", "xylophone"};
        String[] b = {"banana", "carrot", "dog", "xray", "xylophone"};

        Match countMatch = new Match();
        countMatch.countMatch(a, b);
}
}

Answer 10

此函数为您完成工作，在本例中，它的工作是计算两个匹配词恰好一次，而不管它们出现的次数。

让我们看看它是如何工作的：

它遍历 2 个数组，只比较每个数组中最后一次出现的迭代项，不计算重复项。最后，为了进行一些优化，我们跳过检查第一个数组项和第二个数组项是否较小。

此函数仅在 2 个数组按字母顺序排序时有效。

public int commonTwo(String[] a, String[] b) {
  int c = 0;
  for(int i = 0; i < a.length; i++){
    for(int j = 0; j < b.length; j++){
      if(a.length - i >= 2 && a[i].equals(a[i+1])) break;
      if(b.length - j >= 2 && b[j].equals(b[j+1])) continue;
      int cmp = a[i].compareTo(b[j]);
      if(cmp == 0) {
          c++;
      } else if(cmp < 0){
          break;
      }
    }
  }
  return c;
}

样本：

public class Main {

    public static void main(String[] args) {

    String[] a = {"a", "c", "x"};
    String[] b = {"a", "b", "c", "x", "z"};

    int count = commonTwo(a, b);
    System.out.println(count); // prints 3

    String[] a2 = {"a", "a", "b", "b", "c"};
    String[] b2 = {"a", "b", "b", "b", "c"};

    int count = commonTwo(a2, b2);
    System.out.println(count); // prints 3

    }

}

计算 Java 中两个数组中匹配的字符串数

Count number of strings that match in two arrays in Java

java

arrays

sorting

match