Se eu tiver uma string como esta:
FOO[BAR]
Eu preciso de uma maneira genérica de obter a string "BAR" da string, para que não importa qual seja a string entre colchetes, ela poderá obter a string.
por exemplo
FOO[DOG] = DOG
FOO[CAT] = CAT
Você deve poder usar quantificadores não gananciosos, especificamente * ?. Você provavelmente vai querer o seguinte:
Pattern MY_PATTERN = Pattern.compile("\\[(.*?)\\]");
Isso fornecerá um padrão que corresponderá à sua string e colocará o texto entre colchetes no primeiro grupo. Consulte a documentação da API de padrões para obter mais informações.
Para extrair a string, você pode usar algo como o seguinte:
Matcher m = MY_PATTERN.matcher("FOO[BAR]");
while (m.find()) {
String s = m.group(1);
// s now contains "BAR"
}
da maneira não regex:
alternativamente, para um desempenho / uso de memória um pouco melhor (graças ao Hosam):
fonte
lastIndexOf(']')
vez disso, eu usaria , que manipularia colchetes aninhados. Além disso, acredito que usar oindexOf(char)
seria mais rápido queindexOf(String)
.lastIndexOf
certamente será mais rápido encontrar o colchete.Este é um exemplo de trabalho:
RegexpExample.java
Exibe:
fonte
fonte
Se você simplesmente precisar obter o que estiver entre
[]
, poderá usar o\[([^\]]*)\]
seguinte:Se você precisar que ele esteja no formato
identifier + [ + content + ]
, poderá limitar a extração do conteúdo apenas quando o identificador for um alfanumérico:Isso irá validar coisas como
Foo [Bar]
, oumyDevice_123["input"]
por exemplo.Problema principal
O principal problema é quando você deseja extrair o conteúdo de algo assim:
O Regex não funcionará e retornará
BAR[CAT[123
eFOO
.Se alterarmos o Regex para,
\[(.*)\]
então estamos bem, mas, se você estiver tentando extrair o conteúdo de coisas mais complexas, como:Nenhum dos Regexes funcionará.
O Regex mais preciso para extrair o conteúdo adequado em todos os casos seria muito mais complexo, pois seria necessário equilibrar
[]
pares e fornecer a eles o conteúdo.Uma solução mais simples
Se seus problemas estão ficando complexos e o conteúdo do
[]
arbitrário, você pode equilibrar os pares de[]
e extrair a string usando o código antigo simples e rathe do que um Regex:Isso é mais pseudo-código do que código real, não sou um codificador Java, portanto não sei se a sintaxe está correta, mas deve ser fácil o suficiente para melhorar.
O que importa é que esse código funcione e permita que você extraia o conteúdo do
[]
, por mais complexo que seja.fonte
Eu acho que sua expressão regular ficaria assim:
Supondo que o FOO seja constante.
Então, para colocar isso em Java:
fonte
Isso retornará o valor entre o primeiro '[' e o último ']'
Foo [Bar] => Barra
Foo [Barra [teste]] => Barra [teste]
Nota: Você deve adicionar uma verificação de erro se a sequência de entrada não estiver bem formada.
fonte
assumindo que nenhum outro colchete de fechamento seja permitido dentro, / FOO \ [([^ \]] *) \] /
fonte
Eu definiria que quero um número máximo de caracteres não-] entre
[
e]
. Eles precisam ser escapados com barras invertidas (e em Java, eles precisam ser escapados novamente), e a definição de não] é uma classe de caractere, portanto, interna[
e]
(ie[^\\]]
). O resultado:fonte
Assim funciona, se você deseja analisar alguma string que é proveniente de mYearInDB.toString () = [2013], ela dará 2013
fonte
Este regexp funciona para mim:
exemplo:
resultado:
Testado em http://rubular.com/
fonte
Isso retornará uma string, levando apenas a string entre colchetes.
Isso remove toda a corda do lado de fora dos colchetes.
Você pode testar este código de amostra java on-line: http://tpcg.io/wZoFu0
Você pode testar esse regex aqui: https://regex101.com/r/oUAzsS/1
fonte