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()]","_"); 即表示用_替代字符串中出现的空格符、左括号、右括号。