Why not

   for (String elem: vec) {
       String [] carac = elem.split( "," );

Each new `Especie` will have /the same/ `inter` array passed to it.

If all you do is copy the reference to the array, then they'll all
share the same array, so they'll all look like the most recent
update.

There is nothing wrong with it. The problem is with the handling of
inter. You are adding distinct Especie references, but all instances are
created referencing the same instance of inter.

You first need to decide on the rules for the constructor parameter. Is
the caller allowed to change the contents of the array after the
constructor call?

If yes, then the Especie constructor needs to make its own copy of the
array contents before returning, e.g. by creating a new array and using
System.arraycopy.

If no, then the code you quoted should create a new array instance for
each Especie creation.

Patricia

Actually, it looks like you pass in the same inter object to all the
especie objects.
you need to have int inter[] = new int[17] inside your vectsize loop.

Other tips:
When posting code on usenet, try to keep tab size to between 2 and 4 spaces.
Array syntax is better expressed "int[] inter" in Java.

Unless you absolutely need to, don't declare return types or parameters
as ArrayList, or other specialized collections, use the most generic
interface that makes sense.

Also, use the for each construct when appropriate.

public List<Especie> parse(Collection<String> strings) {
  List<Especie> parsed = new ArrayList<Especie>(strings.size());
  for (String string: strings) {
    int[] values = new int[17];
    String[] tokens = string.split(",");
    for (int i = 0; i < 17; ++i) {
      values[i] = Integer.parseInt(tokens[i+1]);
    }
    parsed.add(new Especie(values));
  }
  return parsed;
}

Further design suggestions:

This assumes good form on your input. That is especially dangerous when
dealing with String input.  You might verify that string.split(",")
actually returns 18 tokens, or instead of passing in an int[], use a
List<Integer>, which allows for different sized inputs.

It might also make sense to put the parsing logic into Especie itself.
Create what is called a factory method:
class Especie {
  public static Especie parse(String string) {
    String[] tokens = string.split(",");
    if (tokens.length < 18) {
      throw new IllegalArgumentException("Not enough commas");
    }
    int[] values = new int[17];
    for (int i = 0; i < 17; ++i) {
      values[i] = Integer.parseInt(tokens[i+1]);
    }
    return new Especie(values);
  }
}

Then your other parse loop becomes:

public List<Especie> parse(Collection<String> strings) {
  List<Especie> parsed = new ArrayList<Especie>(strings.size());
  for (String string: strings) {
    parsed.add(Especie.parse(string));
  }
  return parsed;
}

Hope at least some of these suggestions help you out.

On Tue, 20 Nov 2007 05:31:18 -0800 (PST), "Marcel.luchi"
<marcel.luchi@gmail.com> wrote, quoted or indirectly quoted someone
who said :

the problem is type erasure.  Especie becomes Object at run time.
There in no constructor Object ( inter );

see http://mindprod.com/jgloss/generics.html

to create new objects of a variable type requires some fancy footwork,
e.g. by passing a class object and using newInstance or reflection.

Array created here. This happens only once.

Array updated for each loop iteration.

Same array passed to all constructors. The array is changed
after the object is created.

...

Probably not. The Especie objects are different, but my guess is that
the Especie(int[]) constructor *stores* the int array.
Then the next iteration changes the values of that int array, and
alos passes it to a new constructor.

Try copying (e.g., cloning) the array in the constructor instead of
storing the original argument.

All that is wrong is that the "inter" array is the same array for all
calls. The data in it will eventually be the data set by the last
iteration.

/L