Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
682
String Functions
The String Functions section has seven functions that are helpful when working with
strings, including join(), which combines elements in an array into a string; nf(), which
formats numbers into strings; and split(), which separates a series of data within a string
into separate arrays of strings. Here’s a little example using the String function trim(),
which removes whitespace characters around strings:
String s1 = " Hi there, ";
String s2 = " bye now. ";
println(s1+s2);
s1 = trim(s1);
s2 = trim(s2);
println(s1+" "+s2);
Array Functions
The Array Functions section includes nine functions that allow you to manipulate arrays. In
Java, the size of an array can’t be changed once its length has been set. Values at specific
index positions within arrays can easily be changed—as in scores[3] = 23; or names[4]
= "Bella";—and there are ways of easily sorting and searching though arrays (see Java’s
Arrays class). However, in Java, if you want to change the length of an array, you need to
copy the contents of the array into a new array that has been initialized with the new
desired length (too much work). I’ll provide an example of this process later in this section.
There are two additional classes in Java, ArrayList and Vector, that (sort of) function as
mutable arrays, in that they can dynamically change size. However, using these more complex
structures necessitates converting data types (type casting, which I discussed a couple
paragraphs back), and also requires some extra syntax (which I’m not going to cover here).
To learn more about Java’s mutable array structures, check out http://java.sun.com/
j2se/1.4.2/docs/api/java/util/Vector.html.
Processing arrays, in conjunction with the array functions, are a hybrid solution—retaining
the simplicity of using a standard Java array while also providing the ability to modify the
array (including altering its length), similar to Java’s ArrayList and Vector classes.
Processing’s array functions include append() and shorten(), which respectively add or
subtract data to or from the end of an array, changing the array’s length by one position;
splice(), which adds a single value or an entire array of values into an array at a specific
index position, also changing the length of the array by the number of total values added;
and subset(), which extracts an array of elements out of an array at a specific index position.
The subset() function doesn’t affect the initial array.
In the following sections, I’ve included some example implementations of an append()
function. The first sketch example demonstrates the long way to append, as you might
using Java arrays. The second example uses Processing’s built-in append() function. Finally,
the third example uses Processing’s append() function again, but with an array full of
object references instead of primitive values.