给定两个字符串数组a和b，每个都按字母顺序排列，我想返回两个数组中匹配的字符串数量。
public int countMatch(String[] a, String[] b) {
}
我的目标是能够按如下方式调用该方法;
countMatch({"apple", "banana", "xylophone"}, {"banana", "carrot", "dog", "xray", "xylophone"});
应该返回int值2，因为有两个字符串匹配每个数组（＆＃34; banana＆＃34;和＆＃34; xylophone＆＃34;）。
值得注意的是，如果这对解决方案有帮助，那么数组将始终按字母顺序排列。
答案 0 :(得分：4)
只要对这些数组进行排序，您就可以执行以下操作：
您将拥有两个变量：i和j。首先是第一个数组，第二个到第二个数组。
然后您比较a[i]和b[j]。
如果他们是平等的，那么这是一个匹配，你推进两个指数。
如果它们不是相等的提前索引，而是指的是较少（如果a[i] < b[j]提前i其他j）。
答案 1 :(得分：2)
您可以创建一个简单的方法，如：
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();
}
答案 2 :(得分：2)
我的代码如下：
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));
}
}
答案 3 :(得分：2)
您可以使用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
答案 4 :(得分：1)
试试这个
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"}));
}
}
答案 5 :(得分：0)
除非最终性能成为问题，否则请忽略它们已排序的事实。将[]中的所有值放入HashSet。循环遍历b []并计算Set中包含的数量。
答案 6 :(得分：0)
如果你想要计算两个匹配的单词一次，无论它们是什么，如你所说;试试这段代码
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会自动修剪数组中的重复单词。
答案 7 :(得分：0)
如果你完全不关心字母顺序。然后很简单，你需要两个循环来完成工作，即你需要比较所有可能的对。在您的示例中，您需要进行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]，您只需从光标开始而不是重新开始因为光标之前的所有前一个肯定不能匹配[i + 1]。
答案 8 :(得分：0)
使用集合和列表执行此操作的好方法。如果你迟早要使用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);
}
}
答案 9 :(得分：0)
此功能为您完成工作，在这种情况下，它的工作是准确匹配一次两个匹配词，无论它们出现与否。
让我们看看它是如何工作的：
迭代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
}
}