blocks|key|1400189|text|您应该能够使用非贪婪量词，特别是*？您可能需要以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1400190|Pattern+MY_PATTERN+=+Pattern.compile("\\[(.*?)\\]");|code-block|syntax|javascript|1400191|这将为您提供一个与您的字符串匹配的模式，并将文本放在第一组的方括号中。有关更多信息，请查看Pattern+API+Documentation。|offset|length|1400192|要提取字符串，可以使用类似于以下内容的内容：|1400193|Matcher+m+=+MY_PATTERN.matcher("FOO[BAR]");
while+(m.find())+{
++++String+s+=+m.group(1);
++++//+s+now+contains+"BAR"
}|1400194|entityMap|0|LINK|mutability|MUTABLE|url|http://download.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html^0|0|0|19|P|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

You should be able to use non-greedy quantifiers, specifically *?. You're going to probably want the following:

<pre><code>Pattern MY_PATTERN = Pattern.compile("\\[(.*?)\\]");
</code></pre>

This will give you a pattern that will match your string and put the text within the square brackets in the first group. Have a look at the <a href="http://download.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html" rel="noreferrer">Pattern API Documentation</a> for more information.

To extract the string, you could use something like the following:

<pre><code>Matcher m = MY_PATTERN.matcher("FOO[BAR]");
while (m.find()) {
 String s = m.group(1);
 // s now contains "BAR"
}
</code></pre>

blocks|key|1400233|text|非正则表达式的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1400234|String+input+=+"FOO[BAR]",+extracted;
extracted+=+input.substring(input.indexOf("["),input.indexOf("]"));|code-block|syntax|javascript|1400235|或者，为了稍微提高性能/内存使用率(感谢Hosam)：|1400236|String+input+=+"FOO[BAR]",+extracted;
extracted+=+input.substring(input.indexOf('['),input.lastIndexOf(']'));|1400237|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

the non-regex way:

<pre><code>String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf("["),input.indexOf("]"));
</code></pre>

alternatively, for slightly better performance/memory usage (thanks Hosam): 

<pre><code>String input = "FOO[BAR]", extracted;
extracted = input.substring(input.indexOf('['),input.lastIndexOf(']'));
</code></pre>

blocks|key|1400276|text|我认为你的正则表达式应该是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1400277|/FOO\[(.%2B)\]/|code-block|syntax|javascript|1400278|假设FOO是常量。|1400279|因此，将其放在Java中：|1400280|Pattern+p+=+Pattern.compile("FOO\\[(.%2B)\\]");
Matcher+m+=+p.matcher(inputLine);|1400281|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I think your regular expression would look like:

<pre><code>/FOO\[(.+)\]/
</code></pre>

Assuming that FOO going to be constant.

So, to put this in Java:

<pre><code>Pattern p = Pattern.compile("FOO\\[(.+)\\]");
Matcher m = p.matcher(inputLine);
</code></pre>

blocks|key|1615035|text|假设内不允许其他右方括号，则/FOO[(%5E]*)]/|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1615036|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

assuming that no other closing square bracket is allowed within, /FOO\[([^\]]*)\]/

blocks|key|1400383|text|我会定义我希望在[和]之间有一个非]字符的最大数量。它们需要使用反斜杠进行转义(在Java语言中，这些需要再次转义)，并且non-]的定义是一个字符类，因此在[和]+(即[%5E\\]])中。结果是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1400384|FOO\\[([%5E\\]]%2B)\\]|code-block|syntax|javascript|1400385|entityMap^0|8|1|A|1|27|1|29|1|2D|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|L|$]]

I'd define that I want a maximum number of non-] characters between <code>[</code> and <code>]</code>. These need to be escaped with backslashes (and in Java, these need to be escaped again), and the definition of non-] is a character class, thus inside <code>[</code> and <code>]</code> (i.e. <code>[^\\]]</code>). The result:

<pre><code>FOO\\[([^\\]]+)\\]
</code></pre>

