A. java如何将下面字符串解析出来
public static void main(String[] args) {
//要解析的字符串，简单写代替
String json = "[{'':'ff'},{'':33},{'':'ee'}]";
//去除两侧的[]
json = json.substring(1,json.length()-1);
String[] jsons = json.split("}");
//定义json字符串
String jsonStr = "";
for(int i=0;i<jsons.length;i++){
if(i==0){
jsonStr = jsons[0]+"}";
parseJsonStr(jsonStr.toString());
}else{
jsons[i] = jsons[i].substring(1);
jsonStr = jsons[i]+"}";
parseJsonStr(jsonStr.toString());
}
}
}
//解析json字符串
public static void parseJsonStr(String json){
JSONObject jo = JSONObject.fromObject(json);
System.out.println(jo.toString());
}
B. java中 怎么将一个字符串型的算式算出结果 必须要方法易懂，方法别太高级，初学
字符串的算式 我给你说些方法和思路吧 要算 其实就是 拆分他 然后将数字部分转化 然后进行计算
第一步 例如 indexOf("+")找符号 然后String[] arr=split("+") 拆分 然后将两部分运算 arr[0] arr[1]
当然了 这是简单的 或者用 substring(起始位置,终止位置) 截取两个来算也行
C. java中字符串如何变为算式
使用 Integer 类的 静态方法parseInt(String s)
public class Test
{
public static void main(String[] args)
{
String s = "240";
int i =Integer.parseInt(s);
i+=10;
System.out.println(i);
}
}
解释：
parseInt
public static int parseInt(String s)
throws NumberFormatException将字符串参数作为有符号的十进制整数进行分析。除了第一个字符可以是用来表示负值的 ASCII 减号 '-' ('\u002D') 外，字符串中的字符都必须是十进制数字。返回得到的整数值，就好像将该参数和基数 10 作为参数赋予 parseInt(java.lang.String, int) 方法一样。
参数：
s - 包含要分析的 int 表示形式的 String。
返回：
用十进制参数表示的整数值。
抛出：
NumberFormatException - 如果字符串不包含可分析的整数。
parseInt
public static int parseInt(String s,
int radix)
throws NumberFormatException使用第二个参数指定的基数，将字符串参数解析为有符号的整数。除了第一个字符可以是用来表示负值的 ASCII 减号 '-' ('\u002D’)外，字符串中的字符必须都是指定基数的数字（通过 Character.digit(char, int) 是否返回一个负值确定）。返回得到的整数值。
如果发生以下任意一种情况，则抛出一个 NumberFormatException 类型的异常：
第一个参数为 null 或一个长度为零的字符串。
基数小于 Character.MIN_RADIX 或者大于 Character.MAX_RADIX。
假如字符串的长度超过 1，那么除了第一个字符可以是减号 '-' ('u002D’) 外，字符串中的任何字符都不是指定基数的数字。
字符串表示的值不是 int 类型的值。
示例：
parseInt("0", 10) 返回 0
parseInt("473", 10) 返回 473
parseInt("-0", 10) 返回 0
parseInt("-FF", 16) 返回 -255
parseInt("1100110", 2) 返回 102
parseInt("2147483647", 10) 返回 2147483647
parseInt("-2147483648", 10) 返回 -2147483648
parseInt("2147483648", 10) 抛出 NumberFormatException
parseInt("99", 8) 抛出 NumberFormatException
parseInt("Kona", 10) 抛出 NumberFormatException
parseInt("Kona", 27) 返回 411787
参数：
s - 包含要分析的整数表示形式的 String
radix - 分析 s 时使用的基数。
返回：
使用指定基数的字符串参数表示的整数。
抛出：
NumberFormatException - 如果 String 不包含可分析的 int。
D. JAVA 文本表达式解析成数学公式,计算出结果
正则表达分解字符串
然后运算
给你个例子。以前写的，现在忙没空给你写你这个了，public class CalStr { private String src;
/**
* constructor
*
* @param srcthe string(expression) to calculate
*/
public CalStr(String src) {
this.src = src;
}
/**
* calculate to get the result
*
* @return(double)result
*/
public double getResult() {
String postfix = getPostfix();
Stack stk = new Stack();
// System.out.println(postfix);
String parts[] = postfix.split( " + ");
double result = 0;
for (int i = 0; i < parts.length; i++) {
char tmp = parts[i].charAt(0);
if (!isOperator(tmp)) {
stk.push(parts[i]);
} else {
double a = Double.parseDouble((String) stk.pop());
double b = Double.parseDouble((String) stk.pop());
// b is followed by a in the orignal expression
result = calculate(b, a, tmp);
stk.push(String.valueOf(result));
}
}
return result;
}
/**
* test if the character is an operator,such +,-,*,/
*
* @param opthe character to test
* @returntrue if op is an operator otherwise false
*/
private boolean isOperator(char op) {
return (op == '+ ' || op == '- ' || op == '* ' || op == '/ ');
}
/**
* calculate an expression such (a op b)
*
* @param anumber 1
* @param bnumber 2
* @param opthe operator
* @return(double)(a op b)
*/
public double calculate(double a, double b, char op) {
switch (op) {
case '+ ':
return a + b;
case '- ':
return a - b;
case '* ':
return a * b;
case '/ ':
return a / b;
}
return -1;
}
/**
* convert the suffix to postfix
*
* @returnthe postfix as a string
*/
private String getPostfix() {
Stack stk = new Stack();
String postfix = new String();
char op;
int i = 0;
while (i < src.length()) {
if (Character.isDigit(src.charAt(i)) || src.charAt(i) == '. ') {
postfix += " ";
do {
postfix += src.charAt(i++);
} while ((i < src.length())
&& (Character.isDigit(src.charAt(i))));
postfix += " ";
}
else {
switch (op = src.charAt(i++)) {
case '( ':
stk.push( "( ");
break;
case ') ':
while (stk.peek() != "( ") {
String tmp = (String) stk.pop();
postfix += tmp;
if (tmp.length() == 1 && isOperator(tmp.charAt(0)))
postfix += " ";
}
stk.pop();
postfix += " ";
break;
case '+ ':
case '- ':
while ((!stk.empty()) && (stk.peek() != "( ")) {
postfix += stk.pop() + " ";
}
stk.push(String.valueOf(new Character(op)));
break;
case '* ':
case '/ ':
while ((!stk.empty())
&& ((stk.peek() == "* ") || (stk.peek() == "/ "))) {
postfix += stk.pop() + " ";
}
stk.push(String.valueOf(new Character(op)));
break;
}
}
}
ListIterator it = stk.listIterator(stk.size());
while (it.hasPrevious())
postfix += it.previous() + " ";
return postfix.trim().replaceAll( " +\\. ", ". ");
}
/**
* main function
*
* @param args
*/
public static void main(String args[]) {
System.out.println(new CalStr( "((1.5+6.000)*9+9.36)*(8+9-8*8+8*7) ")
.getResult());
}
}
E. 用java解析字符串，如字符串"(1+2/5)*3"当成是数值表达式，进行计算出结果来。
如果你懂Pascal语言,可以到http://user.qzone.qq.com/413405663/blog/1259328420看看
import java.io.*;
import java.util.*;
class BinaryTree{
BinaryTree left=null;
BinaryTree right=null;
char data=0;
}
public class Calculator{
String porder="";
public void postorder(BinaryTree bt){
//递归后序遍历二叉树
if(bt!=null){
postorder(bt.left);
postorder(bt.right);
porder+=bt.data;
}
}
public int calc(String s){
//计算后缀表达式的值
int i=0,len=0,a=0,b=0;
Stack stack=new Stack();
len=s.length();
for(;i<len;i++){
char c=s.charAt(i);
switch(c){
case '+':
a=(int)stack.pop();
b=(int)stack.pop();
stack.push(a+b);
break;
case '-':
b=(int)stack.pop();
a=(int)stack.pop();
stack.push(a-b);
break;
case '*':
a=(int)stack.pop();
b=(int)stack.pop();
stack.push(a*b);
break;
case '/':
b=(int)stack.pop();
a=(int)stack.pop();
stack.push((int)a/b);
break;
default:
//该字符是数字
stack.push(c-'0');
}
}
return stack.pop();
}
public BinaryTree create(String s){
//构造二叉树结点(递归)
int i=0,pos=0,len=0;
String l="",r="";
BinaryTree node=new BinaryTree();
len=s.length();
if(len==0) return null;
if(len==1){
//递归边界
node.data=s.charAt(0);
return node;
}
//去括号
while((pos=s.indexOf(")"))!=-1){
i=pos;
while((s.charAt(i)!='(')&&(i>0)) i--;
String sub=s.substring(i+1,pos);//括号中的表达式
porder="";
postorder(create(sub));//得到后缀表达式
int sum=calc(porder);//计算后缀表达式的值,替换原来括号中的表达式
s=s.substring(0,i)+String.valueOf(sum)+s.substring(pos+1);
len=s.length();//重新计算s的长度
}
//从后往前扫描得到的第一个优先级最低的运算符号的位置
pos=-1;
for(i=len-1;i>0;i--){
char c=s.charAt(i);
if((c=='+')||(c=='-')){
pos=i;
break;
}
else if(((c=='*')||(c=='/'))&&(pos==-1)) pos=i;
}
//在pos位置将s分为左右两部分,递归构造左右两个部分的二叉树
l=s.substring(0,pos);
r=s.substring(pos+1);
node.data=s.charAt(pos);
node.left=create(l);
node.right=create(r);
return node;
}
public static void main(String args[]) throws Exception{
BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
String s=reader.readLine();
Calculator c=new Calculator();
BinaryTree bt=c.create(s);
c.postorder(bt);
System.out.println(c.calc(c.porder));
}
}
F. java解析规律字符串
用split的正则来分隔就好，
String test = "{01:9566}{02:w84394}{03:t50495}{04:p4850}";
String [] strs = test.split("[{}]{1,2}");
for(int i=1; i <strs.length; i++)
System.out.println(strs[i]);
注意i从1开始，不是从0开始，这样strs结果就是:
01:9566
02:w84394
03:t50495
04:p4850
然后再用:来split就可以了
G. java 拼接字符和解析字符串
importjava.util.ArrayList;
importjava.util.List;
/**
*CreatedbyAdministratoron2015/6/14.
*/
publicclassTest{
privatestaticList<String>infor;
static{
infor=newArrayList<String>();
infor.add("流水号1");
infor.add("收款方帐号1");
infor.add("真实姓名");
infor.add("付款金额1");
infor.add("备注说明1");
infor.add("流水号2");
infor.add("收款方帐号2");
infor.add("真实姓名");
infor.add("付款金额2");
infor.add("备注说明2");
}
publicstaticvoidmain(Stringargs[]){
/**
*开始拼接字符串
*/
StringinforString=infor.get(0);
for(inti=1,k=infor.size();i<k;i++){
if(i%5==0){
inforString+="|";
}else{
inforString+="^";
}
inforString+=infor.get(i);
}
System.out.println("拼接后的字符串是:"+inforString);
/**
*开始解释字符串
*/
String[]usersInfor=inforString.split("\|");
System.out.println(usersInfor.length);
Useruser;
String[]userString;
for(inti=0,k=usersInfor.length;i<k;i++){
userString=usersInfor[i].split("\^");
user=newUser();
user.setId(userString[0]);
user.setGathering(userString[1]);
user.setName(userString[2]);
user.setPayment(userString[3]);
user.setRemark(userString[4]);
System.out.println("User"+i+"="+user);
}
}
staticclassUser{
privateStringid;
privateStringgathering;
privateStringname;
privateStringpayment;
privateStringremark;
publicUser(){
}
publicStringgetId(){
returnid;
}
publicvoidsetId(Stringid){
this.id=id;
}
publicStringgetGathering(){
returngathering;
}
publicvoidsetGathering(Stringgathering){
this.gathering=gathering;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetPayment(){
returnpayment;
}
publicvoidsetPayment(Stringpayment){
this.payment=payment;
}
publicStringgetRemark(){
returnremark;
}
publicvoidsetRemark(Stringremark){
this.remark=remark;
}
@Override
publicStringtoString(){
return"[id:"+id+",gathering:"+gathering+",name:"+name+",payment:"+payment+",remark:"+remark+"]";
}
}
}
H. JAVA中如何解析字符串公式，并且利用公式进行计算
可以使用 commons-jexl3 jar包
示例:
public static void main(String[] args){
String expressionString = "1+2+3";
JexlEngine jexlEngine = new JexlBuilder().create();
JexlExpression jexlExpression = jexlEngine.createExpression(expressionString);
Object evaluate = jexlExpression.evaluate(null);
System.out.println(evaluate);
}
结果: 6
示例2:
来个复杂点的
public static void main(String[] args){
// String expressionString = "1+2+3";
String expressionString = "100*10-(200+300)";
JexlEngine jexlEngine = new JexlBuilder().create();
JexlExpression jexlExpression = jexlEngine.createExpression(expressionString);
Object evaluate = jexlExpression.evaluate(null);
System.out.println(evaluate);
}
结果: 500
I. java如何求出字符串表达式的结果如“23+4*5-56/4+（2*5+4）”
你可以自己写个算法去解析字符串中的加减乘除括号等特殊字符，然后在计算。或者你写个存储过程，通过数据库的计算机制来计算。