jodd.json.JsonArray java code examples

@Test
void testCreateFromListNestedJsonArray() {
  List<Object> list = new ArrayList<>();
  list.add("foo");
  list.add(123);
  JsonArray arr2 = new JsonArray().add("blah").add("wibble");
  list.add(arr2);
  JsonArray arr = new JsonArray(list);
  assertEquals("foo", arr.getString(0));
  assertEquals(Integer.valueOf(123), arr.getInteger(1));
  assertSame(list, arr.list());
  assertSame(arr2, arr.getJsonArray(2));
}

@Test
void testRemoveByObject() {
  jsonArray.add("wibble");
  jsonArray.add(true);
  jsonArray.add(123);
  assertEquals(3, jsonArray.size());
  assertTrue(jsonArray.remove("wibble"));
  assertEquals(2, jsonArray.size());
  assertFalse(jsonArray.remove("notthere"));
  assertTrue(jsonArray.remove(true));
  assertTrue(jsonArray.remove(Integer.valueOf(123)));
  assertTrue(jsonArray.isEmpty());
}

@Test
void testAddAllJsonArray() {
  jsonArray.add("bar");
  JsonArray arr = new JsonArray().add("foo").add(48);
  assertSame(jsonArray, jsonArray.addAll(arr));
  assertEquals(arr.getString(0), jsonArray.getString(1));
  assertEquals(arr.getInteger(1), jsonArray.getInteger(2));
}

static boolean elementEquals(final Object o1, final Object o2) {
  if (o1 == o2) {
    return true;
  }
  if (o1 instanceof JsonObject) {
    return objectEquals(((JsonObject) o1).map, o2);
  }
  if (o1 instanceof Map<?, ?>) {
    return objectEquals((Map<?, ?>) o1, o2);
  }
  if (o1 instanceof JsonArray) {
    return JsonArray.arrayEquals(((JsonArray) o1).list(), o2);
  }
  if (o1 instanceof List<?>) {
    return JsonArray.arrayEquals((List<?>) o1, o2);
  }
  if (o1 instanceof Number && o2 instanceof Number && o1.getClass() != o2.getClass()) {
    Number n1 = (Number) o1;
    Number n2 = (Number) o2;
    if (o1 instanceof Float || o1 instanceof Double || o2 instanceof Float || o2 instanceof Double) {
      return n1.doubleValue() == n2.doubleValue();
    } else {
      return n1.longValue() == n2.longValue();
    }
  }
  return o1.equals(o2);
}

@Test
void testSize() {
  jsonArray.add("wibble");
  jsonArray.add(true);
  jsonArray.add(123);
  assertEquals(3, jsonArray.size());
}

