XML (eXtensible Markup Language) is a meta-language for defining vocabularies (custom markup languages), which is the key to XML’s importance and popularity.

The answer is true: XML and HTML are descendants of SGML.

XML provides the XML declaration, elements and attributes, character references and CDATA sections, namespaces, and comments and processing-instruction language features for use in defining custom markup languages.

The XML declaration is special markup that informs an XML parser that the document is XML.

The XML declaration’s three attributes are version, encoding, and standalone. The version attribute is nonoptional.

The answer is false: an element can consist of the empty-element tag, which is a standalone tag whose name ends with a forward slash (/), such as <break/>.

Following the XML declaration, an XML document is anchored in a root element.

Mixed content is a combination of child elements and content.

A character reference is a code that represents a character. The two kinds of character references are numeric character references (such as Σ) and character entity references (such as <).

A CDATA section is a section of literal HTML or XML markup and content surrounded by the <![CDATA[ prefix and the ]]> suffix. You would use a CDATA section when you have a large amount of HTML/XML text and don’t want to replace each literal < (start of tag) and & (start of entity) character with its < and & predefined character entity reference, which is a tedious and possibly error-prone undertaking—you might forget to replace one of these characters.

A namespace is a Uniform Resource Identifier-based container that helps differentiate XML vocabularies by providing a unique context for its contained identifiers.

A namespace prefix is an alias for a URI.

The answer is true: a tag’s attributes don’t need to be prefixed when those attributes belong to the element.

A comment is a character sequence beginning with <!-- and ending with -->. It can appear anywhere in an XML document except before the XML declaration, except within tags, and except within another comment.

A processing instruction is an instruction that’s made available to the application parsing the document. The instruction begins with <? and ends with ?>.

The rules that an XML document must follow to be considered well formed are as follows: all elements must either have start and end tags or consist of empty-element tags, tags must be nested correctly, all attribute values must be quoted, empty elements must be properly formatted, and you must be careful with case. Furthermore, XML parsers that are aware of namespaces enforce two additional rules: all element and attribute names must not include more than one colon character; and no entity names, processing-instruction targets, or notation names can contain colons.

For an XML document to be valid, the document must adhere to certain constraints. For example, one constraint might be that a specific element must always follow another specific element.

The two common grammar languages are Document Type Definition and XML Schema.

The general syntax for declaring an element in a DTD is <!ELEMENT name content-specifier>.

XML Schema lets you create complex types from simple types.

Listing A-1 presents the books.xml document file that was called for in Chapter 1.

Listing A-2 presents the books.xml document file with an internal DTD that was called for in Chapter 1.

SAX is an event-based Java API for parsing an XML document sequentially from start to finish. As a SAX-oriented parser encounters an item from the document’s infoset, it makes this item available to an application as an event by calling one of the methods in one of the application’s handlers, which the application has previously registered with the parser. The application can then consume this event by processing the infoset item in some manner.

You obtain a SAX 2-based parser by obtaining a SAXParserFactory instance , then configuring this instance, then returning a SAXParser instance from the SAXParserFactory, and finally returning an XMLReader instance from the SAXParser.

The purpose of the XMLReader interface is to describe a SAX 2 parser. This interface makes available several methods for configuring the SAX 2 parser and parsing an XML document’s content.

You tell a SAX parser to perform validation by invoking XMLReader’s setFeature(String name, boolean value) method, passing " http://xml.org/sax/features/validation " to name and true to value.

The four kinds of SAX-oriented exceptions that can be thrown when working with SAX are SAXException, SAXNotRecognizedException, SAXNotSupportedException, and SAXParseException.

The interface that a handler class implements to respond to content-oriented events is ContentHandler.

The three other core interfaces that a handler class is likely to implement are DTDHandler, EntityResolver, and ErrorHandler.

Ignorable whitespace is whitespace located between tags where the DTD doesn’t allow mixed content.

The answer is false: void error(SAXParseException exception) is called only for recoverable errors.

