क्या जावा में "ग्लोब" प्रकार के मैच करने के लिए एक मानक (अधिमानतः अपाचे कॉमन्स या इसी तरह गैर-वायरल) पुस्तकालय है? जब मुझे एक बार पर्ल में भी ऐसा ही करना था, तो मैंने बस "" ."से" \."," *"से .*" और " ?" से " ." और उस प्रकार की सभी चीजों को बदल दिया, लेकिन मैं सोच रहा था कि क्या किसी ने किया है " मेरे लिए काम।
इसी तरह का प्रश्न: ग्लोब अभिव्यक्ति से रेगेक्स बनाएं
जवाबों:
बिल्ट-इन कुछ भी नहीं है, लेकिन यह बहुत आसान है कि किसी ग्लोब जैसी चीज़ को एक रेग्ज में बदल दिया जाए:
public static String createRegexFromGlob(String glob)
{
String out = "^";
for(int i = 0; i < glob.length(); ++i)
{
final char c = glob.charAt(i);
switch(c)
{
case '*': out += ".*"; break;
case '?': out += '.'; break;
case '.': out += "\\."; break;
case '\\': out += "\\\\"; break;
default: out += c;
}
}
out += '$';
return out;
}
यह मेरे लिए काम करता है, लेकिन मुझे यकीन नहीं है कि यह ग्लोब "मानक" को कवर करता है, अगर वहाँ एक है :)
पॉल टॉम्बलिन द्वारा अपडेट: मुझे एक पर्ल प्रोग्राम मिला, जो ग्लोब रूपांतरण करता है, और इसे जावा के साथ जोड़कर मैं समाप्त करता हूं:
private String convertGlobToRegEx(String line)
{
LOG.info("got line [" + line + "]");
line = line.trim();
int strLen = line.length();
StringBuilder sb = new StringBuilder(strLen);
// Remove beginning and ending * globs because they're useless
if (line.startsWith("*"))
{
line = line.substring(1);
strLen--;
}
if (line.endsWith("*"))
{
line = line.substring(0, strLen-1);
strLen--;
}
boolean escaping = false;
int inCurlies = 0;
for (char currentChar : line.toCharArray())
{
switch (currentChar)
{
case '*':
if (escaping)
sb.append("\\*");
else
sb.append(".*");
escaping = false;
break;
case '?':
if (escaping)
sb.append("\\?");
else
sb.append('.');
escaping = false;
break;
case '.':
case '(':
case ')':
case '+':
case '|':
case '^':
case '$':
case '@':
case '%':
sb.append('\\');
sb.append(currentChar);
escaping = false;
break;
case '\\':
if (escaping)
{
sb.append("\\\\");
escaping = false;
}
else
escaping = true;
break;
case '{':
if (escaping)
{
sb.append("\\{");
}
else
{
sb.append('(');
inCurlies++;
}
escaping = false;
break;
case '}':
if (inCurlies > 0 && !escaping)
{
sb.append(')');
inCurlies--;
}
else if (escaping)
sb.append("\\}");
else
sb.append("}");
escaping = false;
break;
case ',':
if (inCurlies > 0 && !escaping)
{
sb.append('|');
}
else if (escaping)
sb.append("\\,");
else
sb.append(",");
break;
default:
escaping = false;
sb.append(currentChar);
}
}
return sb.toString();
}
मैं इस जवाब को अपना बनाने के बजाय संपादित कर रहा हूं क्योंकि इस जवाब ने मुझे सही रास्ते पर ला खड़ा किया है।
जावा 7 में ग्लोबिंग को भी लागू करने की योजना है ।
देखें FileSystem.getPathMatcher(String)और "फाइल्स फाइल्स" ट्यूटोरियल ।
उनके योगदान के लिए यहां सभी का धन्यवाद। मैंने पिछले उत्तरों में से किसी से भी अधिक व्यापक रूपांतरण लिखा है:
/**
* Converts a standard POSIX Shell globbing pattern into a regular expression
* pattern. The result can be used with the standard {@link java.util.regex} API to
* recognize strings which match the glob pattern.
* <p/>
* See also, the POSIX Shell language:
* http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_13_01
*
* @param pattern A glob pattern.
* @return A regex pattern to recognize the given glob pattern.
*/
public static final String convertGlobToRegex(String pattern) {
StringBuilder sb = new StringBuilder(pattern.length());
int inGroup = 0;
int inClass = 0;
int firstIndexInClass = -1;
char[] arr = pattern.toCharArray();
for (int i = 0; i < arr.length; i++) {
char ch = arr[i];
switch (ch) {
case '\\':
if (++i >= arr.length) {
sb.append('\\');
} else {
char next = arr[i];
switch (next) {
case ',':
// escape not needed
break;
case 'Q':
case 'E':
// extra escape needed
sb.append('\\');
default:
sb.append('\\');
}
sb.append(next);
}
break;
case '*':
if (inClass == 0)
sb.append(".*");
else
sb.append('*');
break;
case '?':
if (inClass == 0)
sb.append('.');
else
sb.append('?');
break;
case '[':
inClass++;
firstIndexInClass = i+1;
sb.append('[');
break;
case ']':
inClass--;
sb.append(']');
break;
case '.':
case '(':
case ')':
case '+':
case '|':
case '^':
case '$':
case '@':
case '%':
if (inClass == 0 || (firstIndexInClass == i && ch == '^'))
sb.append('\\');
sb.append(ch);
break;
case '!':
if (firstIndexInClass == i)
sb.append('^');
else
sb.append('!');
break;
case '{':
inGroup++;
sb.append('(');
break;
case '}':
inGroup--;
sb.append(')');
break;
case ',':
if (inGroup > 0)
sb.append('|');
else
sb.append(',');
break;
default:
sb.append(ch);
}
}
return sb.toString();
}
और यह साबित करने के लिए इकाई परीक्षण काम करता है:
/**
* @author Neil Traft
*/
public class StringUtils_ConvertGlobToRegex_Test {
@Test
public void star_becomes_dot_star() throws Exception {
assertEquals("gl.*b", StringUtils.convertGlobToRegex("gl*b"));
}
@Test
public void escaped_star_is_unchanged() throws Exception {
assertEquals("gl\\*b", StringUtils.convertGlobToRegex("gl\\*b"));
}
@Test
public void question_mark_becomes_dot() throws Exception {
assertEquals("gl.b", StringUtils.convertGlobToRegex("gl?b"));
}
@Test
public void escaped_question_mark_is_unchanged() throws Exception {
assertEquals("gl\\?b", StringUtils.convertGlobToRegex("gl\\?b"));
}
@Test
public void character_classes_dont_need_conversion() throws Exception {
assertEquals("gl[-o]b", StringUtils.convertGlobToRegex("gl[-o]b"));
}
@Test
public void escaped_classes_are_unchanged() throws Exception {
assertEquals("gl\\[-o\\]b", StringUtils.convertGlobToRegex("gl\\[-o\\]b"));
}
@Test
public void negation_in_character_classes() throws Exception {
assertEquals("gl[^a-n!p-z]b", StringUtils.convertGlobToRegex("gl[!a-n!p-z]b"));
}
@Test
public void nested_negation_in_character_classes() throws Exception {
assertEquals("gl[[^a-n]!p-z]b", StringUtils.convertGlobToRegex("gl[[!a-n]!p-z]b"));
}
@Test
public void escape_carat_if_it_is_the_first_char_in_a_character_class() throws Exception {
assertEquals("gl[\\^o]b", StringUtils.convertGlobToRegex("gl[^o]b"));
}
@Test
public void metachars_are_escaped() throws Exception {
assertEquals("gl..*\\.\\(\\)\\+\\|\\^\\$\\@\\%b", StringUtils.convertGlobToRegex("gl?*.()+|^$@%b"));
}
@Test
public void metachars_in_character_classes_dont_need_escaping() throws Exception {
assertEquals("gl[?*.()+|^$@%]b", StringUtils.convertGlobToRegex("gl[?*.()+|^$@%]b"));
}
@Test
public void escaped_backslash_is_unchanged() throws Exception {
assertEquals("gl\\\\b", StringUtils.convertGlobToRegex("gl\\\\b"));
}
@Test
public void slashQ_and_slashE_are_escaped() throws Exception {
assertEquals("\\\\Qglob\\\\E", StringUtils.convertGlobToRegex("\\Qglob\\E"));
}
@Test
public void braces_are_turned_into_groups() throws Exception {
assertEquals("(glob|regex)", StringUtils.convertGlobToRegex("{glob,regex}"));
}
@Test
public void escaped_braces_are_unchanged() throws Exception {
assertEquals("\\{glob\\}", StringUtils.convertGlobToRegex("\\{glob\\}"));
}
@Test
public void commas_dont_need_escaping() throws Exception {
assertEquals("(glob,regex),", StringUtils.convertGlobToRegex("{glob\\,regex},"));
}
}
कुछ पुस्तकालय हैं जो ग्लोब की तरह के पैटर्न से मेल खाते हैं जो कि सूचीबद्ध लोगों की तुलना में अधिक आधुनिक हैं:
Theres चींटियों निर्देशिका स्कैनर और स्प्रिंग्स AntPathMatcher
मैं दोनों अन्य उपायों की सलाह देता हूं क्योंकि एंट स्टाइल ग्लोबिंग जावा दुनिया में बहुत अधिक मानक ग्लोब सिंटैक्स बन गया है (हडसन, स्प्रिंग, एंट और मुझे लगता है कि मैवेन)।
मैं हाल ही में यह करने के लिए था और इस्तेमाल किया \Qऔर \Eग्लोब पैटर्न से बचने के लिए:
private static Pattern getPatternFromGlob(String glob) {
return Pattern.compile(
"^" + Pattern.quote(glob)
.replace("*", "\\E.*\\Q")
.replace("?", "\\E.\\Q")
+ "$");
}
globग्लोब = पैटर्न.क्वाओट (ग्लोब) के साथ चर को पूर्व-प्रसंस्करण करके , जो मुझे लगता है कि इस तरह के किनारे मामलों को संभालता है। उस स्थिति में, हालांकि, आपको पहले और अंतिम \\ Q और \\ E को पहले से तैयार करने और संलग्न करने की आवश्यकता नहीं है।
यह एक सरल ग्लोब कार्यान्वयन है जो * और? पैटर्न में
public class GlobMatch {
private String text;
private String pattern;
public boolean match(String text, String pattern) {
this.text = text;
this.pattern = pattern;
return matchCharacter(0, 0);
}
private boolean matchCharacter(int patternIndex, int textIndex) {
if (patternIndex >= pattern.length()) {
return false;
}
switch(pattern.charAt(patternIndex)) {
case '?':
// Match any character
if (textIndex >= text.length()) {
return false;
}
break;
case '*':
// * at the end of the pattern will match anything
if (patternIndex + 1 >= pattern.length() || textIndex >= text.length()) {
return true;
}
// Probe forward to see if we can get a match
while (textIndex < text.length()) {
if (matchCharacter(patternIndex + 1, textIndex)) {
return true;
}
textIndex++;
}
return false;
default:
if (textIndex >= text.length()) {
return false;
}
String textChar = text.substring(textIndex, textIndex + 1);
String patternChar = pattern.substring(patternIndex, patternIndex + 1);
// Note the match is case insensitive
if (textChar.compareToIgnoreCase(patternChar) != 0) {
return false;
}
}
// End of pattern and text?
if (patternIndex + 1 >= pattern.length() && textIndex + 1 >= text.length()) {
return true;
}
// Go on to match the next character in the pattern
return matchCharacter(patternIndex + 1, textIndex + 1);
}
}
करने के लिए इसी तरह के टोनी Edgecombe के जवाब है, यहाँ एक संक्षिप्त और सरल globber है कि समर्थन करता है *और ?, regex का उपयोग कर यदि किसी एक की जरूरत के बिना।
public static boolean matches(String text, String glob) {
String rest = null;
int pos = glob.indexOf('*');
if (pos != -1) {
rest = glob.substring(pos + 1);
glob = glob.substring(0, pos);
}
if (glob.length() > text.length())
return false;
// handle the part up to the first *
for (int i = 0; i < glob.length(); i++)
if (glob.charAt(i) != '?'
&& !glob.substring(i, i + 1).equalsIgnoreCase(text.substring(i, i + 1)))
return false;
// recurse for the part after the first *, if any
if (rest == null) {
return glob.length() == text.length();
} else {
for (int i = glob.length(); i <= text.length(); i++) {
if (matches(text.substring(i), rest))
return true;
}
return false;
}
}
यह थोड़ा हैकी दृष्टिकोण हो सकता है। मैंने NIO2 के Files.newDirectoryStream(Path dir, String glob)कोड से इसका पता लगा लिया है । ध्यान दें कि हर मैच नई Pathवस्तु बनाई जाती है। अब तक मैं केवल विंडोज एफएस पर यह परीक्षण करने में सक्षम था, हालांकि, मेरा मानना है कि इसे यूनिक्स पर भी काम करना चाहिए।
// a file system hack to get a glob matching
PathMatcher matcher = ("*".equals(glob)) ? null
: FileSystems.getDefault().getPathMatcher("glob:" + glob);
if ("*".equals(glob) || matcher.matches(Paths.get(someName))) {
// do you stuff here
}
अद्यतन मैक और लिनक्स दोनों पर काम करता है।
बहुत पहले मैं एक विशाल ग्लोब-चालित पाठ फ़िल्टरिंग कर रहा था, इसलिए मैंने कोड का एक छोटा टुकड़ा (कोड की 15 लाइनें, जेडीके से परे कोई निर्भरता नहीं) लिखा है। यह केवल '*' (मेरे लिए पर्याप्त था) को संभालता है, लेकिन '?' के लिए आसानी से बढ़ाया जा सकता है। यह पूर्व-संकलित regexp की तुलना में कई गुना तेज है, किसी भी पूर्व-संकलन की आवश्यकता नहीं है (अनिवार्य रूप से यह स्ट्रिंग-बनाम-स्ट्रिंग की तुलना हर बार पैटर्न से मेल खाता है)।
कोड:
public static boolean miniglob(String[] pattern, String line) {
if (pattern.length == 0) return line.isEmpty();
else if (pattern.length == 1) return line.equals(pattern[0]);
else {
if (!line.startsWith(pattern[0])) return false;
int idx = pattern[0].length();
for (int i = 1; i < pattern.length - 1; ++i) {
String patternTok = pattern[i];
int nextIdx = line.indexOf(patternTok, idx);
if (nextIdx < 0) return false;
else idx = nextIdx + patternTok.length();
}
if (!line.endsWith(pattern[pattern.length - 1])) return false;
return true;
}
}
उपयोग:
public static void main(String[] args) {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
try {
// read from stdin space separated text and pattern
for (String input = in.readLine(); input != null; input = in.readLine()) {
String[] tokens = input.split(" ");
String line = tokens[0];
String[] pattern = tokens[1].split("\\*+", -1 /* want empty trailing token if any */);
// check matcher performance
long tm0 = System.currentTimeMillis();
for (int i = 0; i < 1000000; ++i) {
miniglob(pattern, line);
}
long tm1 = System.currentTimeMillis();
System.out.println("miniglob took " + (tm1-tm0) + " ms");
// check regexp performance
Pattern reptn = Pattern.compile(tokens[1].replace("*", ".*"));
Matcher mtchr = reptn.matcher(line);
tm0 = System.currentTimeMillis();
for (int i = 0; i < 1000000; ++i) {
mtchr.matches();
}
tm1 = System.currentTimeMillis();
System.out.println("regexp took " + (tm1-tm0) + " ms");
// check if miniglob worked correctly
if (miniglob(pattern, line)) {
System.out.println("+ >" + line);
}
else {
System.out.println("- >" + line);
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
पिछले समाधान विन्सेंट रॉबर्ट / dimo414 द्वारा पर निर्भर करता है Pattern.quote()के मामले में लागू किया जा रहा \Q... \Eहै, जो एपीआई में दर्ज नहीं है और इसलिए अन्य / भविष्य जावा कार्यान्वयन के लिए मामला नहीं हो सकता। निम्नलिखित समाधान \Eउपयोग करने के बजाय सभी घटनाओं से बचकर उस कार्यान्वयन निर्भरता को हटा देता है quote()। यह DOTALLमोड को सक्रिय भी करता है ( (?s)) यदि मिलान की जाने वाली स्ट्रिंग में नई सुर्खियाँ हों।
public static Pattern globToRegex(String glob)
{
return Pattern.compile(
"(?s)^\\Q" +
glob.replace("\\E", "\\E\\\\E\\Q")
.replace("*", "\\E.*\\Q")
.replace("?", "\\E.\\Q") +
"\\E$"
);
}
वैसे, ऐसा लगता है जैसे आपने इसे पर्ल में सबसे कठिन तरीका बताया
यह पर्ल में चाल है:
my @files = glob("*.html")
# Or, if you prefer:
my @files = <*.html>