दो पात्रों के बीच एक स्ट्रिंग कैसे प्राप्त करें?

93

मेरे पास एक तार है,

String s = "test string (67)";

मैं 67 नंबर (और) के बीच का स्ट्रिंग प्राप्त करना चाहता हूं।

क्या कोई मुझे बता सकता है कि यह कैसे करना है?

java  string 
— Roshanck
स्रोत
1
ऐसे कई तरीके हैं - जब तक आप तक पहुँचने आप स्ट्रिंग में वर्ण पुनरावृति सकता है (या पहले के सूचकांक को खोजने (और )और सबस्ट्रिंग या, ज्यादातर लोगों क्या करेंगे, रेगुलर एक्सप्रेशन का उपयोग के साथ करते हैं।
— एंड्रियास डॉक

जवाबों:

102

वहाँ शायद एक बहुत साफ RegExp है, लेकिन मैं उस क्षेत्र में noob हूँ, इसलिए इसके बजाय ...

String s = "test string (67)";

s = s.substring(s.indexOf("(") + 1);
s = s.substring(0, s.indexOf(")"));

System.out.println(s);
— MadProgrammer
स्रोत
4
रेगेक्स पार्सिंग की विषमताओं से गुजरने के बिना, मुझे लगता है कि आवश्यक स्ट्रिंग निकालने का यह सबसे अच्छा तरीका है।
— verisimilitude
3
रेगेक्स कहीं अधिक शक्तिशाली है और अधिक मामलों में ले जा सकता है, लेकिन सादगी के लिए, यह काम करता है ...
— MadProgrammer
2
गंभीरता से, यह एक डाउन वोट क्यों आकर्षित करेगा? क्या यह काम नहीं करता है? क्या यह ऑप्स प्रश्न का उत्तर नहीं देता है?
— MadProgrammer
यदि मेरे पास कई मान हैं तो मैं कैसे स्ट्रिंग का उपयोग कर सकता हूं विचार करें कि मेरे पास इस तरह से स्ट्रिंग है 'this is an example of <how><i have it>'और मुझे '<' और '>' के बीच मान खोजने की आवश्यकता है
— विग्नेश
@ विग्नेश एक नियमित अभिव्यक्ति का प्रयोग करें
— MadProgrammer
74

इस समस्या का एक बहुत ही उपयोगी समाधान जो आपको इंडेक्सऑफ करने की आवश्यकता नहीं है अपाचे कॉमन्स पुस्तकालयों का उपयोग कर रहा है ।

 StringUtils.substringBetween(s, "(", ")");

यह विधि आपको तब भी हैंडल करने की अनुमति देगी भले ही समापन स्ट्रिंग के कई घटनाएं हों जो इंडेक्सऑफ समापन स्ट्रिंग की तलाश में आसान न हों।

आप इस पुस्तकालय को यहाँ से डाउनलोड कर सकते हैं: https://mvnrepository.com/artifact/org.apache.commons/commons-lang3/3.4

— पिनी चेनी
स्रोत
7
substringsBetween(...)यदि आप कई परिणामों की अपेक्षा करते हैं, तो भी वही है जो मैं खोज रहा था। धन्यवाद
— Cahen
अधिक उदाहरण के लिए
— लिंक-
72

इसे ऐसे ही आजमाएं

String s="test string(67)";
String requiredString = s.substring(s.indexOf("(") + 1, s.indexOf(")"));

विकल्प के लिए विधि का हस्ताक्षर है:

s.substring(int start, int end);
— user2656003
स्रोत
30

नियमित अभिव्यक्ति का उपयोग करके:

 String s = "test string (67)";
 Pattern p = Pattern.compile("\\(.*?\\)");
 Matcher m = p.matcher(s);
 if(m.find())
    System.out.println(m.group().subSequence(1, m.group().length()-1));
— ग्रिशा वेन्ट्राब
स्रोत
2
मुझे लगता है कि आपको "*।" का उपयोग करके इसे एक गैर-लालची मैच बनाना चाहिए। बजाय। अन्यथा, यदि स्ट्रिंग "टेस्ट स्ट्रिंग (67) और (68) की तरह कुछ भी कर रही है, तो यह" 67) (68) (68) वापस आ जाएगी।
— Chthonic Project
18

