java中實現(xiàn)四則運算代碼
更新時間：2015年08月25日 08:58:14 投稿：hebedich
本文給大家分享了幾個java中實現(xiàn)四則運算的代碼，有個人的也有網友的，代碼寫的不是很好，難免會有BUG，忘發(fā)現(xiàn)BUG的親們能提醒我下，好讓我改進
最近上網查了一下,竟然沒有找到用Java編寫的四則運算的代碼,就小寫了一下.如有問題請大家反饋.
1.說明
代碼只是實現(xiàn)了簡單的四則運算,支持+,-,*,/,(,) 只能計算出正確的表達式的值,沒有對非法表達式進行校驗.
2.實現(xiàn)方法
第一步:將輸入的字符串轉換為List,主要是用來將String轉換為原子:數值/運算符/括號
public List transStr(String str)
{
List strList = new ArrayList();
/* 獲取提出數據的符號串 */
String tmp = str.replaceAll("\\d*", "");
/* 記錄當前的運算符 */
String curLet = null;
/* 記錄tmp字符串中第一個運算符的位置 */
int loc = 0;
/* 符號串長度 */
int len = tmp.length();
for (int i = 0; i < len; i++)
{
curLet = tmp.substring(i, i + 1);
loc = str.indexOf(curLet);
/* 如果當前處理字符為( 或者 ) */
if (!"".equals(str.substring(0, loc).trim()))
{
strList.add(str.substring(0, loc).trim());
}
strList.add(str.substring(loc, loc + 1));
str = str.substring(loc + 1);
}
if (0 < str.length())
{
strList.add(str.trim());
}
return strList;
}
第二步: 將原來的中綴表達式轉換為后綴表達式,在四則運算中,后綴表達式是最方便計算的
public String[] midToEnd(List midList)
{
Stack embl = new Stack();
Stack result = new Stack();
Iterator it = midList.iterator();
String curStr = null;
while (it.hasNext())
{
curStr = (String) it.next();
/* 確認是否式字符串 */
if(sign.containsKey(curStr))
{
/* 如果符號棧為空 或者符號為( */
if (0 == embl.size() || "(".equals(curStr))
{
embl.push(curStr);
}
else
{
/*如果符號為) 符號棧需要出棧,直到匹配一個(為止 */
if(")".equals(curStr))
{
while(!"(".equals((String)embl.peek()))
{
if(0 >= embl.size())
{
return null;
}
result.push(embl.pop());
}
embl.pop();
}
else
{
int p1 = Integer.parseInt((String) sign.get(curStr));
int p2 = Integer.parseInt((String) sign.get(embl.peek()));
/* 如果當前字符的優(yōu)先級大于棧頂符號的優(yōu)先級 */
if (p1 > p2)
{
embl.push(curStr);
}
else
{
while (p1 <= p2 || embl.size() > 0)
{
result.push(embl.pop());
if(0 == embl.size())
{
break;
}
p2 = Integer.parseInt((String) sign.get(embl.peek()));
}
embl.push(curStr);
}
}
}
}
else
{
result.push(curStr);
}
}
while (0 < embl.size())
{
result.push(embl.pop());
}
int len = result.size();
String[] ret = new String[len];
for (int i = 0; i < len; i++)
{
ret[len - i - 1] = (String) result.pop();
}
return ret;
}
第三步:將解析后綴表達式,返回計算的最終結果
/**
* 解析后綴表達式,返回對應的運算結果
* @param String[] endStr 轉換后的后綴表達式
* @return Object 返回運算結果 如果表達式有誤直接打印"Input Error"
*/
public Object calculate(String[] endStr)
{
int len = endStr.length;
Stack calc = new Stack();
double p2;
double p1;
for (int i = 0; i < len; i++)
{
if (sign.containsKey(endStr[i]))
{
try
{
p2 = Double.parseDouble((String) calc.pop());
p1 = Double.parseDouble((String) calc.pop());
calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i])));
}
catch(NumberFormatException ex)
{
ex.printStackTrace();
return "Input Error";
}
catch(Exception ex)
{
ex.printStackTrace();
return "Input Error";
}
}
else
{
calc.push(endStr[i]);
}
}
if (1 == calc.size())
{
return calc.pop();
}
else
{
return "Input Error";
}
}
/**
* 實現(xiàn)底層的運算函數
* @param double p1 數字1
* @param double p1 數字2
* @param String oper 運算符 +-/*
*/
public double simpleCalc(double p1, double p2, String oper)
{
switch(oper.charAt(0))
{
case '+':
return p1 + p2;
case '-':
return p1 - p2;
case '*':
return p1 * p2;
case '/':
return p1 / p2;
default:
return p1;
}
}
第四步:運算符的優(yōu)先級放在了緩存中進行提取
private static HashMap sign = new HashMap();
/* 將運算符的優(yōu)先級放入到緩存處理 */
public CalculateExp()
{
sign.put(")", "3");
sign.put("*", "2");
sign.put("/", "2");
sign.put("+", "1");
sign.put("-", "1");
sign.put("(", "0");
}
完整代碼
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
/**
* Java實現(xiàn)計算表達式
* 只實現(xiàn)有加減乘除以及括號的運算
* 例如: 3+12+25*(20-20/4)+10
* @author GuoBo 2009-3-16
* @version 1.0
*/
public class CalculateExp
{
private static HashMap sign = new HashMap();
/* 將運算符的優(yōu)先級放入到緩存處理 */
public CalculateExp()
{
sign.put(")", "3");
sign.put("*", "2");
sign.put("/", "2");
sign.put("+", "1");
sign.put("-", "1");
sign.put("(", "0");
}
/**
* @param String 輸入的表達式
* @return List 解析后的字符串元素
* 對輸入的字符串進行解析
* 轉換為需要處理的數據
* 例如:3+12+25*(20-20/4)+10
* 轉換后的結果為:
* List 元素為 ret = {3,+,12,+,25,*,(,20,-,20,-,20,/,4,),+,10}
*/
public List transStr(String str)
{
List strList = new ArrayList();
/* 獲取提出數據的符號串 */
String tmp = str.replaceAll("\\d*", "");
/* 記錄當前的運算符 */
String curLet = null;
/* 記錄tmp字符串中第一個運算符的位置 */
int loc = 0;
/* 符號串長度 */
int len = tmp.length();
for (int i = 0; i < len; i++)
{
curLet = tmp.substring(i, i + 1);
loc = str.indexOf(curLet);
/* 如果當前處理字符為( 或者 ) */
if (!"".equals(str.substring(0, loc).trim()))
{
strList.add(str.substring(0, loc).trim());
}
strList.add(str.substring(loc, loc + 1));
str = str.substring(loc + 1);
}
if (0 < str.length())
{
strList.add(str.trim());
}
return strList;
}
/**
* 將表達式從中綴表達式轉換為后綴表達式(波蘭式)
* @Param List 解析后的表達式的列表
* @return String[] 轉換后的表達式字符串數組
*/
public String[] midToEnd(List midList)
{
Stack embl = new Stack();
Stack result = new Stack();
Iterator it = midList.iterator();
String curStr = null;
while (it.hasNext())
{
curStr = (String) it.next();
/* 確認是否式字符串 */
if(sign.containsKey(curStr))
{
/* 如果符號棧為空 或者符號為( */
if (0 == embl.size() || "(".equals(curStr))
{
embl.push(curStr);
}
else
{
/*如果符號為) 符號棧需要出棧,直到匹配一個(為止 */
if(")".equals(curStr))
{
while(!"(".equals((String)embl.peek()))
{
if(0 >= embl.size())
{
return null;
}
result.push(embl.pop());
}
embl.pop();
}
else
{
int p1 = Integer.parseInt((String) sign.get(curStr));
int p2 = Integer.parseInt((String) sign.get(embl.peek()));
/* 如果當前字符的優(yōu)先級大于棧頂符號的優(yōu)先級 */
if (p1 > p2)
{
embl.push(curStr);
}
else
{
while (p1 <= p2 || embl.size() > 0)
{
result.push(embl.pop());
if(0 == embl.size())
{
break;
}
p2 = Integer.parseInt((String) sign.get(embl.peek()));
}
embl.push(curStr);
}
}
}
}
else
{
result.push(curStr);
}
}
while (0 < embl.size())
{
result.push(embl.pop());
}
int len = result.size();
String[] ret = new String[len];
for (int i = 0; i < len; i++)
{
ret[len - i - 1] = (String) result.pop();
}
return ret;
}
/**
* 解析后綴表達式,返回對應的運算結果
* @param String[] endStr 轉換后的后綴表達式
* @return Object 返回運算結果 如果表達式有誤直接打印"Input Error"
*/
public Object calculate(String[] endStr)
{
int len = endStr.length;
Stack calc = new Stack();
double p2;
double p1;
for (int i = 0; i < len; i++)
{
if (sign.containsKey(endStr[i]))
{
try
{
p2 = Double.parseDouble((String) calc.pop());
p1 = Double.parseDouble((String) calc.pop());
calc.push(String.valueOf(simpleCalc(p1, p2,endStr[i])));
}
catch(NumberFormatException ex)
{
ex.printStackTrace();
return "Input Error";
}
catch(Exception ex)
{
ex.printStackTrace();
return "Input Error";
}
}
else
{
calc.push(endStr[i]);
}
}
if (1 == calc.size())
{
return calc.pop();
}
else
{
return "Input Error";
}
}
/**
* 實現(xiàn)底層的運算函數
* @param double p1 數字1
* @param double p1 數字2
* @param String oper 運算符 +-/*
*/
public double simpleCalc(double p1, double p2, String oper)
{
switch(oper.charAt(0))
{
case '+':
return p1 + p2;
case '-':
return p1 - p2;
case '*':
return p1 * p2;
case '/':
return p1 / p2;
default:
return p1;
}
}
/**
* 主控函數
*/
public static void main(String[] args)
{
CalculateExp ce = new CalculateExp();
String tmp = "3+12+25*(20-20/4+10";
String ret = (String) ce.calculate(ce.midToEnd(ce
.transStr(tmp)));
double value = 0;
try
{
value = Double.parseDouble(ret);
}
catch (NumberFormatException ex)
{
System.out.print(ret);
}
System.out.print(value);
}
}
以下是其他網友的補充
代碼的思路是通過正則判斷計算每個最小的計算單元。以下是代碼：
import java.math.BigDecimal;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 計算器工具類
* @author shuqi
* @date 2015-7-23
* @version since 1.0
*/
public class CalculatorUtil {
public static BigDecimal arithmetic(String exp){
if(!exp.matches("\\d+")){
String result = parseExp(exp).replaceAll("[\\[\\]]", "");
return new BigDecimal(result);
}else{
return new BigDecimal(exp);
}
}
/**
* 最小計數單位
*
*/
private static String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$";
/**
* 不帶括號的運算
*/
private static String noParentheses="^[^\\(\\)]+$";
/**
* 匹配乘法或者除法
*/
private static String priorOperatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
/**
* 匹配加法和減法
*/
private static String operatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
/**
* 匹配只帶一個括號的
*/
private static String minParentheses="\\([^\\(\\)]+\\)";
/**
* 解析計算四則運算表達式，例：2+((3+4)*2-22)/2*3
* @param expression
* @return
*/
private static String parseExp(String expression){
//方法進入 先替換空格，在去除運算兩邊的()號
expression=expression.replaceAll("\\s+", "").replaceAll("^\\(([^\\(\\)]+)\\)$", "$1");
//最小表達式計算
if(expression.matches(minExp)){
String result=calculate(expression);
return Double.parseDouble(result)>=0?result:"["+result+"]";
}
//計算不帶括號的四則運算
if(expression.matches(noParentheses)){
Pattern patt=Pattern.compile(priorOperatorExp);
Matcher mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp));
}else{
patt=Pattern.compile(operatorExp);
mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp));
}
}
return parseExp(expression);
}
//計算帶括號的四則運算
Pattern patt=Pattern.compile(minParentheses);
Matcher mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp));
}
return parseExp(expression);
}
/**
* 計算最小單位四則運算表達式（兩個數字）
* @param exp
* @return
*/
private static String calculate(String exp){
exp=exp.replaceAll("[\\[\\]]", "");
String number[]=exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(",");
BigDecimal number1=new BigDecimal(number[0]);
BigDecimal number2=new BigDecimal(number[1]);
BigDecimal result=null;
String operator=exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1");
if("+".equals(operator)){
result=number1.add(number2);
}else if("-".equals(operator)){
result=number1.subtract(number2);
}else if("*".equals(operator)){
result=number1.multiply(number2);
}else if("/".equals(operator)){
//第二個參數為精度，第三個為四色五入的模式
result=number1.divide(number2,5,BigDecimal.ROUND_CEILING);
}
return result!=null?result.toString():null;
}
}
代碼原本是一個博客，原來代碼沒有注釋而且存在BUG，我稍微修稿了一哈添加了注釋。在這里做個筆記，方便以后用
另為表示對原作者的敬意，附上原始代碼
/**
* 四則運算表達式計算
* @author penli
*
*/
public class Arithmetic {
public static void main(String args[]){
System.out.println(arithmetic("2.2+((3+4)*2-22)/2*3.2"));
}
public static double arithmetic(String exp){
String result = parseExp(exp).replaceAll("[\\[\\]]", "");
return Double.parseDouble(result);
}
/**
* 解析計算四則運算表達式，例：2+((3+4)*2-22)/2*3
* @param expression
* @return
*/
public static String parseExp(String expression){
//String numberReg="^((?!0)\\d+(\\.\\d+(?<!0))?)|(0\\.\\d+(?<!0))$";
expression=expression.replaceAll("\\s+", "").replaceAll("^\\((.+)\\)$", "$1");
String checkExp="\\d";
String minExp="^((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))$";
//最小表達式計算
if(expression.matches(minExp)){
String result=calculate(expression);
return Double.parseDouble(result)>=0?result:"["+result+"]";
}
//計算不帶括號的四則運算
String noParentheses="^[^\\(\\)]+$";
String priorOperatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\*\\/]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
String operatorExp="(((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\]))[\\+\\-]((\\d+(\\.\\d+)?)|(\\[\\-\\d+(\\.\\d+)?\\])))";
if(expression.matches(noParentheses)){
Pattern patt=Pattern.compile(priorOperatorExp);
Matcher mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(priorOperatorExp, parseExp(tempMinExp));
}else{
patt=Pattern.compile(operatorExp);
mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(operatorExp, parseExp(tempMinExp));
}
}
return parseExp(expression);
}
//計算帶括號的四則運算
String minParentheses="\\([^\\(\\)]+\\)";
Pattern patt=Pattern.compile(minParentheses);
Matcher mat=patt.matcher(expression);
if(mat.find()){
String tempMinExp=mat.group();
expression=expression.replaceFirst(minParentheses, parseExp(tempMinExp));
}
return parseExp(expression);
}
/**
* 計算最小單位四則運算表達式（兩個數字）
* @param exp
* @return
*/
public static String calculate(String exp){
exp=exp.replaceAll("[\\[\\]]", "");
String number[]=exp.replaceFirst("(\\d)[\\+\\-\\*\\/]", "$1,").split(",");
BigDecimal number1=new BigDecimal(number[0]);
BigDecimal number2=new BigDecimal(number[1]);
BigDecimal result=null;
String operator=exp.replaceFirst("^.*\\d([\\+\\-\\*\\/]).+$", "$1");
if("+".equals(operator)){
result=number1.add(number2);
}else if("-".equals(operator)){
result=number1.subtract(number2);
}else if("*".equals(operator)){
result=number1.multiply(number2);
}else if("/".equals(operator)){
result=number1.divide(number2);
}
return result!=null?result.toString():null;
}
}
最后給大家分享一個網友的實現(xiàn)方法，個人感覺也很不錯
import java.util.Stack;
/**
* 利用棧，進行四則運算的類
* 用兩個棧來實現(xiàn)算符優(yōu)先，一個棧用來保存需要計算的數據numStack,一個用來保存計算優(yōu)先符priStack
*
* 基本算法實現(xiàn)思路為：用當前取得的運算符與priStack棧頂運算符比較優(yōu)先級：若高于，則因為會先運算，放入棧頂；
* 若等于，因為出現(xiàn)在后面，所以會后計算，所以棧頂元素出棧，取出操作數運算；
* 若小于，則同理，取出棧頂元素運算，將結果入操作數棧。各個優(yōu)先級'(' > '*' = '/' > '+' = '-' > ')'
*
*/
public class Operate {
private Stack<Character> priStack = new Stack<Character>();// 操作符棧
private Stack<Integer> numStack = new Stack<Integer>();;// 操作數棧
/**
* 傳入需要解析的字符串，返回計算結果(此處因為時間問題，省略合法性驗證)
* @param str 需要進行技術的表達式
* @return 計算結果
*/
public int caculate(String str) {
// 1.判斷string當中有沒有非法字符
String temp;// 用來臨時存放讀取的字符
// 2.循環(huán)開始解析字符串，當字符串解析完，且符號棧為空時，則計算完成
StringBuffer tempNum = new StringBuffer();// 用來臨時存放數字字符串(當為多位數時)
StringBuffer string = new StringBuffer().append(str);// 用來保存，提高效率
while (string.length() != 0) {
temp = string.substring(0, 1);
string.delete(0, 1);
// 判斷temp，當temp為操作符時
if (!isNum(temp)) {
// 1.此時的tempNum內即為需要操作的數，取出數，壓棧，并且清空tempNum
if (!"".equals(tempNum.toString())) {
// 當表達式的第一個符號為括號
int num = Integer.parseInt(tempNum.toString());
numStack.push(num);
tempNum.delete(0, tempNum.length());
}
// 用當前取得的運算符與棧頂運算符比較優(yōu)先級：若高于，則因為會先運算，放入棧頂；若等于，因為出現(xiàn)在后面，所以會后計算，所以棧頂元素出棧，取出操作數運算；
// 若小于，則同理，取出棧頂元素運算，將結果入操作數棧。
// 判斷當前運算符與棧頂元素優(yōu)先級，取出元素，進行計算(因為優(yōu)先級可能小于棧頂元素，還小于第二個元素等等，需要用循環(huán)判斷)
while (!compare(temp.charAt(0)) && (!priStack.empty())) {
int a = (int) numStack.pop();// 第二個運算數
int b = (int) numStack.pop();// 第一個運算數
char ope = priStack.pop();
int result = 0;// 運算結果
switch (ope) {
// 如果是加號或者減號，則
case '+':
result = b + a;
// 將操作結果放入操作數棧
numStack.push(result);
break;
case '-':
result = b - a;
// 將操作結果放入操作數棧
numStack.push(result);
break;
case '*':
result = b * a;
// 將操作結果放入操作數棧
numStack.push(result);
break;
case '/':
result = b / a;// 將操作結果放入操作數棧
numStack.push(result);
break;
}
}
// 判斷當前運算符與棧頂元素優(yōu)先級， 如果高，或者低于平，計算完后，將當前操作符號，放入操作符棧
if (temp.charAt(0) != '#') {
priStack.push(new Character(temp.charAt(0)));
if (temp.charAt(0) == ')') {// 當棧頂為'('，而當前元素為')'時，則是括號內以算完，去掉括號
priStack.pop();
priStack.pop();
}
}
} else
// 當為非操作符時（數字）
tempNum = tempNum.append(temp);// 將讀到的這一位數接到以讀出的數后(當不是個位數的時候)
}
return numStack.pop();
}
/**
* 判斷傳入的字符是不是0-9的數字
*
* @param str
* 傳入的字符串
* @return
*/
private boolean isNum(String temp) {
return temp.matches("[0-9]");
}
/**
* 比較當前操作符與棧頂元素操作符優(yōu)先級，如果比棧頂元素優(yōu)先級高，則返回true，否則返回false
*
* @param str 需要進行比較的字符
* @return 比較結果 true代表比棧頂元素優(yōu)先級高，false代表比棧頂元素優(yōu)先級低
*/
private boolean compare(char str) {
if (priStack.empty()) {
// 當為空時，顯然 當前優(yōu)先級最低，返回高
return true;
}
char last = (char) priStack.lastElement();
// 如果棧頂為'('顯然，優(yōu)先級最低，')'不可能為棧頂。
if (last == '(') {
return true;
}
switch (str) {
case '#':
return false;// 結束符
case '(':
// '('優(yōu)先級最高,顯然返回true
return true;
case ')':
// ')'優(yōu)先級最低，
return false;
case '*': {
// '*/'優(yōu)先級只比'+-'高
if (last == '+' || last == '-')
return true;
else
return false;
}
case '/': {
if (last == '+' || last == '-')
return true;
else
return false;
}
// '+-'為最低，一直返回false
case '+':
return false;
case '-':
return false;
}
return true;
}
public static void main(String args[]) {
Operate operate = new Operate();
int t = operate.caculate("(3+4*(4*10-10/2)#");
System.out.println(t);
}
}
相關文章
這篇文章主要介紹了spring boot 2整合swagger-ui過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-12-12
IDEA新建bootstrap.yml文件不顯示葉子圖標的問題
這篇文章主要介紹了IDEA新建bootstrap.yml文件不顯示葉子圖標的問題及解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-07-07
這篇文章主要介紹了java泛型基礎知識及通用方法，從以下幾個方面介紹一下java的泛型: 基礎, 泛型關鍵字, 泛型方法, 泛型類和接口，感興趣的可以了解一下2019-04-04
MyBatis-Plus使用ActiveRecord(AR)實現(xiàn)CRUD
本文將結合實例代碼，介紹MyBatis-Plus使用ActiveRecord(AR)實現(xiàn)CRUD，文中通過示例代碼介紹的非常詳細，需要的朋友們下面隨著小編來一起學習學習吧2021-07-07
今天帶大家了解一下Java稀疏數組的相關知識,文中有非常詳細的介紹及代碼示例,對正在學習java的小伙伴們有很好地幫助,需要的朋友可以參考下2021-05-05
Java 8 是迄今為止在語義上改動上最大的一個平臺。下面這篇文章主要給大家介紹了關于Java8如何構建一個Stream的相關資料，文中通過示例代碼介紹的非常詳細，需要的朋友可以參考借鑒，下面隨著小編來一起學習學習吧。2018-04-04
這篇文章主要介紹了JPA @Query時,無法使用limit函數的問題及解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-03-03
這篇文章主要介紹了RocketMQ的消費者類型與最佳實踐詳解,在?RocketMQ?5.0?中,更加強調了客戶端類型的概念,尤其是消費者類型,為了滿足多樣的?RocketMQ?中一共有三種不同的消費者類型,分別是?PushConsumer、SimpleConsumer?和?PullConsumer,需要的朋友可以參考下2023-10-10
這篇文章主要介紹了java的finalize方法,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-09-09
這篇文章主要介紹了Java mockito單元測試實現(xiàn)過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-08-08