Java replace characters in a TextFile - Alice In Wonderland

Question

I'm trying to make a compressor for TextFiles and I get stuck at replacing characters.

This is my code:

compress.setOnAction(event ->
    {
        String line;
        try(BufferedReader reader = new BufferedReader(new FileReader(newFile)))
        {
            while ((line = reader.readLine()) != null)
            {
                int length = line.length();
                String newLine = "";


                for (int i = 1; i < length; i++)
                {
                    int c = line.charAt(i);

                    if (c == line.charAt(i - 1))
                    {

                    }
                }
            }

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

So what I want to do is: I want to find all the words where two characters are equal, if they are aside (Like 'Took'). When the if statement is true, I want to replace the first letter of the two equals characters, so it would look like: 'T2ok'.

I've tried a lot of things and I get an ArrayOutOfbounds, StringOutOfbounds, and so on, all the time...

Hope someone has a great answer :-)

Regards

Answer 1

Create a method that compress one String as follows:
Loop throu every character using a while loop. Count the duplicates in another nested while loop that increments the current index while duplicates are found and skips them from being written to output. Additionally this counts their occurence.

public String compress(String input){
    int length = input.length(); // length of input
    int ix = 0;                  // actual index in input
    char c;                      // actual read character
    int ccounter;                // occurrence counter of actual character
    StringBuilder output =       // the output
            new StringBuilder(length);

    // loop over every character in input
    while(ix < length){
        // read character at actual index then inc index
        c = input.charAt(ix++);
        // we count one occurrence of this character here
        ccounter = 1;
        // while not reached end of line and next character
        // is the same as previously read
        while(ix < length && input.charAt(ix) == c){
            // inc index means skip this character
            ix++;
            // and inc character occurence counter
            ccounter++;
        }
        // if more than one character occurence is counted
        if(ccounter > 1){
            // print the character count
            output.append(ccounter);
        }
        // print the actual character
        output.append(c);
    }
    // return the full compressed output
    return output.toString();
}

Now you can use this method to create a file input to output stream using java8 techniques.

// create input stream that reads line by line, create output writer
try (Stream<String> input = Files.lines(Paths.get("input.txt"));
     PrintWriter output = new PrintWriter("output.txt", "UTF-8")){
    // compress each input stream line, and print to output
    input.map(s -> compress(s)).forEachOrdered(output::println);
} catch (IOException e) {
    e.printStackTrace();
}

If you really want to. You can remove the input file and rename the output file afterwards with

Files.move(Paths.get("output.txt"), Paths.get("input.txt"),StandardCopyOption.REPLACE_EXISTING);

I think this is the most efficient way to do what you want.

Answer 2

try this:

    StringBuilder sb = new StringBuilder();
    String line;
    try(BufferedReader reader = new BufferedReader(new FileReader(newFile)))
    {
        while ((line = reader.readLine()) != null)
        {

            if (!line.isEmpty()) {

                //clear states
                boolean matchedPreviously = false;
                char last = line.charAt(0);

                sb.setLength(0);
                sb.append(last);

                for (int i = 1; i < line.length(); i++) {
                    char c = line.charAt(i);

                    if (!matchedPreviously && c == last) {

                        sb.setLength(sb.length()-1);
                        sb.append(2);

                        matchedPreviously = true;
                    } else matchedPreviously = false;

                    sb.append(last = c);
                }
                System.out.println(sb.toString());
            }
        }

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

This solution uses only a single loop, but can only find occurrences of length 2