जावा रेगुलर एक्सप्रेशन का समर्थन करता है , लेकिन अगर आप वास्तव में उन्हें मैच निकालने के लिए उपयोग करना चाहते हैं तो वे बोझिल हैं। मुझे लगता है कि आप अपने उदाहरण में जो स्ट्रिंग चाहते हैं उसे पाने का सबसे आसान तरीका है कि आप Stringकक्षा की replaceAllविधि में नियमित अभिव्यक्ति समर्थन का उपयोग करें:

String x = "test string (67)".replaceAll(".*\\(|\\).*", "");
// x is now the String "67"

यह बस पहले और बाद (में )और सब कुछ के लिए एक ही -सहित-सब कुछ हटा देता है । यह सिर्फ कोष्ठक के बीच सामान छोड़ देता है।

हालाँकि, इसका परिणाम अभी भी है String। यदि आप इसके बजाय पूर्णांक परिणाम चाहते हैं तो आपको एक और रूपांतरण करने की आवश्यकता है:

int n = Integer.parseInt(x);
// n is now the integer 67
— DaoWen
स्रोत
10

एक पंक्ति में, मेरा सुझाव है:

String input = "test string (67)";
input = input.subString(input.indexOf("(")+1, input.lastIndexOf(")"));
System.out.println(input);`
— बरसाती
स्रोत
7 
String s = "test string (67)";

int start = 0; // '(' position in string
int end = 0; // ')' position in string
for(int i = 0; i < s.length(); i++) { 
    if(s.charAt(i) == '(') // Looking for '(' position in string
       start = i;
    else if(s.charAt(i) == ')') // Looking for ')' position in  string
       end = i;
}
String number = s.substring(start+1, end); // you take value between start and end
— पायोत्र चोजनेकी
स्रोत
7

आप ऐसा करने के लिए अपाचे कॉमन लाइब्रेरी के स्ट्रिंगरिटल्स का उपयोग कर सकते हैं। 

import org.apache.commons.lang3.StringUtils;
...
String s = "test string (67)";
s = StringUtils.substringBetween(s, "(", ")");
....
— ChaitanyaBhatt
स्रोत
7 
String result = s.substring(s.indexOf("(") + 1, s.indexOf(")"));
— techlearner
स्रोत
1
कृपया 4 स्थानों को इंडेंट करके अपना कोड प्रारूपित करें। इसके अलावा, मैं यह बताकर आपके उत्तर को थोड़ा .substringसमझाऊंगा कि आपके आने वाले लोगों के लिए आपका कोड क्या करता है जो अनिश्चित हैं । andindexOf` क्या करता है।
— कीड़े
6

परीक्षण स्ट्रिंग test string (67)जिसमें से आपको स्ट्रिंग प्राप्त करने की आवश्यकता होती है जो कि दो स्ट्रिंग्स के बीच में निहित है।

String str = "test string (67) and (77)", open = "(", close = ")";

कुछ संभावित तरीके सूचीबद्ध : सरल सामान्य समाधान:

String subStr = str.substring(str.indexOf( open ) + 1, str.indexOf( close ));
System.out.format("String[%s] Parsed IntValue[%d]\n", subStr, Integer.parseInt( subStr ));

अपाचे सॉफ्टवेयर फाउंडेशन commons.lang3।

StringUtilsक्लास substringBetween()फंक्शन को स्ट्रिंग मिलता है जिसे दो स्ट्रिंग्स के बीच में घोंसला बनाया जाता है। केवल पहला मैच ही लौटा है।

String substringBetween = StringUtils.substringBetween(subStr, open, close);
System.out.println("Commons Lang3 : "+ substringBetween);

