Groovy：检测列表中重复、非连续值的最简单方法

我知道在Groovy中， 如果

什么时候

回报

[1,2,3]

但如果我想检测列表中重复的、非连续的项的重复值。我该怎么做

detect([1,2,3,1]) => true
detect([1,2,3,2]) => true
detect([1,1,2,3]) => false
detect([1,2,2,3,3]) => false
detect([1,2,3,4]) => false

谢谢

编辑： 加上这两个案例

detect([1,2,2,1]) => true
detect([1,2,1,1]) => true

---

true表示出现任何不连续的重复项。

要确定集合是否包含非唯一项（前两个示例），可以执行以下操作：

def a = [1, 2, 3, 1]   
boolean nonUnique = a.clone().unique().size() != a.size()

class ListUtils {

    static List<String> getDuplicates(List<String> completeList) {
        List<String> duplicates = []
        Set<String> nonDuplicates = new HashSet<>()
        for (String string in completeList) {
            boolean addded = nonDuplicates.add(string)
            if (!addded) {
                duplicates << string
            }
        }
        return duplicates
    }

}

（请注意，

unique（）

修改列表）

同时，

Collection.unique（）

似乎按照您的要求对项目进行“分组”（最后三个示例）

---

编辑：

unique（）

List.metaClass.detect = {
  def rslt = delegate.inject([]){ ret, elem ->
      ret << (ret && ret.last() != elem ? elem : !ret ? elem : 'Dup')
  }
  return (!rslt.contains('Dup') && rslt != rslt.unique(false))
}

assert [1,2,3,1].detect() == true //Non-consecutive Dups 1
assert [1,2,3,2].detect() == true //Non-consecutive Dups 2
assert [1,1,2,3].detect() == false //Consecutive Dups 1
assert [1,2,2,3,3].detect() == false //Consecutive Dups 2 and 3
assert [1,2,3,4].detect() == false //Unique no dups

List.metaClass.detect={
def rslt=delegate.injection（[]）{ret，elem->
ret这应该可以做到：

List list = ["a", "b", "c", "a", "d", "c", "a"]

及

如果需要获取重复的元素：

    def nonUniqueElements = {list ->
        list.findAll{a -> list.findAll{b -> b == a}.size() > 1}.unique()
    }

    assert nonUniqueElements(['a', 'b', 'b', 'c', 'd', 'c']) == ['b', 'c']

要知道是否有重复项，请执行以下操作：

stringList.size() == stringList.toSet().size() // if true, it has no duplicates

要知道哪些值是重复的，可以执行以下操作：

def a = [1, 2, 3, 1]   
boolean nonUnique = a.clone().unique().size() != a.size()

class ListUtils {

    static List<String> getDuplicates(List<String> completeList) {
        List<String> duplicates = []
        Set<String> nonDuplicates = new HashSet<>()
        for (String string in completeList) {
            boolean addded = nonDuplicates.add(string)
            if (!addded) {
                duplicates << string
            }
        }
        return duplicates
    }

}

classlistutils{
静态列表getDuplicates（列表完成列表）{
列出重复项=[]
Set nondeplicates=new HashSet（）
for（completeList中的字符串）{
boolean added=nondeplicates.add（字符串）
如果（！added）{
重复谢谢！但是这个方法不能检测列表项的连续性，是吗？不，它不能-不清楚这就是你想要的。太好了！我只想知道
！ref
如何在你的代码中表示空列表？是的，没错。如果元类实现更为Groove，我可以尝试进一步优化它。oops、 
[1,2,2,1].detect（）
和
[1,2,1,1].detect（）
返回false，但我认为它应该是真的。我在定义问题时忽略了这两种情况。它们怎么可能是真的？它们有连续的重复，对吗？与您的问题标准相匹配？这将与您的问题陈述相矛盾。我应该更清楚地定义，true意味着出现非连续的重复。抱歉我的不清楚。
class ListUtils {

    static List<String> getDuplicates(List<String> completeList) {
        List<String> duplicates = []
        Set<String> nonDuplicates = new HashSet<>()
        for (String string in completeList) {
            boolean addded = nonDuplicates.add(string)
            if (!addded) {
                duplicates << string
            }
        }
        return duplicates
    }

}

import spock.lang.Specification

class ListUtilsSpec extends Specification {

    def "getDuplicates"() {
        when:
        List<String> duplicates = ListUtils.getDuplicates(["a", "b", "c", "a"])

        then:
        duplicates == ["a"]
    }

}