एक स्ट्रिंग से संख्या कैसे निकालें और ints की एक सरणी प्राप्त करें?

Question

मेरे पास एक स्ट्रिंग चर (मूल रूप से एक अनिर्दिष्ट संख्या के साथ एक अंग्रेजी वाक्य) है और मैं पूर्णांक की एक सरणी में सभी संख्याओं को निकालना चाहूंगा। मैं सोच रहा था कि क्या नियमित अभिव्यक्ति के साथ एक त्वरित समाधान था?

---

मैंने सीन के समाधान का उपयोग किया और इसे थोड़ा बदल दिया:

LinkedList<String> numbers = new LinkedList<String>();

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher(line); 
while (m.find()) {
   numbers.add(m.group());
}

Comments

क्या स्थान या अन्य वर्णों से घिरी हुई संख्याएँ हैं? संख्याओं को कैसे स्वरूपित किया जाता है, क्या वे हेक्साडेसिमल, ऑक्टल, बाइनरी, दशमलव हैं?

— बुहके सिंडी

मुझे लगा कि यह सवाल से स्पष्ट है: यह संख्याओं के साथ एक अंग्रेजी वाक्य है। इसके अलावा मैं एक पूर्णांक सरणी के बारे में बात कर रहा था, इसलिए जो मैं देख रहा था वह पूर्णांक थे।

— जॉन मैनाक

Answer 1

Pattern p = Pattern.compile("-?\\d+");
Matcher m = p.matcher("There are more than -2 and less than 12 numbers here");
while (m.find()) {
  System.out.println(m.group());
}

... प्रिंट -2और 12।

---

-? एक प्रमुख नकारात्मक संकेत से मेल खाता है - वैकल्पिक रूप से। \ घ अंक से मेल खाता है, और हम लिखने की ज़रूरत \के रूप में \\एक जावा स्ट्रिंग हालांकि में। तो, \ d + 1 या अधिक अंकों से मेल खाता है।

Comments

क्या आप कृपया अपनी नियमित अभिव्यक्ति की व्याख्या करके अपना उत्तर दे सकते हैं?

— ऑस्कररीज़

-? एक प्रमुख नकारात्मक संकेत से मेल खाता है - वैकल्पिक रूप से। \ d एक अंक से मेल खाता है, और हमें एक जावा स्ट्रिंग में \ as \\ लिखना होगा। तो, \\ d + 1 और अंकों का मिलान करता है

— शॉन ओवेन

मैंने फ़्लोट्स का समर्थन करने के लिए अपनी अभिव्यक्ति पैटर्न.कॉमपाइल ("-? [\\ d \\।] +") में बदल दी। आप निश्चित रूप से मुझे रास्ते में नेतृत्व करते हैं, Thx!

— jlengrand

यह विधि अंकों का पता लगाती है, लेकिन तैयार संख्याओं का पता नहीं लगाती है, जैसे 2,000। ऐसे उपयोग के लिए-?\\d+,?\\d+|-?\\d+

— मुगोमा जे। ओकोमबा

यह केवल एक एकल अल्पविराम का समर्थन करता है, इसलिए "2,000,000" याद होगा। यह "2,00" जैसे तारों को भी स्वीकार करता है। यदि अल्पविराम विभाजकों का समर्थन किया जाना चाहिए, तो: -?\\d+(,\\d{3})*काम करना चाहिए।

— सीन ओवेन

Answer 2

replaceAllJava.lang.String विधि का उपयोग करने के बारे में क्या :

    String str = "qwerty-1qwerty-2 455 f0gfg 4";      
    str = str.replaceAll("[^-?0-9]+", " "); 
    System.out.println(Arrays.asList(str.trim().split(" ")));

आउटपुट:

[-1, -2, 455, 0, 4]

---

विवरण

[^-?0-9]+

• [और ]एकल मिलान किए जाने वाले वर्णों के एक सेट को परिसीमित करता है, अर्थात किसी भी क्रम में केवल एक बार
• ^विशेष पहचानकर्ता सेट की शुरुआत में प्रयुक्त सभी वर्णों का मिलान करने इंगित करने के लिए प्रयोग किया जाता है, नहीं , सीमांकित सेट में मौजूद बजाय सभी पात्रों सेट में प्रस्तुत करते हैं।
• + एक और असीमित समय के बीच, जितनी बार संभव हो, वापस आवश्यकतानुसार
• -? पात्रों में से एक "-" और "?"
• 0-9 "0" और "9" के बीच की सीमा में एक चरित्र

Comments

आप सवालिया निशान क्यों रखना चाहेंगे? इसके अलावा, इस व्यवहार करता है -एक संख्या के रूप अपने आप में, बातों के साथ-साथ की तरह 9-, ---6है, और 1-2-3।

— एलन मूर

पुस्तकालयों का आयात किए बिना एक बहुत अच्छा विकल्प;)

— Jcc.Sanabria

Answer 3

Pattern p = Pattern.compile("[0-9]+");
Matcher m = p.matcher(myString);
while (m.find()) {
    int n = Integer.parseInt(m.group());
    // append n to list
}
// convert list to array, etc

