javastring表達式

㈠ java怎麼實現輸入一個string表達式然後輸出計算的結果

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));
}
}

㈡ java判斷一個string變數是否為十位數字，求正則表達式和代碼

importjava.util.regex.Pattern;

publicclassTest{
publicstaticvoidmain(String[]args){
//匹配模式,\d代表匹配數字,{10}代表正好匹配次數
Stringregex="\d{10}";
System.out.println(Pattern.matches(regex,"9010000000"));
}
}

㈢ java解析字元串 算術表達式求值

Java 有一個jar包 叫groovy

groovy可以實現動態執行 String格式的算數表達式

publicstaticvoidmain(String[]args)throwsException{
Stringstr1="1+2*3";//表達式1固定表達式
GroovyShellgroovyShell=newGroovyShell();
Objectvalue=groovyShell.evaluate(str1);
System.out.println(value);

Stringstr2="A+B*C";//表達式2動態表達式
Bindingbinding=newBinding();
binding.setVariable("A",1);//表達式中所有的A替換為1
binding.setVariable("B",2);//表達式中所有的B替換為2
binding.setVariable("C",3);//表達式中所有的C替換為3
GroovyShellgroovyShell2=newGroovyShell(binding);
Objectvalue2=groovyShell2.evaluate(str2);//str2實際表達式為1+2*3
System.out.println(value2);
}

㈣ java string正則表達式 分割

	/**
	*@authorIT學習者-螃蟹
	*@paramargs
	*/
	publicstaticvoidmain(String[]args){
		//起始分割標識
		StringbeginTag="\[local\]";
		//結束分割標識
		StringendTag="\[\/local\]";
		Stringtest="測試測試1[local]aaabb[/local]測試測試2[local]111122[/local]測試測試3[local]IT學習者(itxxz)[/local]";
		
		List<String>list1=newArrayList<String>();
		List<String>list2=newArrayList<String>();
		for(Stringtemp:test.split(endTag)){
			list1.add(temp.split(beginTag)[0]);
			list2.add(temp.split(beginTag)[1]);
		}
		System.out.println(list1.toString());
		System.out.println(list2.toString());
		//轉換成數組
		Object[]array1=list1.toArray();
		Object[]array2=list2.toArray();
		for(Objectstr:array1){
			System.out.println(str);
		}
	}

運行結果：

㈤ java正則表達式如何獲取字元串中所有匹配內容

java正則表達式如何獲取字元串中所有匹配內容

java正則表達式提取需要用到Matcher類。

正則規則就是「一個數字加上大於等於0個非數字再加上結束符」

Pattern pattern

= Pattern.pile("(\d)[^\d]*$")

Matcher matcher

= pattern.matcher(s)

if(matcher.find())

System.out.println

(matcher.group(1)); } }

如何獲取字元串中匹配到正則表達式的子串開

mport java.util.regex.Matcher;import java.util.regex.Pattern;public class Test {public static void main(String[] args) {String s = "A876X"; 把要匹配的字元串寫成正則表達式，然後要提取的字元使用括弧括起來 在這里，我們要提取最後一個數字，正則規則就是「一個數字加上大於等於0個非數字再加上結束符」Pattern pattern = Pattern.pile("(\d)[^\d]*$");Matcher matcher = pattern.matcher(s);if(matcher.find())System.out.println(matcher.group(1));}}

正則表達式獲取字元串

string pattern=@"<font>(.+?)</font>"
取分組 Match.group[1]

JS如何用正則表達式 獲取字元串內的匹配部份？

實現的效果：在字元串中abcdefgname='test'sddfhskshjsfsjdfps中獲取name的值test
實現的機制：通過replace的回調函數獲取。

可以通過下面的代碼獲取匹配部分

var str = "abcdefgname='test'sddfhskshjsfsjdfps";

var reg = /name='((w|-|s)+)/ig;

str.replace(reg, function() {
console.log(arguments.length); 5
console.log(arguments[1]);test
});

字元串 stringObject 的 replace() 方法執行的是查找並替換的操作。它將在 stringObject 中查找與 regexp 相匹配的子字元串，然後用 replacement 來替換這些子串。如果 regexp 具有全局標志 g，那麼 replace() 方法將替換所有匹配的子串。否則，它只替換第一個匹配子串。

正則表達式如何獲取被匹配字元串的匹配組名

