Re: question
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
}
}
--
Lew