quiz.java

quiz.java

/**
 * Please review the class below and suggest improvements. How would
 * you refactor this class if it would be in a real-life project?
 * There are many problems here, both high-level design mistakes,
 * and low-level implementation bugs. We're interested to see high-level
 * problems first, since they are most critical. The more mistakes
 * you can spot, the better programmer you are.
 */
 
/**
 * This class is thread safe.
 */
public class Parser {
  private File file;
  public synchronized void setFile(File f) {
    file = f;
  }
  public synchronized File getFile() {
    return file;
  }
  public String getContent() throws IOException {
    InputStream i = new FileInputStream(file);
    String output = "";
    int data;
    while ((data = i.read()) > 0) {
      output += (char) data;
    }
    return output;
  }
  public String getContentWithoutUnicode() throws IOException {
    InputStream i = new FileInputStream(file);
    String output = "";
    int data;
    while ((data = i.read()) > 0) {
      if (data < 0x80) {
        output += (char) data;
      }
    }
    return output;
  }
  public void saveContent(String content) throws IOException {
    OutputStream o = new FileOutputStream(file);
    for (int i = 0; i < content.length(); i += 1) {
      o.write(content.charAt(i));
    }
  }
}

/**
 * Made this class fully public for next extend cases
 * For now it's unclear is this need to split FileContent class to different ones
 *
 * F.e. ParsedFile could have two methods returning SimpleContent and UnicodeFreeContent 
 * And each *Content class could have unique logic in it
 * 
 * ParsedFile is thread safe because of immutability 
 */
class FileContent {
    private final String raw;

    public FileContent(String rawContent) {
        this.raw = rawContent;
    }

    public String text() {
        return this.raw;
    }
}

class ParsedFile {
    private final InputStream fileInputStream;

    public ParsedFile(InputStream fileInputStream) {
        this.fileInputStream = fileInputStream;
    }

    public FileContent content() {
        String content = "bytes converted to string";
        return new FileContent(content);
    }

    public FileContent contentUnicodeFree() {
        String content = "bytes converted to string without unicode";
        return new FileContent(content);
    }
}

class DefaultParsedFileUsage {
    public static void main(String[] args) {
            File file = new File("path");
            try(InputStream is = new FileInputStream(file)) {
                ParsedFile parsedFile = new ParsedFile(is);
                FileContent fileContent = parsedFile.content();
                String fileText = fileContent.text();
                // next code
            } catch (IOException ioException) {
                // logging exception
            }
    }
}

I prefer to redesign this peace of code just like that

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.function.UnaryOperator;

interface Content {
    String asString() throws IOException;
    void replaceWith(final String s) throws IOException;
}

final class ContentOf implements Content {
    private final File file;

    public ContentOf(final File f) {
        this.file = f;
    }

    @Override
    public synchronized String asString() throws IOException {
        try (final var f = new FileInputStream(this.file)) {
            return new String(f.readAllBytes(), StandardCharsets.UTF_8);
        }
    }

    @Override
    public synchronized void replaceWith(final String s) throws IOException {
        try (final var f = new FileOutputStream(this.file)) {
            f.write(s.getBytes(StandardCharsets.UTF_8));
        }
    }
}

final class AsciiOnly implements Content {
    private final Content origin;
    private final UnaryOperator<String> filter;

    public AsciiOnly(final Content c) {
        this(
            c,
            s -> s
                .codePoints()
                .filter(el -> el < 0x80)
                .collect(
                    StringBuilder::new,
                    StringBuilder::appendCodePoint,
                    StringBuilder::append
                )
                .toString()
        );
    }

    public AsciiOnly(final Content c, final UnaryOperator<String> f) {
        this.origin = c;
        this.filter = f;
    }

    @Override
    public synchronized String asString() throws IOException {
        return this.filter.apply(this.origin.asString());
    }

    @Override
    public synchronized void replaceWith(final String s) throws IOException {
        this.origin.replaceWith(this.filter.apply(s));
    }
}