Gson 2.14.0 · com.google.gson.stream.JsonReader · APIdia, the JavaDoc alternative

Reads a JSON (RFC 8259) encoded value as a stream of tokens. This stream includes both literal values (strings, numbers, booleans, and nulls) as well as the begin and end delimiters of objects and arrays. The tokens are traversed in depth-first order, the same order that they appear in the JSON document. Within JSON objects, name/value pairs are represented by a single token.

Parsing JSON

To create a recursive descent parser for your own JSON streams, first create an entry point method that creates a JsonReader.

Next, create handler methods for each structure in your JSON text. You'll need a method for each object type and for each array type.

Within array handling methods, first call beginArray to consume the array's opening bracket. Then create a while loop that accumulates values, terminating when hasNext is false. Finally, read the array's closing bracket by calling endArray.
Within object handling methods, first call beginObject to consume the object's opening brace. Then create a while loop that assigns values to local variables based on their name. This loop should terminate when hasNext is false. Finally, read the object's closing brace by calling endObject.

When a nested object or array is encountered, delegate to the corresponding handler method.

When an unknown name is encountered, strict parsers should fail with an exception. Lenient parsers should call skipValue() to recursively skip the value's nested tokens, which may otherwise conflict.

If a value may be null, you should first check using peek(). Null literals can be consumed using either nextNull() or skipValue().

Configuration

The behavior of this reader can be customized with the following methods:

setStrictness(Strictness), the default is Strictness#LEGACY_STRICT
setNestingLimit(int), the default is 255

The default configuration of JsonReader instances used internally by the com.google.gson.Gson class differs, and can be adjusted with the various com.google.gson.GsonBuilder methods.

Example

Suppose we'd like to parse a stream of messages such as the following:

[
  {
    "id": 912345678901,
    "text": "How do I read a JSON stream in Java?",
    "geo": null,
    "user": {
      "name": "json_newb",
      "followers_count": 41
     }
  },
  {
    "id": 912345678902,
    "text": "@json_newb just use JsonReader!",
    "geo": [50.454722, -104.606667],
    "user": {
      "name": "jesse",
      "followers_count": 2
    }
  }
]

This code implements the parser for the above structure:

public List<Message> readJsonStream(InputStream in) throws IOException {
  JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
  try {
    return readMessagesArray(reader);
  } finally {
    reader.close();
  }
}

public List<Message> readMessagesArray(JsonReader reader) throws IOException {
  List<Message> messages = new ArrayList<>();

  reader.beginArray();
  while (reader.hasNext()) {
    messages.add(readMessage(reader));
  }
  reader.endArray();
  return messages;
}

public Message readMessage(JsonReader reader) throws IOException {
  long id = -1;
  String text = null;
  User user = null;
  List<Double> geo = null;

  reader.beginObject();
  while (reader.hasNext()) {
    String name = reader.nextName();
    if (name.equals("id")) {
      id = reader.nextLong();
    } else if (name.equals("text")) {
      text = reader.nextString();
    } else if (name.equals("geo") && reader.peek() != JsonToken.NULL) {
      geo = readDoublesArray(reader);
    } else if (name.equals("user")) {
      user = readUser(reader);
    } else {
      reader.skipValue();
    }
  }
  reader.endObject();
  return new Message(id, text, user, geo);
}

public List<Double> readDoublesArray(JsonReader reader) throws IOException {
  List<Double> doubles = new ArrayList<>();

  reader.beginArray();
  while (reader.hasNext()) {
    doubles.add(reader.nextDouble());
  }
  reader.endArray();
  return doubles;
}

public User readUser(JsonReader reader) throws IOException {
  String username = null;
  int followersCount = -1;

  reader.beginObject();
  while (reader.hasNext()) {
    String name = reader.nextName();
    if (name.equals("name")) {
      username = reader.nextString();
    } else if (name.equals("followers_count")) {
      followersCount = reader.nextInt();
    } else {
      reader.skipValue();
    }
  }
  reader.endObject();
  return new User(username, followersCount);
}

