概括具有不同一元运算符的两个相似方法

Question

Suppose I have the following implementations

private static String encryptPassword(String password) {
    String encryptedPassword = "";
    char[] chars = password.toCharArray();
    for (char c : chars) {
        encryptedPassword = encryptedPassword.concat(String.valueOf(++c));
    }
    return encryptedPassword;
}

private static String decryptPassword(String encryptedPassword) {
    String decryptedPassword = "";
    char[] chars = encryptedPassword.toCharArray();
    for (char c : chars) {
        decryptedPassword = decryptedPassword.concat(String.valueOf(--c));
    }
    return decryptedPassword;
}

These methods do very simple stuff that it will increase each character in a string by 1 and this process is considered as encryption. As a contrast, the process of decryption will decrease the value.

I can see that these two methods are pretty much the same, except the unary operators.

How can I generalize these two methods?

Furthermore, I also prefer streaming processing to looping. If you have any ideas regarding this point please posting as well.

Answer 1

You can make use of the Java 8 Functional programming features to provide the behavior expressed as a Function as a method argument.

Here's how your logic can be implemented using Stream API, the additional argument the method expects is of type IntUnaryOperator ( which is a function expecting a single int argument, and producing int value as the result ).

public static String processPassword(String password,
                                     IntUnaryOperator operator) {
    return password.chars()
        .map(operator)
        .collect(
            StringBuilder::new,
            StringBuilder::appendCodePoint,
            StringBuilder::append
        )
        .toString();
}

And here's how you can call this method from the client code:

String encrypted = processPassword("fooBar", i -> ++i);
System.out.println(encrypted);
String decrypted = processPassword(encrypted, i -> --i);
System.out.println(decrypted);

Output:

gppCbs
fooBar

But, it's error-prone (for instance, a function with ++i can be accidentally instead of a function with --i ), and has a maintainability issue because you might end up with repeating these functions in several places, so it would be harder to change them.

The better approach would be to abstract the client from the actual implementations of the functions used in encrypting/decrypting and store these functions in one place, so that they can be easily modified without effecting the rest of the code.

This can be achieved by introducing an enum .

public enum ProcessType {
    ENCRYPT(i -> ++i),
    DECRYPT(i -> --i);
    
    private IntUnaryOperator operator;

    // constructor, getter
}

And we need to modify the method shown above to make it consume an enum constant instead of a function:

public static String processPassword(String password,
                                     ProcessType type) {
    return password.chars()
        .map(type.getOperator())
        .collect(
            StringBuilder::new,
            StringBuilder::appendCodePoint,
            StringBuilder::append
        )
        .toString();
}

And that's how the client code would look like:

String encrypted = processPassword("fooBar", ProcessType.ENCRYPT);
System.out.println(encrypted);
String decrypted = processPassword(encrypted, ProcessType.DECRYPT);
System.out.println(decrypted);

Output:

gppCbs
fooBar

Answer 2

Define a enum to specify operaiton type, based on the enum you can apply business logic.

private static enum OperationType {
        ENCRYPTION(1), DECRYPTION(-1);

        int val;

        private OperationType(int val) {
            this.val = val;
        }

    }

    private static String process(final String data, final OperationType operationType) {
        final char[] chars = data.toCharArray();

        final StringBuilder builder = new StringBuilder();
        for (char ch : chars) {

            builder.append(String.valueOf(ch + operationType.val));
        }
        return builder.toString();

    }

To work with streams, you can use string chars method like below.

Stream<Character> charStream = data.chars().mapToObj(i->(char)i);

Answer 3

The difference between the two methods encryptPassword and decryptPassword is the value that you are adding to each char in the String . Therefore I suggest adding a third method that takes two parameters: the first is the String to encrypt (or decrypt) and the second is the value to add to each char . In the below code, I called this third method adjustPassword .

As described in the book Java by Comparison I suggest keeping methods encryptPassword and decryptPassword and have those methods call method adjustPassword with the appropriate value. That way, when you want to encrypt or decrypt a password, you don't need to remember what value to pass for the required operation.

Explanations after the code.

public class Solution {

    private static String encryptPassword(String password) {
        return adjustPassword(password, 1);
    }

    private static String decryptPassword(String encryptedPassword) {
        return adjustPassword(encryptedPassword, -1);
    }

    private static String adjustPassword(String password, int adjustment) {
        StringBuilder sb = new StringBuilder(password.length());
        password.chars()
                .map(c -> c + adjustment)
                .forEach(i -> sb.append((char) i));
        return sb.toString();
    }

    public static void main(String[] args) {
        String password = "George";
        System.out.println("Original: " + password);
        String encrypted = encryptPassword(password);
        System.out.println("Encrypted: " + encrypted);
        System.out.println("Decrypted: " + decryptPassword(encrypted));
    }
}

Running the above code produces the following output:

Original: George
Encrypted: Hfpshf
Decrypted: George

• Since Java 9, class String has method chars() which returns an IntStream since char is essentially an int .
• Class StringBuilder has overloaded append methods. In the forEach method, the type of the method parameter, ie i , is int , hence the cast to char , otherwise method adjustPassword would return a String that only contained digits.