दिए गए स्ट्रिंग को बदल देता है, स्ट्रिंग के साथ जो दो स्ट्रिंग्स के बीच में घोंसला है। #395

रेगुलर-एक्सप्रेशंस के साथ पैटर्न: (\()(.*?)(\)).*

डॉट से मेल खाता है (लगभग) किसी भी चरित्र .? = .{0,1}, .* = .{0,}, .+ = .{1,}

String patternMatch = patternMatch(generateRegex(open, close), str);
System.out.println("Regular expression Value : "+ patternMatch);

उपयोगिता वर्ग RegexUtilsऔर कुछ कार्यों के साथ नियमित अभिव्यक्ति ।
      Pattern.DOTALL: लाइन टर्मिनेटर सहित किसी भी वर्ण से मेल खाता है।
      Pattern.MULTILINE: इनपुट क्रम के अंत तक शुरू से पूरे स्ट्रिंग का मिलान करता है।^$

public static String generateRegex(String open, String close) {
    return "(" + RegexUtils.escapeQuotes(open) + ")(.*?)(" + RegexUtils.escapeQuotes(close) + ").*";
}

public static String patternMatch(String regex, CharSequence string) {
    final Pattern pattern  = Pattern.compile(regex, Pattern.DOTALL);
    final Matcher matcher = pattern .matcher(string);

    String returnGroupValue = null;
    if (matcher.find()) { // while() { Pattern.MULTILINE }
        System.out.println("Full match: " + matcher.group(0));
        System.out.format("Character Index [Start:End]«[%d:%d]\n",matcher.start(),matcher.end());
        for (int i = 1; i <= matcher.groupCount(); i++) {
            System.out.println("Group " + i + ": " + matcher.group(i));
            if( i == 2 ) returnGroupValue = matcher.group( 2 );
        }
    }
    return returnGroupValue;
}
— यश
स्रोत
— StringUtils
5 
public String getStringBetweenTwoChars(String input, String startChar, String endChar) {
    try {
        int start = input.indexOf(startChar);
        if (start != -1) {
            int end = input.indexOf(endChar, start + startChar.length());
            if (end != -1) {
                return input.substring(start + startChar.length(), end);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return input; // return null; || return "" ;
}

उपयोग:

String input = "test string (67)";
String startChar = "(";
String endChar   = ")";
String output = getStringBetweenTwoChars(input, startChar, endChar);
System.out.println(output);
// Output: "67"
— एसआर
स्रोत
4

उपयोग Pattern and Matcher 

public class Chk {

    public static void main(String[] args) {

        String s = "test string (67)";
        ArrayList<String> arL = new ArrayList<String>();
        ArrayList<String> inL = new ArrayList<String>();

        Pattern pat = Pattern.compile("\\(\\w+\\)");
        Matcher mat = pat.matcher(s);

        while (mat.find()) {

            arL.add(mat.group());
            System.out.println(mat.group());

        }

        for (String sx : arL) {

            Pattern p = Pattern.compile("(\\w+)");
            Matcher m = p.matcher(sx);

            while (m.find()) {

                inL.add(m.group());
                System.out.println(m.group());
            }
        }

        System.out.println(inL);

    }

}
— कुमार विवेक मित्र
स्रोत
2
चर नाम बोलने से विधि अधिक अनुकूल हो सकती है।
— ज़ोन
3

विभाजन विधि का उपयोग करने का दूसरा तरीका

public static void main(String[] args) {


    String s = "test string (67)";
    String[] ss;
    ss= s.split("\\(");
    ss = ss[1].split("\\)");

    System.out.println(ss[0]);
}
— Jayy
स्रोत
3

मुझे रेगेक्स और पैटर्न / माचिस वर्गों के साथ ऐसा करने का सबसे कम सामान्य तरीका मिला:

String text = "test string (67)";

String START = "\\(";  // A literal "(" character in regex
String END   = "\\)";  // A literal ")" character in regex

// Captures the word(s) between the above two character(s)
String pattern = START + "(\w+)" + END;

Pattern pattern = Pattern.compile(pattern);
Matcher matcher = pattern.matcher(text);

while(matcher.find()) {
    System.out.println(matcher.group()
        .replace(START, "").replace(END, ""));
}

यह और अधिक जटिल regex समस्याओं के लिए मदद कर सकता है जहाँ आप दो अक्षरों के बीच पाठ प्राप्त करना चाहते हैं।

— होने के लिए
स्रोत
2

ऐसा करने का "सामान्य" तरीका स्ट्रिंग को शुरू से पार्स करना है, पहले ब्रैकेट से पहले सभी वर्णों को फेंकना, पहले ब्रैकेट के बाद वर्णों को रिकॉर्ड करना, और दूसरे ब्रैकेट के बाद वर्णों को फेंक देना।

मुझे यकीन है कि वहाँ एक regex पुस्तकालय या इसे करने के लिए कुछ है।

— जोनाथन एशवर्थ
स्रोत
जावा नियमित अभिव्यक्ति का समर्थन करता है। Regexp4j लाइब्रेरी के लिए कोई ज़रूरत नहीं है;)
— एंड्रियास
2

अन्य संभव समाधान यह है lastIndexOfकि यह चरित्र के लिए उपयोग करें या पीछे से स्ट्रिंग के लिए दिखेगा।

मेरे परिदृश्य में, मेरे पास निम्नलिखित थे Stringऔर मुझे निकालना था<<UserName>>

1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc

इसलिए, indexOfऔर StringUtils.substringBetweenउपयोगी नहीं था क्योंकि वे शुरू से ही चरित्र की तलाश में थे।

तो, मैंने इस्तेमाल किया lastIndexOf

String str = "1QAJK-WKJSH_MyApplication_Extract_<<UserName>>.arc";
String userName = str.substring(str.lastIndexOf("_") + 1, str.lastIndexOf("."));

और, यह मुझे देता है 

<<UserName>>
— रवि
स्रोत
1

कुछ इस तरह:

public static String innerSubString(String txt, char prefix, char suffix) {

    if(txt != null && txt.length() > 1) {

        int start = 0, end = 0;
        char token;
        for(int i = 0; i < txt.length(); i++) {
            token = txt.charAt(i);
            if(token == prefix)
                start = i;
            else if(token == suffix)
                end = i;
        }

        if(start + 1 < end)
            return txt.substring(start+1, end);

    }

    return null;
}
— अहमद अलमुग्रेबी
स्रोत
1

यह एक सरल उपयोग \D+regex और काम किया है।
यह अंकों को छोड़कर सभी वर्णों का चयन करता है, जटिल करने की आवश्यकता नहीं है

/\D+/
— पास्कल तोवोहरी
स्रोत
1

अगर मैच रेगेक्स नहीं है तो यह मूल स्ट्रिंग लौटाएगा

var iAm67 = "test string (67)".replaceFirst("test string \\((.*)\\)", "$1");

कोड में मेल जोड़ें

String str = "test string (67)";
String regx = "test string \\((.*)\\)";
if (str.matches(regx)) {
    var iAm67 = str.replaceFirst(regx, "$1");
}

--- संपादित करें ---

मैं regex का परीक्षण करने के लिए https://www.freeformatter.com/java-regex-tester.html#ad-output का उपयोग करता हूं ।

इसे जोड़ना बेहतर है? कम मैच के बाद *। कुछ इस तरह:

String str = "test string (67)(69)";
String regx1 = "test string \\((.*)\\).*";
String regx2 = "test string \\((.*?)\\).*";
String ans1 = str.replaceFirst(regx1, "$1");
String ans2 = str.replaceFirst(regx2, "$1");
System.out.println("ans1:"+ans1+"\nans2:"+ans2); 
// ans1:67)(69
// ans2:67
— bigiCrab
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.