Java, regex para dividir uma string em um delimitador com restrições

Daniel:

Eu tenho uma string base64 malformado em java.

Não é absolutamente mal formado, mas a corda às vezes contém mais base64 codificados dados.

Quero dividir a string, e acho que regex é a melhor maneira de conseguir isso.

Há casos:

• se houver apenas um base64 na seqüência, ele quer
  • não contém qualquer carvão animal estofamento =
  • contém carvão animal estofamento (s) (um ou dois) unicamente na extremidade
• se há mais base64 na seqüência, será
  • conter carvão animal estofamento (s) (um ou dois) não no final (ou não somente no final)

Agora eu quero ter uma String[]que detém as cordas base64 individuais.

Então regex não tem que dividir se não houver nenhum caractere de preenchimento, ou o caractere de preenchimento é no final. Mas tem que dividir se não houver preenchimento caractere no meio (e não pode haver caracteres um ou dois de preenchimento).

Teste trecho:

import java.util.Base64;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/*
TEST CASES:
output array shall contain one item only
TG9y
TG9yZW0=
TG9yZQ==

output array shall contain two items
TG9yZW0=TG9y
TG9yZW0=TG9yZW0=
TG9yZW0=TG9yZQ==

TG9yZQ==TG9y
TG9yZQ==TG9yZW0=
TG9yZQ==TG9yZQ==

output array shall contain three items
TG9yZW0=TG9yZW0=TG9y
TG9yZQ==TG9yZW0=TG9y
...
*/

public class MyClass {
  public static void main(String args[]) {

    String buffer = "";

    try {
      byte[] decodedString = Base64.getDecoder().decode(buffer.getBytes("UTF-8"));
      System.out.println(new String(decodedString));
    } catch (IllegalArgumentException e) {
      e.printStackTrace();
      System.err.println("Buffer: " + buffer);
    } catch (UnsupportedEncodingException e) { }
  }
}

Eu não tenho certeza se regex é plenamente capaz disto, ou se é o melhor método para fazer isso.

Andreas:

Como mencionado em um comentário , você pode dividir a string após um = igual sinal, que não é seguido por um = igual sinal, usando uma combinação de (?<=X) de largura zero lookbehind positiva e (?!X) de largura zero lookahead negativo :

String[] arr = input.split("(?<==)(?!=)");

Teste

String[] inputs = {
        "TG9y",
        "TG9yZW0=",
        "TG9yZQ==",
        "TG9yZW0=TG9y",
        "TG9yZW0=TG9yZW0=",
        "TG9yZW0=TG9yZQ==",
        "TG9yZQ==TG9y",
        "TG9yZQ==TG9yZW0=",
        "TG9yZQ==TG9yZQ==",
        "TG9yZW0=TG9yZW0=TG9y",
        "TG9yZQ==TG9yZW0=TG9y",
        "TG9yTG9yZQ==TG9yZW0=" };
Decoder decoder = Base64.getDecoder();
for (String input : inputs) {
    String[] arr = input.split("(?<==)(?!=)");
    for (int i = 0; i < arr.length; i++)
        arr[i] = new String(decoder.decode(arr[i]), StandardCharsets.US_ASCII);
    System.out.println(Arrays.toString(arr));
}

Resultado

[Lor]
[Lorem]
[Lore]
[Lorem, Lor]
[Lorem, Lorem]
[Lorem, Lore]
[Lore, Lor]
[Lore, Lorem]
[Lore, Lore]
[Lorem, Lorem, Lor]
[Lore, Lorem, Lor]
[LorLore, Lorem]