Question

我知道在Groovy中，如果

list = [1,2,3,1]

当

list.unique()

带回程

[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表示任何非连续的重复发生。

Answer 1

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

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

（请注意unique()修改了列表。）

与此同时，Collection.unique()似乎做了你所要求的“分组”项目（你的最后三个例子）。

编辑：unique()无论集合是否已排序，都能正常工作。

Answer 2

这应该这样做：

list.countBy{it}.grep{it.value > 1}.collect{it.key}

和

template<typename>
struct S { };

template<typename, typename>
struct B;

template <typename R, typename... Args, template<class> class C>
struct B<R(Args...), C<R>> {
    void f() { }
};

int main() {
    B<void(), S<void>> b;
    b.f();
}

Answer 3

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

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

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

Answer 4

您应该可以metaClass列出并添加自己的detect方法，如下所示：

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

Answer 5

要知道它是否重复：

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

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

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
    }

}

这里是Spock测试用例：

import spock.lang.Specification

class ListUtilsSpec extends Specification {

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

        then:
        duplicates == ["a"]
    }

}

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

5 个答案: