Как перебрать список и создать собственный непоследовательный вывод

Question

Мне нужно сравнить строки двух отдельных файлов и вывести результат (сохраненный в отдельный список) заданным c способом. Файл1 - это оригинальный текст. Файл2 имеет несколько одинаковых или новых строк. Это означает, что некоторые строки, присутствующие в File1, отсутствуют в File2.

Например:
File1 :
A
B
C
D
E

Файл2 :
B
C
D
F
G

Вывод объединенного списка перед пользовательской сортировкой:
A - Удалено
B - То же
C - То же
D - То же
E - Удалено
F - Новое
G - Новое

Что мне нужно сделать, это вывести список следующим образом:
A - Удалено
B - То же самое
E - Удалено
C - То же самое
F - Новый
D - Тот же
G - Новый

По сути, одинаковые строки необходимо показывать (или сохранять изначально?) В каждом втором индексе.

Мне до сих пор удавалось сравнивать файлы (добавляя строки из каждого файла в два отдельных связанных списка и сравнивая их) и создал комбинированный список со статусом строки (то есть, тот же, удален, новый), добавленный к каждой строке.
Тем не менее, я просто не могу обернуться Алгоритм для этого вида пользовательской сортировки, так как я новичок в Java. Нужно ли создавать собственный итератор и передавать его в объединенный список? Или это может быть достигнуто с помощью listIterator по умолчанию?

Код до сих пор:

public class Solution {
    public static List<LineItem> lines = new ArrayList<>();

    public static void main(String[] args) {

        try (BufferedReader fileOne = new BufferedReader(new FileReader("file1.txt"));
             BufferedReader fileTwo = new BufferedReader(new FileReader("file2.txt"))) {

            List<String> listOne = new LinkedList<>();
            List<String> listTwo = new LinkedList<>();
            List<LineItem> listOfSame = new LinkedList<>();
            List<LineItem> result = new ArrayList<>();

            String line;

            while ((line = fileOne.readLine()) != null) {
                listOne.add(line);
            }

            while ((line = fileTwo.readLine()) != null) {
                listTwo.add(line);
            }

            for (String s : listOne) {
                if (listTwo.contains(s)) {
                    listOfSame.add(new LineItem(Type.SAME, s));
                } else if (!listTwo.contains(s)) {
                    lines.add(new LineItem(Type.REMOVED, s));
                }
            }

            for (String s : listTwo) {
                if (!listOne.contains(s)) {
                    lines.add(new LineItem(Type.ADDED, s));
                }
            }


            Iterator<LineItem> itSame = listOfSame.iterator();

            for (int i = 0; i < lines.size(); i++) {
                result.add(lines.get(i));

                if (i % 2 == 0 && itSame.hasNext()) {
                   result.add(itSame.next());
                }
            }

            while (itSame.hasNext()) {
                result.add(itSame.next());
            }

            for (LineItem item : result) {
              System.out.println(item.type.toString() + " " + item.line);                
            }


        } catch (IOException e) { e.printStackTrace(); }

    }

    public static enum Type {
        ADDED,        // New line added
        REMOVED,      // Line deleted
        SAME          // No change
    }

    public static class LineItem {
        public Type type;
        public String line;

        public LineItem(Type type, String line) {
            this.type = type;
            this.line = line;
        }
    }
}

Answer 1

Полагаю, вы могли бы переместить элементы SAME в отдельный список, а затем go через оба списка и выводить строку SAME через каждую другую итерацию (выполняя псевдо сортировку слиянием ). Что-то вроде:

List<LineItem> sameOnes = new ArrayList();
Iterator<LineItem> it = lines.iterator();
while (it.hasNext()) {
  LineItem item = it.next();
  if (item.type == Type.SAME) {
    sameOnes.add(item);
    it.remove();
  }
}

А потом:

List<LineItem> result = new ArrayList<>();
Iterator<LineItem> sameIt = sameOnes.iterator();
for (int i = 0; i < lines.size(); i++) {
  result.add(lines.get(i));
  // Ensure there still are same lines to output
  if (sameIt.hasNext()) {
    result.add(sameIt.next());
  }
}
// Fill in the rest in case there were more same than different lines
while (sameIt.hasNext()) {
  result.add(sameIt.next());
}