Java/Groovy双精度语句问题

这是一个Java/Groovy问题，我做这个函数是为了在我的网站的搜索机制中实现。我有两份清单：

String [] lista = temp.split() // ignore the temp part
String [] searchLista = search.split() // ignore the search part

基本上，列表是这样的：

    lista = {a, b, c, d}
    searchLista= {a, b, a, d}
    boolean test

我想验证列表'lista'上的任何元素是否与'searchLista'上的相同。为此，我执行了以下功能：

for(int i = 0; i< lista.length-1; i++){

                for(int j = 0; j< searchLista.length-1; j++) {

                    if(lista[i].contains(searchLista[j])){
                        test = true
                        ##
                    }
                }
            }

for（int i=0；i

---

我的问题是，如果此验证为真：“lista[i].contains（searchLista[j]）”，则布尔变量test变为真，接下来我想跳出这两个FOR。在###s处简单的“中断”就可以了？

简单的中断只会中断内部for循环。

---

但是您可以在自己的函数中执行此操作，并在##处添加一个return语句。

简单的中断只会中断内部for循环。 但是您可以在自己的函数中执行此操作，并在##处添加一个return语句。

（顺便问一下，您是否故意遗漏了两个列表的最后一个元素？）

正常的

break

语句只会退出内部循环

如果要打破两个级别，有三个常用选项：

• 使外部循环的条件成为你可以在身体中制造为假的东西
• 使整个循环成为一个方法，然后从中返回
• 使用带标签的分隔符

最后一个选项的示例：

// Code before loop
outerLoop:
for (...) {
    for (...) {
        if (...) {
            break outerLoop;
        }
    }
}

就我个人而言，我不经常使用标签——如果可能的话，我宁愿使用“使整个双循环成为一种方法”选项。

（顺便问一下，您是否故意遗漏了两个列表的最后一个元素？）

正常的

break

语句只会退出内部循环

如果要打破两个级别，有三个常用选项：

• 使外部循环的条件成为你可以在身体中制造为假的东西
• 使整个循环成为一个方法，然后从中返回
• 使用带标签的分隔符

最后一个选项的示例：

// Code before loop
outerLoop:
for (...) {
    for (...) {
        if (...) {
            break outerLoop;
        }
    }
}

---

就我个人而言，我不经常使用标签——如果可能的话，我宁愿使用“使整个双循环成为一种方法”选项。

简短的答案是否定的——尽管稍长的答案是“这只会影响性能，但不会影响正确性，因为一旦（最终）退出循环，

测试仍然是正确的”

原因是
break
仅从直接封闭循环中中断。在本例中，您有双重嵌套的循环，并且希望从这两个循环中分离出来。一种方法是使用标签：

OUTER: for(int i = 0; i< lista.length-1; i++){
   for(int j = 0; j< searchLista.length-1; j++) {
      if(lista[i].contains(searchLista[j])){
          test = true
          break OUTER;
      }
   }
}

就性能而言，这可能也不会更糟。
简短的答案是否定的，尽管稍长的答案是“这只会影响性能，但不会影响正确性，因为一旦（最终）退出循环，
测试仍然是正确的”

原因是
break
仅从直接封闭循环中中断。在本例中，您有双重嵌套的循环，并且希望从这两个循环中分离出来。一种方法是使用标签：

OUTER: for(int i = 0; i< lista.length-1; i++){
   for(int j = 0; j< searchLista.length-1; j++) {
      if(lista[i].contains(searchLista[j])){
          test = true
          break OUTER;
      }
   }
}

就性能而言，这可能也不差。
您可以使用org.apache.commons.collections.CollectionUtils.intersection（Collection，Collection）
。首先将每个数组放入一个
集中。
您可以使用
org.apache.commons.collections.CollectionUtils.intersection（Collection，Collection）
。首先将每个数组放入一个
集中。
如果您只是想知道这两个数组是否有任何共同元素，Groovy最有效的方法是：

boolean haveElementsInCommon(array, otherArray) {
  !array.toList().disjoint(otherArray.toList())
}

下面是对上述函数/方法的一些测试

// create some test data
String[] list1 = [1,2,3,4]
String[] list2 = [5,6,7,8]
String[] list3 = [8,9,10,11]

// test the function works for arrays with nothing in common           
assert !haveElementsInCommon(list1, list2)
// test the function works for arrays with at least one element in common    
assert haveElementsInCommon(list2, list3)

您可以在中运行上面的代码来验证它是否工作
如果您只是想知道这两个数组是否有任何共同的元素，Groovy最有效的方法是：

boolean haveElementsInCommon(array, otherArray) {
  !array.toList().disjoint(otherArray.toList())
}

下面是对上述函数/方法的一些测试

// create some test data
String[] list1 = [1,2,3,4]
String[] list2 = [5,6,7,8]
String[] list3 = [8,9,10,11]

// test the function works for arrays with nothing in common           
assert !haveElementsInCommon(list1, list2)
// test the function works for arrays with at least one element in common    
assert haveElementsInCommon(list2, list3)

您可以在中运行上面的代码，以验证其是否有效。使用Groovy执行此操作的最简单方法是：

lista.any { it in searchLista }

使用Groovy执行此操作的最简单方法是：

lista.any { it in searchLista }

一个标签非常类似于一个“Go-to-Statement被认为是有害的”（但也有“Go-to-Statement被认为是有害的”被认为是有害的），等等。）@Michael:我不认为它几乎像goto一样武断。。。但我还是喜欢更简单的方法。“Go-To-Statement被认为是非常方便的，如果使用得宜，那么”只是没有那么吸引人，我猜一个标签非常类似于“Go-To-Statement”goto
，我们都知道“Go-To-Statement被认为是有害的”（但也有“Go-To-Statement被认为是有害的”“被认为是有害的”，等等）：）@Michael：我不认为这像goto一样武断。。。但我还是喜欢更简单的方法。“当使用得体和适当的时候，Go-To语句被认为是非常方便的”，我想这并没有那么吸引人