आप वास्तव में [0-9] को d से बदल सकते हैं, लेकिन इसमें डबल बैकस्लैश बचना शामिल है, जिससे इसे पढ़ना मुश्किल हो जाता है।

Comments

ओह। शॉन नकारात्मक संख्याओं को संभालता है, इसलिए यह एक सुधार है।

— मकड़ी

अगर आप का उपयोग आपकी भी ऋणात्मक संख्याओं को संभाल लेंगे? "- [0-9] +"

— cegprakash

Answer 4

  StringBuffer sBuffer = new StringBuffer();
  Pattern p = Pattern.compile("[0-9]+.[0-9]*|[0-9]*.[0-9]+|[0-9]+");
  Matcher m = p.matcher(str);
  while (m.find()) {
    sBuffer.append(m.group());
  }
  return sBuffer.toString();

यह दशमलव को बनाए रखने वाली संख्या निकालने के लिए है

Comments

नकारात्मक को नहीं संभालता है

— OneCricketeer

Answer 5

स्वीकृत उत्तर अंकों का पता लगाता है, लेकिन प्रारूपित संख्याओं, जैसे 2,000, और न ही दशमलव, जैसे 4.8 का पता नहीं लगाता है। ऐसे उपयोग के लिए -?\\d+(,\\d+)*?\\.?\\d+?:

        Pattern p = Pattern.compile("-?\\d+(,\\d+)*?\\.?\\d+?");
        List<String> numbers = new ArrayList<String>();
        Matcher m = p.matcher("Government has distributed 4.8 million textbooks to 2,000 schools");
        while (m.find()) {  
            numbers.add(m.group());
        }   
        System.out.println(numbers);

आउटपुट: [4.8, 2,000]

Comments

@ जुलिएनस: मैं असहमत हूं। यह रेगेक्स ओपी द्वारा पूछे जाने की तुलना में बहुत अधिक है, और यह गलत तरीके से करता है। (कम से कम, दशमलव भाग एक वैकल्पिक समूह में होना चाहिए, इसमें सब कुछ आवश्यक और लालची है (?:\.\d+)?।)

— एलन मूर

दशमलव भाग के लिए आपके पास निश्चित रूप से एक बिंदु है। हालाँकि यह स्वरूपित संख्याओं का सामना करना बहुत आम है।

— जुलिएन

@AlanMoore कई एसओ के आगंतुकों को अलग-अलग समानता / अंतर के साथ मुद्दों को हल करने के लिए किसी भी / विभिन्न तरीकों की तलाश कर रहे हैं, और यह मददगार है कि सुझाव को लाया जाता है। यहां तक ​​कि ओपी की देखरेख हो सकती है।

— मुगोमा जे। ओकोमाबा

Answer 6

तर्कसंगत संख्याओं के लिए यह प्रयोग करें: (([0-9]+.[0-9]*)|([0-9]*.[0-9]+)|([0-9]+))

Comments

ओपी ने कहा कि पूर्णांक, वास्तविक संख्या नहीं हैं। इसके अलावा, आप डॉट्स से बचना भूल गए, और उनमें से कोई भी कोष्ठक आवश्यक नहीं है।

— एलन मूर

Answer 7

जावा 8 का उपयोग करते हुए, आप कर सकते हैं:

String str = "There 0 are 1 some -2-34 -numbers 567 here 890 .";
int[] ints = Arrays.stream(str.replaceAll("-", " -").split("[^-\\d]+"))
                 .filter(s -> !s.matches("-?"))
                 .mapToInt(Integer::parseInt).toArray();
System.out.println(Arrays.toString(ints)); // prints [0, 1, -2, -34, 567, 890]

यदि आपके पास ऋणात्मक संख्या नहीं है, तो आप replaceAll(और उपयोग !s.isEmpty()में filter) से छुटकारा पा सकते हैं , क्योंकि यह केवल कुछ को ठीक से विभाजित करने के लिए है 2-34(यह शुद्ध रूप से रेगेक्स के साथ भी संभाला जा सकता है split, लेकिन यह काफी जटिल है)।

Arrays.streamहमारे String[]एक में बदल जाता है Stream<String>।

filterअग्रणी और अनुगामी खाली तारों के साथ-साथ किसी भी -नंबर का हिस्सा नहीं है।

mapToInt(Integer::parseInt).toArray()हमें देने के लिए parseIntप्रत्येक पर कॉल Stringकरता है int[]।

---

वैकल्पिक रूप से, जावा 9 में एक Matcher.results विधि है, जिसे कुछ इस तरह की अनुमति देनी चाहिए:

Pattern p = Pattern.compile("-?\\d+");
Matcher m = p.matcher("There 0 are 1 some -2-34 -numbers 567 here 890 .");
int[] ints = m.results().map(MatchResults::group).mapToInt(Integer::parseInt).toArray();
System.out.println(Arrays.toString(ints)); // prints [0, 1, -2, -34, 567, 890]

---

