JSON array type from java.util.Collection or Object[] about json-simple HOT 11 CLOSED

Good suggestion. Yes we have quite a few requests on it. May consider it in 
future release.

Issue 67 has been merged into this issue.

Keen to hear thoughts on the solution attached for serializing Object[] to 
JSONArray

Changed files only based on read-only checkout.

Thanks for implementing this. ArrayIterator will work, but you could keep your 
implementation a bit more slim by using java.util.Arrays.asList() to convert 
Object[] to List<Object> and then iterating over that List...

Apart from that, what do you think about convenience methods for serialising 
arrays, such as byte[], short[], int[], long[], double[], float[], boolean[], 
char[]?

Cheers
Lukas

I did think of using Arrays.asList(), but I wasn't sure it was worth the extra 
overhead as all we want to do is iterate over it. That said, in my testing 
today it seems that the Arrays.asList() code is significantly faster, so I'll 
convert what I've done.

Primitive arrays can't be used with Arrays.asList() in json-simple to maintain 
backwards compatibility with jdks - I believe it requires autoboxing from 1.5.

You can iterate over primitive arrays using reflection, so that's an option. In 
the same test as above (testing with int[] as opposed to Integer[]), the 
primitive iteration using reflection was faster than the object iteration 
regardless.

Based on that, I have an updated version - using Arrays.asList and reflection 
for Primitives. 

Again, keen to hear thoughts. There does seem to be a bit of repetition in 
JSONArray, but based on my limited testing the code seems to run faster this 
way. 

Cheers
Mike

Added additional test case. 

"I did think of using Arrays.asList(), but I wasn't sure it was worth the extra 
overhead as all we want to do is iterate over it. That said, in my testing 
today it seems that the Arrays.asList() code is significantly faster, so I'll 
convert what I've done."

This seems to be incorrect, using the ArrayIterator *is* faster than 
Arrays.asList(), there was a class loading delay that I didn't take into 
account in my instrumentation.

Hi Mike,

You are right, there is a slight overhead when using Arrays.asList() compared 
to when using your ArrayIterator. This is obviously because of the additional 
load on the garbage collector, which has to collect a few more objects. I 
measured an improvement of around 8% when iterating over an array of 6 elements 
100M times (see attachment Test.java)

My output:
Arrays.asList(): 13.688056242
ArrayIterator  : 14.815422996


As far as primitive type arrays are concerned, I think you could overload your 
API method for every primitive type. I personally prefer that for type-safety, 
rather than having "hidden" instanceof checks on a generic Object-type 
argument. Specifically, when overloading a method once with List (raw-type) and 
once with Object, you actually lose some of your API expressiveness... 

So my suggestion is to overload the API several times:

public static String toJSONString(List<?> array);
public static String toJSONString(Object[] array);
public static String toJSONString(byte[] array);
public static String toJSONString(short[] array);
public static String toJSONString(int[] array);
public static String toJSONString(long[] array);

... etc. That is my personal taste (and I'm following some of the JDK's code 
patterns, such as in the java.util.Array class), but your taste may differ :-)

Implementation-wise, you might want to have a look at the various 
java.util.Arrays.toString() methods. For numeric values, you could maybe use 
those? Although, they render an additional whitespace after the comma, so that 
might not be what you need. Anyway, your int[]/long[] serialisation 
implementation can be done a lot more efficiently, as you don't need to escape 
any values...

Cheers
Lukas 

I had another look at the various alternatives and drew inspiration from the 
openjdk's implementation of Arrays.toString() (which is only avail in jdk 1.5+) 
to produce this next iteration. 

I've updated the original list implementations to be slightly more efficient, 
and added methods for the various types of primitive arrays and updated 
JSONValue to take advantage of this. 

I'm no longer using the ArrayIterator - using the jdk's for loop pattern was 
faster in my testing. I think the comments should also reference the 
Arrays.toString() method (they're really similar) somehow, but not sure what's 
appropriate. Let me know what you think?

Cheers

mike

Hi Mike,

I think this is going the right way! Agreed, for future readers, it would be 
nice to document that the inspiration came from Arrays.toString() methods

Thanks for your work!
Cheers
Lukas

This is done in r211.