lettura più elementi da un file JSON

Question

Ho un file JSON con molti elementi come questi:

{ 
"code" : "hfuiew89", 
"type" : "location", 
"coordinates" : [ { "lat" : 40.9861, "lon" : 29.1046, "index" : 1 }, 
      { "lat" : 40.9976, "lon" : 29.1153, "index" : 2 }, 
      { "lat" : 40.9809, "lon" : 29.2194, "index" : 3 }] 
} 
{ 
"code" : "klsdsjh", 
"type" : "location", 
"relatedTags" : [ "kolmha" ], 
"coordinates" : [ { "lat" : 40.9808, "lon" : 29.1605, "index" : 1 }, 
       { "lat" : 40.9965, "lon" : 29.1672, "index" : 2 }] 
} 

voglio leggere quel file con GSON ma tutti gli esempi che ho trovato sono solo per un elemento. quindi dopo aver letto il primo, lancia l'eccezione 'EOF previsto'. come posso superare questo?

Answer 1

Greg ha ragione, questo è JSON errato, e dovresti provare a generare JSON valido, che è anteporre "[" all'inizio, append "]" alla fine e separare ogni elemento con una virgola (", "), in modo che sia un array JSON di oggetti JSON.

Tuttavia, se non è possibile modificare il formato che si possiede, considerarlo "una stringa contenente una concatenazione di frammenti JSON ben formati". Avvicinandoti in questo modo, spezza la grande stringa in stringhe json più piccole e valide e analizzale una ad una.

Per rompere la grande stringa in singoli frammenti è sufficiente contare le parentesi. Con un "pre-parser" che copia elementi in un buffer (un StringBuilder?), Incrementa un contatore ogni volta che incontra un "{", diminuisce ogni volta che enouter un "}" e se il contatore è a zero pass la stringa del buffer su gson per l'analisi, cancellare il buffer e andare alla fine del file.

Puoi anche usare quel pre-parser per convertirlo in json valido, semplicemente aggiungendo un "," quando il contatore raggiunge lo zero, e il passaggio di tutto a gson per un singolo parsing, ma ciò potrebbe significare caricare tutto in ram e non so quanto è grande il tuo file.

Answer 2

Per quel che vale ...

la seguente istruzione non è corretto. Gson non ha una funzione incorporata per gestire semplicemente la deserializzazione di tale sequenza JSON. (Vedere i commenti.)

Se l'opzione JSON-to/from-Java API è un'opzione, Jackson dispone di tale funzionalità, come illustrato di seguito.

input.json

{ 
"name":"A" 
} 
{ 
"name":"B" 
} 

JacksonFoo.java

import static com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility.ANY; 
import static com.fasterxml.jackson.annotation.PropertyAccessor.FIELD; 

import java.io.File; 
import java.util.Iterator; 

import com.fasterxml.jackson.databind.ObjectMapper; 

public class JacksonFoo 
{ 
    public static void main(String[] args) throws Exception 
    { 
    ObjectMapper mapper = new ObjectMapper().setVisibility(FIELD, ANY); 
    Iterator<Thing> thingsIterator = mapper.reader(Thing.class).readValues(new File("input.json")); 
    while (thingsIterator.hasNext()) 
    { 
     System.out.println(thingsIterator.next()); 
    } 
    } 
} 

class Thing 
{ 
    private String name; 

    @Override 
    public String toString() 
    { 
    return String.format("Thing: name=%s", name); 
    } 
} 

uscita:

Thing: name=A 
Thing: name=B 

---

Aggiornamento: Una soluzione simile che utilizza Gson.

GsonFoo.java

import java.io.FileReader; 

import com.google.gson.Gson; 
import com.google.gson.GsonBuilder; 
import com.google.gson.JsonStreamParser; 

public class GsonFoo 
{ 
    public static void main(String[] args) throws Exception 
    { 
    Gson gson = new GsonBuilder().create(); 

    JsonStreamParser parser = new JsonStreamParser(new FileReader("input.json")); 
    while(parser.hasNext()) 
    { 
     System.out.println(gson.fromJson(parser.next(), Thing.class)); 
    } 
    } 
}