Convert Java List to Javascript Array

Use GSON to convert java objects to JSON string, you can do it by

Gson gson = new Gson();
TestObject o1 = new TestObject("value1", 1);
TestObject o2 = new TestObject("value2", 2);
TestObject o3 = new TestObject("value3", 3);

List<TestObject> list = new ArrayList<TestObject>();
list.add(o1);
list.add(o2);
list.add(o3);

gson.toJson(list) will give you

[{"prop1":"value1","prop2":1}, {"prop1":"value2","prop2":2}, {"prop1":"value3","prop2":3}]

Now you can use JSON.parse(), to deserialize from JSON to Javascript Object.

You can use Gson Library.

Gson gson = new GsonBuilder().create();
JsonArray jsonArray = gson.toJsonTree(your_list, TypeClass.class).getAsJsonArray();

http://google-gson.googlecode.com/svn/trunk/gson/docs/javadocs/com/google/gson/Gson.html

Use Jackson. You'll need to add an " @JsonProperty" annotation to every property of your POJOs you want to pass, then do something like this:

    String respStr = "";

            for(Object whatever: MyList)    
        {
                JSONObject dato = new JSONObject();                    
                    dato.put("FirstField", whatever.SomeData());        
                        dato.put("SecondField", whatever.SomeData2());

                    StringEntity entity = new StringEntity(dato.toString());        
                    post.setEntity(entity);

                           webView.loadUrl("javascript:fetchFriends("+entity+")");
        }

I am not sure why no answer mentioned about jaxb. I am just thinking jaxb would be a good fit for this type of problems...

For a sample style of annotated jaxb class, please find this.

import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class ResponseAsList {
    private List < Object > list = new ArrayList < Object > ();

    public ResponseAsList() {
        // private default constructor for JAXB
    }
    public List < Object > getList() {
        return list;
    }

    public void setList(List < Object > list) {
        this.list = list;
    }

}

You will stuff your data in these lists and you will marshal either in xml or a json. After you get a json to the client, you can do a var myArray = JSON.parse(response);...

Although I typically advocate using something like GSON or Jackson to do JSON conversions for you, its pretty easy to roll your own if you're in a limited environment (like Android) and don't want to bundle a bunch of dependencies.

public class JsonHelper {
  public static String convertToJSON(List<GraphUser> users) {
    StringBuilder sb = new StringBuilder();
    for (GraphUser user : users) {
      sb.append(convertToJSON(user));
    }
    return sb.toString();
  }

  public static String convertToJSON(GraphUser user) {
    return new StringBuilder()
      .append("{")
        .append("\"id\":").append(user.getId()).append(",")
        .append("\"admin\":").append(user.isAdmin() ? "true" : "false").append(",")
        .append("\"name\":\"").append(user.getName()).append("\",")
        .append("\"email\":\"").append(user.getEmail()).append("\"")
      .append("}")
      .toString();
  }
}

You could obviously make a toJSON() method on GraphUser to put the logic if you prefer. Or use an injectable json helper library instead of static methods (I would). Or any number of other abstractions. Many developers prefer to separate representation of model objects into their own object, myself included. Personally, I might model it something like this if I wanted to avoid dependencies:

• interface Marshaller<F,T> with methods T marshall(F obj) and F unmarshall(T obj)
• interface JsonMarshaller<F> extends Marshaller<String>
• class GraphUserMarshaller implements JsonMarshaller<GraphUser>
• class GraphUserCollectionMarshaller implements JsonMarshaller<Collection<GraphUser>> which could do type-checking or use the visitor pattern or something to determine the best way to represent this type of collection of objects.

Along the way, I'm sure you'll find some repeated code to extract to super- or composite- classes, particularly once you start modeling collection marshallers this way. Although this can get to be pretty verbose (and tedious), it works particularly well in resource-constrained environments where you want to limit the number of libraries on which you depend.

You can use the Google Gson library (http://code.google.com/p/google-gson/) to convert the Java List Object to JSON. Ensure that the right fields are set like ID, UserName, FirstName, etc and on the java script side that same code would work.

Its just an example, First add javascript interface. It will be a bridge between javascript and java code. webView.addJavascriptInterface(new JSInterface(), "interface");

In javascript you can add like this,

     "window.interface.setPageCount(pageCount1);"

The interface is a keyword in common between java and javascript. create a class JSInterace and define a method setPageCount(int a). The script will return a value, and you can use that value in your java method