The purpose of the DefaultHandler class is to serve as a convenience base class for SAX 2 applications. It provides default implementations for all of the callbacks in the four core SAX 2 handler interfaces: ContentHandler, DTDHandler, EntityResolver, and ErrorHandler.

An entity is aliased data. An entity resolver is an object that uses the public identifier to choose a different system identifier. Upon encountering an external entity, the parser calls the custom entity resolver to obtain this identifier.

Listing A-3 presents the DumpUserInfo application that was called for in Chapter 2.

Listings A-4 and A-5 present the SAXSearch and Handler classes that were called for in Chapter 2.

When you use Listing 2-1’s SAXDemo application to validate Exercise A-22’s books.xml content against its DTD, you should observe no validation errors.

DOM is a Java API for parsing an XML document into an in-memory tree of nodes and for creating an XML document from a tree of nodes. After a DOM parser has created a document tree, an application uses the DOM API to navigate over and extract infoset items from the tree’s nodes.

The answer is false: Java 11 supports DOM Levels 1, 2, and 3.

The 12 types of DOM nodes are attribute node, CDATA section node, comment node, document node, document fragment node, document type node, element node, entity node, entity reference node, notation node, processing-instruction node, and text node.

You obtain a document builder by first instantiating DocumentBuilderFactory via one of its newInstance() methods and then invoking newDocumentBuilder() on the returned DocumentBuilderFactory object to obtain a DocumentBuilder object.

You use a document builder to parse an XML document by invoking one of DocumentBuilder’s parse() methods.

The answer is true: Document and all other org.w3c.dom interfaces that describe different kinds of nodes are subinterfaces of the Node interface.

You use a document builder to create a new XML document by invoking DocumentBuilder’s Document newDocument() method and by invoking Document’s various “create” methods.

You would determine if a node has children by calling Node’s boolean hasChildNodes() method , which returns true when a node has child nodes.

The answer is false: when creating a new XML document, you cannot use the DOM API to specify the XML declaration’s encoding attribute.

The purpose of the Load and Save API is to provide a standard way to load XML content into a new DOM tree and save an existing DOM tree to an XML document.

The difference between NodeIterator and TreeWalker is as follows: A NodeIterator presents a flattened view of the subtree as an ordered sequence of nodes, presented in document order. Conversely, a TreeWalker maintains the hierarchical relationships of the subtree, allowing navigation of this hierarchy.

The difference between Range’s selectNode() and selectNodeContents() methods is as follows: selectNode() selects a node and its contents, whereas selectNodeContents() selects the contents within a node (without also selecting the node).

Listing A-6 presents the DumpUserInfo application that was called for in Chapter 3.

Listing A-7 presents the DOMSearch application that was called for in Chapter 3.

Listing A-8 presents the DOMValidate application that was called for in Chapter 3.

Listing A-9 presents the DOMDemo application that was called for in Chapter 3.

StAX is a Java API for parsing an XML document sequentially from start to finish and also for creating XML documents.

The javax.xml.stream, javax.xml.stream.events, and javax.xml.stream.util packages make up the StAX API.

The answer is false: an event-based reader extracts the next infoset item from an input stream by obtaining an event.

You obtain a document reader by calling one of the various “create” methods that are declared in the XMLInputFactory class. You obtain a document writer by calling one of the various “create” methods that are declared in the XMLOutputFactory class.

When you call XMLOutputFactory’s void setProperty(String name, Object value) method with XMLOutputFactory.IS_REPAIRING_NAMESPACES as the property name and true as the value, the document writer takes care of all namespace bindings and declarations, with minimal help from the application. The output is always well formed with respect to namespaces.

Listing A-10 presents the ParseXMLDoc application that was called for in Chapter 4.

XPath is a nonXML declarative query language (defined by the W3C) for selecting an XML document’s infoset items as one or more nodes.

XPath is commonly used to simplify access to a DOM tree’s nodes and in the context of XSLT to select those input document elements (via XPath expressions) that are to be copied to an output document.

