Re: Java Collections List : Converting from List '<Column <String1,
String2>>' to 'List <String1>'
On 2/19/11 8:04 PM, asil klin wrote:
I have a function that returns a list like this:-
List<Column<String1, String2>>
Next I want to pass this list to a 2nd function, but 2nd function just needs a list which contains only 1st part (string1) of the Column(s) of the above list.
So I want pass just this list to 2nd function:-
List<String1>
What would be the best way to do this ??
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);
}
}
}