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）」
你可以自己寫個演算法去解析字元串中的加減乘除括弧等特殊字元，然後在計算。或者你寫個存儲過程，通過資料庫的計算機制來計算。