StringList is 1 of the newest composites starring in Processing 2.
It's based on Java's ArrayList , but specialized on String data-type only!
Here's its reference -> http://processing.org/reference/StringList.html

Unfortunately, only regular Arrays allow multiple item initialization within curly braces. 
However, you can use an Array to initialize your List! 
After that, you can append() and/or remove() entries from your List.

Check it out:

final String[] str = {"apple", "tomato", "banana"};

final StringList fruit_list = new StringList(str);

println(fruit_list);
println();

fruit_list.remove(1);  // removes "tomato".

fruit_list.append("orange");
fruit_list.append("pineapple");

println(fruit_list);
println();

println( fruit_list.get(1) );

exit();

Thank you for your answer.

Excellent answer above.
Here is a shortcut to the above syntax, if you want to avoid creating an array variable for the init:

1. StringList fruit_list = new StringList(new String[] { "Apricot", "Banana", "Citrus" });

Easy as your ABC (almost).

final just means, this variable is constant, meaning we can't change it later.
which is true for both str and StringList but looks confusing on StringList because we change the items later...

Greetings, Chrisir     

If you need an answer, please send me a personal message since this forum doesn't notify.

Keyword final -> http://processing.org/reference/final.html
It forces a variable to keep its stored value for its whole existence.

Both str & fruit_list are final variables. They store the reference pointers (memory addresses) from objects
{"apple", "tomato", "banana"};    &   new StringList(str);    respectively.

Thus, both str & fruit_list are forever bound to those object instances!
Any attempts to change them later cancels the program's compilation itself!

final String[] str = {"apple", "tomato", "banana"};

final StringList fruit_list = new StringList(str);

println(fruit_list);
println();

// FAILED: can't assign a new reference to final variable fruit_list!
fruit_list = new StringList(new String[] {"açaí", "mangosteen"});

// FAILED: can't even assign null to final variable str:
str = null;

println(fruit_list);
println();

exit();

Its usefulness is to ease debugging later.
Any programmer looking at your code knows he/she doesn't need to chase
after some later changes on that final variable. It's 1 less work to worry about! 

Also, declaring a field (or "global") primitive variable w/ final makes it a real constant.
Java compiler inlines its real value in place of that variable itself!

final float SQUARE_OF_TWO = 1.4142135;

// the code line below is compiled internally as literal number 7.07068
// rather than some (variable * 5) which has to be calculated later at runtime:
println(SQUARE_OF_TWO * 5); 

exit();

So there's a slightly performance gain by using final global primitives! 

Hi

Both fruit_list & str are "object" variables.
Their purpose is to store the initial physical memory addresses of object instances.
Memory addresses are also called pointers or references.

Java doesn't allow arithmetic calculations of any kind on memory addresses.
Actually, any kind of direct accesses at them either!

Object variable fruit_list stores a reference to StringList object instance.
Thus, you're allowed to use any methods from class StringList through fruit_list.

To obtain a String stored in a StringList, you have to use its method -> get():

final String str_item = fruit_list.get(1);

However, since str_item above is also an object variable which references a String object,
you can't use arithmetic operations on it either. 

Arithmetic operations are only for numerical variables and literals of it!