im not quite sure what you trying to achieve.

but maybe this is what you want:

1. String my_string = "a,b,c,d,e,f,g,h";
2. ArrayList<String> my_list = new ArrayList<String>( Arrays.asList(my_string.split(",")) );

Yes, that is what i'm searching for:

an arraylist is only faster if you need to add/remove/insert elements (to dynamically change the size of the array).
if you know the exact size, and dont need to add elements, its allways faster to use a normal array.
also, the shorter for-loop you mentioned is a little bit slower, than the usual forloop.
i have no idea whats the reason for  this, but you can compare this, my printing out the milliseconds.

1. int elements = 10000000;
2. int timer = 0;
3. 
   
4. ArrayList<String> objects = new ArrayList<String>(elements);
5. for (int i = 0; i < elements; i++ )
6.   objects.add("hello");
7. 
   
8. 
   
9. timer = millis();
10. for (int i = 0; i < elements; i++ ) {
11.   String tmp = objects.get(i);
12. }
13. println("usual for-loop: time for "+elements+ " elements: " + (millis()-timer)); // 469 ms on my machine
    
14. 
    
15. 
    
16. timer = millis();
17. for ( String s : objects) {
18.   String tmp = s;
19. }
20. println("short for-loop: time for "+ elements+ " elements: " + (millis()-timer));  // 1125 ms on my machine

Beware of such micro-benchmark. Often, the compiler can compile away some code it sees as no-op, and either the JIT compiler hasn't time to kick in, or it might optimize away other code...
For reliable benchmarks, I now use Caliper (at GoogleCode). It avoids such pitfalls and ease testing.
I made a little bench, with the following code:

1. class BenchmarkTester
2. {
3.   public static final int SIZE = 10000;
4.   public ArrayList<String> stuff = new ArrayList<String>(SIZE);
5.   public void init()
6.   {
7.     System.out.println("Init");
8.     for (int i = 0; i < SIZE; i++)
9.     {
10.       stuff.add("Test " + i);
11.     }
12.   }
13.   public boolean check1()
14.   {
15.     StringBuilder sb = new StringBuilder();
16.     for (int i = 0; i < SIZE; i++)
17.     {
18.       String el = stuff.get(i);
19.       sb.append(el);
20.     }
21. //~     return true;
22.     return sb.length() > 0;
23.   }
24.   public boolean check2()
25.   {
26.     StringBuilder sb = new StringBuilder();
27.     for (int i = 0; i < stuff.size(); i++)
28.     {
29.       String el = stuff.get(i);
30.       sb.append(el);
31.     }
32. //~     return true;
33.     return sb.length() > 0;
34.   }
35.   public boolean check3()
36.   {
37.     StringBuilder sb = new StringBuilder();
38.     for (int i = 0, s = stuff.size(); i < s; i++)
39.     {
40.       String el = stuff.get(i);
41.       sb.append(el);
42.     }
43. //~     return true;
44.     return sb.length() > 0;
45.   }
46.   public boolean check4()
47.   {
48.     StringBuilder sb = new StringBuilder();
49.     for (String str : stuff)
50.     {
51.       String el = str;
52.       sb.append(el);
53.     }
54. //~     return true;
55.     return sb.length() > 0;
56.   }
57. }

and the corresponding Caliper code test.
I tested with and without the StringBuilder code.

Indeed, without it, the for-each loop takes roughly twice the time of the pure numerical loop.
 0% Scenario{vm=java, trial=0, benchmark=Checking1} 108278,19 ns; ?=712,28 ns @ 3 trials
25% Scenario{vm=java, trial=0, benchmark=Checking2} 113503,43 ns; ?=1079,27 ns @ 9 trials
50% Scenario{vm=java, trial=0, benchmark=Checking3} 108921,51 ns; ?=981,37 ns @ 3 trials
75% Scenario{vm=java, trial=0, benchmark=Checking4} 270592,54 ns; ?=5980,26 ns @ 10 trials

benchmark  us logarithmic runtime
Checking1 108 =
Checking2 114 ==
Checking3 109 =
Checking4 271 ==============================

But with it, the time spent in the loop logic is reduced with regard to the overall time to do a loop, and the advantage is reduced.
 0% Scenario{vm=java, trial=0, benchmark=Checking1} 569319,86 ns; ?=5852,04 ns @ 10 trials
25% Scenario{vm=java, trial=0, benchmark=Checking2} 567657,56 ns; ?=4089,58 ns @ 3 trials
50% Scenario{vm=java, trial=0, benchmark=Checking3} 567690,92 ns; ?=5310,11 ns @ 3 trials
75% Scenario{vm=java, trial=0, benchmark=Checking4} 721832,85 ns; ?=4979,20 ns @ 3 trials

benchmark  us logarithmic runtime
Checking1 569 =
Checking2 568 =
Checking3 568 =
Checking4 722 ==============================

In general, you do more or less complex stuff in a loop, so the time spent in the loop logic is probably neglectful.
Often, the advantage of the advanced loop syntax override the loss of time.
Note that some other structures, like LinkedList, might even be faster with such loop (as we keep a current position in the list).

Thanks for the tips!

Arraylist.add() is much faster than processings append, but basically they do the same.

to add elements to an existing array, they both (add(), and append())  have to generate a new array, and then copy the old array to the new.

the difference is, an arraylist increases its intern array-size blockwise (buffered) ... append() only increases the array by one element., ... so, the more elements you are adding, the more time you waste by using processings append().

there is another processing function called expand() which is more like an arraylists add() function, because you can increase the array blockwise.