The seven kinds of nodes that XPath recognizes are element, attribute, text, namespace, processing instruction, comment, and document.

The answer is false: XPath doesn’t recognize CDATA sections.

XPath provides location path expressions for selecting nodes. A location path expression locates nodes via a sequence of steps starting from the context node, which is the root node or some other document node that is the current node. The returned set of nodes might be empty, or it might contain one or more nodes.

The answer is true: in a location path expression, you must prefix an attribute name with the @ symbol.

The functions that XPath provides for selecting comment, text, and processing-instruction nodes are comment(), text(), and processing-instruction().

XPath provides wildcards for selecting unknown nodes. The * wildcard matches any element node regardless of the node’s type. It doesn’t match attributes, text nodes, comments, or processing-instruction nodes. When you place a namespace prefix before the *, only elements belonging to that namespace are matched. The node() wildcard is a function that matches all nodes. Finally, the @* wildcard matches all attribute nodes.

You perform multiple selections by using the vertical bar (|). For example, author/*|publisher/* selects the children of author and the children of publisher.

A predicate is a square bracket-delimited Boolean expression that’s tested against each selected node. If the expression evaluates to true, that node is included in the set of nodes returned by the XPath expression; otherwise, the node isn’t included in the set.

The functions that XPath provides for working with nodesets are last(), position(), id(), local-name(), namespace-uri(), and name().

The three advanced features that the XPath API provides to overcome limitations with the XPath 1.0 language are namespace contexts, extension functions and function resolvers, and variables and variable resolvers.

The answer is false: the XPath API maps XPath’s number type to java.lang.Double.

Listings A-11 and A-12 present the contacts.xml document file and XPathSearch application that were called for in Chapter 5.

XSLT is a family of languages for transforming and formatting XML documents.

XSLT accomplishes its work by using XSLT processors and stylesheets. An XSLT processor is a software component that applies an XSLT stylesheet to an input document (without modifying the document), and copies the transformed result to a result tree, which can be output to a file or output stream, or even piped into another XSLT processor for additional transformations.

The answer is false: call Transformer’s void transform(Source xmlSource, Result outputTarget) method to transform a source to a result.

Listings A-13 and A-14 present the books.xsl document stylesheet file and MakeHTML application that were called for in Chapter 6.

JSON (JavaScript Object Notation) is a language-independent data format that expresses JSON objects as human-readable lists of properties.

The answer is false: JSON is derived from a nonstrict subset of JavaScript.

The JSON data format presents a JSON object as a brace-delimited and comma-separated list of properties.

The six types that JSON supports are number, string, Boolean, array, object, and null.

The answer is true: JSON doesn’t support comments.

You would parse a JSON object into an equivalent JavaScript object by calling the JSON object’s parse() method with the text to be parsed as this method’s argument.

JSON Schema is a grammar language for defining the structure, content, and (to some extent) semantics of JSON objects.

When creating a schema, you identify those properties that must be present in those JSON objects that the schema validates by placing their names in the array that’s assigned to the schema’s required property name.

Listing A-15 presents the JSON object that was called for in Chapter 7.

Listing A-16 presents the schema that was called for in Chapter 7.

mJson is a small Java-based JSON library for parsing JSON objects into Java objects and vice versa.

The Json class describes a JSON object or part of a JSON object. It contains Schema and Factory interfaces, more than 50 methods, and other members.

Json’s methods for reading and parsing external JSON objects are Json read(String s), Json read(URL url), and Json read(CharacterIterator ci).

The answer is true: the read() methods can also parse smaller JSON fragments, such as an array of different-typed values.

The methods that Json provides for creating JSON objects are Json array(), Json array(Object... args), Json make(Object anything), Json nil(), Json object(), and Json object(Object... args).

Json’s boolean isPrimitive() method returns true when the invoking Json object describes a JSON number, string, or Boolean value.

You return a Json object’s JSON array by calling List<Json> asJsonList() to return a list of Json objects (one per array element) or by calling List<Object> asList() to return a list of Java objects (each object describes one of the elements).

The answer is false: Json’s Map<String, Object> asMap() method returns a map of the properties of a Json object that describes a JSON object. The returned map is a copy, and modifications to it don’t affect the Json object.

Json’s Json at(int index), Json at(String propName), Json at(String propName, Json defValue), and Json at(String propName, Object defValue) methods let you access the contents of arrays and objects.

Json’s boolean is(int index, Object value) method returns true when this Json object describes a JSON array that has the specified value at the specified index; otherwise, it returns false.

When you attempt to set the value for a nonexistent array element, Json throws IndexOutOfBoundsException.

The difference between Json’s atDel() and delAt() methods is as follows: the atDel() methods return the removed array element or object property, whereas the delAt() methods do not return the removed array element or object property.

Json’s Json with(Json objectorarray) method combines this Json object’s JSON object or JSON array with the argument passed to objectorarray. The JSON type of this Json object and the JSON type of objectorarray must match. If objectorarray identifies a JSON object, all of its properties are appended to this Json object’s object. If objectorarray identifies a JSON array, all of its elements are appended to this Json object’s array.

Json’s methods for obtaining a Json.Schema object are Json.Schema schema(Json jsonSchema), Json.Schema schema(Json jsonSchema, URI uri), and Json.Schema schema(URI uri).

You validate a JSON document against a schema by calling Json.Schema’s Json validate(Json document) method with the JSON document passed as a Json argument to this method.

The difference between Json’s setGlobalFactory() and attachFactory() methods is that setGlobalFactory() installs the specified factory as a global factory, which is used by all threads that don’t have a specific thread-local factory attached to them, whereas attachFactory() attaches the specified factory to the invoking thread only.

The Json dup() method returns a clone (a duplicate) of this Json entity. The String pad(String callback) method wraps a function named callback around the JSON object described by the current Json object. This is done for the reason explained in Wikipedia’s “JSONP” entry ( https://en.wikipedia.org/wiki/JSONP ).

Listing A-17 presents the mJsonDemo application that was called for in Chapter 8.

Gson is a small Java-based library for parsing and creating JSON objects. Google developed Gson for its own projects, but later made Gson publicly available, starting with version 1.0.

Gson’s packages are com.google.gson (provides access to Gson, the main class for working with Gson), com.google.gson.annotations (provides annotation types for use with Gson), com.google.gson.reflect (provides a utility class for obtaining type information from a generic type), and com.google.gson.stream (provides utility classes for reading and writing JSON-encoded values).

The two ways to obtain a Gson object are to call the Gson() constructor or to invoke the create() method on a GsonBuilder object.

The types for which Gson provides default serialization and deserialization are java.lang.Enum, java.util. Map , java.net . URL , java.net . URI , java.util. Locale , java.util. Date , java.math. BigDecimal , and java.math. BigInteger .

You would enable pretty-printing by calling GsonBuilder’s setPrettyPrinting() method .

The answer is true: by default, Gson excludes transient or static fields from consideration for serialization and deserialization.

Once you have a Gson object, you can call various fromJson() and toJson() methods to convert between JSON and Java objects.

You use Gson to customize JSON object parsing by implementing the JsonDeserializer<T> interface , instantiating an object from the implementation, and registering with Gson the deserializer object along with the class object of the Java class whose objects are to be serialized/deserialized.

The JsonElement class represents a JSON element (such as a number, a Boolean value, or an array). It provides various methods for obtaining an element value, such as double getAsDouble(), boolean getAsBoolean(), and JsonArray getAsJsonArray().

The JsonElement subclasses are JsonArray, JsonNull, JsonObject, and JsonPrimitive.

You call GsonBuilder’s GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) method to register a serializer or deserializer with a Gson object.

JsonSerializer provides the JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context) method to serialize a Java object to a JSON object.

Gson provides the Expose, JsonAdapter, SerializedName, Since, and Until annotation types to simplify serialization and deserialization.

The answer is false: to use Expose, it’s not enough to annotate a field, as in @Expose(serialize = true, deserialize = false). You also have to call GsonBuilder’s GsonBuilder excludeFieldsWithoutExposeAnnotation() method.

JsonSerializationContext and JsonDeserializationContext provide access to methods for performing default serialization and default deserialization, which are handy when dealing with nested arrays and objects that don’t require special treatment.

The answer is false: you can call <T> T fromJson( String json, Class <T> classOfT) to deserialize nongeneric objects (i.e., objects created from nongeneric classes) only.

You should prefer TypeAdapter to JsonSerializer and JsonDeserializer because TypeAdapter is more efficient. Unlike JsonSerializer and JsonDeserializer , which are associated with an intermediate layer of code that converts Java and JSON objects to JsonElements, TypeAdapter doesn’t perform this conversion.

Listing A-18 presents the GsonDemo application that was called for in Chapter 9.

JsonPath is a declarative query language (also known as a path-expression-syntax) for selecting and extracting a JSON document’s property values.

The answer is false: JsonPath is based on XPath 1.0.

The operator that represents the root JSON object is $.

You can specify JsonPath expressions in dot notation and square bracket notation.

The @ operator represents the current node being processed by a filter predicate.

The answer is false: JsonPath’s deep scan operator (..) is equivalent to XPath’s // symbol.

JsonPath’s JsonPath compile(String jsonPath, Predicate... filters) static method compiles the JsonPath expression stored in the jsonPath-referenced string to a JsonPath object (to improve performance when JsonPath expressions are reused). The array of predicates is applied to ? placeholders appearing in the string.

The return type of the <T> T read(String json) generic method that returns JSON object property names and their values is LinkedHashMap.

The three predicate categories are inline predicates, filter predicates, and custom predicates.

Listing A-19 presents the JsonPathDemo application that was called for in Chapter 10.

Jackson is a suite of data-processing tools for Java. These tools include a streaming JSON parser/generator library, a matching data-binding library (for converting Plain Old Java Objects [POJOs] to and from JSON), and additional data format modules for processing data encoded in XML and other formats.

Jackson’s packages include Jackson Core (com.fasterxml.jackson.core), Jackson Databind (com.fasterxml.jackson.databind), and Jackson Annotations (com.fasterxml.jackson.annotation).

The answer is false: Jackson supports simple data binding and full (also known as POJO) data binding.

Streaming in Jackson deserializes (reads) and serializes (writes) JSON content as discrete events. Reading is performed by a parser that tokenizes JSON content into tokens and associated data; writing is performed by a generator that constructs JSON content based on a sequence of calls that output JSON tokens.

The answer is false: streaming is the most efficient way to process JSON content.

You create a stream-based parser by instantiating the JsonFactory class and invoking one of this class’s overloaded createParser() methods on the instance to obtain a JsonParser instance.

After you obtain a parser, you enter a loop that repeats until the parser’s isClosed() method returns true. Each loop iteration invokes JsonParser’s nextToken() method, which returns a JsonToken object that identifies the next token from the JSON content. You can interrogate this object to obtain additional information about the token and then take appropriate action.

You create a stream-based generator by instantiating the JsonFactory class and invoking one of this class’s overloaded createGenerator() methods on the instance to obtain a JsonGenerator instance.

After you obtain a generator, you invoke JsonGenerator methods such as writeStartObject() and writeStringField() to output JSON content. You complete this task by invoking JsonGenerator’s close() method.

The answer is true: the tree model provides a mutable in-memory tree representation of a JSON document.

The ObjectMapper class is used to start building a tree. The tree’s nodes are instances of classes that descend from the abstract JsonNode class.

You read a JSON document into an in-memory tree by invoking one of ObjectMapper’s readTree() methods .

The difference between JsonNode get(int index) and JsonNode path(int index) is that get() returns null for a missing value, whereas path() returns a MissingNode reference for a missing value.

You write a tree to a JSON document by invoking one of ObjectMapper’s writeTree() methods .

Data binding in Jackson is parsing JSON content to and from Java objects such as POJOs. JSON content is deserialized into Java objects, and Java objects are serialized into JSON content.

The purpose of the TypeReference class is to pass a generic type definition (removed by type erasure) to one of ObjectMapper’s readValue() methods.

Simple data binding differs from full data binding in that simple data binding converts to and from a limited number of core JDK types, whereas full data binding also converts to and from any Java bean type.

By default, Jackson maps the fields of a JSON object to fields in a Java object by matching the names of the JSON fields to the getter and setter methods in the Java object. Jackson removes the get and set parts of the names of the getter and setter methods and converts the first character of the remaining name to lowercase.

The answer is false: a getter method makes a non-public field serializable and deserializable.

Jackson’s read-only annotation types are JsonSetter, JsonAnySetter, JsonCreator and JsonProperty, JacksonInject, and JsonDeserialize.

The JsonPropertyOrder annotation type specifies the order in which a Java object’s fields should be serialized to JSON content.

The difference between a stateful and a stateless pretty printer class is that the stateful class must implement the Instantiatable<T> interface, to allow for the construction of per-generation instances in order to avoid state corruption when sharing the pretty printer instance among threads. This is not a requirement for a stateless class.

You prevent ObjectMapper’s writeValue() methods from closing the System.out stream by executing disable(JsonGenerator.Feature.AUTO_CLOSE_TARGET) on the ObjectMapper instance.

Listing A-20 presents the JacksonDemo application that was called for in Chapter 11.

JSON Processing (JSON-P) is a Java API for processing (i.e., parsing, generating, querying, and transforming) JSON content.

JSON-P 1.0 consists of 25 types located in package javax.json, along with the support packages javax.json.spi and javax.json.stream. The javax.json package mainly contains types that support the object model, the javax.json.spi package contains a single type that describes a service provider for JSON processing objects, and the javax.json.stream package contains types that support the streaming model.

The types for creating JsonArray and JsonObject models are JsonArrayBuilder and JsonObjectBuilder.

JSONValue is the superinterface of interface types that represent immutable JSON values.

JSON-P 1.1 differs from JSON-P 1.0 in that it supports JSON Pointer, JSON Patch, and JSON Merge Patch. Also, the new version adds editing and transformation operations to JSON array and object builders; and it also updates the API to better support Java SE 8 stream operations (including JSON-specific collectors).

The answer is false: JSON-P 1.0’s object model is more flexible than its streaming model.

You construct a JsonObject model by invoking Json’s createObjectBuilder() method to return a JsonObjectBuilder instance, invoking a chain of JsonObjectBuilder’s add() methods on this instance to add a hierarchy of objects, and invoking JsonObjectBuilder’s build() method on the builder instance to return a JsonObject that serves as the root of the tree.

The types that the streaming model provides to read and write JSON content are JsonParser and JsonGenerator.

JSON Merge Patch defines a JSON document structure for expressing a sequence of changes to be made to a target JSON document via a syntax that closely mimics that document. Recipients of a JSON Merge Patch document determine the exact set of changes being requested by comparing the content of the provided patch against the current content of the target document. If the patch contains members that don’t appear in the target, those members are added. If the target does contain the member, the value is replaced. Null values in the merge patch are given special meaning to indicate the removal of existing values in the target.

The editing/transformation operations that have been added to JsonArrayBuilder and JsonObjectBuilder are as follows: JsonArrayBuilder has received several add(int index, ...) methods for adding a value between array elements, several set(int index, ...) methods for updating an existing element, and a remove() method for removing an element. JsonObjectBuilder has received a remove() method for removing a name/value pair.

The answer is true: JSON-P 1.1 introduced a JsonCollectors class whose static collector methods return JSONObjects or JsonArrays instead of Maps or Lists.

Listing A-21 presents the JSONPDemo application that was called for in Chapter 12.