RE: Make iterators cloneable?

[timo.kinnunen]

No, 

It breaks on Fi (or Fum) in the inner loop before it gets the chance to output 
Fi-Fum (or Fum-Fi) if Fi (respectively Fum) comes first in iteration order.






-- 
Have a nice day, 
Timo

Sent from Mail for Windows 10

From: Dave Brosius

Re: Make iterators cloneable?

[Dave Brosius]

That would give you unwanted duplicates

Fi-Fum and Fum-Fi for instance


On 09/11/2016 08:58 PM, Tagir Valeev wrote:
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 > 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
> 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 set = Set.of(1, 2, 3, 4);

Iterator it1 = set.iterator();
for (int n1 = 0; it1.hasNext(); n1++) {
Integer e1 = it1.next();
Iterator 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 s = Collections.newSetFromMap(new
DB> ConcurrentHashMap());

DB>  s.add("Fee");
DB>  s.add("Fi");
DB>  s.add("Fo");
DB>  s.add("Fum");

DB>  Iterator it1 = s.iterator();
DB>  while (it1.hasNext()) {
DB>  String v1 = it1.next();

DB>  Iterator it2 = (Iterator) 
it1.*clone*();
DB>  while (it2.hasNext()) {
DB>  String v2 = it2.next();

DB>  System.out.println(v1 + " <-->" + v2);
DB>  }
DB>  }
DB>  }
DB> }

Re: Make iterators cloneable?

[Tagir Valeev]

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  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 
> 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 set = Set.of(1, 2, 3, 4);
>>
>> Iterator it1 = set.iterator();
>> for (int n1 = 0; it1.hasNext(); n1++) {
>> Integer e1 = it1.next();
>> Iterator 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 s = Collections.newSetFromMap(new
>> DB> ConcurrentHashMap());
>>
>> DB>  s.add("Fee");
>> DB>  s.add("Fi");
>> DB>  s.add("Fo");
>> DB>  s.add("Fum");
>>
>> DB>  Iterator it1 = s.iterator();
>> DB>  while (it1.hasNext()) {
>> DB>  String v1 = it1.next();
>>
>> DB>  Iterator it2 = (Iterator) it1.*clone*();
>> DB>  while (it2.hasNext()) {
>> DB>  String v2 = it2.next();
>>
>> DB>  System.out.println(v1 + " <-->" + v2);
>> DB>  }
>> DB>  }
>> DB>  }
>> DB> }
>>
>>
>>
>>
>

Re: Make iterators cloneable?

[Tagir Valeev]

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 
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 set = Set.of(1, 2, 3, 4);
>
> Iterator it1 = set.iterator();
> for (int n1 = 0; it1.hasNext(); n1++) {
> Integer e1 = it1.next();
> Iterator 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 s = Collections.newSetFromMap(new
> DB> ConcurrentHashMap());
>
> DB>  s.add("Fee");
> DB>  s.add("Fi");
> DB>  s.add("Fo");
> DB>  s.add("Fum");
>
> DB>  Iterator it1 = s.iterator();
> DB>  while (it1.hasNext()) {
> DB>  String v1 = it1.next();
>
> DB>  Iterator it2 = (Iterator) it1.*clone*();
> DB>  while (it2.hasNext()) {
> DB>  String v2 = it2.next();
>
> DB>  System.out.println(v1 + " <-->" + v2);
> DB>  }
> DB>  }
> DB>  }
> DB> }
>
>
>
>

Re: Make iterators cloneable?

[Peter Levart]

I would say the algorithm is O(n), when you take n to be the number of 
emitted pairs, wouldn't you ;-)


You wanted an algorithm that emits n*(n-1) / 2 distinct pairs of 
elements from a set of n elements, didn't you?


Regards, Peter


On 09/11/2016 06:55 PM, Dave Brosius wrote:
Sure, but both of those algorithms are n^2, which is a bit painful, 
especially given all the pointer chasing that occurs with iterators.



On 09/11/2016 08:20 AM, Peter Levart 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 set = Set.of(1, 2, 3, 4);

