實現處理表達式的編譯器java

⑴ java正則表達式

正則表達式定義了字元串的模式。
正則表達式可以用來搜索、編輯或處理文本。
正則表達式並不僅限於某一種語言，但是在每種語言中有細微的差別。
Java正則表達式和Perl的是最為相似的。
java.util.regex包主要包括以下三個類：
Pattern類：
pattern對象是一個正則表達式的編譯表示。Pattern類沒有公共構造方法。要創建一個Pattern對象，你必須首先調用其公共靜態編譯方法，它返回一個Pattern對象。該方法接受一個正則表達式作為它的第一個參數。
Matcher類：
Matcher對象是對輸入字元串進行解釋和匹配操作的引擎。與Pattern類一樣，Matcher也沒有公共構造方法。你需要調用Pattern對象的matcher方法來獲得一個Matcher對象。
PatternSyntaxException：
PatternSyntaxException是一個非強制異常類，它表示一個正則表達式模式中的語法錯誤。

⑵ 輸入運算公式 得到結果 java

通過棧實猛襲現,先用棧將中綴表達式轉化為後綴表達式，知鬧然後再用棧計算後綴表達式的值的
package com.saturday;

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MyParse {
static Map<String,Integer> optrOrder;
static {
optrOrder=new HashMap<String,Integer>();
optrOrder.put("(", 0);
optrOrder.put("*", 1);
optrOrder.put("/", 1);
optrOrder.put("%", 1);
optrOrder.put("+",2);
optrOrder.put("-",2);
optrOrder.put("^",3);
optrOrder.put("枝猛兄#",3);
}

public static void main(String[] args){
List<String> tokens;
try{
//詞法分析
tokens=lex("+2* (-2+3*4)+-5");

//中綴轉後綴
tokens=toRpn(tokens);

//計算結果
System.out.println(calcRpn(tokens));

}catch(Exception ex){
ex.printStackTrace();
}
}

/**
* 將輸入串轉換為操作符串
* @param sExpres
* @return
*/
public static List<String> lex(String sExpres){
List<String> tokens=new ArrayList<String>();

//將表達式分割成符號序列
String sRegExp="(((?<=^|\\(|\\+|-|\\*|/|%)(\\+|-))?\\d+(\\.\\d+)?)"
+"|\\(|\\)|\\*|/|\\+|-";
Pattern p=Pattern.compile(sRegExp);
Matcher m=p.matcher(sExpres.replaceAll("\\s+",""));
while(m.find()){
tokens.add(m.group());
}

tokens.add("#");

return tokens;
}

/**
* 將中綴表單時轉化為後綴表達式
* @param tokens
* @return
*/
public static List<String> toRpn(List<String> tokens)
throws Exception{
List<String> rpnList=new ArrayList<String>();
Stack<String> optrStack=new Stack<String>();

optrStack.add("^");
for(String token:tokens){
if(token.matches("^(\\+|-)?\\d+(\\.\\d+)?$")){
rpnList.add(token);
}else{
outputOptr(token,optrStack,rpnList);
}
}

if(!optrStack.isEmpty()
&&optrStack.lastElement().equals("#")){
return rpnList;
}else{
throw new Exception("後綴表達式轉化錯誤!");
}
}

/**
* 計算後綴表達式的值
* @param rpnTokens
* @return
* @throws Exception
*/
public static double calcRpn(List<String> rpnTokens)
throws Exception{
NumberFormat nf=NumberFormat.getInstance();
Stack<Double> numStack=new Stack<Double>();

for (String token : rpnTokens) {
if (token.matches("^(\\+|-)?\\d+(.\\d+)?$")) {
token=token.indexOf('+')==0
?token.substring(1)
:token;
numStack.add(nf.parse(token).doubleValue());
} else {
doCalcByOptr(token, numStack);
}
}

if (!numStack.isEmpty() && numStack.size() == 1) {
return numStack.lastElement();
} else {
throw new Exception("計算錯誤！");
}
}

/**
* 將運算符輸出到後綴表達式序列.
* @param optr
* @param optrStack
* @param rpnList
* @throws Exception
*/
public static void outputOptr(String optr,
Stack<String> optrStack,
List<String> rpnList)
throws Exception{
String preOptr;

if(optr.equals("(")){//處理左括弧
optrStack.push(optr);
return;
}

if(optr.equals(")")){//處理右括弧
while(!optrStack.isEmpty()){
preOptr=optrStack.pop();
if(!preOptr.equals("(")){
rpnList.add(preOptr);
}else{
break;
}
}

if(optrStack.isEmpty()){
throw new Exception("括弧未閉合!");
}

return;
}

/*按優先順序處理其他運算符，若當前運算符優先順序較高
* 直接入棧，否則將棧中運算符出戰直至棧頂運算符
* 低於當前運算符
*/
preOptr=optrStack.lastElement();
if(optrCmp(optr,preOptr)<0){
optrStack.push(optr);
}else{
while(!preOptr.equals("(")
&&!optrStack.isEmpty()
&&optrCmp(optr,preOptr)>=0){

preOptr=optrStack.pop();
if(!preOptr.equals("^")){
rpnList.add(preOptr);
}
}
optrStack.push(optr);
}
}

/**
* 運算符優先順序比較函數,optr1優先順序大於optr2返回小於0值,
* 優先順序相等返回0,optr1小於optr2返回大於0值.
* @param optr1
* @param optr2
* @return
*/
public static int optrCmp(String optr1,String optr2){
int order1=optrOrder.get(optr1);
int order2=optrOrder.get(optr2);
return order1-order2;
}

/**
* 根據運算符對數據棧中的內容進行操作.
* @param optr
* @param numStack
*/
public static void doCalcByOptr(String optr,
Stack<Double> numStack){
double n1,n2;
n2=numStack.pop();
n1=numStack.pop();

if(optr.equals("+")){
numStack.push(n1+n2);
}else if(optr.equals("-")){
numStack.push(n1-n2);
}else if(optr.equals("*")){
numStack.push(n1*n2);
}else if(optr.equals("/")){
numStack.push(n1/n2);
}else if(optr.equals("%")){
numStack.push(n1%n2);
}
}
}

