Declaring a JavaScript Array: Variable Declaration

Let’s follow the format used in Chapter 4 and first look at how to define a data array using the JavaScript programming language. Then you see how to access this data using JavaScript dot notation (this works in Java as well) and how arrays can be represented using JSON. Similar to soft-object literal notation, you start the array data declaration with the var (variable) keyword and the name that you wish to use for your array, followed by an equals operator. Instead of the curly braces {...} used for defining objects, arrays use square brackets [...] instead. To define an array containing a used car dealership’s inventory, including make, model, color, and list price, you can create an array data structure where each data record is an object, with colon-delimited key:value pairs separated using commas, and with the object definitions themselves separated by commas within the array, which is defined using square brackets. Remember that attribute names and string values are contained in double quotes. The JavaScript code looks like the following array data definition:

var carInventory = [
    { "carName":"Toyota", "model":"Prius", "color":"Green", "price":24995 },
    { "carName":"Nissan", "model":"300ZX", "color":"Brown", "price":21795 },
    { "carName":"Dodge",  "model":"Viper", "color":"White", "price":26495 },
    { "carName":"Chevy",  "model":"Camaro", "color":"Blue", "price":27895 }
]

Now that you have defined an array of data objects, let’s look at how you access elements of arrays using the array name, element indices, object properties, and dot notation.

Accessing a JavaScript Array: Using the Index

Array data elements are accessed by using their indices, which are contained in square brackets just like the array itself. As you may imagine, the array name comes first, using an integer index specification, to specify which data record you wish to access. Then the dot-notation syntax is used to chain together that data record with the property name you wish to reference. The following example puts together a construct that accesses the first (carName) object attribute ("Toyota"):

carInventory[0].carName       // Will return the String value: "Toyota"

You can also concatenate data together using a plus operator and insert blank space using quotation mark delimiters with a space in between. The following example takes a carName object attribute and appends it to the model object attribute, creating the full car manufacturer and model name as a result ("Toyota Prius"):

carInventory[0].carName + " " + carInventory[0].model     // "Toyota Prius"

There’s an alternate way to access object attributes in an array data record, which does not use dot notation. This involves using the square brackets used with arrays to hold a quoted attribute name value. So instead of using arrayName[n].attributeName, you can use [n]["attributeName"], as shown in the following JavaScript code example:

carInventory[0]["carName"]   // Will also return the String value: "Toyota"

Again, you can concatenate data together using a plus operator and insert blank space using quotation mark delimiters with a space between them. This example takes a carName object attribute and appends it to the model object attribute, resulting in the manufacturer and model name ("Toyota Prius"):

carInventory[0]["carName"] +" "+ carInventory[0]["model"] // "Toyota Prius"

You can create constructs that access the array object data in whatever order suits your purpose. The following data-access example outputs a more descriptive formatting of the object data, perhaps for sales and marketing purposes:

carInventory[3].color   + " "   +
carInventory[3].carName + " "   +
carInventory[3].model   + ": $" +
carInventory[3].price             // Returns: "Blue Chevy Camaro: $27895"

This can also be represented using the alternate array object attribute data -access format, which uses the following JavaScript code syntax:

carInventory[3]["color"]   + " "   +
carInventory[3]["carName"] + " "   +
carInventory[3]["model"]   + ": $" +
carInventory[3]["price"]            // Returns: "Blue Chevy Camaro: $27895"

Next, let’s look at the syntax for defining an array using JSON. This is similar to the JavaScript approach but uses a colon instead of the equals operator and does not use the var (variable) keyword. After that, you look at how Java 8 provides JSON array and object libraries for handling the object and array structures you saw in the previous two chapters.

Defining a JSON Array: Using the Colon Operator

The basic format for JSON array data structures can be found on the json.org web site and uses square brackets to contain the data values, which are comma delimited (separated by commas). You saw this in the previous section, where you separated data objects using commas, with each object structure contained in curly braces. The basic JSON array format diagram, from json.org, is reproduced in Figure 5-1.