java正則提取需要用到Matcher類，下面給出案例示例供參考
需要提取車牌號中最後一個數字，比如說：蘇A7865提取5，蘇A876X提取6
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test {
public static void main(String[] args) {
String s = "A876X";
把要匹配的字元串寫成正則表達式，然後要提取的字元使用括弧括起來
在這里，我們要提取最後一個數字，正則規則就是「一個數字加上大於等於0個非數字再加上結束符」
Pattern pattern = Pattern.pile("(\d)[^\d]*$");
Matcher matcher = pattern.matcher(s);
if(matcher.find())
System.out.println(matcher.group(1));
}
}
關於Matcher 中的幾個方法說明：
Mathcer.start()
Matcher.end()
Matcher.group()
當使用matches(),lookingAt(),find()執行匹配操作後,就可以利用以上三個方法得到更詳細的信息.
start()返回匹配到的子字元串在字元串中的索引位置.
end()返回匹配到的子字元串的最後一個字元在字元串中的索引位置.
group()返回匹配到的子字元串
示例代碼如下，具體功能請參考注釋
Pattern p=Pattern.pile(「d+」);
Matcher m=p.matcher(「aaa2223bb」);
m.find();匹配2223
m.start();返回3
m.end();返回7,返回的是2223後的索引號
m.group();返回2223
Mathcer m2=p.matcher(「2223bb」);
m2.lookingAt(); 匹配2223
m2.start(); 返回0,由於lookingAt()只能匹配前面的字元串,所以當使用lookingAt()匹配時,start()方法總是返回0
m2.end(); 返回4
m2.group(); 返回2223
Matcher m3=p.matcher(「2223」); 如果Matcher m3=p.matcher(「2223bb」); 那麼下面的方法出錯，因為不匹配返回false
m3.matches(); 匹配整個字元串
m3.start(); 返回0
m3.end(); 返回3,原因相信大家也清楚了,因為matches()需要匹配所有字元串
m3.group(); 返回2223
另外，Mathcer類中start(),end(),group()均有一個重載方法它們是start(int i),end(int i),group(int i)專用於分組操作,Mathcer類還有一個groupCount()用於返回有多少組.
示例如下：
Pattern p=Pattern.pile(「([a-z]+)(d+)」);
Matcher m=p.matcher(「aaa2223bb」);
m.find(); 匹配aaa2223
m.groupCount(); 返回2,因為有2組
m.start(1); 返回0 返回第一組匹配到的子字元串在字元串中的索引號
m.start(2); 返回3
m.end(1); 返回3 返回第一組匹配到的子字元串的最後一個字元在字元串中的索引位置.
m.end(2); 返回7
m.group(1); 返回aaa,返回第一組匹配到的子字元串
m.group(2); 返回2223,返回第二組匹配到的子字元串
注意: 只有當匹配操作成功,才可以使用start(),end(),group()三個方法,否則會拋出java.lang.IllegalStateException,也就是當matches(),lookingAt(),find()其中任意一個方法返回true時,才可以使用。

C# 正則表達式獲取字元串?

針對你的問題:
<aa>是給數組命名
(?<name>subexpression)
其中name是有效的組名稱，而subexpression是任何有效的正則表達式模式。 name不得包含任何標點符號字元，並且不能以數字開頭。
這個方式相當於下面這個表達式
"(?<!0-9a-zA-Z)([0-9]|[a-z]|[A-Z]){1,}"

java正則表達式如何獲取分組匹配內容

String str = "我的QQ是:456456我的電話是:0532214我的郵箱是:aaa@aaa.";
d 表示0-9 任意一個數字 後面有+號 說明這個0-9單個數位出現一到多次 比如21312314
String reg = "\d+";
Pattern是一個正則表達式經編譯後的表現模式。
Pattern pattern = Pattern.pile (reg);
Matcher 一個Matcher對象是一個狀態機器，它依據Pattern對象做為匹配模式對字元串展開匹配檢查。
Matcher matcher = pattern.matcher (str);
只有執行了find()方法 後，狀態機matcher才是真正開始進行匹配工作的！
while (matcher.find ())
{
matcher.group()返回匹配到的子字元串
System.out.println (matcher.group ());
}
}

Java正則表達式匹配是否存在字元串。