@Test
@SuppressWarnings("UnnecessaryBoxing")
void testAddObject() {
  jsonArray.add((Object) "bar");
  jsonArray.add((Object) (Integer.valueOf(123)));
  jsonArray.add((Object) (Long.valueOf(123L)));
  jsonArray.add((Object) (Float.valueOf(1.23f)));
  jsonArray.add((Object) (Double.valueOf(1.23d)));
  jsonArray.add((Object) true);
  byte[] bytes = randomByteArray(10);
  jsonArray.add((Object) (bytes));
  JsonObject obj = new JsonObject().put("foo", "blah");
  JsonArray arr = new JsonArray().add("quux");
  jsonArray.add((Object) obj);
  jsonArray.add((Object) arr);
  assertEquals("bar", jsonArray.getString(0));
  assertEquals(Integer.valueOf(123), jsonArray.getInteger(1));
  assertEquals(Long.valueOf(123L), jsonArray.getLong(2));
  assertEquals(Float.valueOf(1.23f), jsonArray.getFloat(3));
  assertEquals(Double.valueOf(1.23d), jsonArray.getDouble(4));
  assertEquals(true, jsonArray.getBoolean(5));
  assertArrayEquals(bytes, jsonArray.getBinary(6));
  assertEquals(obj, jsonArray.getJsonObject(7));
  assertEquals(arr, jsonArray.getJsonArray(8));
  try {
    jsonArray.add(new SomeClass());
    fail("error");
  jsonArray.add(new BigDecimal(123));

@Test
void testJsonArrayEquality() {
  JsonObject obj = new JsonObject(Collections.singletonMap("abc", Collections.singletonList(3)));
  assertEquals(obj, new JsonObject(Collections.singletonMap("abc", Collections.singletonList(3))));
  assertEquals(obj, new JsonObject(Collections.singletonMap("abc", Collections.singletonList(3L))));
  assertEquals(obj, new JsonObject(Collections.singletonMap("abc", new JsonArray().add(3))));
  assertEquals(obj, new JsonObject(Collections.singletonMap("abc", new JsonArray().add(3L))));
  assertNotEquals(obj, new JsonObject(Collections.singletonMap("abc", Collections.singletonList(4))));
  assertNotEquals(obj, new JsonObject(Collections.singletonMap("abc", new JsonArray().add(4))));
  JsonArray array = new JsonArray(Collections.singletonList(Collections.singletonList(3)));
  assertEquals(array, new JsonArray(Collections.singletonList(Collections.singletonList(3))));
  assertEquals(array, new JsonArray(Collections.singletonList(Collections.singletonList(3L))));
  assertEquals(array, new JsonArray(Collections.singletonList(new JsonArray().add(3))));
  assertEquals(array, new JsonArray(Collections.singletonList(new JsonArray().add(3L))));
  assertNotEquals(array, new JsonArray(Collections.singletonList(Collections.singletonList(4))));
  assertNotEquals(array, new JsonArray(Collections.singletonList(new JsonArray().add(4))));
}

@Test
void testGetValue() {
  jsonArray.add(123);
  assertEquals(123, jsonArray.getValue(0));
  jsonArray.add(123L);
  assertEquals(123L, jsonArray.getValue(1));
  jsonArray.add(123f);
  assertEquals(123f, jsonArray.getValue(2));
  jsonArray.add(123d);
  assertEquals(123d, jsonArray.getValue(3));
  jsonArray.add(false);
  assertEquals(false, jsonArray.getValue(4));
  jsonArray.add(true);
  assertEquals(true, jsonArray.getValue(5));
  jsonArray.add("bar");
  assertEquals("bar", jsonArray.getValue(6));
  JsonObject obj = new JsonObject().put("blah", "wibble");
  jsonArray.add(obj);
  assertEquals(obj, jsonArray.getValue(7));
  JsonArray arr = new JsonArray().add("blah").add("wibble");
  jsonArray.add(arr);
  assertEquals(arr, jsonArray.getValue(8));
  byte[] bytes = randomByteArray(100);
  jsonArray.add(bytes);
  assertArrayEquals(bytes, Base64.getDecoder().decode((String) jsonArray.getValue(9)));
  jsonArray.addNull();
  assertNull(jsonArray.getValue(10));
  try {
    jsonArray.getValue(-1);
    fail("error");

/**
 * Returns the JsonArray at position {@code pos} in the array.
 */
public JsonArray getJsonArray(final int pos) {
  Object val = list.get(pos);
  if (val instanceof List) {
    val = new JsonArray((List) val);
  }
  return (JsonArray) val;
}

@Test
void testClear() {
  jsonArray.add("wibble");
  jsonArray.add(true);
  jsonArray.add(123);
  assertEquals(3, jsonArray.size());
  assertEquals(jsonArray, jsonArray.clear());
  assertEquals(0, jsonArray.size());
  assertTrue(jsonArray.isEmpty());
}

@Test
void testRemoveMethodReturnedObject() {
  JsonArray obj = new JsonArray();
  obj.add("bar")
    .add(new JsonObject().put("name", "vert.x").put("count", 2))
    .add(new JsonArray().add(1.0).add(2.0));
  Object removed = obj.remove(0);
  assertTrue(removed instanceof String);
  removed = obj.remove(0);
  assertTrue(removed instanceof JsonObject);
  assertEquals(((JsonObject) removed).getString("name"), "vert.x");
  removed = obj.remove(0);
  assertTrue(removed instanceof JsonArray);
  assertEquals(((JsonArray) removed).getDouble(0), 1.0, 0.1);
}

@Test
void testGetJsonArray() {
  JsonArray arr = new JsonArray().add("foo");
  jsonArray.add(arr);
  assertEquals(arr, jsonArray.getJsonArray(0));
  try {
    jsonArray.getJsonArray(-1);
    fail("error");
  }
  catch (IndexOutOfBoundsException e) {
    // OK
  }
  try {
    jsonArray.getJsonArray(1);
    fail("error");
  }
  catch (IndexOutOfBoundsException e) {
    // OK
  }
  jsonArray.add(123);
  try {
    jsonArray.getJsonArray(1);
    fail("error");
  }
  catch (ClassCastException e) {
    // OK
  }
  jsonArray.addNull();
  assertNull(jsonArray.getJsonArray(2));
}

@Test
void testCreateFromMapNestedJsonArray() {
  Map<String, Object> map = new HashMap<>();
  JsonArray nestedArr = new JsonArray().add("foo");
  map.put("nested", nestedArr);
  JsonObject obj = new JsonObject(map);
  JsonArray nestedRetrieved = obj.getJsonArray("nested");
  assertEquals("foo", nestedRetrieved.getString(0));
}

@Test
void testIterator() {
  jsonArray.add("foo");
  jsonArray.add(123);
  JsonObject obj = new JsonObject().put("foo", "bar");
  jsonArray.add(obj);
  Iterator<Object> iter = jsonArray.iterator();
  assertTrue(iter.hasNext());
  Object entry = iter.next();
  assertEquals("foo", entry);
  assertTrue(iter.hasNext());
  entry = iter.next();
  assertEquals(123, entry);
  assertTrue(iter.hasNext());
  entry = iter.next();
  assertEquals(obj, entry);
  assertFalse(iter.hasNext());
  iter.remove();
  assertFalse(jsonArray.contains(obj));
  assertEquals(2, jsonArray.size());
}

@Test
void testAddJsonArray() {
  JsonArray arr = new JsonArray().add("foo");
  assertSame(jsonArray, jsonArray.add(arr));
  assertEquals(arr, jsonArray.getJsonArray(0));
}

@Test
void testHasNull() {
  jsonArray.addNull();
  jsonArray.add("foo");
  assertEquals(null, jsonArray.getString(0));
  assertTrue(jsonArray.hasNull(0));
  assertFalse(jsonArray.hasNull(1));
}

@Test
void testEncode() throws Exception {
  jsonArray.add("foo");
  jsonArray.add(123);
  jsonArray.add(1234L);
  jsonArray.add(1.23f);
  jsonArray.add(2.34d);
  jsonArray.add(true);
  byte[] bytes = randomByteArray(10);
  jsonArray.add(bytes);
  jsonArray.addNull();
  jsonArray.add(new JsonObject().put("foo", "bar"));
  jsonArray.add(new JsonArray().add("foo").add(123));
  String strBytes = Base64.getEncoder().encodeToString(bytes);
  String expected = "[\"foo\",123,1234,1.23,2.34,true,\"" + strBytes + "\",null,{\"foo\":\"bar\"},[\"foo\",123]]";
  String json = JsonSerializer.create().serialize(jsonArray);
  assertEquals(expected, json);
}

@Test
void testGetList() {
  JsonObject obj = new JsonObject().put("quux", "wibble");
  jsonArray.add("foo").add(123).add(obj);
  List<Object> list = jsonArray.list();
  list.remove("foo");
  assertFalse(jsonArray.contains("foo"));
  list.add("floob");
  assertTrue(jsonArray.contains("floob"));
  assertSame(obj, list.get(1));
  obj.remove("quux");
}

  @Override
  public boolean serialize(final JsonContext jsonContext, final JsonArray jsonArray) {
    final int length = jsonArray.size();

    if (length == 0 && jsonContext.isExcludeEmpty()) {
      return true;
    }

    jsonContext.writeOpenArray();

    int count = 0;

    for (int i = 0; i < length; i++) {
      if (count > 0) {
        jsonContext.writeComma();
      }

      if (jsonContext.serialize(jsonArray.getValue(i))) {
        count++;
      }
    }

    jsonContext.writeCloseArray();

    return true;
  }
}

@Test
void testContains() {
  jsonArray.add("wibble");
  jsonArray.add(true);
  jsonArray.add(123);
  JsonObject obj = new JsonObject();
  JsonArray arr = new JsonArray();
  jsonArray.add(obj);
  jsonArray.add(arr);
  assertFalse(jsonArray.contains("eek"));
  assertFalse(jsonArray.contains(false));
  assertFalse(jsonArray.contains(321));
  assertFalse(jsonArray.contains(new JsonObject().put("blah", "flib")));
  assertFalse(jsonArray.contains(new JsonArray().add("oob")));
  assertTrue(jsonArray.contains("wibble"));
  assertTrue(jsonArray.contains(true));
  assertTrue(jsonArray.contains(123));
  assertTrue(jsonArray.contains(obj));
  assertTrue(jsonArray.contains(arr));
}

Javadoc

Representation of JSON array.

Most used methods

<init>
Creates an instance from a List. The List is not copied.
getValue
Returns the object value at position pos in the array.
list
Returns the underlying list.
size
Returns the number of values in this JSON array.
add
Adds a binary value to the JSON array. JSON has no notion of binary so the binary will be base64 enc
addAll
Appends all of the elements in the specified array to the end of this JSON array.
addNull
Adds a null value to the JSON array.
arrayEquals
clear
Removes all entries from the JSON array.
contains
Returns true if given value exist.
equals
getBinary
Returns the byte[] at position pos in the array. JSON itself has no notion of a binary, so this meth

Popular in Java

Making http requests using okhttp
compareTo (BigDecimal)
notifyDataSetChanged (ArrayAdapter)
getApplicationContext (Context)
Socket (java.net)
Provides a client-side TCP socket.
Manifest (java.util.jar)
The Manifest class is used to obtain attribute information for a JarFile and its entries.
Servlet (javax.servlet)
Defines methods that all servlets must implement. A servlet is a small Java program that runs within
LogFactory (org.apache.commons.logging)
Factory for creating Log instances, with discovery and configuration features similar to that employ
Project (org.apache.tools.ant)
Central representation of an Ant project. This class defines an Ant project with all of its targets,
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble
Github Copilot alternatives

How to useJsonArray in jodd.json

Best Java code snippets using jodd.json.JsonArray (Showing top 20 results out of 315)

How to use
JsonArray
in
jodd.json