Suivi de la ponctuation, de l'espacement, lors de la modification d'un fichier en Java

Question

J'écris un programme pour supprimer des mots consécutifs en double d'un fichier texte, puis remplace ce fichier texte sans les doublons. Je sais que mon code actuel ne gère pas le cas où un mot dupliqué est à la fin d'une ligne, et au début de la ligne suivante depuis que j'ai lu chaque ligne dans un ArrayList, trouver le doublon, et le supprimer. Après l'avoir écrit, je ne savais pas si c'était un bon moyen de le faire car maintenant je ne sais pas comment l'écrire. Je ne suis pas sûr de la façon dont je peux suivre la ponctuation des phrases de début et de fin de ligne, ainsi que l'espacement correct, et quand il y a des retours de ligne dans le fichier texte d'origine. Existe-t-il un moyen de gérer ces choses (espacement, ponctuation, etc.) avec ce que j'ai jusqu'ici? Ou dois-je faire une refonte? L'autre chose que j'ai pensé que je pourrais faire est de retourner un tableau de quels indices de mots j'ai besoin supprimé, mais je ne savais pas si c'est beaucoup mieux. Quoi qu'il en soit, voici mon code: (merci à l'avance!)

/** Removes consecutive duplicate words from text files. 
It accepts only one argument, that argument being a text file 
or a directory. It finds all text files in the directory and 
its subdirectories and moves duplicate words from those files 
as well. It replaces the original file. */ 

import java.io.*; 
import java.util.*; 

public class RemoveDuplicates { 

    public static void main(String[] args) { 


     if (args.length != 1) { 
      System.out.println("Program accepts one command-line argument. Exiting!"); 
      System.exit(1); 
     } 
     File f = new File(args[0]); 
     if (!f.exists()) { 
      System.out.println("Does not exist!"); 
     } 

     else if (f.isDirectory()) { 
      System.out.println("is directory"); 

     } 
     else if (f.isFile()) { 
      System.out.println("is file"); 
      String fileName = f.toString(); 
      RemoveDuplicates dup = new RemoveDuplicates(f); 
      dup.showTextFile(); 
      List<String> noDuplicates = dup.doDeleteDuplicates(); 
      showTextFile(noDuplicates); 
      //writeOutputFile(fileName, noDuplicates); 
     } 
     else { 
      System.out.println("Shouldn't happen"); 
     } 
    } 

    /** Reads in each line of the passed in .txt file into the lineOfWords array. */ 
    public RemoveDuplicates(File fin) { 
     lineOfWords = new ArrayList<String>(); 
     try { 
      BufferedReader in = new BufferedReader(new FileReader(fin)); 
      for (String s = null; (s = in.readLine()) != null;) { 
       lineOfWords.add(s); 
      } 
     } 
     catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    public void showTextFile() { 
     for (String s : lineOfWords) { 
      System.out.println(s); 
     } 
    } 

    public static void showTextFile(List<String> list) { 
     for (String s : list) { 
      System.out.print(s); 
     } 
    } 

    public List<String> doDeleteDuplicates() { 
     List<String> noDup = new ArrayList<String>(); // List to be returned without duplicates 
     // go through each line and split each word into end string array 
     for (String s : lineOfWords) { 
      String endString[] = s.split("[\\s+\\p{Punct}]"); 
      // add each word to the arraylist 
      for (String word : endString) { 
       noDup.add(word); 
      } 
     } 
     for (int i = 0; i < noDup.size() - 1; i++) { 
      if (noDup.get(i).toUpperCase().equals(noDup.get(i + 1).toUpperCase())) { 
       System.out.println("Removing: " + noDup.get(i+1)); 
       noDup.remove(i + 1); 
       i--; 
      } 
     } 
     return noDup; 
    } 

    public static void writeOutputFile(String fileName, List<String> newData) { 
     try { 
      PrintWriter outputFile = new PrintWriter(new BufferedWriter(new FileWriter(fileName))); 
      for (String str : newData) { 
       outputFile.print(str + " "); 
      } 
      outputFile.close(); 
     } 
     catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    private List<String> lineOfWords; 
} 

Un exemple.txt:

Hello hello this is a test test in order 
order to see if it deletes duplicates Duplicates words. 

Answer 1

Que diriez-vous quelque chose comme ça? Dans ce cas, je suppose qu'il est insensible à la casse.

Pattern p = Pattern.compile("(\\w+) \\1"); 
    String line = "Hello hello this is a test test in order\norder to see if it deletes duplicates Duplicates words."; 

    Matcher m = p.matcher(line.toUpperCase()); 

    StringBuilder sb = new StringBuilder(1000); 
    int idx = 0; 

    while (m.find()) { 
     sb.append(line.substring(idx, m.end(1))); 
     idx = m.end(); 
    } 
    sb.append(line.substring(idx)); 

    System.out.println(sb.toString()); 

est ici la sortie: -

Hello this a test in order 
order to see if it deletes duplicates words.