Daniel Moyne wrote:
Yes Peter what you suggest works but also thoses slightly different
versions work as well :
(a)
import java.util.Map;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.ArrayList;
public class map {
public static void main(String args[]) {
ArrayList<String>clonableDataList();
Map<Integer,ArrayList<String>>clonableDataMap=new
HashMap<Integer,ArrayList<String>>();
for (int i=0;i<3;i++) {
clonableDataList.add(Integer.toString(i));
clonableDataList.add(Integer.toString(i+1));
clonableDataMap.put(i,clonableDataList);
clonableDataList=new ArrayList<String>();
}
}
}
Actually, this one won't work. The line
ArrayList<String>clonableDataList();
won't compile, as it looks sort of like a declaration and sort of like a
method invocation. It's not legal Java.
Does the Map really need to genericize on ArrayList? List is usually a
better choice, and I see nothing here to compel the use of ArrayList.
You should use whitespace, e.g., between "ArrayList<String>" and the
variable (if that is what it is) "clonableDataList" being declared, and
around
operators like '='. It enhances readability and maintainability.
Why do you convert the integers to String instead of using them (boxed) in
the list?
Someone else pointed out that "map" is not a good name for a class. It is
confusingly similar to a standard API class, and it doesn't follow the
conventions.
(b)
import java.util.Map;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.ArrayList;
public class map {
public static void main(String args[]) {
ArrayList<String>clonableDataList;
Map<Integer,ArrayList<String>>clonableDataMap=new
HashMap<Integer,ArrayList<String>>();
for (int i=0;i<3;i++) {
clonableDataList=new ArrayList<String>();
clonableDataList.add(Integer.toString(i));
clonableDataList.add(Integer.toString(i+1));
clonableDataMap.put(i,clonableDataList);
}
}
}
this one looks much more normal, except that you declared clonableDataList
outside the loop, which is too wide a scope.
regarding the put action on the map adding all the time the pointer to
the list and not the modified content of this very same list as I
thought.
All non-primitive variables are simply references to objects, and
primitive variables can often be pretend-treated as if they were
references to the equivalent wrapper objects, a /very/ loose but sometimes
useful viewpoint.
Peter Fourneau wrote:
It's indeed better to create a new clonableDataList before going to
the next loop and not as first action of a new loop.
public class map {
public static void main(String args[]) {
ArrayList<String>clonableDataList=new ArrayList<String>();
Map<Integer,ArrayList<String>>clonableDataMap= new
HashMap<Integer,ArrayList<String>>();
for (int i=0;i<3;i++) {
clonableDataList.add(Integer.toString(i));
clonableDataList.add(Integer.toString(i+1));
clonableDataMap.put(i,clonableDataList);
clonableDataList=new ArrayList<String>();
}
}
}
so in this case, we don't create a unnecessary clonableDataList in the
first loop.
Huh?
You're creating it /before/ the loop, so where's the improvement? In
fact, you're increasing the scope of the variable this way, which can be a
Bad
Thing. You also now have two assignments statements in the source where
one would suffice.
Better to declare and initialize the variable inside the loop, which b)
above also got wrong as it only sets the variable inside the loop, not
declares it.
Even so, there is no "unnecessary" creation inside the loop, only
necessary
creation.
public class Mapper
{
public static void main( String [] args )
{
Map <Integer, List<String>> clonable
= new HashMap <Integer, List<String>> ();
for ( int i = 0; i < 3; i++ )
{
List <String> cl = new ArrayList<String>();
cl.add( i );
cl.add( i+1 );
clonable.put( i, cl );
}
// don't forget to do something useful with the Map here
}
}
my work.
----------------------------------------oOO-(_)-OOo--------------------------