blocks|key|1400421|text|String+input+=+"FOO[BAR]";
String+result+=+input.substring(input.indexOf("[")%2B1,input.lastIndexOf("]"));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1400422|这将返回第一个'‘和最后一个'’之间的值|unstyled|1400423|FooBar+=>栏|1400424|Foo[Bartest]+=>+Bartest|1400425|注意:如果输入字符串的格式不正确，则应添加错误检查。|1400426|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>String input = "FOO[BAR]";
String result = input.substring(input.indexOf("[")+1,input.lastIndexOf("]"));
</code></pre>

This will return the value between first '[' and last ']'

Foo[Bar] => Bar

Foo[Bar[test]] => Bar[test]

Note: You should add error checking if the input string is not well formed.

blocks|key|1615166|text|这是一个有效的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1615167|RegexpExample.java|1615168|package+org.regexp.replace;

import+java.util.ArrayList;
import+java.util.List;
import+java.util.regex.Matcher;
import+java.util.regex.Pattern;

public+class+RegexpExample
{
++++public+static+void+main(String[]+args)
++++{
++++++++String+string+=+"var1[value1],+var2[value2],+var3[value3]";
++++++++Pattern+pattern+=+Pattern.compile("(\\[)(.*?)(\\])");
++++++++Matcher+matcher+=+pattern.matcher(string);

++++++++List<String>+listMatches+=+new+ArrayList<String>();

++++++++while(matcher.find())
++++++++{
++++++++++++listMatches.add(matcher.group(2));
++++++++}

++++++++for(String+s+:+listMatches)
++++++++{
++++++++++++System.out.println(s);
++++++++}
++++}
}|code-block|syntax|javascript|1615169|它显示：|1615170|value1
value2
value3|1615171|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is a working example :

RegexpExample.java

<pre><code>package org.regexp.replace;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexpExample
{
 public static void main(String[] args)
 {
 String string = "var1[value1], var2[value2], var3[value3]";
 Pattern pattern = Pattern.compile("(\\[)(.*?)(\\])");
 Matcher matcher = pattern.matcher(string);

 List&lt;String&gt; listMatches = new ArrayList&lt;String&gt;();

 while(matcher.find())
 {
 listMatches.add(matcher.group(2));
 }

 for(String s : listMatches)
 {
 System.out.println(s);
 }
 }
}
</code></pre>

It displays :

<pre><code>value1
value2
value3
</code></pre>

blocks|key|1615203|text|它的工作原理是这样的，如果你想解析来自mYearInDB.toString()+=2013的字符串，它会给出2013|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1615204|Matcher+n+=+MY_PATTERN.matcher("FOO[BAR]"%2BmYearInDB.toString());
while+(n.find())+{
+extracredYear++=+n.group(1);
+//+s+now+contains+"BAR"
++++}
++++System.out.println("Extrated+output+is+:+"%2BextracredYear);|code-block|syntax|javascript|1615205|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Like this its work if you want to parse some string which is coming from mYearInDB.toString() =[2013] it will give 2013

<pre><code>Matcher n = MY_PATTERN.matcher("FOO[BAR]"+mYearInDB.toString());
while (n.find()) {
 extracredYear = n.group(1);
 // s now contains "BAR"
 }
 System.out.println("Extrated output is : "+extracredYear);
</code></pre>

blocks|key|1615217|text|import+java.util.*;
import+java.util.regex.Matcher;
import+java.util.regex.Pattern;

public+static+String+get_match(String+s,+String+p)+{
++++//+returns+first+match+of+p+in+s+for+first+group+in+regular+expression+
++++Matcher+m+=+Pattern.compile(p).matcher(s);
++++return+m.find()+?+m.group(1)+:+"";
}

get_match("FOO[BAR]",+"\\[(.*?)\\]")++//+returns+"BAR"

public+static+List<String>+get_matches(String+s,+String+p)+{
++++//+returns+all+matches+of+p+in+s+for+first+group+in+regular+expression+
++++List<String>+matches+=+new+ArrayList<String>();
++++Matcher+m+=+Pattern.compile(p).matcher(s);
++++while(m.find())+{
++++++++matches.add(m.group(1));
++++}
++++return+matches;
}