Number Handling

This reader permits numeric values to be read as strings and string values to be read as numbers. For example, both elements of the JSON array [1, "1"] may be read using either nextInt or nextString. This behavior is intended to prevent lossy numeric conversions: double is JavaScript's only numeric type and very large values like 9007199254740993 cannot be represented exactly on that platform. To minimize precision loss, extremely large values should be written and read as strings in JSON.

Non-Execute Prefix

Web servers that serve private data using JSON may be vulnerable to Cross-site request forgery attacks. In such an attack, a malicious site gains access to a private JSON file by executing it with an HTML <script> tag.

Prefixing JSON files with ")]}'\n" makes them non-executable by <script> tags, disarming the attack. Since the prefix is malformed JSON, strict parsing fails when it is encountered. This class permits the non-execute prefix when lenient parsing is enabled.

Each JsonReader may be used to read a single JSON stream. Instances of this class are not thread safe.

Field Summary

Modifier and Type	Field and Description
private final char[]	buffer Use a manual buffer to easily read and unread upcoming characters, and also so we can create strings without an intermediate StringBuilder.
pack-priv static final int	BUFFER_SIZE
pack-priv static final int	DEFAULT_NESTING_LIMIT
private final Reader	in The input JSON.
private int	limit
private int	lineNumber
private int	lineStart
private static final long	MIN_INCOMPLETE_INTEGER
private int	nestingLimit
private static final int	NUMBER_CHAR_DECIMAL
private static final int	NUMBER_CHAR_DIGIT
private static final int	NUMBER_CHAR_EXP_DIGIT
private static final int	NUMBER_CHAR_EXP_E
private static final int	NUMBER_CHAR_EXP_SIGN
private static final int	NUMBER_CHAR_FRACTION_DIGIT
private static final int	NUMBER_CHAR_NONE
private static final int	NUMBER_CHAR_SIGN
private int[]	pathIndices
private String[]	pathNames
pack-priv int	peeked
private static final int	PEEKED_BEGIN_ARRAY
private static final int	PEEKED_BEGIN_OBJECT
private static final int	PEEKED_BUFFERED When this is returned, the string value is stored in peekedString.
private static final int	PEEKED_DOUBLE_QUOTED
private static final int	PEEKED_DOUBLE_QUOTED_NAME
private static final int	PEEKED_END_ARRAY
private static final int	PEEKED_END_OBJECT
private static final int	PEEKED_EOF
private static final int	PEEKED_FALSE
private static final int	PEEKED_LONG When this is returned, the integer value is stored in peekedLong.
private static final int	PEEKED_NONE
private static final int	PEEKED_NULL
private static final int	PEEKED_NUMBER
private static final int	PEEKED_SINGLE_QUOTED
private static final int	PEEKED_SINGLE_QUOTED_NAME
private static final int	PEEKED_TRUE
private static final int	PEEKED_UNQUOTED
private static final int	PEEKED_UNQUOTED_NAME
private long	peekedLong A peeked value that was composed entirely of digits with an optional leading dash.
private int	peekedNumberLength The number of characters in a peeked number literal.
private String	peekedString A peeked string that should be parsed on the next double, long or string.
private int	pos
private int[]	stack The nesting stack.
private int	stackSize
private Strictness	strictness

Constructor Summary

Access	Constructor and Description
public	JsonReader(Reader in) Creates a new instance that reads a JSON-encoded stream from `in`.

Method Summary