Iterator it1 = set.iterator();
for (int n1 = 0; it1.hasNext(); n1++) {
Integer e1 = it1.next();
Iterator 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 s = Collections.newSetFromMap(new
DB> ConcurrentHashMap());

DB>  s.add("Fee");
DB>  s.add("Fi");
DB>  s.add("Fo");
DB>  s.add("Fum");

DB>  Iterator it1 = s.iterator();
DB>  while (it1.hasNext()) {
DB>  String v1 = it1.next();

DB>  Iterator it2 = (Iterator) 
it1.*clone*();

DB>  while (it2.hasNext()) {
DB>  String v2 = it2.next();

DB>  System.out.println(v1 + " <-->" + v2);
DB>  }
DB>  }
DB>  }
DB> }

Re: Make iterators cloneable?

[Dave Brosius]

Sure, but both of those algorithms are n^2, which is a bit painful, 
especially given all the pointer chasing that occurs with iterators.



On 09/11/2016 08:20 AM, Peter Levart 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 set = Set.of(1, 2, 3, 4);

Iterator it1 = set.iterator();
for (int n1 = 0; it1.hasNext(); n1++) {
Integer e1 = it1.next();
Iterator 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 s = Collections.newSetFromMap(new
DB> ConcurrentHashMap());

DB>  s.add("Fee");
DB>  s.add("Fi");
DB>  s.add("Fo");
DB>  s.add("Fum");

DB>  Iterator it1 = s.iterator();
DB>  while (it1.hasNext()) {
DB>  String v1 = it1.next();

DB>  Iterator it2 = (Iterator) it1.*clone*();
DB>  while (it2.hasNext()) {
DB>  String v2 = it2.next();

DB>  System.out.println(v1 + " <-->" + v2);
DB>  }
DB>  }
DB>  }
DB> }

Re: Make iterators cloneable?

[Peter Levart]

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 set = Set.of(1, 2, 3, 4);

Iterator it1 = set.iterator();
for (int n1 = 0; it1.hasNext(); n1++) {
Integer e1 = it1.next();
Iterator 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 s = Collections.newSetFromMap(new
DB> ConcurrentHashMap());

DB>  s.add("Fee");
DB>  s.add("Fi");
DB>  s.add("Fo");
DB>  s.add("Fum");

DB>  Iterator it1 = s.iterator();
DB>  while (it1.hasNext()) {
DB>  String v1 = it1.next();

DB>  Iterator it2 = (Iterator) it1.*clone*();
DB>  while (it2.hasNext()) {
DB>  String v2 = it2.next();

DB>  System.out.println(v1 + " <-->" + v2);
DB>  }
DB>  }
DB>  }
DB> }

Re: Make iterators cloneable?

[Tagir F. Valeev]

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 s = Collections.newSetFromMap(new 
DB> ConcurrentHashMap());

DB>  s.add("Fee");
DB>  s.add("Fi");
DB>  s.add("Fo");
DB>  s.add("Fum");

DB>  Iterator it1 = s.iterator();
DB>  while (it1.hasNext()) {
DB>  String v1 = it1.next();

DB>  Iterator it2 = (Iterator) it1.*clone*();
DB>  while (it2.hasNext()) {
DB>  String v2 = it2.next();

DB>  System.out.println(v1 + " <-->" + v2);
DB>  }
DB>  }
DB>  }
DB> }

Re: Make iterators cloneable?

[Dave Brosius]

Hi,


The failfast argument is is irrelevant. It only matters if you use 
it.remove() which is no different than any other failfast situation.


Obviously the 3rd argument is bogus too, as you say.

The second argument, ok, is not arguable, as it's just a persons 
opinion. The bug report is in the genre of subList implementation which 
is different than this use, but ok. The problem is that there are no 
reasonable concurrent indexable collections, and the thought of copying 
large collections into a List everytime you want to do this is crazy.



Unfortunately you can't even have one-off fixes for specific collections 
by having an iterator with a 'copy constructor' for instance, as in the 
case of collection iterators you _really_ have no business knowing what 
the real class is.



On 09/11/2016 05:40 AM, Remi Forax wrote:


Hi,
digging a little bit in the bug database, there is a bug from 1999
   https://bugs.openjdk.java.net/browse/JDK-4244952

