I need help explaining what this means res += (char) ((c + key.charAt(j) - 2 * 'A') % 26 + 'A');

public static String encrypt(String text, final String key)
{
    String res = "";
    text = text.toUpperCase();
    for (int i = 0, j = 0; i < text.length(); i++)
    {
        char c = text.charAt(i);
        if (c < 'A' || c > 'Z')
            continue;
        //				(0 + A - 2 * A) % 26 + A
        
        res += (char) ((c + key.charAt(j) - 2 * 'A') % 26 + 'A');

        //System.out.println("C: "+ c +" i: "+i+ " j: "+j + " key.char: "+key.charAt(j) + " res: " + res);
        
        j = ++j % key.length();
    }
    return res;
}

I basically just want to understand what " res += (char) ((c + key.charAt(j) - 2 * 'A') % 26 + 'A');
" this means. I pretty much figured out that its some kind of append to string? but I can figure out what the rest of it means.

The method is misnamed. This isn't encryption. Or if it is, it is the kind of encryption a 3 year old baboon can 'decrypt'.

char is actually a numeric datatype, hence why you can do things like 2*'A'. The number is the unicode code. As this is clearly ascii based, and all ascii codes map straight to their unicode equivalent with no changes, you can just search the web for any ascii code chart. 'A' is just an alternate way to write 65, for example.

Thus, let's start with:

c + key.charAt(j) - 2 * 'A'

The way java's precedence rules work, the 2*'A' is resolved first, so this subtracts 130 from c + key.charAt(j). It becomes easier to understand if you treat it as: (c - 'A') + (key.charAt(j) - 'A'). That formula always produces the exact same result as what you have, as I just moved terms around (I deconstructed -2*'A' into -'A'-'A' which always works out, then moved terms around).

c is a character value, but because of the if that precedes it, we know for sure that the content is between 'A' (65) and 'Z' (90), guaranteed.

The key could be anything (not clear from your paste), but it looks like the general idea is that the key consists of solely uppercase letters, so, that too is 65-90.

Let's say the key is 'WORLD' and the text to encrypt is 'HELLO'.

Then that boils down to: ('W' - 'A') + ('H' - 'A'). ('W'-'A') is just calculating the 'index' of the letter W in the alphabet. 'A' is the 0 letter. B is the 1 letter. C is the 2 letter. W is the 22 letter. Then we do the same thing ot the letter in the key for this position... and adding them together. W is the 22 letter, H is the 7 letter, so this becomes 29.

Next, it does %26 to that getup. % is remainder: divide 29 by 26, toss the result, keep the remainder. So, 3. (26%26 = 0, 27%26 1. etcetera). The reason it's 26 is because there are 26 letters in the alphabet. If I ask you to add 'B' to 'D' you might tell me: okay, that is 'E'. But if I ask you to add 'Z' to 'B', how does that work? Well, we 'loop' around, that becomes 'A'. That's what the % 26 is accomplishing: That looping behaviour.

Then, we add that to 'A', and treat the result as a character . 3+'A' becomes 'D'. That's just turning an index number (the 5 letter) back into the actual letter. 0+'A' is A, 1+'A' is B, etcetera.

Note that this algorithm does weird things and ends up with negative numbers if the key contains non-capitals (for example, if it contains a space). Clearly the author of this 'encoder ring' level craziness did not consider this.

So, what is the point of this line?

This is how this encryption protocol works:

Given a key 'ABC' and plaintext 'HELLOWORLD', we loop through each letter in the plaintext. For each letter, we find the matching letter in the key. Here the plaintext is longer than the key, and that's fixed by just looping the key. So, 'HELLOWORLD' is matched by 'ABCABCABCA' (why? That's what j = ++j % key.length(); is about).

The result of encrypting that H in hello world is therefore:

(/*plaintext */ 'H' + /* key */ 'A' - 'A' - 'A') % 26 + 'A' which is just H.

The result of encrypting that E in hello world is therefore:

(/*plaintext */ 'E' + /* key */ 'B' - 'A' - 'A') % 26 + 'A' which is just F.

In other words, if the key character is, say, 'C', then the letter in the plaintext is 'encrypted' by adding 2 to it. D becomes F. A becomes C. X becomes Z. And it loops around; Z becomes B.

The result of this 'encryption' protocol with key ABC to encrypt text HELLOWORLD is: HFNLPZOSND.