Modifier and Type	Method and Description
public void	beginArray() Consumes the next token from the JSON stream and asserts that it is the beginning of a new array.
public void	beginObject() Consumes the next token from the JSON stream and asserts that it is the beginning of a new object.
private void	checkLenient()
public void	close() Implements java.io.Closeable.close. Closes this JSON reader and the underlying `Reader`.
private void	consumeNonExecutePrefix() Consumes the non-execute prefix if it exists.
pack-priv int	doPeek()
public void	endArray() Consumes the next token from the JSON stream and asserts that it is the end of the current array.
public void	endObject() Consumes the next token from the JSON stream and asserts that it is the end of the current object.
private boolean	fillBuffer(int minimum) Returns true once `limit - pos >= minimum`.
public final int	getNestingLimit() Returns the nesting limit of this reader.
private String	getPath(boolean usePreviousPath)
public String	getPath() Returns a JSONPath in dot-notation to the next (or current) location in the JSON document.
public String	getPreviousPath() Returns a JSONPath in dot-notation to the previous (or current) location in the JSON document.
public final Strictness	getStrictness() Returns the strictness of this reader.
public boolean	hasNext() Returns true if the current array or object has another element.
public final boolean	isLenient() Returns true if the `Strictness` of this reader is equal to `Strictness#LENIENT`.
private boolean	isLiteral(char c)
pack-priv String	locationString()
public boolean	nextBoolean() Returns the `boolean` value of the next token, consuming it.
public double	nextDouble() Returns the `double` value of the next token, consuming it.
public int	nextInt() Returns the `int` value of the next token, consuming it.
public long	nextLong() Returns the `long` value of the next token, consuming it.
public String	nextName() Returns the next token, a `property name`, and consumes it.
private int	nextNonWhitespace(boolean throwOnEof) Returns the next character in the stream that is neither whitespace nor a part of a comment.
public void	nextNull() Consumes the next token from the JSON stream and asserts that it is a literal null.
private String	nextQuotedValue(char either ' or ". quote) Returns the string up to but not including `quote`, unescaping any character escape sequences encountered along the way.
public String	nextString() Returns the `string` value of the next token, consuming it.
private String	nextUnquotedValue() Returns an unquoted value as a string.
public JsonToken	peek() Returns the type of the next token without consuming it.
private int	peekKeyword()
private int	peekNumber()
private void	push(int newTop)
private char	readEscapeCharacter() Unescapes the character identified by the character or characters that immediately follow a backslash.
public final void	setLenient(boolean whether this reader should be lenient. If true, the strictness is set to `Strictness#LENIENT`. If false, the strictness is set to `Strictness#LEGACY_STRICT`. lenient) Deprecated Please use `setStrictness(Strictness)` instead. Sets the strictness of this reader.
public final void	setNestingLimit(int limit) Sets the nesting limit of this reader.
public final void	setStrictness(Strictness the new strictness value of this reader. May not be `null`. strictness) Configures how liberal this parser is in what it accepts.
private void	skipQuotedValue(char quote)
private boolean	skipTo(String a string to search for. Must not contain a newline. toFind)
private void	skipToEndOfLine() Advances the position until after the next newline character.
private void	skipUnquotedValue()
public void	skipValue() Skips the next value recursively.
private MalformedJsonException	syntaxError(String message) Throws a new `MalformedJsonException` with the given message and information about the current location.
public String	toString() Overrides java.lang.Object.toString. Returns a string representation of the object.
private IllegalStateException	unexpectedTokenError(String expected)
private void	validateAscii(String s)

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll wait wait wait

Field Detail

buffer	back to summary
private final char[] buffer Use a manual buffer to easily read and unread upcoming characters, and also so we can create strings without an intermediate StringBuilder. We decode literals directly out of this buffer, so it must be at least as long as the longest token that can be reported as a number.

BUFFER_SIZE	back to summary
pack-priv static final int BUFFER_SIZE

DEFAULT_NESTING_LIMIT	back to summary
pack-priv static final int DEFAULT_NESTING_LIMIT

in	back to summary
private final Reader in The input JSON.

limit	back to summary
private int limit

lineNumber	back to summary
private int lineNumber

lineStart	back to summary
private int lineStart

MIN_INCOMPLETE_INTEGER	back to summary
private static final long MIN_INCOMPLETE_INTEGER

nestingLimit	back to summary
private int nestingLimit

NUMBER_CHAR_DECIMAL	back to summary
private static final int NUMBER_CHAR_DECIMAL

NUMBER_CHAR_DIGIT	back to summary
private static final int NUMBER_CHAR_DIGIT

NUMBER_CHAR_EXP_DIGIT	back to summary
private static final int NUMBER_CHAR_EXP_DIGIT

NUMBER_CHAR_EXP_E	back to summary
private static final int NUMBER_CHAR_EXP_E

NUMBER_CHAR_EXP_SIGN	back to summary
private static final int NUMBER_CHAR_EXP_SIGN

NUMBER_CHAR_FRACTION_DIGIT	back to summary
private static final int NUMBER_CHAR_FRACTION_DIGIT

NUMBER_CHAR_NONE	back to summary
private static final int NUMBER_CHAR_NONE

NUMBER_CHAR_SIGN	back to summary
private static final int NUMBER_CHAR_SIGN

pathIndices	back to summary
private int[] pathIndices

pathNames	back to summary
private String[] pathNames

peeked	back to summary
pack-priv int peeked

PEEKED_BEGIN_ARRAY	back to summary
private static final int PEEKED_BEGIN_ARRAY

PEEKED_BEGIN_OBJECT	back to summary
private static final int PEEKED_BEGIN_OBJECT

PEEKED_BUFFERED	back to summary
private static final int PEEKED_BUFFERED When this is returned, the string value is stored in peekedString.

PEEKED_DOUBLE_QUOTED	back to summary
private static final int PEEKED_DOUBLE_QUOTED

PEEKED_DOUBLE_QUOTED_NAME	back to summary
private static final int PEEKED_DOUBLE_QUOTED_NAME

PEEKED_END_ARRAY	back to summary
private static final int PEEKED_END_ARRAY

PEEKED_END_OBJECT	back to summary
private static final int PEEKED_END_OBJECT

PEEKED_EOF	back to summary
private static final int PEEKED_EOF

PEEKED_FALSE	back to summary
private static final int PEEKED_FALSE

PEEKED_LONG	back to summary
private static final int PEEKED_LONG When this is returned, the integer value is stored in peekedLong.

PEEKED_NONE	back to summary
private static final int PEEKED_NONE

PEEKED_NULL	back to summary
private static final int PEEKED_NULL

PEEKED_NUMBER	back to summary
private static final int PEEKED_NUMBER

PEEKED_SINGLE_QUOTED	back to summary
private static final int PEEKED_SINGLE_QUOTED

PEEKED_SINGLE_QUOTED_NAME	back to summary
private static final int PEEKED_SINGLE_QUOTED_NAME

PEEKED_TRUE	back to summary
private static final int PEEKED_TRUE

PEEKED_UNQUOTED	back to summary
private static final int PEEKED_UNQUOTED

PEEKED_UNQUOTED_NAME	back to summary
private static final int PEEKED_UNQUOTED_NAME

peekedLong	back to summary
private long peekedLong A peeked value that was composed entirely of digits with an optional leading dash. Positive values may not have a leading 0.

peekedNumberLength	back to summary
private int peekedNumberLength The number of characters in a peeked number literal. Increment 'pos' by this after reading a number.

peekedString	back to summary
private String peekedString A peeked string that should be parsed on the next double, long or string. This is populated before a numeric value is parsed and used if that parsing fails.

pos	back to summary
private int pos

stack	back to summary
private int[] stack The nesting stack. Using a manual array rather than an ArrayList saves 20%.

stackSize	back to summary
private int stackSize

strictness	back to summary
private Strictness strictness

Constructor Detail

JsonReader	back to summary
public JsonReader(Reader in) Creates a new instance that reads a JSON-encoded stream from `in`.

Method Detail

beginArray	back to summary
public void beginArray() throws IOException Consumes the next token from the JSON stream and asserts that it is the beginning of a new array. Exceptions IllegalStateException: if the next token is not the beginning of an array.

beginArray

back to summary

public void beginArray() throws IOException

Consumes the next token from the JSON stream and asserts that it is the beginning of a new array.

Exceptions

IllegalStateException:: if the next token is not the beginning of an array.

beginObject

back to summary

public void beginObject() throws IOException

Consumes the next token from the JSON stream and asserts that it is the beginning of a new object.

Exceptions

IllegalStateException:: if the next token is not the beginning of an object.

checkLenient	back to summary
private void checkLenient() throws MalformedJsonException

close back to summary

public void close() throws IOException

Implements java.io.Closeable.close.

Closes this JSON reader and the underlying Reader.

Using the JSON reader after it has been closed will throw an IllegalStateException in most cases.

Annotations

@Override

Exceptions

IOException:

Doc from java.io.Closeable.close.

if an I/O error occurs

consumeNonExecutePrefix	back to summary
private void consumeNonExecutePrefix() throws IOException Consumes the non-execute prefix if it exists.

doPeek	back to summary
pack-priv int doPeek() throws IOException Annotations @SuppressWarnings:fallthrough

endArray

back to summary

public void endArray() throws IOException

Consumes the next token from the JSON stream and asserts that it is the end of the current array.

Exceptions

IllegalStateException:: if the next token is not the end of an array.

endObject

back to summary

public void endObject() throws IOException

Consumes the next token from the JSON stream and asserts that it is the end of the current object.

Exceptions

IllegalStateException:: if the next token is not the end of an object.

fillBuffer	back to summary
private boolean fillBuffer(int minimum) throws IOException Returns true once `limit - pos >= minimum`. If the data is exhausted before that many characters are available, this returns false.

getNestingLimit back to summary

public final int getNestingLimit()

Returns the nesting limit of this reader.

Since: 2.12.0
See Also: setNestingLimit(int)

getPath	back to summary
private String getPath(boolean usePreviousPath)

getPath

back to summary

public String getPath()

Returns a JSONPath in dot-notation to the next (or current) location in the JSON document. That means:

For JSON arrays the path points to the index of the next element (even if there are no further elements).
For JSON objects the path points to the last property, or to the current property if its name has already been consumed.

This method can be useful to add additional context to exception messages before a value is consumed, for example when the peeked token is unexpected.

getPreviousPath

back to summary

public String getPreviousPath()

Returns a JSONPath in dot-notation to the previous (or current) location in the JSON document. That means:

For JSON arrays the path points to the index of the previous element.
If no element has been consumed yet it uses the index 0 (even if there are no elements).
For JSON objects the path points to the last property, or to the current property if its name has already been consumed.

This method can be useful to add additional context to exception messages after a value has been consumed.

getStrictness back to summary

public final Strictness getStrictness()

Returns the strictness of this reader.

Since: 2.11.0
See Also: setStrictness(Strictness)

hasNext	back to summary
public boolean hasNext() throws IOException Returns true if the current array or object has another element.

isLenient back to summary

public final boolean isLenient()

Returns true if the Strictness of this reader is equal to Strictness#LENIENT.

See Also: getStrictness()

isLiteral	back to summary
private boolean isLiteral(char c) throws IOException Annotations @SuppressWarnings:fallthrough

locationString	back to summary
pack-priv String locationString()

nextBoolean back to summary

public boolean nextBoolean() throws IOException

Returns the boolean value of the next token, consuming it.

Exceptions

IllegalStateException:: if the next token is not a boolean.

nextDouble back to summary

public double nextDouble() throws IOException

Returns the double value of the next token, consuming it. If the next token is a string, this method will attempt to parse it as a double using Double#parseDouble(String).

Exceptions

IllegalStateException:: if the next token is neither a number nor a string.
NumberFormatException:: if the next literal value cannot be parsed as a double.
MalformedJsonException:: if the next literal value is NaN or Infinity and this reader is not lenient.

nextInt back to summary

public int nextInt() throws IOException

Returns the int value of the next token, consuming it. If the next token is a string, this method will attempt to parse it as an int. If the next token's numeric value cannot be exactly represented by a Java int, this method throws.

Exceptions

IllegalStateException:: if the next token is neither a number nor a string.
NumberFormatException:: if the next literal value cannot be parsed as a number, or exactly represented as an int.

nextLong back to summary

public long nextLong() throws IOException

Returns the long value of the next token, consuming it. If the next token is a string, this method will attempt to parse it as a long. If the next token's numeric value cannot be exactly represented by a Java long, this method throws.

Exceptions

IllegalStateException:: if the next token is neither a number nor a string.
NumberFormatException:: if the next literal value cannot be parsed as a number, or exactly represented as a long.

nextName back to summary

public String nextName() throws IOException

Returns the next token, a property name, and consumes it.

Exceptions

IllegalStateException:: if the next token is not a property name.

nextNonWhitespace	back to summary
private int nextNonWhitespace(boolean throwOnEof) throws IOException Returns the next character in the stream that is neither whitespace nor a part of a comment. When this returns, the returned character is always at `buffer[pos-1]`; this means the caller can always push back the returned character by decrementing `pos`.

nextNull

back to summary

public void nextNull() throws IOException

Consumes the next token from the JSON stream and asserts that it is a literal null.

Exceptions

IllegalStateException:: if the next token is not a JSON null.

nextQuotedValue back to summary

private String nextQuotedValue(char quote) throws IOException

Returns the string up to but not including quote, unescaping any character escape sequences encountered along the way. The opening quote should have already been read. This consumes the closing quote, but does not include it in the returned string.

Parameters

quote:char: either ' or ".

nextString back to summary

public String nextString() throws IOException

Returns the string value of the next token, consuming it. If the next token is a number, this method will return its string form.

Exceptions

IllegalStateException:: if the next token is not a string.

nextUnquotedValue

back to summary

private String nextUnquotedValue() throws IOException

Returns an unquoted value as a string.

Annotations

@SuppressWarnings:fallthrough

peek	back to summary
public JsonToken peek() throws IOException Returns the type of the next token without consuming it.

peekKeyword	back to summary
private int peekKeyword() throws IOException

peekNumber	back to summary
private int peekNumber() throws IOException

push	back to summary
private void push(int newTop) throws MalformedJsonException

readEscapeCharacter

back to summary

private char readEscapeCharacter() throws IOException

Unescapes the character identified by the character or characters that immediately follow a backslash. The backslash '\' should have already been read. This supports both Unicode escapes "u000A" and two-character escapes "\n".

Annotations

@SuppressWarnings:fallthrough

Exceptions

MalformedJsonException:: if the escape sequence is malformed

setLenient back to summary

public final void setLenient(boolean lenient)

Deprecated

Please use setStrictness(Strictness) instead. JsonReader.setLenient(true) should be replaced by JsonReader.setStrictness(Strictness.LENIENT) and JsonReader.setLenient(false) should be replaced by JsonReader.setStrictness(Strictness.LEGACY_STRICT).
However, if you used setLenient(false) before, you might prefer Strictness#STRICT now instead.

Sets the strictness of this reader.

Parameters

lenient:boolean: whether this reader should be lenient. If true, the strictness is set to Strictness#LENIENT. If false, the strictness is set to Strictness#LEGACY_STRICT.

Annotations

@Deprecated
@SuppressWarnings:InlineMeSuggester

See Also

setStrictness(Strictness)

setNestingLimit back to summary

public final void setNestingLimit(int limit)

Sets the nesting limit of this reader.

The nesting limit defines how many JSON arrays or objects may be open at the same time. For example a nesting limit of 0 means no arrays or objects may be opened at all, a nesting limit of 1 means one array or object may be open at the same time, and so on. So a nesting limit of 3 allows reading the JSON data [{"a":[true]}], but for a nesting limit of 2 it would fail at the inner [true].

The nesting limit can help to protect against a StackOverflowError when recursive com.google.gson.TypeAdapter implementations process deeply nested JSON data.

The default nesting limit is 255.

Exceptions

IllegalArgumentException:: if the nesting limit is negative.

Since

2.12.0

See Also

getNestingLimit()

setStrictness back to summary

public final void setStrictness(Strictness strictness)

Configures how liberal this parser is in what it accepts.

In strict mode, the parser only accepts JSON in accordance with RFC 8259. In legacy strict mode (the default), only JSON in accordance with the RFC 8259 is accepted, with a few exceptions denoted below for backwards compatibility reasons. In lenient mode, all sort of non-spec compliant JSON is accepted (see below).

Strictness#STRICT

In strict mode, only input compliant with RFC 8259 is accepted.

Strictness#LEGACY_STRICT

In legacy strict mode, the following departures from RFC 8259 are accepted:

JsonReader allows the literals true, false and null to have any capitalization, for example fAlSe or NULL
JsonReader supports the escape sequence \', representing a ' (single-quote)
JsonReader supports the escape sequence \LF (with LF being the Unicode character U+000A), resulting in a LF within the read JSON string
JsonReader allows unescaped control characters (U+0000 through U+001F)

Strictness#LENIENT

In lenient mode, all input that is accepted in legacy strict mode is accepted in addition to the following departures from RFC 8259:

Streams that start with the non-execute prefix, ")]'\n"}
Streams that include multiple top-level values. With legacy strict or strict parsing, each stream must contain exactly one top-level value.
Numbers may be NaNs or infinities represented by NaN and (-)Infinity respectively.
End of line comments starting with // or # and ending with a newline character.
C-style comments starting with /* and ending with */. Such comments may not be nested.
Names that are unquoted or 'single quoted'.
Strings that are unquoted or 'single quoted'.
Array elements separated by ; instead of ,.
Unnecessary array separators. These are interpreted as if null was the omitted value.
Names and values separated by = or => instead of :.
Name/value pairs separated by ; instead of ,.