answers seems to be
- having different iterators on the same collection is error prone because 
iterators are failfast,
   the proposed workaround to use an array or a List with several indexes
- it's too C++ish, C++ defines clone and equals, Java tries to define a simpler 
iteration protocol
   (from now, given that this question is raised only once in a while, it's 
doesn't seem to be a bad idea)
- iterators are interfaces, so having several iterators means several virtual 
dispatch calls
   (this one is not true anymore because any JITs routinely devirtualize this 
kind of call).

cheers,
Rémi

- Mail original -

De: "Dave Brosius" <dbros...@mebigfatguy.com>
À: "Louis Wasserman" <lowas...@google.com>, "Jonathan Bluett-Duncan" 
<jbluettdun...@gmail.com>
Cc: core-libs-dev@openjdk.java.net
Envoyé: Dimanche 11 Septembre 2016 02:23:41
Objet: Re: Make iterators cloneable?

Iterators reading from a BufferedReader

yes that's true. altho given the contract of Cloneable, adding the clone
method on Iterator would be safe, as it would only be available if the
real implementing class 'extends Cloneable'... it's actually kind of
funny that Object methods aren't available on interface references, anyway.


But i get the "age of Iterator" answer.. Shame there isn't an answer, tho.

thanks, dave

On 09/10/2016 07:44 PM, Louis Wasserman wrote:

Some iterators might be.  Many may not be. Certainly Iterator as an
interface has been out there for long enough there are Iterator
implementations out there that aren't cloneable -- say, Iterators
reading from a BufferedReader, where there really won't be any way to
do what you're hoping for; BufferedReaders certainly aren't cloneable.

On Sat, Sep 10, 2016 at 4:33 PM Dave Brosius <dbros...@mebigfatguy.com
<mailto:dbros...@mebigfatguy.com>> wrote:

 Yes Louis is correct.

 I want the pair wise associations or all elements of a set.

 Fee-Fi

 Fee-Fo

 Fee-Fum

 Fi-Fo

 Fi-Fum

 Fo-Fum


 the independent iterators produce Fee-Fee (etc) as well as the
 duplicate Fee-Fi and Fi-Fee (etc), both of which i don't want.


 This is obviously simplistic with index based collections, but not
 with sets/maps

 I don't see why an Iterator isn't by nature easily cloneable.



 On 09/10/2016 06:45 PM, Jonathan Bluett-Duncan wrote:

 Ah okay Louis, if that's the case then that certainly makes
 sense, and I'd agree that there's no good way of doing so, as one
 would need to copy the set into a list.

 Dave, did Louis hit the mark? If not, would you kindly go into
 further detail as to exactly what it is you're trying to do?

 Best,
 Jonathan

 On 10 September 2016 at 23:36, Jonathan Bluett-Duncan
 <jbluettdun...@gmail.com <mailto:jbluettdun...@gmail.com>> wrote:

 Hi Dave,

 Rather than using Iterator.clone(), how about you just call
 collection.iterator() 2 times to return 2 unique, non-same
 iterators; something like the following:

 import java.util.Collections;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;

 public class Example {public static void main(String[] args) { 
Set s =
 Collections.newSetFromMap(new ConcurrentHashMap<String,
 Boolean>()); s.add("Fee"); s.add("Fi"); s.add("Fo");
 s.add("Fum"); Iterator it1 = s.iterator();  for (String v1 
=null;
 it1.hasNext(); v1 =it1.next()) {
Iterator it2 = s.iterator();// a completely separate 
iterator to it1 for
(String v2 =null; it2.hasNext(); v2 = it2.next()) 
{System.out.println(v1 + "
<-->" + v2); } } } }

 Or, even better, if you're using Java 5+, you can skip using
 Iterators altogether and use for-loops directly:

 imp

Re: Make iterators cloneable?

[Remi Forax]

Hi,
digging a little bit in the bug database, there is a bug from 1999
  https://bugs.openjdk.java.net/browse/JDK-4244952

answers seems to be
- having different iterators on the same collection is error prone because 
iterators are failfast,
  the proposed workaround to use an array or a List with several indexes
- it's too C++ish, C++ defines clone and equals, Java tries to define a simpler 
iteration protocol
  (from now, given that this question is raised only once in a while, it's 
doesn't seem to be a bad idea)
- iterators are interfaces, so having several iterators means several virtual 
dispatch calls
  (this one is not true anymore because any JITs routinely devirtualize this 
kind of call).

cheers,
Rémi

- Mail original -
> De: "Dave Brosius" <dbros...@mebigfatguy.com>
> À: "Louis Wasserman" <lowas...@google.com>, "Jonathan Bluett-Duncan" 
> <jbluettdun...@gmail.com>
> Cc: core-libs-dev@openjdk.java.net
> Envoyé: Dimanche 11 Septembre 2016 02:23:41
> Objet: Re: Make iterators cloneable?

>>> Iterators reading from a BufferedReader
> 
> yes that's true. altho given the contract of Cloneable, adding the clone
> method on Iterator would be safe, as it would only be available if the
> real implementing class 'extends Cloneable'... it's actually kind of
> funny that Object methods aren't available on interface references, anyway.
> 
> 
> But i get the "age of Iterator" answer.. Shame there isn't an answer, tho.
> 
> thanks, dave
> 
> On 09/10/2016 07:44 PM, Louis Wasserman wrote:
>> Some iterators might be.  Many may not be. Certainly Iterator as an
>> interface has been out there for long enough there are Iterator
>> implementations out there that aren't cloneable -- say, Iterators
>> reading from a BufferedReader, where there really won't be any way to
>> do what you're hoping for; BufferedReaders certainly aren't cloneable.
>>
>> On Sat, Sep 10, 2016 at 4:33 PM Dave Brosius <dbros...@mebigfatguy.com
>> <mailto:dbros...@mebigfatguy.com>> wrote:
>>
>> Yes Louis is correct.
>>
>> I want the pair wise associations or all elements of a set.
>>
>> Fee-Fi
>>
>> Fee-Fo
>>
>> Fee-Fum
>>
>> Fi-Fo
>>
>> Fi-Fum
>>
>> Fo-Fum
>>
>>
>> the independent iterators produce Fee-Fee (etc) as well as the
>> duplicate Fee-Fi and Fi-Fee (etc), both of which i don't want.
>>
>>
>> This is obviously simplistic with index based collections, but not
>> with sets/maps
>>
>> I don't see why an Iterator isn't by nature easily cloneable.
>>
>>
>>
>> On 09/10/2016 06:45 PM, Jonathan Bluett-Duncan wrote:
>>> Ah okay Louis, if that's the case then that certainly makes
>>> sense, and I'd agree that there's no good way of doing so, as one
>>> would need to copy the set into a list.
>>>
>>> Dave, did Louis hit the mark? If not, would you kindly go into
>>> further detail as to exactly what it is you're trying to do?
>>>
>>> Best,
>>> Jonathan
>>>
>>> On 10 September 2016 at 23:36, Jonathan Bluett-Duncan
>>> <jbluettdun...@gmail.com <mailto:jbluettdun...@gmail.com>> wrote:
>>>
>>> Hi Dave,
>>>
>>> Rather than using Iterator.clone(), how about you just call
>>> collection.iterator() 2 times to return 2 unique, non-same
>>> iterators; something like the following:
>>>
>>> import java.util.Collections;
>>> import java.util.Iterator;
>>> import java.util.Set;
>>> import java.util.concurrent.ConcurrentHashMap;
>>>
>>> public class Example {public static void main(String[] args) { 
>>> Set s =
>>> Collections.newSetFromMap(new ConcurrentHashMap<String,
>>> Boolean>()); s.add("Fee"); s.add("Fi"); s.add("Fo");
>>> s.add("Fum"); Iterator it1 = s.iterator();  for (String 
>>> v1 =null;
>>> it1.hasNext(); v1 =it1.next()) {
>>>Iterator it2 = s.iterator();// a completely separate 
>>> iterator to it1 for
>>>(String v2 =null; it2.hasNext(); v2 = it2.next()) 
>>> {System.out.println(v1 + "
>>><-->" + v2); } } } }
>>>
>>> Or, even better, if you're using Java 5+, you can skip using
>>> Iterators altoget

Re: Make iterators cloneable?

[Dave Brosius]

>> Iterators reading from a BufferedReader

yes that's true. altho given the contract of Cloneable, adding the clone 
method on Iterator would be safe, as it would only be available if the 
real implementing class 'extends Cloneable'... it's actually kind of 
funny that Object methods aren't available on interface references, anyway.



But i get the "age of Iterator" answer.. Shame there isn't an answer, tho.

thanks, dave

On 09/10/2016 07:44 PM, Louis Wasserman wrote:
Some iterators might be.  Many may not be. Certainly Iterator as an 
interface has been out there for long enough there are Iterator 
implementations out there that aren't cloneable -- say, Iterators 
reading from a BufferedReader, where there really won't be any way to 
do what you're hoping for; BufferedReaders certainly aren't cloneable.


On Sat, Sep 10, 2016 at 4:33 PM Dave Brosius > wrote:


Yes Louis is correct.

I want the pair wise associations or all elements of a set.

Fee-Fi

Fee-Fo

Fee-Fum

Fi-Fo

Fi-Fum

Fo-Fum


the independent iterators produce Fee-Fee (etc) as well as the
duplicate Fee-Fi and Fi-Fee (etc), both of which i don't want.


This is obviously simplistic with index based collections, but not
with sets/maps

I don't see why an Iterator isn't by nature easily cloneable.



On 09/10/2016 06:45 PM, Jonathan Bluett-Duncan wrote:

Ah okay Louis, if that's the case then that certainly makes
sense, and I'd agree that there's no good way of doing so, as one
would need to copy the set into a list.

Dave, did Louis hit the mark? If not, would you kindly go into
further detail as to exactly what it is you're trying to do?

Best,
Jonathan

On 10 September 2016 at 23:36, Jonathan Bluett-Duncan
> wrote:

Hi Dave,

Rather than using Iterator.clone(), how about you just call
collection.iterator() 2 times to return 2 unique, non-same
iterators; something like the following:

import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Example {public static void main(String[] args) { 
Set s =
Collections.newSetFromMap(new ConcurrentHashMap()); s.add("Fee"); s.add("Fi"); s.add("Fo");
s.add("Fum"); Iterator it1 = s.iterator();  for (String v1 
=null; it1.hasNext(); v1 =it1.next()) {
   Iterator it2 = s.iterator();// a completely separate iterator to it1 for 
(String v2 =null; it2.hasNext(); v2 = it2.next()) {System.out.println(v1 + " <-->" + 
v2); } } } }

Or, even better, if you're using Java 5+, you can skip using
Iterators altogether and use for-loops directly:

import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Example {public static void main(String[] args) { 
Set s =
Collections.newSetFromMap(new ConcurrentHashMap()); s.add("Fee"); s.add("Fi"); s.add("Fo");
s.add("Fum");  for (String v1 : s) {
   for (String v2 : s) {System.out.println(v1 + "<-->" + v2); } } } 
}

Kind regards,
Jonathan
On 10 September 2016 at 23:13, Dave Brosius
>
wrote:

It would be nice to be able to associate each element in
a collection with another element in the collection,
which is something very easily done with index based
collections, but with sets, etc this isn't so easy...
unless i'm having a brainfart. So i'd like to do this,
but Iterator doesn't implement Cloneable... Any reason
not to? or is there another way that's missing me? public
class ItClone { public static void main(String[]
args) { Set s =
Collections.newSetFromMap(new ConcurrentHashMap()); s.add("Fee"); s.add("Fi");  
  s.add("Fo"); s.add("Fum");
Iterator it1 = s.iterator(); while
(it1.hasNext()) { String v1 = it1.next();
Iterator it2 = (Iterator)
it1.*clone*(); while (it2.hasNext()) {  
  String v2 = it2.next();
System.out.println(v1 + " <-->" + v2); }
} } } 

Re: Make iterators cloneable?

[Louis Wasserman]

Some iterators might be.  Many may not be.  Certainly Iterator as an
interface has been out there for long enough there are Iterator
implementations out there that aren't cloneable -- say, Iterators reading
from a BufferedReader, where there really won't be any way to do what
you're hoping for; BufferedReaders certainly aren't cloneable.

On Sat, Sep 10, 2016 at 4:33 PM Dave Brosius 
wrote:

> Yes Louis is correct.
>
> I want the pair wise associations or all elements of a set.
>
> Fee-Fi
>
> Fee-Fo
>
> Fee-Fum
>
> Fi-Fo
>
> Fi-Fum
>
> Fo-Fum
>
>
> the independent iterators produce Fee-Fee (etc) as well as the duplicate
> Fee-Fi and Fi-Fee (etc), both of which i don't want.
>
>
> This is obviously simplistic with index based collections, but not with
> sets/maps
>
> I don't see why an Iterator isn't by nature easily cloneable.
>
>
>
> On 09/10/2016 06:45 PM, Jonathan Bluett-Duncan wrote:
>
> Ah okay Louis, if that's the case then that certainly makes sense, and I'd
> agree that there's no good way of doing so, as one would need to copy the
> set into a list.
>
> Dave, did Louis hit the mark? If not, would you kindly go into further
> detail as to exactly what it is you're trying to do?
>
> Best,
> Jonathan
>
> On 10 September 2016 at 23:36, Jonathan Bluett-Duncan <
> jbluettdun...@gmail.com> wrote:
>
> Hi Dave,
>
> Rather than using Iterator.clone(), how about you just call
> collection.iterator() 2 times to return 2 unique, non-same iterators;
> something like the following:
>
> import java.util.Collections;import java.util.Iterator;import 
> java.util.Set;import java.util.concurrent.ConcurrentHashMap;
> public class Example {
>   public static void main(String[] args) {
> Set s = Collections.newSetFromMap(new ConcurrentHashMap Boolean>());
>
> s.add("Fee");
> s.add("Fi");
> s.add("Fo");
> s.add("Fum");
>
> Iterator it1 = s.iterator();for (String v1 = null; 
> it1.hasNext(); v1 =it1.next()) {
>   Iterator it2 = s.iterator(); // a completely separate iterator 
> to it1  for (String v2 = null; it2.hasNext(); v2 = it2.next()) {
> System.out.println(v1 + " <-->" + v2);
>   }
> }
>   }
> }
>
> Or, even better, if you're using Java 5+, you can skip using Iterators
> altogether and use for-loops directly:
>
> import java.util.Collections;import java.util.Set;import 
> java.util.concurrent.ConcurrentHashMap;
> public class Example {
>   public static void main(String[] args) {
> Set s = Collections.newSetFromMap(new ConcurrentHashMap Boolean>());
>
> s.add("Fee");
> s.add("Fi");
> s.add("Fo");
> s.add("Fum");
> for (String v1 : s) {
>   for (String v2 : s) {
> System.out.println(v1 + "<-->" + v2);
>   }
> }
>   }
> }
>
> Kind regards,
> Jonathan
> On 10 September 2016 at 23:13, Dave Brosius 
> wrote:
>
> It would be nice to be able to associate each element in a collection with
> another element in the collection, which is something very easily done with
> index based collections, but with sets, etc this isn't so easy... unless
> i'm having a brainfart. So i'd like to do this, but Iterator doesn't
> implement Cloneable... Any reason not to? or is there another way that's
> missing me? public class ItClone { public static void main(String[]
> args) { Set s = Collections.newSetFromMap(new
> ConcurrentHashMap()); s.add("Fee");
> s.add("Fi"); s.add("Fo"); s.add("Fum");
> Iterator it1 = s.iterator(); while (it1.hasNext()) {
>   String v1 = it1.next(); Iterator it2 =
> (Iterator) it1.*clone*(); while (it2.hasNext()) {
>   String v2 = it2.next(); System.out.println(v1 + "
> <-->" + v2); } } } }
>
>

Re: Make iterators cloneable?

[Dave Brosius]

Yes Louis is correct.

I want the pair wise associations or all elements of a set.

Fee-Fi

Fee-Fo

Fee-Fum

Fi-Fo

Fi-Fum

Fo-Fum


the independent iterators produce Fee-Fee (etc) as well as the duplicate 
Fee-Fi and Fi-Fee (etc), both of which i don't want.



This is obviously simplistic with index based collections, but not with 
sets/maps


I don't see why an Iterator isn't by nature easily cloneable.



On 09/10/2016 06:45 PM, Jonathan Bluett-Duncan wrote:
Ah okay Louis, if that's the case then that certainly makes sense, and 
I'd agree that there's no good way of doing so, as one would need to 
copy the set into a list.


Dave, did Louis hit the mark? If not, would you kindly go into further 
detail as to exactly what it is you're trying to do?


Best,
Jonathan

On 10 September 2016 at 23:36, Jonathan Bluett-Duncan 
> wrote:


Hi Dave,

Rather than using Iterator.clone(), how about you just call
collection.iterator() 2 times to return 2 unique, non-same
iterators; something like the following:

import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Example {public static void main(String[] args) { Set 
s =
Collections.newSetFromMap(new ConcurrentHashMap()); s.add("Fee"); s.add("Fi"); s.add("Fo"); s.add("Fum");
Iterator it1 = s.iterator();  for (String v1 =null; 
it1.hasNext(); v1 =it1.next()) {
   Iterator it2 = s.iterator();// a completely separate iterator to it1 for 
(String v2 =null; it2.hasNext(); v2 = it2.next()) {System.out.println(v1 + " <-->" + 
v2); } } } }

Or, even better, if you're using Java 5+, you can skip using
Iterators altogether and use for-loops directly:

import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Example {public static void main(String[] args) { Set 
s =
Collections.newSetFromMap(new ConcurrentHashMap()); s.add("Fee"); s.add("Fi"); s.add("Fo"); s.add("Fum");  for 
(String v1 : s) {
   for (String v2 : s) {System.out.println(v1 + "<-->" + v2); } } } }

Kind regards,
Jonathan
On 10 September 2016 at 23:13, Dave Brosius
> wrote:

It would be nice to be able to associate each element in a
collection with another element in the collection, which is
something very easily done with index based collections, but
with sets, etc this isn't so easy... unless i'm having a
brainfart. So i'd like to do this, but Iterator doesn't
implement Cloneable... Any reason not to? or is there another
way that's missing me? public class ItClone { public
static void main(String[] args) { Set s =
Collections.newSetFromMap(new ConcurrentHashMap()); s.add("Fee"); s.add("Fi");  
  s.add("Fo"); s.add("Fum"); Iterator
it1 = s.iterator(); while (it1.hasNext()) {  
  String v1 = it1.next(); Iterator it2 =

(Iterator) it1.*clone*(); while
(it2.hasNext()) { String v2 = it2.next();
System.out.println(v1 + " <-->" + v2);
} } } } 

Re: Make iterators cloneable?

[Jonathan Bluett-Duncan]

Ah okay Louis, if that's the case then that certainly makes sense, and I'd
agree that there's no good way of doing so, as one would need to copy the
set into a list.

Dave, did Louis hit the mark? If not, would you kindly go into further
detail as to exactly what it is you're trying to do?

Best,
Jonathan

On 10 September 2016 at 23:36, Jonathan Bluett-Duncan <
jbluettdun...@gmail.com> wrote:

> Hi Dave,
>
> Rather than using Iterator.clone(), how about you just call
> collection.iterator() 2 times to return 2 unique, non-same iterators;
> something like the following:
>
> import java.util.Collections;
> import java.util.Iterator;
> import java.util.Set;
> import java.util.concurrent.ConcurrentHashMap;
>
> public class Example {
>   public static void main(String[] args) {
> Set s = Collections.newSetFromMap(new ConcurrentHashMap Boolean>());
>
> s.add("Fee");
> s.add("Fi");
> s.add("Fo");
> s.add("Fum");
>
> Iterator it1 = s.iterator();
> for (String v1 = null; it1.hasNext(); v1 =it1.next()) {
>   Iterator it2 = s.iterator(); // a completely separate iterator 
> to it1
>   for (String v2 = null; it2.hasNext(); v2 = it2.next()) {
> System.out.println(v1 + " <-->" + v2);
>   }
> }
>   }
> }
>
>
> Or, even better, if you're using Java 5+, you can skip using Iterators
> altogether and use for-loops directly:
>
> import java.util.Collections;
> import java.util.Set;
> import java.util.concurrent.ConcurrentHashMap;
>
> public class Example {
>   public static void main(String[] args) {
> Set s = Collections.newSetFromMap(new ConcurrentHashMap Boolean>());
>
> s.add("Fee");
> s.add("Fi");
> s.add("Fo");
> s.add("Fum");
>
> for (String v1 : s) {
>   for (String v2 : s) {
> System.out.println(v1 + "<-->" + v2);
>   }
> }
>   }
> }
>
>
> Kind regards,
> Jonathan
>
> On 10 September 2016 at 23:13, Dave Brosius 
> wrote:
>
>> It would be nice to be able to associate each element in a collection
>> with another element in the collection, which is something very easily done
>> with index based collections, but with sets, etc this isn't so easy...
>> unless i'm having a brainfart.
>>
>> So i'd like to do this, but Iterator doesn't implement Cloneable... Any
>> reason not to? or is there another way that's missing me?
>>
>> public class ItClone {
>>
>> public static void main(String[] args) {
>> Set s = Collections.newSetFromMap(new
>> ConcurrentHashMap());
>>
>> s.add("Fee");
>> s.add("Fi");
>> s.add("Fo");
>> s.add("Fum");
>>
>> Iterator it1 = s.iterator();
>> while (it1.hasNext()) {
>> String v1 = it1.next();
>>
>> Iterator it2 = (Iterator) it1.*clone*();
>> while (it2.hasNext()) {
>> String v2 = it2.next();
>>
>> System.out.println(v1 + " <-->" + v2);
>> }
>> }
>> }
>> }
>>
>
>

Re: Make iterators cloneable?

[Jonathan Bluett-Duncan]

Hi Dave,

Rather than using Iterator.clone(), how about you just call
collection.iterator() 2 times to return 2 unique, non-same iterators;
something like the following:

import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Example {
  public static void main(String[] args) {
Set s = Collections.newSetFromMap(new
ConcurrentHashMap());

s.add("Fee");
s.add("Fi");
s.add("Fo");
s.add("Fum");

Iterator it1 = s.iterator();
for (String v1 = null; it1.hasNext(); v1 =it1.next()) {
  Iterator it2 = s.iterator(); // a completely separate
iterator to it1
  for (String v2 = null; it2.hasNext(); v2 = it2.next()) {
System.out.println(v1 + " <-->" + v2);
  }
}
  }
}


Or, even better, if you're using Java 5+, you can skip using Iterators
altogether and use for-loops directly:

import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Example {
  public static void main(String[] args) {
Set s = Collections.newSetFromMap(new
ConcurrentHashMap());

s.add("Fee");
s.add("Fi");
s.add("Fo");
s.add("Fum");

for (String v1 : s) {
  for (String v2 : s) {
System.out.println(v1 + "<-->" + v2);
  }
}
  }
}


Kind regards,
Jonathan

On 10 September 2016 at 23:13, Dave Brosius 
wrote:

> It would be nice to be able to associate each element in a collection with
> another element in the collection, which is something very easily done with
> index based collections, but with sets, etc this isn't so easy... unless
> i'm having a brainfart.
>
> So i'd like to do this, but Iterator doesn't implement Cloneable... Any
> reason not to? or is there another way that's missing me?
>
> public class ItClone {
>
> public static void main(String[] args) {
> Set s = Collections.newSetFromMap(new
> ConcurrentHashMap());
>
> s.add("Fee");
> s.add("Fi");
> s.add("Fo");
> s.add("Fum");
>
> Iterator it1 = s.iterator();
> while (it1.hasNext()) {
> String v1 = it1.next();
>
> Iterator it2 = (Iterator) it1.*clone*();
> while (it2.hasNext()) {
> String v2 = it2.next();
>
> System.out.println(v1 + " <-->" + v2);
> }
> }
> }
> }
>