How to handle a large number of optional parameters

I am currently developing on a small library allowing to read and write Java .properties files while retaining all the formatting (comments, whitespace, etc.): https://github.com/hupfdule/apron

This library has a saveTo method to write the content of such a PropertyFile to a file or an OutputStream. At the moment this saveTo allows a Charset to be given as parameter to specify the encoding (if the default UTF-8 should not apply). This leaves me with the following method signatures:

saveTo(File)
saveTo(File, Charset)
saveTo(OutputStream)
saveTo(OutputStream, Charset)

However there are corresponding update and overwrite methods so there are actually 6 more methods (update does not allow an OutputStream):

update(File)
update(File, Charset)
overwrite(File)
overwrite(File, Charset)
overwrite(OutputStream)
overwrite(OutputStream, Charset)

Now I need to introduce another optional Parameter of the enum-type MissingKeyAction.

The question is: How to change the method signatures to allow, but not require the optional parameters.

I see the following approaches at the moment:

1. Provide only some parameter-combinations. This is similar to e.g. JOptionPane#showConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon) where I need to provide title, optionType and messageType when I actually only want to provide an icon.
2. Specify an overloaded method for each combination of optional parameters.
3. Introduce a new parameter object Options to encapsulate all optional parameters and only provide a method with and without such an Options parameter.

The 1st approach is not user friendly in my opinion as the consumer of the API needs to specify some parameter values even though he would like to just use the default for them.

The 2nd approach requires a lot of tedious work for specifying all method combinations and I would end up with lots of overloaded methods. This would get even worse if I need to introduce another parameter!

The 3rd approach seems to be the best in my opinion as it does not clutter the interface, allows the API user to provide only the Options where he does not want to rely on the default and it is even upward compatible as I do not need to change the method signatures when I need to add another optional parameter in the future.

If I provide a fluent interface for the Options class the client code could look something like this:

import java.io.File;
import static java.nio.charset.StandardCharsets.UTF_8;

public class TestApron {
  public static void main(String[] args) {
    final Options apronOptions= Options.create()
      .with(UTF_8)
      .with(MissingKeyAction.DELETE);
    final PropertyFile propertyFile= new PropertyFile();
    propertyFile.setValue("myKey", "myValue");
    propertyFile.saveTo(new File("someFile.properties"), apronOptions);
  }
}

As I already mentioned above I consider this new Options parameter as the best solution and am willing to implement this.

However I want to hear some other opinions on that topic and if there are even some other possibilities for addressing this problem I haven't thought of yet.