Java дезинфицирует предложения записей Arraylist

Question

Я ищу идею, как выполнить эту задачу. Итак, я начну с того, как работает моя программа.

Моя программа читает файл CSV. Это пары ключ-значение, разделенные запятой.

  L1234456,ygja-3bcb-iiiv-pppp-a8yr-c3d2-ct7v-giap-24yj-3gie
  L6789101,zgna-3mcb-iiiv-pppp-a8yr-c3d2-ct7v-gggg-zz33-33ie

так далее

Функция берет файл и анализирует его в arrayList из String[]. Функция возвращает ArrayList.

    public ArrayList<String[]> parseFile(File csvFile) {
    Scanner scan = null;
    try {
        scan = new Scanner(csvFile);
    } catch (FileNotFoundException e) {

    }

    ArrayList<String[]> records = new ArrayList<String[]>();
    String[] record = new String[2];
    while (scan.hasNext()) {
        record = scan.nextLine().trim().split(",");
        records.add(record);
    }
    return records;
 }

Вот код, где я вызываю файл разбора и передаю в CSVFile.

  ArrayList<String[]> Records = parseFile(csvFile);

Затем я создал еще один ArrayList для файлов, которые не анализируются.

  ArrayList<String> NotParsed = new ArrayList<String>();

Таким образом, программа продолжает очищать пары ключ-значение, разделенные запятой. Итак, сначала мы начнем с первого ключа в записи. Например, L1234456. Если запись не может быть очищена, то текущий ключ заменяется текстом "CouldNOtBeParsed".

for (int i = 0; i < Records.size(); i++) {
        if(!validateRecord(Records.get(i)[0].toString())) {
            Logging.info("Records could not be parsed " + Records.get(i)[0]);
               NotParsed.add(srpRecords.get(i)[0].toString());
            Records.get(i)[0] = "CouldNotBeParsed";
        } else {
            Logging.info(Records.get(i)[0] + " has been sanitized");
        }
    }

Затем мы делаем 2-й ключ в паре ключ-значение, например, ygja-3bcb-iiiv-pppp-a8yr-c3d2-ct7v-giap-24yj-3gie

for (int i = 0; i < Records.size(); i++) {
        if(!validateRecordKey(Records.get(i)[1].toString())) {
            Logging.info("Record Key could not be parsed " + Records.get(i)[0]);
               NotParsed.add(Records.get(i)[1].toString());
            Records.get(i)[1] = "CouldNotBeParsed";
        } else {
            Logging.info(Records.get(i)[1] + " has been sanitized");
        }
    }

Проблема в том, что мне нужно провести дезинфекцию обеих пар значений ключей, составить отдельный список пар ключей, которые не могли быть продезинфицированы, и список тех, которые были продезинфицированы, чтобы их можно было вставить в базу данных. Те, которые не могут быть распечатаны пользователю.

Я думал о зацикливании, думал о записях и удалял записи с текстом "CouldNotBeParsed", чтобы просто оставить те, которые могут быть проанализированы. Я также попытался удалить записи из цикла for Records.remove((i)); Однако это портит цикл For, потому что если первая запись не может быть очищена, то она удаляется, а на следующей итерации цикла она пропускается, потому что запись 2 теперь является записью 1. Именно поэтому я пошел с добавлением текста.

На самом деле мне нужны два списка, один для записей, которые были продезинфицированы, а другой нет.

Поэтому я подумал, что должен быть лучший способ сделать это. Или лучший метод дезинфекции обеих пар ключ-значение одновременно или что-то в этом роде. Предложения?

Answer 1

Начните с изменения структуры данных: вместо использования списка из двух элементов String[] массивы, определите класс для ваших пар ключ-значение:

class KeyValuePair {
    private final String key;
    private final String value;
    public KeyValuePair(String k, String v) { key = k; value = v; }
    public String getKey() { return key; }
    public String getValue() { return value; }
}

Обратите внимание, что класс является неизменным.

Теперь сделайте объект с тремя списками KeyValuePair объекты:

class ParseResult {
    private final List<KeyValuePair> sanitized = new ArrayList<KeyValuePair>();
    private final List<KeyValuePair> badKey = new ArrayList<KeyValuePair>();
    private final List<KeyValuePair> badValue = new ArrayList<KeyValuePair>();
    public ParseResult(List<KeyValuePair> s, List<KeyValuePair> bk, List<KeyValuePair> bv) {
        sanitized = s;
        badKey = bk;
        badValue = bv;
    }
    public List<KeyValuePair> getSanitized() { return sanitized; }
    public List<KeyValuePair> getBadKey() { return badKey; }
    public List<KeyValuePair> getBadValue() { return badValue; }
}

Наконец, заполните эти три списка в одном цикле, который читает из файла:

public static ParseResult parseFile(File csvFile) {
    Scanner scan = null;
    try {
        scan = new Scanner(csvFile);
    } catch (FileNotFoundException e) {
        ???
        // Do something about this exception.
        // Consider not catching it here, letting the caller deal with it.
    }
    final List<KeyValuePair> sanitized = new ArrayList<KeyValuePair>();
    final List<KeyValuePair> badKey = new ArrayList<KeyValuePair>();
    final List<KeyValuePair> badValue = new ArrayList<KeyValuePair>();
    while (scan.hasNext()) {
        String[] tokens = scan.nextLine().trim().split(",");
        if (tokens.length != 2) {
            ???
            // Do something about this - either throw an exception,
            // or log a message and continue.
        }
        KeyValuePair kvp = new KeyValuePair(tokens[0], tokens[1]);
        // Do the validation on the spot
        if (!validateRecordKey(kvp.getKey())) {
            badKey.add(kvp);
        } else if (!validateRecord(kvp.getValue())) {
            badValue.add(kvp);
        } else {
            sanitized.add(kvp);
        }
    }
    return new ParseResult(sanitized, badKey, badValue);
}

Теперь у вас есть единственная функция, которая выдает единый результат, в котором все ваши записи четко разделены на три группы - то есть очищенные записи, записи с плохими ключами и записи с хорошими ключами, но с плохими значениями.