There are 4 known possible reasons why you may get empty Json in Unity.

1.Not including [Serializable]. You get empty json if you don't include this.

2.Using property (get/set) as your variable. JsonUtility does not support this.

3.Trying to serializing a collection other than List.

4.Your json is multi array which JsonUtility does not support and needs a wrapper to work.

The problem looks like #1. You are missing [Serializable] on the the classes. You must add using System; in order to use that.

Copy[Serializable]
public class SpriteData {
    public string sprite_name;
    public Vector2 sprite_size;
    public List<Vector2> subimage;
}

and

Copy[Serializable]
public class SpriteDataCollection
{
    public SpriteData[] sprites;
}

5.Like the example, given above in the SpriteData class, the variable must be a public variable. If it is a private variable, add [SerializeField] at the top of it.

Copy[Serializable]
public class SpriteDataCollection
{
    [SerializeField]
    private SpriteData[] sprites;
}

If still not working then your json is probably invalid. Read "4.TROUBLESHOOTING JsonUtility" from the answer in the "Serialize and Deserialize Json and Json Array in Unity" post. That should give you inside on how to fix this.

To be able to serialize some data using Unity's built in serializer, you will have to contain your data in a class. You can't simply serialize a list as is.

Something like this should work. You can make some sort of generic class like here, if you only need to serialize lists containing different types of data:

using System.Collections.Generic;
using UnityEngine;

public class SerializationDemo : MonoBehaviour
{
    [SerializeField] List<string> yourList;

    void Start()
    {
        // Your list with some data
        yourList = new List<string> { "foo", "bar" };

        // Store your data into a container class, 
        // this can be serialized
        var data = new SaveData<string>(yourList);

        // Class contents to json using Unity's serializer
        var jsonText = JsonUtility.ToJson(data);

        // Save your json data here instead of logging it...
        // JSON: {"list":["foo","bar"]}
        Debug.Log("JSON: " + jsonText.ToString());
    }
}


[System.Serializable]
public class SaveData<T>
{
    public List<T> list;

    public SaveData(List<T> data)
    {
        this.list = data;
    }
}

You can't serialize a List<> directly, same with a top-level array; you need a data container object. See below for an example, just put this script on an empty GameObject in your scene and press Play:

using System;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Demonstration of generic List serialization using JsonUtility
/// </summary>
public class ListTest : MonoBehaviour
{
	/// <summary>
	/// Initialization
	/// </summary>
	void Start ()
	{
		string json = SerializeToJson();
		DeserializeFromJson(json);
	}


	/// <summary>
	/// Creates the list and serializes it to a Json string
	/// </summary>
	/// <returns>Serialized Json string</returns>
	string SerializeToJson()
	{
		List<SomeDataModel> dataList = new List<SomeDataModel>();

		dataList.Add(new SomeDataModel(0, "Entry 1"));
		dataList.Add(new SomeDataModel(1, "Entry 2"));
		dataList.Add(new SomeDataModel(2, "Entry 3"));

		ListContainer container = new ListContainer(dataList);

		// TODO: Wrap this in try/catch to handle serialization exceptions
		string json = JsonUtility.ToJson(container);

		// Outputs: {"dataList":[{"ID":0,"Name":"Entry 1"},{"ID":1,"Name":"Entry 2"},{"ID":2,"Name":"Entry 3"}]}
		Debug.Log(json);

		return json;
	}


	/// <summary>
	/// Deserializes the Json string into the list object
	/// </summary>
	/// <param name="json">Json string</param>
	void DeserializeFromJson(string json)
	{
		// TODO: Wrap this in try/catch to handle deserialization exceptions
		ListContainer container = JsonUtility.FromJson<ListContainer>(json);

		Debug.Log(container.dataList.Count);
		for (int i = 0; i < container.dataList.Count; i++)
		{
			Debug.Log("ID: " + container.dataList[i].ID + ", Name: " + container.dataList[i].Name);
		}
	}
}


/// <summary>
/// Container struct for the List
/// </summary>
public struct ListContainer
{
	public List<SomeDataModel> dataList;

    /// <summary>
	/// Constructor
	/// </summary>
	/// <param name="_dataList">Data list value</param>
	public ListContainer(List<SomeDataModel> _dataList)
	{
		dataList = _dataList;
	}
}


/// <summary>
/// Some generic data model, used for List entries
/// </summary>
[Serializable]
public struct SomeDataModel
{
	public int ID;
	public string Name;

	/// <summary>
	/// Constructor
	/// </summary>
	/// <param name="_ID">ID value</param>
	/// <param name="_Name">Name value</param>
	public SomeDataModel(int _ID, string _Name)
	{
		ID = _ID;
		Name = _Name;
	}
}