正則表達式為：.*a.*b.*c.*
package .test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexTest {
/**
* @param args
*/
public static void main(String[] args) {
TODO Auto-generated method stub
String source = "abcdefg " +
"uaibec " +
"wabbcd " +
"adb " +
"acb";
String regex = "(.*a.*b.*c.*)";
Pattern pattern = Pattern.pile(regex,Pattern.MULTILINE);
Matcher matcher = pattern.matcher(source);
while(matcher.find()){
System.out.println(matcher.group());
}
}
}
你可以直接復制出來，運行一下就可以了

㈥ java 如何對String類型的邏輯表達式求值

對String類型的邏輯表達式求值
import java.util.ArrayList;
import java.util.Stack;
/**
*
* @author yhh
*
*/
public class Calculate {

/**
* 將字元串轉化成List
* @param str
* @return
*/

㈦ Java 字元串算術表達式求值

Java 字元串算術表達式求值:
import java.util.ArrayList;
import java.util.Stack;

/**
*
* @author yhh
*
*/
public class Calculate {

/**
* 將字元串轉化成List
* @param str
* @return
*/
public ArrayList<String> getStringList(String str){
ArrayList<String> result = new ArrayList<String>();
String num = "";
for (int i = 0; i < str.length(); i++) {
if(Character.isDigit(str.charAt(i))){
num = num + str.charAt(i);
}else{
if(num != ""){
result.add(num);
}
result.add(str.charAt(i) + "");
num = "";
}
}
if(num != ""){
result.add(num);
}
return result;
}

/**
* 將中綴表達式轉化為後綴表達式
* @param inOrderList
* @return
*/
public ArrayList<String> getPostOrder(ArrayList<String> inOrderList){

ArrayList<String> result = new ArrayList<String>();
Stack<String> stack = new Stack<String>();
for (int i = 0; i < inOrderList.size(); i++) {
if(Character.isDigit(inOrderList.get(i).charAt(0))){
result.add(inOrderList.get(i));
}else{
switch (inOrderList.get(i).charAt(0)) {
case '(':
stack.push(inOrderList.get(i));
break;
case ')':
while (!stack.peek().equals("(")) {
result.add(stack.pop());
}
stack.pop();
break;
default:
while (!stack.isEmpty() && compare(stack.peek(), inOrderList.get(i))){
result.add(stack.pop());
}
stack.push(inOrderList.get(i));
break;
}
}
}
while(!stack.isEmpty()){
result.add(stack.pop());
}
return result;
}

/**
* 計算後綴表達式
* @param postOrder
* @return
*/
public Integer calculate(ArrayList<String> postOrder){
Stack stack = new Stack();
for (int i = 0; i < postOrder.size(); i++) {
if(Character.isDigit(postOrder.get(i).charAt(0))){
stack.push(Integer.parseInt(postOrder.get(i)));
}else{
Integer back = (Integer)stack.pop();
Integer front = (Integer)stack.pop();
Integer res = 0;
switch (postOrder.get(i).charAt(0)) {
case '+':
res = front + back;
break;
case '-':
res = front - back;
break;
case '*':
res = front * back;
break;
case '/':
res = front / back;
break;
}
stack.push(res);
}
}
return (Integer)stack.pop();
}

/**
* 比較運算符等級
* @param peek
* @param cur
* @return
*/
public static boolean compare(String peek, String cur){
if("*".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){
return true;
}else if("/".equals(peek) && ("/".equals(cur) || "*".equals(cur) ||"+".equals(cur) ||"-".equals(cur))){
return true;
}else if("+".equals(peek) && ("+".equals(cur) || "-".equals(cur))){
return true;
}else if("-".equals(peek) && ("+".equals(cur) || "-".equals(cur))){
return true;
}
return false;
}

public static void main(String[] args) {
Calculate calculate = new Calculate();
String s = "12+(23*3-56+7)*(2+90)/2";
ArrayList result = calculate.getStringList(s); //String轉換為List
result = calculate.getPostOrder(result); //中綴變後綴
int i = calculate.calculate(result); //計算
System.out.println(i);

}

}

㈧ Java中String.replace()時的正則表達式不會寫了, :(

srcString.replaceAll("[\s()]","_");

\s表示一個空白符；
[\s()]表示 空格 左括弧 或者 右括弧中出現其中任何一個

replaceAll("[\s()]","_"); 即表示用_替代字元串中出現的空格符、左括弧、右括弧。