⑶ 簡述JAVA程序的編輯編譯和運行過程

第一步(編譯): 創建完源文件之後，程序會先被編譯為.class文件。Java編譯一個類時，如果這個類所依賴的類還沒有被編譯，編譯器就會先編譯這個被依賴的類，然後引用，否則直接引用，這個有點象make。

如果java編譯器在指定目錄下找不到該類所其依賴的類的.class文件或者.java源文件的話，編譯器話報「cant find symbol」的錯誤。

第二步（運行）：java類運行的過程大概可分為兩個過程：1、類的載入 2、類的執行。需要說明的是：JVM主要在程序第一次主動使用類的時候，才會去載入該類。也就是說，JVM並不是在一開始就把一個程序就所有的類都載入到內存中，而是到不得不用的時候才把它載入進來，而且只載入一次。

特別說明：java類中所有public和protected的實例方法都採用動態綁定機制，所有私有方法、靜態方法、構造器及初始化方法<clinit>都是採用靜態綁定機制。而使用動態綁定機制的時候會用到方法表，靜態綁定時並不會用到。

(3)實現處理表達式的編譯器java擴展閱讀：

Java整個編譯以及運行的過程相當繁瑣，本文通過一個簡單的程序來簡單的說明整個流程。

Java代碼編譯:是由Java源碼編譯器來完成;

Java位元組碼的執行:是由JVM執行引擎來完成

Java程序從源文件創建到程序運行要經過兩大步驟：

1、源文件由編譯器編譯成位元組碼（ByteCode）

2、位元組碼由java虛擬機解釋運行。因為java程序既要編譯同時也要經過JVM的解釋運行，所以說Java被稱為半解釋語言（ "semi-interpreted" language）。

⑷ 如何編譯java

用命令提示符編譯java程序的步驟：

1.先新建文本文檔，輸入自己的java程序。

這里我寫一個簡單的java程序，來做示範。

import java.util.*;

public class HelloDate{

public static void main(String[] args)

{

System.out.println("Hello,it's:");

System.out.println(new Date());

}

}

經驗總結：運行一個java程序的大概的流程是：

書寫源代碼------>編譯------->運行---->結束。

注意事項：

1.在輸入的時候一定要注意區分大小寫。

2.操作之前要保證自己的電腦配置了java的運行環境。

⑸ 編譯java程序需要使用什麼命令

編譯命令是 javac

1. 首先使用記事本編輯一段簡單的Java代碼

   

   ⑹ java的編譯器是什麼

   你說的編譯器指的是java開發軟體吧？
   記事本就可以，但是word不行，因為不支持asc2碼，
   專業的有jbuilder和netBeans、eclipse等
   初學者還是用記事本比較好，
   然後還是最好用netBeans，因為這個軟體漢化的比較好，其他的都不行！你上狗狗下載就ok了
   www.gougou.com， 搜netBeans
   回答完畢

   ⑺ javac是什麼意思

   javac 是java語言編程編譯器。全稱java compiler。javac工具讀由java語言編寫的類和介面的定義，並將它們編譯成位元組代碼的class文遲搭件。

   

   當編譯源文件時，編解碼宏拿器常常需要它還沒有識別出的類型的有關信息。對於源文絕純件中使用、擴展或實現的每個類或介面，編譯器都需要其類型信息。這包括在源文件中沒有明確提及、但通過繼承提供信息的類和介面。

   ⑻ JAVA的編譯器有哪些

   JCreater 、JBuilder、eclipse、myeclipse、netbean這幾個是主流，eclipse和myeclipse(eclipse的擴展功能更多)是主流中的主流