Home > Articles > Programming > Java

  • Print
  • + Share This
This chapter is from the book


Sequences are ordered lists of objects. Because ordered lists are used so often in programming, JavaFX supports sequence as a first class feature. There is built-in support in the language for declaring sequences, inserting, deleting, and modifying items in the sequence. There is also powerful support for retrieving items from the sequence.

Declaring Sequences

To declare a sequence, use square brackets with each item separated by a comma. For example:

public def monthNames = ["January", "February", "March",
                     "April", "May", "June",
                     "July", August", "September",
                     "October", "November", "December"];

This sequence is a sequence of Strings, because the elements within the brackets are Strings. This could have also been declared as

public def monthNames: String[] = [ "January", .....];

To assign an empty sequence, just use square brackets, []. This is also the default value for a sequence. For example, the following two statements both equal the empty sequence.

public var nodes:Node[] = [];

public var nodes:Node[];

When the sequence changes, you can assign a trigger function to process the change. This is discussed in depth in the next chapter.

A shorthand for declaring a sequence of Integers and Numbers uses a range, a start integer or number with an end. So, [1..9] is the sequence of the integers from 1 thru 9, inclusive; the exclusive form is [1..<9]—that is, 1 through 8. You can also use a step function, so if, for example, you want even positive integers, use [2..100 step 2]. For numbers, you can use decimal fractions, [0.1..1.0 step 0.1]. Without the step, a step of 1 or 1.0 is implicit.

Ranges may also go in decreasing order. To do this, the first number must be higher than the second. However, without a negative step function, you always end up with an empty sequence. This is because the default step is always positive 1.

var negativeNumbers = [0..-10]; // Empty sequence
var negativeNumbers = [0..-10 step -1]; // 0,-1,-2,...-10
var negativeNumbers = [0..<-10 step -1]; // 0,-1,-2,...,-9

To build sequences that include the elements from other sequences, just include the source sequences within the square brackets.

var negativePlusEven = [ negativeNumbers, evenNumbers ];

Also, you can use another sequence to create a sequence by using the Boolean operator. Another sequence is used as the source, and a Boolean operator is applied to each element in the source sequence, and the elements from the source that evaluate to true are returned in the new sequence. In the following example, n represents each item in the sequence of positive integers and n mod 2 == 0 is the evaluation.

var evenIntegers = positiveIntegers[n | n mod 2 == 0];

One can also allocate a sequence from a for loop. Each object “returned” from the iteration of the for loop is added to the sequence:

// creates sequence of Texts
var lineNumbers:Text[] = for(n in [1..100]) {
      Text { content: "{n}" };

// creates Integer sequence, using indexof operator
var indexNumbers = for(n in nodes) {
      indexof n;

To get the current size of a sequence use the sizeof operator.

var numEvenNumbers = sizeof evenNumbers;

Accessing Sequence Elements

To access an individual element, use the numeric index of the element within square brackets:

var firstMonth =  monthNames[0];

You can also take slices of sequence by providing a range. Both of the next two sequences are equal.

var firstQuarter = monthNames[0..2];

var firstQuarter = monthNames[0..<3];

The following two sequences are also equal. The second example uses a syntax for range to indicate start at an index and return all elements after that index.

var fourthQuarter = monthNames[9..11 ];

var fourthQuarter = monthNames[9.. ];

To iterate over a sequence, use the for loop:

for( month in monthNames) {

Modifying Sequences

To replace an element in a sequence, just assign a new value to that indexed location in the index.

var students = [ "joe", "sally", "jim"];
students[0] = "vijay";

To insert an element into the sequence, use the insert statement:

// add "vijay" to the end of students
insert "vijay" into students;

// insert "mike" at the front of students
insert "mike" before students[0];

// insert "george" after the second student
insert "george" after students[1];

To delete an element, use the delete statement:

delete students[0]; // remove the first student
delete students[0..1]; // remove the first 2 students
delete students[0..<2]; // remove the first 2 students
delete students[1..]; // remove all but the first student
delete "vijay" from students;
delete students; // remove all students

Native Array

Native array is a feature that allows you to create Java arrays. This feature is mainly used to handle the transfer of arrays back and forth from JavaFX and Java. An example of creating a Java int[] array is shown in the following code.

var ints: nativearray of Integer =
               [1,2,3] as nativearray of Integer;

Native arrays are not the same as sequences, though they appear similar. You cannot use the sequence operators, such as insert and delete, or slices. However, you can do assignments to the elements of the array as shown in the following code:

ints[2] = 4;

However, if you assign outside of the current bounds of the array, you will get an ArrayIndexOutOfBounds Exception.

You can also use the for operator to iterate over the elements in the native array. The following code shows an example of this.

for(i in ints) {
for(i in ints where i mod 2 == 0) {
  • + Share This
  • 🔖 Save To Your Account