Groovy 列表的克隆仍然会更正原始列表

在groovy中，当我更改克隆列表中的值时，原始值会被覆盖。有人知道我是做错了还是groovy的错误吗

我正在做这样的事情：

List<Foo> myFooList = fooList.newFoos.findAll { it.type == "Types}
List<Foo> newFoo = fooList.oldFoos.findAll { it.type == "Types}.clone()

newFoo.each {
   it.value = "neeeew value"
}

Foo fooOne = newFoo.each { foooo ->
   fooTwo = fooList.oldFoos.find { it.id == foooo.id}
   if(fooTwo.value != foooo.value) {
       //Here it should go... but it turns out that fooTwo.value == foooo.value
   }
}

List mywhoolist=whoolist.newFoos.findAll{it.type==“Types}
List newFoo=doulist.oldFoos.findAll{it.type==“Types}.clone（）
纽福{
it.value=“新值”
}
Foo fooOne=newFoo.each{foooo->
fooTwo=doulist.oldFoos.find{it.id==fooo.id}
if（fooTwo.value！=fooo.value）{
//应该是这样的……但结果是fooTwo.value==fooo.value
}
}

在list上调用的

clone

方法生成一个新的列表，但其中包含相同的对象

您希望使用新对象生成新列表。以下是一个例子：

@groovy.transform.ToString
class Foo{
    String type
    String value
}

def fooList = [
    new Foo(type:"Types", value:'old value1'),
    new Foo(type:"Not",   value:'old value2'),
    new Foo(type:"Types", value:'old value3'),
    new Foo(type:"Not",   value:'old value4'),
]

def newFooList = fooList.
    findAll{it.type=='Types'}.
    collect{ new Foo(type:it.type, value:"new value") } //build new array with transformed elements

//check the original list
fooList.each{assert it.value!='new value'}
//check new list
newFooList.each{assert it.value=='new value'}
assert newFooList.size()==2

println fooList
println newFooList

---

我通过添加元素的克隆解决了这个问题，无论它以何种方式成为牛仔修复的主要部分：

List<Foo> myFooList = fooList.newFoos.findAll { it.type == "Types}
List<Foo> newFoo = fooList.oldFoos.findAll { it.type == "Types}.collect {it.clone()}

newFoo.each {
   it.value = "neeeew value"
}

Foo fooOne = newFoo.each { foooo ->
   fooTwo = fooList.oldFoos.find { it.id == foooo.id}
   if(fooTwo.value != foooo.value) {
       //Here it should go... but it turns out that fooTwo.value == foooo.value
   }
}

List mywhoolist=whoolist.newFoos.findAll{it.type==“Types}
列出newFoo=doulist.oldFoos.findAll{it.type==“Types}.collect{it.clone（）}
纽福{
it.value=“新值”
}
Foo fooOne=newFoo.each{foooo->
fooTwo=doulist.oldFoos.find{it.id==fooo.id}
if（fooTwo.value！=fooo.value）{
//应该是这样的……但结果是fooTwo.value==fooo.value
}
}

这将克隆列表，但不会克隆

Foo

。您必须执行

…收集{new Foo（it.properties）}

（或类似操作），而不是

克隆

，您需要对项目进行迭代并逐个克隆。为此，您必须让Foo类实现可克隆接口和clone（）方法。@cfrick他正在比较Foo对象的基本属性；虽然对象引用不相等，但它们的基本属性是相等的。谢谢，但我问的是克隆方法。你给了我一个解决这个问题的办法。收集{it.clone}