Figure 5-1. A JSON array is contained in square brackets and uses commas to separate values

A basic JSON array of number values thus uses the following data format:

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]

The name for a JSON array is contained in double quotation marks, using the colon operator between the JSON array name and the JSON array structure itself. Here is an example of how the array data structure from the previous section is created as a JSON array data definition structure:

"carInventory" : [
    { "carName":"Toyota", "model":"Prius", "color":"Green", "price":24995 },
    { "carName":"Nissan", "model":"300ZX", "color":"Brown", "price":21795 },
    { "carName":"Dodge",  "model":"Viper", "color":"White", "price":26495 },
    { "carName":"Chevy",  "model":"Camaro", "color":"Blue", "price":27895 }
]

Now that you’ve seen the two major JSON data structure types, objects and arrays, the next section presents an overview of the Java 8 programming language capabilities regarding JSON, and after that, you can proceed to the chapters covering numbers, characters and other data values.

JSON Object Model: Java Object and Array Builder

The JSON Object Model API is similar to the Document Object Model (DOM) API for XML or HTML5. The JSON Object Model is a high-level API that provides immutable object models for JSON object structures, which you learned about in Chapter 5; and JSON array structures, which you saw earlier in this chapter. These JSON structures are represented as Java object models using the Java types JSONObject and JSONArray.

The JSONObject class provides a Map object view to access an unordered collection of zero or more key:value pairs from a JSON data-object definition model. The JSONArray class provides a List object view to access an ordered sequence of zero or more values from a JSON data-array definition model.

The JSONObject, JSONArray, JSONString, and JSONNumber classes are subclasses, and therefore subtypes, of the JSONValue superclass. Constants are defined in this JSON API for null, true, and false JSON values, which are covered in Chapter 6. These are held in the JSONNull and JSONBoolean subclasses.

The JSON Object Model API uses builder patterns to create JSON object models from scratch. Application code can use the JSONObjectBuilder interface to create the JSON data-definition models that represent JSON objects. The resulting model is of the Object type JSONObject.

Application code can use the Java interface JSONArrayBuilder to create models that represent JSON Array Objects. The resulting model from this type of builder is of Object type JSONArray.

These object models can also be created using an input source (such as InputStream or Reader) using the Java interface JSONReader. Similarly, these object models can be written to an output source, such as OutputStream or Writer, using the Java class JSONWriter. These classes and interfaces are shown in Table 5-1, which lists the primary Java classes and Java interfaces contained in the JSON Object Model API for the Java programming language.

The next section presents a brief overview of the JSON Streaming Model API for Oracle Java.

The JSON Streaming Model: Parser and Generator

The JSON Streaming API is a low-level API that is designed to process very large amounts of JSON data efficiently. Other JSON frameworks (such as JSON binding) can also be implemented using this API. The JSON Streaming API is similar to the StAX XML Streaming API. The JSON Streaming API consists of the Java interface JSONParser as well as the Java interface JSONGenerator.

As you may have guessed, the JSONParser interface contains methods to parse JSON data using this JSON streaming model. The JSONGenerator interface contains methods for writing JSON data stream into an output source.

The JSONParserinterface provides forward-moving, sequential, read-only access to JSON data by using the pull-parsing programming model. In this model, your application code controls the thread and calls methods in the JSONParser interface to move the parser forward sequentially or, alternately, to obtain JSON data from the current state of this parser.

The JSONGenerator interface , on the other hand, provides Java methods to write JSON data out to a datastream. This interface should be used to write your key:value pairs into JSON objects and to write sequential data values into JSON arrays. The primary Java classes and interfaces contained in the JSON Streaming API are shown in Table 5-2; note that the JSON class spans both the object and streaming models.

Now that you have learned about JSON objects and arrays, you can examine the different types of data values that can be contained in these two types of JSON structures.