Re: Java Collections List : Converting from List '<Column <String1, String2>>' to 'List <String1>'

On 2/19/11 8:04 PM, asil klin wrote:


If the second method is already written and there is the literal
requirement that you pass a List<String> to it (I've never heard of the
"String1" type, so don't really know what that's supposed to mean, if
not simply a "String"), then I think you are pretty much stuck copying
the individual strings from your Column instance into the new
List<String> list.

Note that with a little effort, you can implement a .NET-like
"enumerable" solution, in which the new object need not actually copy
the entire data set, but rather simply "project" from the original.

In C#, it's very concise:

   void method2(IEnumerable<string> names)
   {
     foreach (string name in names)
     {
       // do something
     }
   }

where you call like this:

   List<Column> columns = ???; // initialized somehow

   method2(columns.Select(column => column.String1));

But you can accomplish much the same sort of thing, albeit with not
quite as concise a call site (but at least the entire collection doesn't
have to be duplicated). For example:

public interface Select<T, S>
{
     S select(T t);
}

public class Iterables
{
   public static <T, S> Iterable<S> Select(Iterable<T> source, Select<T,
S> select)
   {
       return new SelectIterable<T, S>(source, select);
   }

   private static class SelectIterable<T, S> implements Iterable<S>
   {
       private final Iterable<T> source;
       private final Select<T, S> select;

       public SelectIterable(Iterable<T> source, Select<T, S> select)
       {
           this.source = source;
           this.select = select;
       }

       @Override
       public java.util.Iterator<S> iterator()
       {
           return new Iterator(source.iterator());
       }

       private class Iterator implements java.util.Iterator<S>
       {
         private final java.util.Iterator<T> source;

         public Iterator(java.util.Iterator<T> source)
         {
             this.source = source;
         }

         @Override
         public boolean hasNext()
         {
             return source.hasNext();
         }

         @Override
         public S next()
         {
             return SelectIterable.this.select.select(source.next());
         }

         @Override
         public void remove()
         {
             throw new UnsupportedOperationException();
         }
       }
   }
}

public class Column
{
     private final String string1;
     private final String string2;

     public Column(String string1, String string2)
     {
         this.string1 = string1;
         this.string2 = string2;
     }

     public String getString1() { return string1; }
     public String getString2() { return string2; }
}

import java.util.ArrayList;
import java.util.List;

public class Main
{

     /**
      * @param args
      */
     public static void main(String[] args)
     {
         List<Column> columns = new ArrayList<Column>();

         columns.add(new Column("1", "A"));
         columns.add(new Column("2", "B"));
         columns.add(new Column("3", "C"));

         method2(Iterables.Select(columns, new Select<Column, String>()
             {
                public String select(Column column)
                {
                    return column.getString1();
                }
             }));
     }

     private static void method2(Iterable<String> names)
     {
         for (String name : names)
         {
             System.out.println(name);
         }
     }

}