Fatal编程技术网
  • java/
  • Java—将字符串转换为数字的想法（RegEx/Parsing/etc）？

Java—将字符串转换为数字的想法（RegEx/Parsing/etc）？

java regex file parsing

Java—将字符串转换为数字的想法（RegEx/Parsing/etc）？,java,regex,file,parsing,Java,Regex,File,Parsing,我从一个文件中读取，输入如下： Description (1.0,2.0) (2,7.6) (2.1,3.0) Description2 (4,1) ... Description_n (4,18) (8, 7.20) 我希望能够将括号内的数字转换成数字，这样我就可以对它们进行数学运算。现在，为了简化，我的代码只读取第一行，然后根据空格将其拆分： BufferedReader reader = null; try { reader = new BufferedReader(new F

我从一个文件中读取，输入如下：

Description (1.0,2.0) (2,7.6) (2.1,3.0)
Description2 (4,1)
...
Description_n (4,18) (8, 7.20)
我希望能够将括号内的数字转换成数字，这样我就可以对它们进行数学运算。现在，为了简化，我的代码只读取第一行，然后根据空格将其拆分：

BufferedReader reader = null;

try {
    reader = new BufferedReader(new FileReader(new File("filename.txt")));

    //reader reads in the first line
    String firstLine = reader.readLine();

    //splits into an array of ["Description","(1.0,2.0)","(2,7.6)","(2.1,3.0)"]
    String[] parts = first.split(" "); 

    //now I want to store 1.0, 2, and 2.1 in one array as ints and 2.0, 7.6, and 3.0 in another int array

} catch (Exception e) {
    System.exit(0); 
}
有哪些方法可以将括号内的数字存储到两个独立的整数数组中（请参见上面的注释）？我是否应该使用正则表达式以某种方式捕获形式为“（[1-9.]，[1-9.]）”的某些内容，然后将它们传递到另一个函数中，该函数将把对中的第一个数字与第二个数字分开，然后将它们都转换为整数？我不熟悉Java中的正则表达式解析，所以我不知道如何实现它

或者有没有一个简单、更好的方法来做到这一点

如何分析每个项目：

parseDouble（“这里的字符串”）

至于存储，我没有得到您想要存储值的模式。为什么要将1.0、2和2.1放在一个数组中，并将2.0、7.6和3.0放在另一个数组中？

如何分析每个项目：

parseDouble（“这里的字符串”）

至于存储，我没有得到您想要存储值的模式。为什么要将1.0、2和2.1放在一个数组中，并将2.0、7.6和3.0放在另一个数组中？

如何分析每个项目：

parseDouble（“这里的字符串”）

至于存储，我没有得到您想要存储值的模式。为什么要将1.0、2和2.1放在一个数组中，并将2.0、7.6和3.0放在另一个数组中？

如何分析每个项目：

parseDouble（“这里的字符串”）

至于存储，我没有得到您想要存储值的模式。为什么您希望1.0、2和2.1在1个数组中，2.0、7.6和3.0在另一个数组中？只需执行Integer.parseInt（字符串）或Double.parseDouble（字符串），然后将它们添加到数组中。不过，我不是100%确定你在问什么。

只需执行Integer.parseInt（字符串）或Double.parseDouble（字符串），然后将它们添加到数组中。不过，我不是100%确定你在问什么。

只需执行Integer.parseInt（字符串）或Double.parseDouble（字符串），然后将它们添加到数组中。不过，我不是100%确定你在问什么。

只需执行Integer.parseInt（字符串）或Double.parseDouble（字符串），然后将它们添加到数组中。不过，我并不是100%确定你在问什么。

这将数字存储到
双
数组中（不是二维数组，双
对象数组），因为有些数组具有
。
。int数组将消除小数点后的部分

它使用regex
\b（[\d.]+）\b
查找每个paren组中的每个数字，并将每个数字添加到
数组列表中。请注意，它假定所有输入都是完美的（与
（bogus，3.2）
完全不同）。然后将列表转换为一个
双
对象数组

这会给你一个迈向目标的良好开端


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

/**
   <P>{@code java DoubleInParenStringsToArrays}</P>
 **/
public class DoubleInParenStringsToArrays  {
   public static final void main(String[] ignored)  {
      String input = "(1.0,2.0) (2,7.6) (2.1,3.0)";
      String[] inputs = input.split(" ");

      //"": Dummy string, to reuse matcher
      Matcher mtchrGetNums = Pattern.compile("\\b([\\d.]+)\\b").matcher("");
      for(String s : inputs)  {

         ArrayList<Double> doubleList = new ArrayList<Double>();
         mtchrGetNums.reset(s);
         while(mtchrGetNums.find())  {
            //TODO: Crash if it's not a number!
            doubleList.add(Double.parseDouble(mtchrGetNums.group(0)));
         }

         Double[] doubles = doubleList.toArray(new Double[doubleList.size()]);
         System.out.println(Arrays.toString(doubles));
      }
   }
}



这将数字存储到
Double
-数组中（不是二维数组，
Double
对象的数组），因为有些数组具有
.
。int数组将消除小数后的部分

它使用正则表达式
\b（[\d.]+）\b
查找每个paren组中的每个数字，并将每个数字添加到
数组列表中。请注意，它假设所有输入都是完美的（与
（bogus，3.2）
完全不同）。然后将该列表转换为
双
对象数组

这会给你一个迈向目标的良好开端


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

/**
   <P>{@code java DoubleInParenStringsToArrays}</P>
 **/
public class DoubleInParenStringsToArrays  {
   public static final void main(String[] ignored)  {
      String input = "(1.0,2.0) (2,7.6) (2.1,3.0)";
      String[] inputs = input.split(" ");

      //"": Dummy string, to reuse matcher
      Matcher mtchrGetNums = Pattern.compile("\\b([\\d.]+)\\b").matcher("");
      for(String s : inputs)  {

         ArrayList<Double> doubleList = new ArrayList<Double>();
         mtchrGetNums.reset(s);
         while(mtchrGetNums.find())  {
            //TODO: Crash if it's not a number!
            doubleList.add(Double.parseDouble(mtchrGetNums.group(0)));
         }

         Double[] doubles = doubleList.toArray(new Double[doubleList.size()]);
         System.out.println(Arrays.toString(doubles));
      }
   }
}



这将数字存储到
Double
-数组中（不是二维数组，
Double
对象的数组），因为有些数组具有
.
。int数组将消除小数后的部分

它使用正则表达式
\b（[\d.]+）\b
查找每个paren组中的每个数字，并将每个数字添加到
数组列表中。请注意，它假设所有输入都是完美的（与
（bogus，3.2）
完全不同）。然后将该列表转换为
双
对象数组

这会给你一个迈向目标的良好开端


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

/**
   <P>{@code java DoubleInParenStringsToArrays}</P>
 **/
public class DoubleInParenStringsToArrays  {
   public static final void main(String[] ignored)  {
      String input = "(1.0,2.0) (2,7.6) (2.1,3.0)";
      String[] inputs = input.split(" ");

      //"": Dummy string, to reuse matcher
      Matcher mtchrGetNums = Pattern.compile("\\b([\\d.]+)\\b").matcher("");
      for(String s : inputs)  {

         ArrayList<Double> doubleList = new ArrayList<Double>();
         mtchrGetNums.reset(s);
         while(mtchrGetNums.find())  {
            //TODO: Crash if it's not a number!
            doubleList.add(Double.parseDouble(mtchrGetNums.group(0)));
         }

         Double[] doubles = doubleList.toArray(new Double[doubleList.size()]);
         System.out.println(Arrays.toString(doubles));
      }
   }
}



这将数字存储到
Double
-数组中（不是二维数组，
Double
对象的数组），因为有些数组具有
.
。int数组将消除小数后的部分

它使用正则表达式
\b（[\d.]+）\b
查找每个paren组中的每个数字，并将每个数字添加到
数组列表中。请注意，它假设所有输入都是完美的（与
（bogus，3.2）
完全不同）。然后将该列表转换为
双
对象数组

这会给你一个迈向目标的良好开端


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

/**
   <P>{@code java DoubleInParenStringsToArrays}</P>
 **/
public class DoubleInParenStringsToArrays  {
   public static final void main(String[] ignored)  {
      String input = "(1.0,2.0) (2,7.6) (2.1,3.0)";
      String[] inputs = input.split(" ");

      //"": Dummy string, to reuse matcher
      Matcher mtchrGetNums = Pattern.compile("\\b([\\d.]+)\\b").matcher("");
      for(String s : inputs)  {

         ArrayList<Double> doubleList = new ArrayList<Double>();
         mtchrGetNums.reset(s);
         while(mtchrGetNums.find())  {
            //TODO: Crash if it's not a number!
            doubleList.add(Double.parseDouble(mtchrGetNums.group(0)));
         }

         Double[] doubles = doubleList.toArray(new Double[doubleList.size()]);
         System.out.println(Arrays.toString(doubles));
      }
   }
}



我会使用字符串标记器。但是需要更多的信息和思想来实现完整的impl

这是你的台词：“描述（1.0,2.0）（2,7.6）（2.1,3.0）”

第一件事-是否会有没有括号的情况？是否总是有f 2,2,2数字集

是否要处理每个数字的错误，或者如果出现错误（例如数字的数量不匹配），则跳过该行或跳过处理

现在，您需要一个数据结构来保存数字。如果每个数字在域中都有不同的含义，您可以创建一个类来保存单独属性中的每个元素，或者如果您希望将其视为简单的数字列表，则可以创建一个数组列表或简单数组。如果类1示例（不完整）：

类别行项目{

}

现在，要真正分解字符串，有很多方法。这取决于数据的质量以及您希望如何处理可能的错误

一种方法是找到第一个左括号（取字符串的其余部分并使用字符串标记器进行解析）

比如：


int i = str.indexOf("(");
String s2 = str.substring(i);
StringTokenizer st = new StringTokenizer(s2, "() ,";//parenthesis, comma and space

ArrayList<Double> lineVals1 = new ArrayList<Double>();
ArrayList<Double> lineVals1 = new ArrayList<Double>();
int cnt = 0;
while(st.hasMoreTokens()){
    cnt++;//use this to keep count of how many numbers you got in line and raise error if need be
    String stemp = st.nextToken();
    if(isNumeric(stemo)){
         if(cnt % 2 == 1){
             lineVals1.add(Double.parseDouble(stemp));
         }else{
            lineVals2.add(Double.parseDouble(stemp));    
         }    
    }else{
         /raise error if not numberic
    }
}


public static boolean isNumeric(String str)
{
  NumberFormat formatter = NumberFormat.getInstance();
  ParsePosition pos = new ParsePosition(0);
  formatter.parse(str, pos);
  return str.length() == pos.getIndex();
}



inti=str.indexOf（“”）；
字符串s2=str.substring（i）；
StringTokenizer st=新的StringTokenizer（s2，“（），”；//括号、逗号和sp