如何從字符串中提取正整數和負整數

Question

我需要從String形式的二項式表達式中提取正整數和負整數。 然后，這些數字將分配給數組。

該字符串：

"(-22x+43)^2"

會變成這個數組：

[-22, 43, 2]

要么，

該字符串：

"(x-22)^-2"

會變成這個數組：

[1, -22, -2]

我對數組很熟悉，但是不知道如何提取數字。 我研究了正則表達式，這個過程似乎很神秘。 可以不使用正則表達式嗎？ 考慮解決此類問題的最佳方法是什么？

Answer 1

您可以嘗試通過以下正則表達式進行匹配： “ [-\\ d ++ \\ d +]”

Answer 2

有無正則表達式 ：-

public static void main(String[] args) {
    String test = "(-22x+43)^2";
    System.out.println(extractNumbers(test));
    System.out.println(extractNumbersRegexStyle(test));
}

private static List<Integer> extractNumbers(String str) {
    str += " ";
    List<String> arr = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    for (char c : str.toCharArray()) {
        if (Character.isDigit(c) || (sb.length() == 0 && c == '-')) {
            sb.append(c);
        } else if (Character.isLetter(c) && sb.length() == 0) {
            sb.append(1);
        } else {
            if (Character.isLetter(c) && sb.toString().equals("-")) {
                sb.append(1);
            }
            if (sb.length() > 0) {
                arr.add(sb.toString());
                sb = new StringBuilder();
            }
            if (c == '-') {
                sb.append(c);
            }
        }
    }
    return arr.stream()
            .map(Integer::parseInt)
            .collect(Collectors.toList());
}

private static List<Integer> extractNumbersRegexStyle(String str) {
    List<String> arr = new ArrayList<>();
    Pattern p = Pattern.compile("-?\\d+");
    Matcher m = p.matcher(str);
    while (m.find()) {
        arr.add(m.group());
    }
    return arr.stream()
            .map(Integer::parseInt)
            .collect(Collectors.toList());
}

產量

[-22, 43, 2]
[-22, 43, 2]

然后，您可以根據需要將List轉換為int數組。

Answer 3

您應該通過檢查每個字符的條件來做到這一點。

public static void main(String[] args) {
        String exp="(x-y)^-2";
        String arr[]=new String[5];
        int i=0;
        String input1="";
        for(int x=0;x<exp.length();x++){
            char ch=exp.charAt(x);
            if(ch=='-'||(ch>=48&&ch<=57)){
                input1 += String.valueOf(ch);
            }
            else{
                if((ch>=65&&ch<=90)||(ch>=97&&ch<=122)||ch=='^'){
                    if(input1.equals("")){
                        input1="0";
                    }
                    if(!input1.equals("-")){
                    arr[i]=input1;

                    i++;
                    }
                    input1="";
                    }
            }

        }
        if(!input1.equals("")){
            arr[i]=input1;
        }
        System.out.println("Array IS");
        for(String c:arr){
            System.out.println(c);
        }
    }

Answer 4

考慮到字符串具有(ax-b)^n形式的表達式，並且您需要系數[a , b, n]

可以為此編寫一個自定義解析器，而我可以用Java來實現（您可以使用任何其他語言，但是邏輯幾乎相同）。

public static int[] getBinomialCoefficients(String exp){

     int l=exp.length();
     // "(x-22)^-2" for example

     int obIndex = exp.indexOf('('); //opening bracket Index
     int xIndex  = exp.indexOf('x'); // x index
     int cbIndex = exp.indexOf(')'); // closing bracket Index

     int a=0,b=0,n=1;
     if(obIndex+1!=xIndex){
          a = Integer.parseInt(exp.substring(obIndex+1,xIndex));
     }
     if(cbIndex-1!=xIndex){
          b = Integer.parseInt(exp.substring(xIndex+1,cbIndex));
     }
     if(cbIndex!=l-1){
          n = Integer.parseInt(exp.substring(cbIndex+2,l));
     }


    return new int[] {a,b,n};
}

我在這里計算每個變量的索引，但是如果您認為將其拆分為數組會有所幫助，則也可以使用該方法。 該字符串不會那么長，因此我們可以使用這些方法中的任何一種。

Answer 5

你可以試試

import java.util.ArrayList;

public class NumberExtraction
{
    private static String oneNumber ="";
    private static ArrayList<Integer> ar = new ArrayList<Integer>();
    public static void main(String[] args)
    {
        String exp = "(-22x+43)^2";
        char[] cr = exp.toCharArray();
        for(char c : cr)
        {
            doCheck(c);
        }
        doCheck('e');
        System.out.println(ar);
    }
    static void doCheck(char c)
    {
        if((c>=48 && c<=57) || c==45)
        {
            oneNumber +=c;
        }else if(((c>=97 && c<=122) || (c>=65 && c<=90) ) &&("".equalsIgnoreCase(oneNumber)||"-".equalsIgnoreCase(oneNumber) ))
        {
            oneNumber +=0;
        }else if(!"".equalsIgnoreCase(oneNumber))
        {
            ar.add(Integer.parseInt(oneNumber));
            oneNumber="";
        }

    }
}

Answer 6

使用字符串函數，嘗試這一

import java.io.*;
 import java.util.*;
 public class Series
 {
  public static void main(String [] args) {
      String str = "(x-22)^-2";  
      String[] arstr = str.replaceFirst("\\)","").split("[x^]"); // replacing ")", with "" and splitting at x and ^ 
      if(arstr[0].equals("("))   // checking for coefficient
            arstr[0]="0";
       else
           arstr[0]=arstr[0].substring(1);
       if(arstr[1].contains("+"))         // checking sign "+" to remove
           arstr[1]=arstr[1].substring(1);
      System.out.println(Arrays.toString(arstr));   // printing result

    }  
 }

輸入

String str = "(x-22)^-2"; 
String str2 =  "(-22x+43)^2"

輸出：

[0, -22, -2]
[-22, 43, 2]

Answer 7

您可以使用此正則表達式（和其他替換）：

\\((-?(?:\\d+|x))x?(?:\\+(\\d+)|(-\\d+))\\)\\^(-?\\d+)

替換為： [$1, $2$3, $4] 。 然后，將x替換為1

演示 （第一部分）

碼：

String str = "(-x-99)^-9";

str = str.replaceAll("\\((-?(?:\\d+|x))x?(?:\\+(\\d+)|(-\\d+))\\)\\^(-?\\d+)", "[$1, $2$3, $4]")
         .replaceAll("x", "1");

輸出：

[-1，-99，-9]

正則表達式解釋：

\(                   # Literal '('
  (-?(?:\d+|x))      # First capturing group: Either digits or single x
  x?                 # Followed by an optional x
  (?:\+(\d+)|(-\d+)) # Match either: positive number on 2nd capturing group (without + sign)
                     # or negative number on 3rd capturing group (with - sign)
\)                   # Literal ')'
\^                   # Literal '^'
(-?\d+)              # Exponent, 4th capturing group