Cómo obtener datos de intervalo de tiempo de org.json. ¿JSONArray en Java?

Tengo abajo los datos:

[{
    "DT": "2020-12-18 09:20:00",
    "High": 1432.15,
    "Open": 1425.8
}, {
    "DT": "2020-12-18 09:25:00",
    "High": 1425,
    "Open": 1424
}, {
    "DT": "2020-12-18 09:30:00",
    "High": 1423.1,
    "Open": 1423.1
}, {
    "DT": "2020-12-18 09:35:00",
    "High": 1421.1,
    "Open": 1419.15
}, {
    "DT": "2020-12-18 09:40:00",
    "High": 1420.85,
    "Open": 1418.7
}, {
    "DT": "2020-12-18 09:45:00",
    "High": 1418.9,
    "Open": 1415.85
}, {
    "DT": "2020-12-18 09:50:00",
    "High": 1418.9,
    "Open": 1418.5
}]

pero quiero datos como:

por intervalo de 10 minutos :

[{
    "DT": "2020-12-18 09:20:00",
    "High": 1432.15,
    "Open": 1425.8
},  {
    "DT": "2020-12-18 09:30:00",
    "High": 1423.1,
    "Open": 1423.1
},  {
    "DT": "2020-12-18 09:40:00",
    "High": 1420.85,
    "Open": 1418.7
}, {
    "DT": "2020-12-18 09:50:00",
    "High": 1418.9,
    "Open": 1418.5
}]

por intervalo de 15 minutos

[{
    "DT": "2020-12-18 09:20:00",
    "High": 1432.15,
    "Open": 1425.8
},{
    "DT": "2020-12-18 09:35:00",
    "High": 1421.1,
    "Open": 1419.15
}, {
    "DT": "2020-12-18 09:50:00",
    "High": 1418.9,
    "Open": 1418.5
}]

Pregunta hecha hace 3 años, 4 meses, 27 días - Por coderchampion

3 Respuestas:

  • Java 8 y superior

    Crear los métodos a continuación y llamar JSONArray tenMinutesArray = filterData( originalJSONArray, 10 );

    private static JSONArray filterData( JSONArray values, int interval ) {
    JSONArray newArray = new JSONArray();
    newArray.put( values.getJSONObject( 0 ) );
    LocalDateTime start = parseDate( values.getJSONObject( 0 ).getString( "DT" ) );

    for ( int i = 1; i < values.length(); i++ ) {
        JSONObject entry = values.getJSONObject( i );
        LocalDateTime dt = parseDate( entry.getString( "DT" ) );
        int diff = dt.minusMinutes( start.getMinute() ).getMinute();
        if ( diff % interval == 0 ) {
            newArray.put( entry );
        }
    }
    return newArray;
}

private static LocalDateTime parseDate( String dateTime ) {
    return LocalDateTime.parse( dateTime.replaceAll( " ", "T" ) );
}

    Java 7 y más viejo

    Esto es más fácil de hacer con Joda-Time.

    Añadir la dependencia a tu nodo en tu pom.xml:

    
    joda-time
    joda-time
    2.10.8

    Copiar los métodos a continuación y llamar JSONArray tenMinutesArray = filterData( originalJSONArray, 10 ); con la cantidad de minutos que desea establecer como intervalo.

    private static JSONArray filterData( JSONArray values, int interval ) {
    JSONArray newArray = new JSONArray();
    DateTime start = parseDate( values.getJSONObject( 0 ).getString( "DT" ) );
    newArray.put( values.getJSONObject( 0 ) );

    for ( int i = 1; i < values.length(); i++ ) {
        JSONObject entry = values.getJSONObject( i );
        DateTime dt = parseDate( entry.getString( "DT" ) );
        Minutes diff = Minutes.minutesBetween( start, dt );
        if ( diff.getMinutes() % interval == 0 ) {
            newArray.put( entry );
        }
    }
    return newArray;
}

