# Make iterators cloneable?

Tagir Valeev amaembo at gmail.com
Mon Sep 12 00:58:27 UTC 2016

```Actually given the fact that we're iterating the Set (so the elements are
unique) and using the assumption that iteration of the same set is stable,
you can avoid numbering like this:

for(String e1 : set) {
for(String e2 : set) {
if(e1 == e2) break;
System.out.println(e1+" <-> "+e2);
}
}

Again, such algorithm is fragile to concurrent changes.

With best regards,
Tagir Valeev.

On Mon, Sep 12, 2016 at 7:51 AM, Tagir Valeev <amaembo at gmail.com> wrote:

> Hello, Peter!
>
> I thought about numbering, but original Dave's code involved concurrent
> set, so I presume that it's expected to be modified from other threads. In
> this case my algorithm would output some legal pairs (probably reflecting
> changes or not or reflecting only partially) while your algorithm can
> output garbage (pair with equal e1, e2 or two pairs like e1 <-> e2, e2 <->
> e1 or can even die with NoSuchElementException). Not sure what is better in
> author's case.
>
> Tagir.
>
> On Sun, Sep 11, 2016 at 7:20 PM, Peter Levart <peter.levart at gmail.com>
> wrote:
>
>> Hi,
>>
>> Even if the elements are not comparable, you could rely on the fact that
>> Collection(s) usually create iterators with stable iteration order, so you
>> could do the following:
>>
>>
>>         Set<Integer> set = Set.of(1, 2, 3, 4);
>>
>>         Iterator<Integer> it1 = set.iterator();
>>         for (int n1 = 0; it1.hasNext(); n1++) {
>>             Integer e1 = it1.next();
>>             Iterator<Integer> it2 = set.iterator();
>>             for (int n2 = 0; n2 < n1; n2++) {
>>                 Integer e2 = it2.next();
>>                 System.out.println(e1 + " <-> " + e2);
>>             }
>>         }
>>
>>
>> Regards, Peter
>>
>>
>> On 09/11/2016 02:02 PM, Tagir F. Valeev wrote:
>>
>> Hello!
>>
>> As your keys are comparable, you can create normal iterators and
>> filter the results like this:
>>
>> for(String v1 : s) {
>>   for(String v2 : s) {
>>     if(v1.compareTo(v2) < 0) {
>>       System.out.println(v1 + " <-->" + v2);
>>     }
>>   }
>> }
>>
>> Or using Stream API:
>>
>> s.stream().flatMap(v1 -> s.stream()
>>     .filter(v2 -> v1.compareTo(v2) < 0).map(v2 -> v1 + " <-->" + v2))
>>  .forEach(System.out::println);
>>
>> With best regards,
>> Tagir Valeev.
>>
>>
>> DB> It would be nice to be able to associate each element in a collection
>> DB> with another element in the collection, which is something very easily
>> DB> done with index based collections, but with sets, etc this isn't so
>> DB> easy... unless i'm having a brainfart.
>>
>> DB> So i'd like to do this, but Iterator doesn't implement Cloneable... Any
>> DB> reason not to? or is there another way that's missing me?
>>
>> DB> public class ItClone {
>>
>> DB>      public static void main(String[] args) {
>> DB>          Set<String> s = Collections.newSetFromMap(new
>> DB> ConcurrentHashMap<String, Boolean>());
>>
>>
>> DB>          Iterator<String> it1 = s.iterator();
>> DB>          while (it1.hasNext()) {
>> DB>              String v1 = it1.next();
>>
>> DB>              Iterator<String> it2 = (Iterator<String>) it1.*clone*();
>> DB>              while (it2.hasNext()) {
>> DB>                  String v2 = it2.next();
>>
>> DB>                  System.out.println(v1 + " <-->" + v2);
>> DB>              }
>> DB>          }
>> DB>      }
>> DB> }
>>
>>
>>
>>
>
```