GSON and NaN

[Jon Swanson]

I am trying to use GSON to serialize a MAP that is keyed on an object. For the most part, it is working, but I get the error:

Exception in thread "AWT-EventQueue-0" java.lang.IllegalArgumentException: JSON forbids NaN and infinities: NaN

I believe that GSON should accept NaN. Here is an old coderanch question where the suggestion was to use gson:

https://coderanch.com/t/528867/java/JSON-Parsing-NaN-Infinity

Here is my code. First the attempt to convert the map to a GSON string and back and then a simplified example of the class that contains the key. I thought that "serializeSpecialFloatingPointValues()" would allow using NaN, but it is not working. If I change the DataEntry class and removed the Double.NaN assignment, I get a GSON string, but, of course, the class no longer works correctly in the application.

Any thoughts on what I am missing? I am using gson 2.8.5.

import java.util.*;
import java.awt.*;
import javax.swing.*;
import java.io.*;
//
// For GSON
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import com.google.gson.annotations.SerializedName;
//
// Tests to determine best way to save and load maps
public class TestSaveLoadMap extends JFrame
{
   Map<DataEntry, ArrayList<String>> testMap;

   String gsonString;

   TestSaveLoadMap()
   {
      buildTestMap();
      listTestMap();
   }

   private void buildTestMap()
   {
      testMap = new TreeMap<DataEntry, ArrayList<String>>();
      testMap.put( new DataEntry( 50, 80 ),
                   new ArrayList<String>(
                       Arrays.asList( "A", "B", "C" ) ) );
      testMap.put( new DataEntry( 60, 60 ),
                   new ArrayList<String>(
                       Arrays.asList( "D", "E", "F" ) ) );
      testMap.put( new DataEntry( 60, 40 ),
                   new ArrayList<String>(
                       Arrays.asList( "G", "H", "I" ) ) );
      testMap.put( new DataEntry( 70, 20 ),
                   new ArrayList<String>(
                       Arrays.asList( "J", "K", "L" ) ) );
//
// Convert to gson
      GsonBuilder gb = new GsonBuilder();
      gb.serializeSpecialFloatingPointValues();
      gb.enableComplexMapKeySerialization();
      gb.serializeNulls();
      gb.setLenient();
  
      Gson g = gb.create();
      gsonString = g.toJson( testMap );
      System.out.println( gsonString );
   }

   private void listTestMap()
   {
      java.lang.reflect.Type mapType =
         new TypeToken<Map<DataEntry, ArrayList<String>>>(){}.getType();
      Map<DataEntry, ArrayList<String>> testMapOut =
         new Gson().fromJson( gsonString, mapType );
      for ( DataEntry entry : testMapOut.keySet() )
         System.out.println( entry + " contains " + testMapOut.get( entry ) );
   }

   public static void main( String args[] )
   {
      Runnable runMe = new Runnable()
      {
         public void run()
         {
            TestSaveLoadMap testMe = new TestSaveLoadMap();
         }
      };

      SwingUtilities.invokeLater( runMe );
   }
}

import java.util.*;

/**
 * Defines basic data entry
 *
 */
class DataEntry implements Comparable<DataEntry>
{
   double a;
   double b;
   double c;
   double precision = 0.0001;
/**
 * Create from a, b, c
 *
 */
   DataEntry( double a, double b, double c )
   {
      this.a  = a;
      this.b  = b;
      this.c  = c;
   }
/**
 * Create from a, c
 *
 */
   DataEntry( double a, double c )
   {
      this.a  = a;
      this.b  = Double.NaN;
      this.c  = c;
   }
/**
 * Overrides equals method
 *
 * @param  obj  the condition being compared
 *
 * @return true if conditions are equal, false otherwise
 */
   @Override
   public boolean equals( Object obj )
   {
      if ( obj == null )
         return false;
      if ( !( obj instanceof DataEntry ) )
         return false;
      if ( obj == this )
         return true;

      DataEntry other = (DataEntry) obj;

      if (   Double.isNaN( b ) && ! Double.isNaN( other.b ) ) return false;
      if ( ! Double.isNaN( b ) &&   Double.isNaN( other.b ) ) return false;

      boolean result = ( Math.abs( a  - other.a  ) < precision );

      if ( ! Double.isNaN( b ) && ! Double.isNaN( other.b ) )
      {
         if ( Math.abs( b - other.b ) > precision )
            result = false;
      }

      if ( Math.abs( c  - other.c  ) > precision )
         result = false;

      return result;
   }
/**
 * Overrides hashCode method
 *
 */
   @Override
   public int hashCode()
   {
      long C1;

      long hash;

      hash   = Math.round( a * 100  );

      if ( ! Double.isNaN( b ) )
      {
         hash = ( hash * ( Math.round( b * 100 ) + hash ) );
      }

      hash = ( hash * ( (long) c + hash ) );

      return (int) hash;
   }
/**
 * Overrides compareTo method
 *
 * @param  obj the condition being compared
 *
 * @return -1 if less, 0 if equals, 1 if greater
 */
   @Override
   public int compareTo( DataEntry obj )
   {
      if ( obj == null )
         throw new NullPointerException();

      DataEntry other = obj;

      long   A1l = Math.round( a       / precision );
      long   A2l = Math.round( other.a / precision );

      if ( A1l != A2l )
         return (int) (A1l - A2l );

      if (   Double.isNaN( b ) && ! Double.isNaN( other.b ) ) return -1;
      if ( ! Double.isNaN( b ) &&   Double.isNaN( other.b ) ) return  1;

      if ( ! Double.isNaN( b ) && ! Double.isNaN( other.b ) )
      {
         long   B1l = Math.round( b       / precision );
         long   B2l = Math.round( other.b / precision );

         if ( B1l != B2l )
            return (int) ( B1l - B2l );
      }

      long   C1l = Math.round( c        / precision );
      long   C2l = Math.round( other.c  / precision );

      if ( C1l != C2l )
         return (int) ( C1l - C2l );

      return 0;
   }
/**
 * Overrides toString method
 *
 * @return String formatted
 */
   @Override
   public String toString()
   {
      if ( Double.isNaN( b ) )
         return String.format( "(%.2f, %.2f)", a, c  );

      return String.format( "(%.2f, %.2f, %.2f)", a, b, c );
   }
}