private static DateTime parseDate( String dateTime ) {
    return DateTime.parse( ( dateTime + "Z" ).replaceAll( " 0?", "T" ) );
}

    Respondida el Dec 18, 2020 a las 14:26 - por compilerhero

    Votos positivos: 0 | Votos negativos: 0

  • Para lograr esto, primero necesitas convertir los datos JSON en un JSONArray. Luego, puedes iterar sobre el JSONArray y comparar las fechas para obtener los datos correspondientes al intervalo de tiempo.

    Aquí te muestro un ejemplo de cómo puedes lograr esto:

    java
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) throws JSONException, ParseException {
        String jsonData = "[{\"DT\":\"2020-12-18 09:20:00\", \"High\":1432.15, \"Open\":1425.8}, {\"DT\":\"2020-12-18 09:25:00\", \"High\":1425, \"Open\":1424}, {\"DT\":\"2020-12-18 09:30:00\", \"High\":1423.1, \"Open\":1423.1}, {\"DT\":\"2020-12-18 09:35:00\", \"High\":1421.1, \"Open\":1419.15}, {\"DT\":\"2020-12-18 09:40:00\", \"High\":1420.85, \"Open\":1418.7}, {\"DT\":\"2020-12-18 09:45:00\", \"High\":1418.9, \"Open\":1415.85}, {\"DT\":\"2020-12-18 09:50:00\", \"High\":1418.9, \"Open\":1418.5}]";

        JSONArray jsonArray = new JSONArray(jsonData);

        int intervaloMinutos = 15; // Puedes cambiar el intervalo de minutos según tus necesidades
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date fechaAnterior = null;

        for (int i = 0; i < jsonArray.length(); i++) {
            JSONObject data = jsonArray.getJSONObject(i);
            Date fechaActual = dateFormat.parse(data.getString("DT"));

            if (fechaAnterior == null || (fechaActual.getTime() - fechaAnterior.getTime()) >= intervaloMinutos  60  1000) {
                System.out.println(data);
                fechaAnterior = fechaActual;
            }
        }
    }
}

    En este ejemplo, primero convertimos la cadena de datos JSON en un JSONArray. Luego, definimos el intervalo de tiempo en minutos y creamos un formato de fecha. Luego, iteraremos sobre el JSONArray, parsearemos las fechas y compararemos si el tiempo transcurrido desde la fecha anterior es mayor o igual al intervalo especificado. Si es así, imprimiremos los datos correspondientes.

    Por favor, ajusta el código según tus necesidades específicas y asegúrate de manejar las excepciones adecuadamente.

    Respondida el Dec 19, 2020 a las 14:21 - por Gpt

    Votos positivos: 0 | Votos negativos: 0 

  • java
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import org.json.JSONArray;

import java.lang.reflect.Type;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.*;

public class DataInterval {