जैसा कि यह खड़ा है, इनमें से न तो परिणामों पर लूपिंग के साथ एक बड़ा सुधार है Pattern/ Matcherजैसा कि अन्य उत्तरों में दिखाया गया है, लेकिन यह सरल होना चाहिए यदि आप इसे और अधिक जटिल संचालन के साथ पालन करना चाहते हैं जो कि इसके उपयोग के साथ काफी सरल हैं धाराओं।

Answer 8

इसका उपयोग करके सभी वास्तविक संख्याएँ निकालें।

public static ArrayList<Double> extractNumbersInOrder(String str){

    str+='a';
    double[] returnArray = new double[]{};

    ArrayList<Double> list = new ArrayList<Double>();
    String singleNum="";
    Boolean numStarted;
    for(char c:str.toCharArray()){

        if(isNumber(c)){
            singleNum+=c;

        } else {
            if(!singleNum.equals("")){  //number ended
                list.add(Double.valueOf(singleNum));
                System.out.println(singleNum);
                singleNum="";
            }
        }
    }

    return list;
}


public static boolean isNumber(char c){
    if(Character.isDigit(c)||c=='-'||c=='+'||c=='.'){
        return true;
    } else {
        return false;
    }
}

Answer 9

वास्तविक संख्याओं का प्रतिनिधित्व करने के लिए अंश और समूहन वर्ण भाषाओं के बीच भिन्न हो सकते हैं। भाषा के आधार पर एक ही वास्तविक संख्या को बहुत अलग तरीकों से लिखा जा सकता है।

जर्मन में संख्या दो मिलियन

2,000,000.00

और अंग्रेजी में

2.000.000,00

भाषा अज्ञेय तरीके से दिए गए स्ट्रिंग से वास्तविक संख्याओं को पूरी तरह से निकालने की एक विधि:

public List<BigDecimal> extractDecimals(final String s, final char fraction, final char grouping) {
    List<BigDecimal> decimals = new ArrayList<BigDecimal>();
    //Remove grouping character for easier regexp extraction
    StringBuilder noGrouping = new StringBuilder();
    int i = 0;
    while(i >= 0 && i < s.length()) {
        char c = s.charAt(i);
        if(c == grouping) {
            int prev = i-1, next = i+1;
            boolean isValidGroupingChar =
                    prev >= 0 && Character.isDigit(s.charAt(prev)) &&
                    next < s.length() && Character.isDigit(s.charAt(next));                 
            if(!isValidGroupingChar)
                noGrouping.append(c);
            i++;
        } else {
            noGrouping.append(c);
            i++;
        }
    }
    //the '.' character has to be escaped in regular expressions
    String fractionRegex = fraction == POINT ? "\\." : String.valueOf(fraction);
    Pattern p = Pattern.compile("-?(\\d+" + fractionRegex + "\\d+|\\d+)");
    Matcher m = p.matcher(noGrouping);
    while (m.find()) {
        String match = m.group().replace(COMMA, POINT);
        decimals.add(new BigDecimal(match));
    }
    return decimals;
}

Answer 10

यदि आप शब्दों के भीतर सम्‍मिलित संख्‍याओं को बाहर करना चाहते हैं, जैसे कि bar1 या aa1bb, तो regex आधारित उत्‍तरों में से किसी एक में शब्द सीमाएँ \ b जोड़ें। उदाहरण के लिए:

Pattern p = Pattern.compile("\\b-?\\d+\\b");
Matcher m = p.matcher("9There 9are more9 th9an -2 and less than 12 numbers here9");
while (m.find()) {
  System.out.println(m.group());
}

प्रदर्शित करता है:

2
12

Answer 11

मैं स्ट्रिंग से नंबर निकालने के लिए ASCII मूल्यों की जांच करने का सुझाव दूंगा मान लीजिए कि आपके पास myname12345 के रूप में एक इनपुट स्ट्रिंग है और यदि आप केवल संख्या 12345 निकालना चाहते हैं, तो आप स्ट्रिंग को कैरेक्टर एरे में परिवर्तित करके ऐसा कर सकते हैं: निम्नलिखित छद्म कोड का उपयोग करें:

    for(int i=0; i < CharacterArray.length; i++)
    {
        if( a[i] >=48 && a[i] <= 58)
            System.out.print(a[i]);
    }

एक बार संख्या निकालने के बाद उन्हें एक सरणी में जोड़ दें

उम्मीद है की यह मदद करेगा

Comments

जावा स्ट्रिंग को यूनिकोड / यूटीएफ -16 कोड-यूनिट के अनुक्रम में गिना जाता है। UTF-16 के डिजाइन से पहले 128 वर्णों का समान मान (समान आकार नहीं) उनके ASCII एन्कोडिंग के समान है; इसके अलावा, यह सोचकर कि आप ASCII के साथ काम कर रहे हैं, त्रुटियों को जन्म देगा।

— टॉम ब्लोडेट

Answer 12

मुझे यह अभिव्यक्ति सबसे सरल लगी

String[] extractednums = msg.split("\\\\D++");

Answer 13

public static String extractNumberFromString(String number) {
    String num = number.replaceAll("[^0-9]+", " ");
    return num.replaceAll(" ", "");
}

स्ट्रिंग से केवल संख्या निकालता है