get_matches("FOO[BAR]+FOO[CAT]",+"\\[(.*?)\\]"))+//+returns+[BAR,+CAT]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1615218|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public static String get_match(String s, String p) {
 // returns first match of p in s for first group in regular expression 
 Matcher m = Pattern.compile(p).matcher(s);
 return m.find() ? m.group(1) : "";
}

get_match("FOO[BAR]", "\\[(.*?)\\]") // returns "BAR"

public static List&lt;String&gt; get_matches(String s, String p) {
 // returns all matches of p in s for first group in regular expression 
 List&lt;String&gt; matches = new ArrayList&lt;String&gt;();
 Matcher m = Pattern.compile(p).matcher(s);
 while(m.find()) {
 matches.add(m.group(1));
 }
 return matches;
}

get_matches("FOO[BAR] FOO[CAT]", "\\[(.*?)\\]")) // returns [BAR, CAT]
</code></pre>

blocks|key|1615259|text|下面的regexp适用于我：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1615260|form\[([%5E']*?)\]|code-block|syntax|javascript|1615261|示例：|1615262|form[company_details][0][name]
form[company_details][0][common_names][1][title]|1615263|输出：|1615264|Match+1
1.++company_details
Match+2
1.++company_details|1615265|在http://rubular.com/上测试|offset|length|1615266|entityMap|0|LINK|mutability|MUTABLE|url|http://rubular.com/^0|0|0|0|0|0|0|1|J|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@$Q|17|R|18|1|19]]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

This regexp works for me:

<pre><code>form\[([^']*?)\]
</code></pre>

example:

<pre><code>form[company_details][0][name]
form[company_details][0][common_names][1][title]
</code></pre>

output:

<pre><code>Match 1
1. company_details
Match 2
1. company_details
</code></pre>

Tested on <a href="http://rubular.com/" rel="nofollow">http://rubular.com/</a>

blocks|key|1615315|text|"FOO[DOG]".replaceAll("%5E.*?\\[%7C\\].*",+"");|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1615316|这将返回一个字符串，它只接受方括号中的字符串。|unstyled|1615317|这将删除方括号外部的所有字符串。|1615318|您可以在线测试这个java示例代码：http://tpcg.io/wZoFu0|offset|length|1615319|您可以从这里测试这个正则表达式：https://regex101.com/r/oUAzsS/1|1615320|entityMap|0|LINK|mutability|MUTABLE|url|http://tpcg.io/wZoFu0|1|https://regex101.com/r/oUAzsS/1^0|0|0|0|I|L|0|0|G|V|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|11|8|@]|9|@$K|12|L|13|1|14]]|A|$]]|$1|M|3|N|5|F|7|15|8|@]|9|@$K|16|L|17|1|18]]|A|$]]|$1|O|3|-4|5|F|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

<pre><code>"FOO[DOG]".replaceAll("^.*?\\[|\\].*", "");
</code></pre>

This will return a string 
taking only the string inside square brackets.

This remove all string outside from square brackets.

You can test this java sample code online:
<a href="http://tpcg.io/wZoFu0" rel="nofollow noreferrer">http://tpcg.io/wZoFu0</a>

You can test this regex from here:
<a href="https://regex101.com/r/oUAzsS/1" rel="nofollow noreferrer">https://regex101.com/r/oUAzsS/1</a>

If I have a string like this:

<pre><code>FOO[BAR]
</code></pre>

I need a generic way to get the "BAR" string out of the string so that no matter what string is between the square brackets it would be able to get the string.

e.g.

<pre><code>FOO[DOG] = DOG
FOO[CAT] = CAT
</code></pre>

Using Java to find substring of a bigger string using Regular Expression

Java

如果我有一个这样的字符串：FOO[BAR]我需要一种通用的方法来从字符串中取出"BAR“字符串，这样无论什么字符串在方括号之间，它都能够获得字符串。例如：FOO[DOG] = DOGFOO[CAT] = CAT

问利用正则表达式在Java中查找较大字符串的子串
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问利用正则表达式在Java中查找较大字符串的子串EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问利用正则表达式在Java中查找较大字符串的子串
EN