    public static void main(String[] args) {
        // Datos de ejemplo
        String data = "[{\n" +
                "    \"DT\": \"2020-12-18 09:20:00\",\n" +
                "    \"High\": 1432.15,\n" +
                "    \"Open\": 1425.8\n" +
                "}, {\n" +
                "    \"DT\": \"2020-12-18 09:25:00\",\n" +
                "    \"High\": 1425,\n" +
                "    \"Open\": 1424\n" +
                "}, {\n" +
                "    \"DT\": \"2020-12-18 09:30:00\",\n" +
                "    \"High\": 1423.1,\n" +
                "    \"Open\": 1423.1\n" +
                "}, {\n" +
                "    \"DT\": \"2020-12-18 09:35:00\",\n" +
                "    \"High\": 1421.1,\n" +
                "    \"Open\": 1419.15\n" +
                "}, {\n" +
                "    \"DT\": \"2020-12-18 09:40:00\",\n" +
                "    \"High\": 1420.85,\n" +
                "    \"Open\": 1418.7\n" +
                "}, {\n" +
                "    \"DT\": \"2020-12-18 09:45:00\",\n" +
                "    \"High\": 1418.9,\n" +
                "    \"Open\": 1415.85\n" +
                "}, {\n" +
                "    \"DT\": \"2020-12-18 09:50:00\",\n" +
                "    \"High\": 1418.9,\n" +
                "    \"Open\": 1418.5\n" +
                "}]";

        // Convertir la cadena JSON a un objeto JSONArray
        JSONArray jsonArray = new JSONArray(data);

        // Crear un conversor Gson
        Gson gson = new Gson();

        // Obtener el tipo de lista de objetos de datos de intervalo de tiempo
        Type type = new TypeToken>() {}.getType();

        // Convertir el JSONArray a una lista de objetos de datos de intervalo de tiempo
        List intervalDataList = gson.fromJson(jsonArray.toString(), type);

        // Agrupar los datos por intervalo de 10 minutos
        Map> interval10Minutes = groupByInterval(intervalDataList, 10);

        // Imprimir los datos agrupados
        System.out.println("Datos agrupados por intervalo de 10 minutos:");
        for (Map.Entry> entry : interval10Minutes.entrySet()) {
            System.out.println(entry.getKey());
            for (TimeIntervalData intervalData : entry.getValue()) {
                System.out.println(intervalData);
            }
        }

        // Agrupar los datos por intervalo de 15 minutos
        Map> interval15Minutes = groupByInterval(intervalDataList, 15);

        // Imprimir los datos agrupados
        System.out.println("Datos agrupados por intervalo de 15 minutos:");
        for (Map.Entry> entry : interval15Minutes.entrySet()) {
            System.out.println(entry.getKey());
            for (TimeIntervalData intervalData : entry.getValue()) {
                System.out.println(intervalData);
            }
        }
    }

    // Método para agrupar los datos por intervalo de tiempo
    private static Map> groupByInterval(List intervalDataList, int interval) {
        // Ordenar los datos por fecha y hora
        intervalDataList.sort(Comparator.comparing(TimeIntervalData::getDateTime));

        // Crear un mapa para almacenar los datos agrupados
        Map> intervalMap = new HashMap<>();

        // Recorrer los datos y agruparlos por intervalo de tiempo
        LocalDateTime previousDateTime = null;
        List currentIntervalData = new ArrayList<>();
        for (TimeIntervalData intervalData : intervalDataList) {
            // Obtener la fecha y hora actual
            LocalDateTime currentDateTime = intervalData.getDateTime();

            // Comprobar si la fecha y hora actual está dentro del intervalo
            if (previousDateTime == null || currentDateTime.minusMinutes(interval).isAfter(previousDateTime)) {
                // Si es el primer intervalo o si la fecha y hora actual está fuera del intervalo anterior,
                // crear un nuevo intervalo y añadir los datos actuales
                String intervalKey = currentDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:00"));
                intervalMap.put(intervalKey, new ArrayList<>());
                currentIntervalData = intervalMap.get(intervalKey);
                currentIntervalData.add(intervalData);
            } else {
                // Si la fecha y hora actual está dentro del intervalo, añadir los datos actuales al intervalo actual
                currentIntervalData.add(intervalData);
            }

            // Actualizar la fecha y hora anterior
            previousDateTime = currentDateTime;
        }

        // Devolver los datos agrupados
        return intervalMap;
    }

    // Clase para representar los datos del intervalo de tiempo
    static class TimeIntervalData {
        private LocalDateTime dateTime;
        private double high;
        private double open;

        public TimeIntervalData(String dateTime, double high, double open) {
            this.dateTime = LocalDateTime.parse(dateTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            this.high = high;
            this.open = open;
        }

        public LocalDateTime getDateTime() {
            return dateTime;
        }

        public double getHigh() {
            return high;
        }

        public double getOpen() {
            return open;
        }

        @Override
        public String toString() {
            return String.format("{\"DT\": \"%s\", \"High\": %.2f, \"Open\": %.2f}",
                    dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:00")), high, open);
        }
    }
}

    Respondida el Dec 19, 2020 a las 14:32 - por Gemini

    Votos positivos: 0 | Votos negativos: 0