[Ron McLeod]

I wrote a simple application to try it myself - seems like registering the serializeSpecialFloatingPointValues() method does support NaN and +/- Infinity - both serializing and deserializing.Test data: value=123.4 value=NaN value=-Infinity value=Infinity Serialized: [{"value":123.4},{"value":NaN},{"value":-Infinity},{"value":Infinity}] Deserialized: value=123.4 value=NaN value=-Infinity value=Infinity

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;

public class MyDoubleTest {
	private Gson gson;
	private Type doubleDataListType;

	public static void main(String[] args) {
		// create test data
		List<MyDoubleData> items = new ArrayList<>();
		items.add(new MyDoubleData(123.4));
		items.add(new MyDoubleData(Double.NaN));
		items.add(new MyDoubleData(Double.NEGATIVE_INFINITY));
		items.add(new MyDoubleData(Double.POSITIVE_INFINITY));
		System.out.println("Test data:");
		items.forEach(item -> System.out.println(item));
		System.out.println();

		MyDoubleTest test = new MyDoubleTest();

		// serialize
		String json = test.serialize(items);
		System.out.printf("Serialized:\n%s\n\n", json);

		// deserialize
		List<MyDoubleData> deserializedItems = test.deserialize(json);
		System.out.println("Deserialized:");
		deserializedItems.forEach(item -> System.out.println(item));
	}

	private MyDoubleTest() {
		gson = new GsonBuilder().serializeSpecialFloatingPointValues().create();
		doubleDataListType = new TypeToken<List<MyDoubleData>>() {
		}.getType();
	}

	private String serialize(List<MyDoubleData> items) {
		return gson.toJson(items);
	}

	private List<MyDoubleData> deserialize(String json) {
		return gson.fromJson(json, doubleDataListType);
	}

}

public class MyDoubleData {

	private double value;

	public MyDoubleData(double value) {
		this.value = value;
	}

	public double getItem() {
		return value;
	}

	public void setItem(double value) {
		this.value = value;
	}

	@Override
	public String toString() {
		return "value=" + value;
	}

}

[Ron McLeod]

It looks like you have run in to the Serialization of NaN/Inf with complex map key serialization and special floating point values enabled is broken issue - which appears to still be unresolved.

You can work-around this by defining a TypeAdapter for your key class to serialize and deserialize the key - for example:

import java.io.IOException;

import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;

public class DataEntryAdapter extends TypeAdapter<DataEntry> {

	@Override
	public void write(JsonWriter out, DataEntry entry) throws IOException {
		// Writes one JSON value (an array, object, string, number, boolean or null) for
		// value.
		out.value(String.format("%.2f,%.2f,%.2f", entry.a, entry.b, entry.c));

	}

	@Override
	public DataEntry read(JsonReader in) throws IOException {
		// Reads one JSON value (an array, object, string, number, boolean or null) and
		// converts it to a Java object.
		String key = in.nextString();
		String[] parts = key.split(",");
		if (parts.length == 3) {
			return new DataEntry(Double.valueOf(parts[0]), Double.valueOf(parts[1]), Double.valueOf(parts[2]));
		}
		return null;
	}

}

Change the JSON representation to whatever is needed if the key needs to be compatible with other applications.

The adapter needs to be registered with your Gson instances - for example:

   private void buildTestMap()
   {
      ...
//
// Convert to gson
      Gson gson = new GsonBuilder()
      .serializeSpecialFloatingPointValues()
      .enableComplexMapKeySerialization()
      .registerTypeAdapter(DataEntry.class, new DataEntryAdapter()) // <<<<<<<<
      .setPrettyPrinting()
      .create();
   
      gsonString = gson.toJson( testMap );
      System.out.println( gsonString );
   }

   private void listTestMap()
   {
      java.lang.reflect.Type mapType =
         new TypeToken<Map<DataEntry, ArrayList<String>>>(){}.getType();

         Gson gson = new GsonBuilder()
        	      .setLenient()
        	      .registerTypeAdapter(DataEntry.class, new DataEntryAdapter()) // <<<<<<<<
        	      .create();
         
         Map<DataEntry, ArrayList<String>> testMapOut =
         gson.fromJson( gsonString, mapType );
      for ( DataEntry entry : testMapOut.keySet() )
         System.out.println( entry + " contains " + testMapOut.get( entry ) );
   }

{  "50.00,NaN,80.00": [    "A",    "B",    "C"  ],  "60.00,NaN,40.00": [    "G",    "H",    "I"  ],  "60.00,NaN,60.00": [    "D",    "E",    "F"  ],  "70.00,NaN,20.00": [    "J",    "K",    "L"  ] } (50.00, 80.00) contains [A, B, C] (60.00, 40.00) contains [G, H, I] (60.00, 60.00) contains [D, E, F] (70.00, 20.00) contains [J, K, L]

[Jon Swanson]

That's great, thank you. The TypeAdapter seems to resolve my problem nicely. The actual class (optionally) takes an instance of another class as an argument, i.e. DataEntry( Point p, double v) but that other class is quite simple (just created to implement Comparable) so it should just be a matter of writing the read/write methods for DataEntry to handle that situation.