Parameters

strictness:Strictness: the new strictness value of this reader. May not be null.

Since

2.11.0

See Also

getStrictness()

skipQuotedValue	back to summary
private void skipQuotedValue(char quote) throws IOException

skipTo	back to summary
private boolean skipTo(String toFind) throws IOException Parameters toFind:String a string to search for. Must not contain a newline.

skipToEndOfLine	back to summary
private void skipToEndOfLine() throws IOException Advances the position until after the next newline character. If the line is terminated by "\r\n", the '\n' must be consumed as whitespace by the caller.

skipUnquotedValue	back to summary
private void skipUnquotedValue() throws IOException Annotations @SuppressWarnings:fallthrough

skipValue back to summary

public void skipValue() throws IOException

Skips the next value recursively. This method is intended for use when the JSON token stream contains unrecognized or unhandled values.

The behavior depends on the type of the next JSON token:

Start of a JSON array or object: It and all of its nested values are skipped.
Primitive value (for example a JSON number): The primitive value is skipped.
Property name: Only the name but not the value of the property is skipped. skipValue() has to be called again to skip the property value as well.
End of a JSON array or object: Only this end token is skipped.
End of JSON document: Skipping has no effect, the next token continues to be the end of the document.

syntaxError	back to summary
private MalformedJsonException syntaxError(String message) throws MalformedJsonException Throws a new `MalformedJsonException` with the given message and information about the current location.

toString back to summary

public String toString()

Overrides java.lang.Object.toString.

Doc from java.lang.Object.toString.

Returns a string representation of the object. Satisfying this method's contract implies a non-null result must be returned.

Annotations

@Override

unexpectedTokenError	back to summary
private IllegalStateException unexpectedTokenError(String expected) throws IOException

validateAscii	back to summary
private void validateAscii(String s) throws MalformedJsonException

public Class JsonReader

Parsing JSON

Configuration

Example

Number Handling

Non-Execute Prefix

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail