Class RJArrIntoBoxedConsumer

  • public class RJArrIntoBoxedConsumer
extends java.lang.Object
    RJArrIntoBoxedConsumer 🠞
    • RJArr - Read JsonArray
      This class is used for reading data directly from an already parsed JsonArray instance.

    • Into - Data that is extracted, is sent to a specific User-Provided Destination.

    • BoxedConsumer - Data is sent to a Java-Consumer of a Boxed-Primitive Type.
    Utilities for parsing Json Array's and sending the parsed values into a Java Consumer of Boxed-Primitives.

    This class builds on the J2EE Standard 'Glass-Fish' JSON Processor

    There are several JSON Parsers available, and even more implementations for serializing and de-serializing data to/from JSON. The tool included in the J2EE is available on GitHub, and that is the one used by the Java HTML JAR Library. (See: javax.json.* )

    Primary Classes Used: JsonArray and JsonObject

    Each of the methods in this class, all of which are declared 'static', accept a standard JsonArray as input, and make a (User-Specified) "Best Efforts" attempt to convert the elements of the Input-Array into one of Java's Boxed-Primitives.

    Just to serve as a reminder, a Java 'Boxed Primitive' structure is nearly identical to a primitive, save for the following differences:

    • Boxed Primitive's are wrapped in an (artificial) Object-Reference, and may be passed-by-reference, no different than any othe Java Object-Reference. (In reality they are variant of 'Value-Classes', and their wrappers do not actually exists)

    • Boxed-Types may be assigned null, and will not force NullPointerException to throw when they are assigned null - nor produce any other adverse or unintended issues..

    • Boxed-Types have several Class-Member functions to which their values may be applied


    Each Json-Array Element that is successfully converted into a Boxed-Value (or null) is subsequently passed to a (User-Provided) Consumer<X>, where the Generic-Type 'X' is identical to (or a parent of) the Json-Array Method-Type in this class which you have selected.

    This class is capable of processing 7 of the 8 Java Boxed-Types that are available. The standard type 'java.lang.Character' is not accomodated by any of the Json Array-Processing Classes in this Json-Package. For each method in this class, the user is expected to provide a single JsonArray as input, along with an appropriate & matching Consumer.


    JSON Binding Helper-Class:
    JSON-Binding is the art of converting data that has been stored, saved or transmitted using Java-Script Object Notation into a Primitive-Type or Object-Type of any Programming Language, for instance Java. JSON often arrives into Java-Program Memory from an external Internet Connection, and may have traveled hundreds or even thousands of miles from a Host-Server.

    Unlike Java-Types which are checked by the Java-Compiler each-and-every time a programmer compiles his project, any guarantee that JSON-Type Data is pristine, uncorrupted, and in any kind of pre-agreed format is never completely assured.

    Being able to handle changes that might be made to an API (possibly from great distances away, and without the Software-Manager's consent) is the type of feature that robust JSON-Code simply has to offer.


    Binding-Helper Features:
    • Utilizes the Java-Standard javax.json.* Package-Library, & its Glass-Fish Implementation
    • Handles the Transfer & Conversion of All Json-Type's into Java-Type's with just One Line of Code
    • Provides all manner of User-Configurable Exception-Handling & Error-Decision Management via Class JFlag
    • Provides a Fine-Grained Suite of Exception-Classes, all with Consistent & Meaningful Error-Messages
    • Primary Helper-Classes for the (Experimental) Google-Chrome Headless Browser Package


    Method Parameters

    Parameter Explanation
    JsonArray ja This may be any parsed JsonArray whose contents are consistent with the Input-Parameters to the User-Provided Consumer 'c'.
    <PRIMITIVE> defaultValue When an appropriate JFlag-Value is included in the mask, this Default-Value will be passed to the User-Provided Consumer in whichever Error-Circumstance has occured (as per the Flag-Value Name).

    This Default-Value may be requested through JFlag-Values such as: RD_AEX, RD_IOB and RD_M (among others). The 'RD' in these Flag's Names is an abbreviation for "Return Default-Value".

    The Complete List of Flags which request that this Default-Value Parameter be employed under various Error-Circumstances may be viewed in the following link. The name of each of these flags attempts identify the type of Error-Situation to which it may be applied.

    Default-Value Flags
    int FLAGS A Bit-Wise Flag-Mask that provides a means for configuring the Array-Processing Logic to properly handle several types of Error-Cases & potentatial, unexpected, array contents.

    A Flag-Mask of '0' requests that any Error-Situations which occur, should they crop up while processing the array, be handled by standard means - meaning by throwing one of the germaine Exception-Class.
    Function
    <String, BOXED_TYPE>
    optionalUserParser    		 This parameter can only serve a purpose when it is used in conjunction with a JFlag-Vaule which explicity requests that Java String-Values be handled by a parser (rather than causing an exception to throw).

    The two flags which may be employed to signal this Handler-Behavior are: RETURN_PARSE_ON_STR and RP_S (the latter being merely the abbreviated variant of the former).

    If neither of these flags have been AND'ed into the Flag-Mask parameter ("FLAGS"), then any function which is passed to this parameter ("optionalUserParser") is wholly ignored - simply because using a String-Parser is not a "Default Behavior of this class' Array-Processing Logic.
    Consumer<BOXED_TYPE> c This is the Output-Target to which all retrieved values from the User-Provided JsonArray are sent.
    IntIntTConsumer<BOXED_TYPE> c

    The other Consumer-Type which may be provided as input to this class, has a Method-Sigature which also accepts two extra integers. The two extra int-Parameters are a JsonArray-Index, and also an additional 'count'.

    The value of integer 'count' is the number of times the returned consumer has been provided a value.

    Note that there are certain Error-Cases in which a user may request that the contents of an Array-Index be skipped (via JFlag-Value), rather than force an exception throw. This, hopefully, explains why the 'count' may may, from time to time, be different from the Input Array-Index (although, in most scenarios the Array-Index int and the Count int will be identical).
    See Also:
    Json, JsonArray



    Stateless Class:
    This class neither contains any program-state, nor can it be instantiated. The @StaticFunctional Annotation may also be called 'The Spaghetti Report'. Static-Functional classes are, essentially, C-Styled Files, without any constructors or non-static member fields. It is a concept very similar to the Java-Bean's @Stateless Annotation.

    • 1 Constructor(s), 1 declared private, zero-argument constructor
    • 16 Method(s), 16 declared static
    • 0 Field(s)


    • Method Summary

       
      Read the Contents of a Json-Array into a Java Boxed-Primitives Consumer
      Modifier and Type Method
      static void booleanArr​(JsonArray ja, boolean defaultValue, int FLAGS, Function<String,​Boolean> optionalUserParser, Consumer<Boolean> c)
      static void byteArr​(JsonArray ja, byte defaultValue, int FLAGS, Function<String,​Byte> optionalUserParser, Consumer<Byte> c)
      static void doubleArr​(JsonArray ja, double defaultValue, int FLAGS, Function<String,​Double> optionalUserParser, Consumer<Double> c)
      static void floatArr​(JsonArray ja, float defaultValue, int FLAGS, Function<String,​Float> optionalUserParser, Consumer<Float> c)
      static void intArr​(JsonArray ja, int defaultValue, int FLAGS, Function<String,​Integer> optionalUserParser, Consumer<Integer> c)
      static void longArr​(JsonArray ja, long defaultValue, int FLAGS, Function<String,​Long> optionalUserParser, Consumer<Long> c)
      static void numberArr​(JsonArray ja, Number defaultValue, int FLAGS, Function<String,​Number> optionalUserParser, Consumer<Number> c)
      static void shortArr​(JsonArray ja, short defaultValue, int FLAGS, Function<String,​Short> optionalUserParser, Consumer<Short> c)
       
      Read the Contents of a Json-Array into a Boxed-Primitives Consumer, w/ Array-Indices
      Modifier and Type Method
      static void booleanArr2​(JsonArray ja, boolean defaultValue, int FLAGS, Function<String,​Boolean> optionalUserParser, IntIntTConsumer<Boolean> c)
      static void byteArr2​(JsonArray ja, byte defaultValue, int FLAGS, Function<String,​Byte> optionalUserParser, IntIntTConsumer<Byte> c)
      static void doubleArr2​(JsonArray ja, double defaultValue, int FLAGS, Function<String,​Double> optionalUserParser, IntIntTConsumer<Double> c)
      static void floatArr2​(JsonArray ja, float defaultValue, int FLAGS, Function<String,​Float> optionalUserParser, IntIntTConsumer<Float> c)
      static void intArr2​(JsonArray ja, int defaultValue, int FLAGS, Function<String,​Integer> optionalUserParser, IntIntTConsumer<Integer> c)
      static void longArr2​(JsonArray ja, long defaultValue, int FLAGS, Function<String,​Long> optionalUserParser, IntIntTConsumer<Long> c)
      static void numberArr2​(JsonArray ja, Number defaultValue, int FLAGS, Function<String,​Number> optionalUserParser, IntIntTConsumer<Number> c)
      static void shortArr2​(JsonArray ja, short defaultValue, int FLAGS, Function<String,​Short> optionalUserParser, IntIntTConsumer<Short> c)

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    • Method Detail

      • intArr

        🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void intArr​
            (JsonArray ja,
             int defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Integer> optionalUserParser,
             java.util.function.Consumer<java.lang.Integer> c)
        Java-Consumer which accepts Boxed-Integers
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Integer Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Integer> myConsumer = (Integer boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.intArr(ja, -1, 0, null, myConsumer);

      • shortArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void shortArr​
            (JsonArray ja,
             short defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Short> optionalUserParser,
             java.util.function.Consumer<java.lang.Short> c)
        Java-Consumer which accepts Boxed Short-Integers
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Short Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Short> myConsumer = (Short boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.shortArr(ja, -1, 0, null, myConsumer);

      • byteArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void byteArr​
            (JsonArray ja,
             byte defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Byte> optionalUserParser,
             java.util.function.Consumer<java.lang.Byte> c)
        Java-Consumer which accepts Boxed-Bytes
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Byte Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Byte> myConsumer = (Byte boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.byteArr(ja, -1, 0, null, myConsumer);

      • longArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void longArr​
            (JsonArray ja,
             long defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Long> optionalUserParser,
             java.util.function.Consumer<java.lang.Long> c)
        Java-Consumer which accepts Boxed Long-Integers
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Long Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Long> myConsumer = (Long boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.longArr(ja, -1, 0, null, myConsumer);

      • doubleArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void doubleArr​
            (JsonArray ja,
             double defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Double> optionalUserParser,
             java.util.function.Consumer<java.lang.Double> c)
        Java-Consumer which accepts Boxed-Doubles
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Double Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Double> myConsumer = (Double boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.doubleArr(ja, -1, 0, null, myConsumer);

      • floatArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void floatArr​
            (JsonArray ja,
             float defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Float> optionalUserParser,
             java.util.function.Consumer<java.lang.Float> c)
        Java-Consumer which accepts Boxed-Floats
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Float Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Float> myConsumer = (Float boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.floatArr(ja, -1, 0, null, myConsumer);

      • booleanArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void booleanArr​
            (JsonArray ja,
             boolean defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Boolean> optionalUserParser,
             java.util.function.Consumer<java.lang.Boolean> c)
        Java-Consumer which accepts Boxed-Booleans
        Invokes: Method ProcessJsonArray.booleanToJava(JsonArray, SettingsRec)
        Passes: Java Boolean Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Boolean> myConsumer = (Boolean boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.booleanArr(ja, -1, 0, null, myConsumer);

      • numberArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void numberArr​
            (JsonArray ja,
             java.lang.Number defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Number> optionalUserParser,
             java.util.function.Consumer<java.lang.Number> c)
        Java-Consumer which accepts Best-Fit Boxed-Numbers
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Number Settings-Record
        See: Class JFlag for information about parameter 'FLAGS'
         

        Example:
        Consumer<Number> myConsumer = (Number boxedVal) -> System.out.println(boxedVal);
RJArrIntoBoxedConsumer.intArr(ja, -1, 0, null, myConsumer);

      • intArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void intArr2​
            (JsonArray ja,
             int defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Integer> optionalUserParser,
             IntIntTConsumer<java.lang.Integer> c)
        Java-Consumer accepting Boxed-Integers, w/ Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Integer Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Integer>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Integer value)
         

        Example:
        IntIntTConsumer<Integer> myConsumer = (int i1, int i2, Integer boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.intArr2(ja, -1, 0, null, myConsumer);

      • shortArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void shortArr2​
            (JsonArray ja,
             short defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Short> optionalUserParser,
             IntIntTConsumer<java.lang.Short> c)
        Java-Consumer accepting Boxed Short-Integers, w/ Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Short Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Short>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Short value)
         

        Example:
        IntIntTConsumer<Short> myConsumer = (int i1, int i2, Short boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.shortArr2(ja, -1, 0, null, myConsumer);

      • byteArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void byteArr2​
            (JsonArray ja,
             byte defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Byte> optionalUserParser,
             IntIntTConsumer<java.lang.Byte> c)
        Java-Consumer accepting Boxed-Bytes, w/ Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Byte Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Byte>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Byte value)
         

        Example:
        IntIntTConsumer<Byte> myConsumer = (int i1, int i2, Byte boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.byteArr2(ja, -1, 0, null, myConsumer);

      • longArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void longArr2​
            (JsonArray ja,
             long defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Long> optionalUserParser,
             IntIntTConsumer<java.lang.Long> c)
        Java-Consumer accepting Boxed Long-Integers, w/ Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Long Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Long>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Long value)
         

        Example:
        IntIntTConsumer<Long> myConsumer = (int i1, int i2, Long boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.longArr2(ja, -1, 0, null, myConsumer);

      • doubleArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void doubleArr2​
            (JsonArray ja,
             double defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Double> optionalUserParser,
             IntIntTConsumer<java.lang.Double> c)
        Java-Consumer accepting Boxed-Doubles, w/ Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Double Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Double>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Double value)
         

        Example:
        IntIntTConsumer<Double> myConsumer = (int i1, int i2, Double boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.doubleArr2(ja, -1, 0, null, myConsumer);

      • floatArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void floatArr2​
            (JsonArray ja,
             float defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Float> optionalUserParser,
             IntIntTConsumer<java.lang.Float> c)
        Java-Consumer accepting Boxed-Floats, w/ Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Float Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Float>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Float value)
         

        Example:
        IntIntTConsumer<Float> myConsumer = (int i1, int i2, Float boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.floatArr2(ja, -1, 0, null, myConsumer);

      • booleanArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void booleanArr2​
            (JsonArray ja,
             boolean defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Boolean> optionalUserParser,
             IntIntTConsumer<java.lang.Boolean> c)
        Java-Consumer accepting Boxed-Booleans, w/ Array-Indices
        Invokes: Method ProcessJsonArray.booleanToJava(JsonArray, SettingsRec)
        Passes: Java Boolean Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Boolean>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Boolean value)
         

        Example:
        IntIntTConsumer<Boolean> myConsumer = (int i1, int i2, Boolean boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.booleanArr2(ja, -1, 0, null, myConsumer);

      • numberArr2

        🡅  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void numberArr2​
            (JsonArray ja,
             java.lang.Number defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,​java.lang.Number> optionalUserParser,
             IntIntTConsumer<java.lang.Number> c)
        Java-Consumer accepting Best-Fit Boxed-Numbers, w/ Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Number Settings-Record, w/ an "Array-Indices & Count Consumer"
        See: Class JFlag for information about parameter 'FLAGS'
        Input-Consumer: Interface IntIntTConsumer<Number>
        Consumer-Signature: Like void accept (int jsonArrIndex, int successCount, Number value)
         

        Example:
        IntIntTConsumer<Number> myConsumer = (int i1, int i2, Number boxedVal) ->
    System.out.println("jsonArr[" + i1 + "], successCount[" + i2 + "]: " + boxedVal);

RJArrIntoBoxedConsumer.numberArr2(ja, -1, 0, null, myConsumer);