[新手上路]批处理新手入门导读[视频教程]批处理基础视频教程[视频教程]VBS基础视频教程[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动[批处理精品]CMD命令50条不能说的秘密[在线下载]第三方命令行工具[在线帮助]VBScript / JScript 在线参考
返回列表 发帖
happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
1楼 跳转到 » 正序看帖
打印
tT
发表于 2017-8-6 23:28 | 只看该作者

JAVA第三方计算工具: jcalc

[1.0.0.6]版，修复数组边界漏洞，修复随机函数算法。
跨平台JAVA第三方计算工具: jcalc.jar，使用增强版revpolish核心打造的。从 手机端 到 桌面端、服务器端 全覆盖运行。（所有图片一律为外链，jar包仅10kb，请下载附件）
链接: https://pan.baidu.com/s/1HhUgmb_dcFTqVD4v42TRrw?pwd=kx3x
兼容性   ：java 1.6、java7、java8
跨平台性：完全做到一次编译，处处运行。可在各类安卓手机上直接运行，windows、linux、unix、mac、树莓派、各类微型智能设备，只要具备jre环境均可运行，不具备也可使用API转化技术运行。针对IOS设备可使用j2oc转化技术运行。
WINDOWS下运行图


linux下运行图

手机端运行请使用 ej 脚本运行http://www.bathome.net/thread-44950-1-1.html，更为便捷。
安卓手机下运行图


原创代码：
  1. package com.android.jcalc;

  2. 

  3. 

  4. /**Main主类

  5.  * @author Happy from BatHome

  6.  * @date Thu Aug 06 2017 20:11:16 GMT+0800

  7.  * @description jcalc.jar

  8.  */

  9. public class Main

  10. {

  11. 	//帮助说明

  12. 	private static final String HELP_INFORMATION =

  13. 	    ""

  14. 	    + "JCALC.JAR - JAVA CONSOLE CALCULATE TOOL, COPYRIGHT@2017~2019 BY HAPPY\n"

  15. 	    + "-----------------------------------------------------------------------\n"

  16. 	    + "Usage instructions:\n"

  17. 	    + "       java -jar jcalc.jar [expression]\n"

  18. 	    + "       java -Xms128m -Xmx1024m -jar jcalc.jar ...\n"

  19. 	    + "-----------------------------------------------------------------------\n"

  20. 	    + "General options:\n"

  21. 	    + "       --help, -h  Show help information\n\n"

  22. 	    + "Available math function:\n"

  23. 	    + "       pi=3.1415926535897932, e=2.7182818284590452\n"

  24. 	    + "       rand, round, int, ceil, floor, abs, sqrt, lg, ln, exp, cbrt\n"

  25. 	    + "       torad, sin, cos, tan, arcsin, arccos, arctan\n"

  26. 	    + "       sinh, cosh, tanh, arcsinh, arccosh, arctanh\n\n"

  27. 	    + "Official website:\n"

  28. 	    + "       http://www.bathome.net/thread-18688-1-1.html\n"

  29. 	    + "-----------------------------------------------------------------------\n"

  30. 	    + "AT LEAST JRE1.6, VERSION: 1.0.0.6\n";

  31. 

  32. 	//数学函数关键词

  33. 	private static final String KEY_WORDS[]= {"e", "pi", "sqrt", "lg", "ln", "sin", "cos", "tan", "arcsin", "arccos", "arctan", "torad", "abs", "round", "floor", "ceil", "exp", "sinh", "cosh", "tanh", "arcsinh", "arccosh", "arctanh", "int", "cbrt", "rand", null};

  34. 

  35. 	//创建计算的堆栈

  36. 	private static final int STACK_SIZE = 1024;

  37. 	private static char[] STACK1= new char[STACK_SIZE];

  38. 	private static char[] STACK2= new char[STACK_SIZE];

  39. 	private static double[] STACK3= new double[STACK_SIZE];

  40. 

  41. 

  42. 	/**阶乘函数

  43. 	 * @param n

  44. 	 * @return

  45. 	 */

  46. 	private static long fact(long n)

  47. 	{

  48. 		return (n<2) ?1 :n*(fact(n-1));

  49. 	}

  50. 	

  51. 	/**计算器核心

  52. 	 * @param expression

  53. 	 */

  54. 	private static double JCalcCore(String expression)

  55. 	{

  56. 		char[] parseArray = expression.toCharArray();

  57. 		int parseArrayLen = parseArray.length;

  58. 

  59. 		char[] tmpKeyCharArray;

  60. 		int tmpKeyCharArrayLen;

  61. 

  62. 		int indexS1=0, indexS2=0, indexS3=0, brackets=0, indexKey, op, cp, kp;

  63. 		double di, ni;

  64. 

  65. 

  66. 		STACK3[0]=0;

  67. 		op = 0;

  68. 

  69. 		//生成逆波兰

  70. 		while(op < parseArrayLen)

  71. 		{

  72. 			switch(parseArray[op])

  73. 			{

  74. 			case ' ' :

  75. 			case '\t':

  76. 			case '\r':

  77. 			case '\n':

  78. 				//过滤空字符

  79. 				op++;

  80. 				continue;

  81. 

  82. 			case '(':

  83. 				brackets++;

  84. 				STACK1[++indexS1]=parseArray[op];

  85. 				if(parseArray[op+1]=='-' || parseArray[op+1]=='+')

  86. 				{

  87. 					STACK2[indexS2++]='0';

  88. 					STACK2[indexS2++]=' ';

  89. 				}

  90. 				break;

  91. 

  92. 			case ')':

  93. 				//验证括号是否闭合

  94. 				if(brackets ==0)

  95. 				{

  96. 					System.out.println("The brackets or ')' are not need");

  97. 					System.exit(1);

  98. 				}

  99. 				brackets--;

  100. 				while(STACK1[indexS1] != '(')

  101. 				{

  102. 					STACK2[indexS2++] = STACK1[indexS1--];

  103. 				}

  104. 				//舍弃'('

  105. 				indexS1--;

  106. 				break;

  107. 

  108. 			case '+':

  109. 			case '-':

  110. 				while( (indexS1 != 0) && (STACK1[indexS1] != '(') )

  111. 				{

  112. 					STACK2[indexS2++] = STACK1[indexS1--];

  113. 				}

  114. 				STACK1[++indexS1] = parseArray[op];

  115. 				break;

  116. 

  117. 			case '^':

  118. 				//指数符

  119. 				while('A'<=STACK1[indexS1] && STACK1[indexS1]<='Z')

  120. 				{

  121. 					STACK2[indexS2++] = STACK1[indexS1--];

  122. 				}

  123. 				STACK1[++indexS1] = parseArray[op];

  124. 				break;

  125. 

  126. 			case '!':

  127. 				//阶乘符

  128. 				STACK2[indexS2++] = parseArray[op];

  129. 				break;

  130. 

  131. 			case '%':

  132. 			case '*':

  133. 			case '/':

  134. 				while(

  135. 				    (

  136. 				        ('A' <= STACK1[indexS1]) &&

  137. 				        (STACK1[indexS1] <= 'Z')

  138. 				    )                    ||

  139. 				    STACK1[indexS1]=='%' ||

  140. 				    STACK1[indexS1]=='*' ||

  141. 				    STACK1[indexS1]=='/' ||

  142. 				    STACK1[indexS1]=='^'

  143. 				)

  144. 				{

  145. 					STACK2[indexS2++] = STACK1[indexS1--];

  146. 				}

  147. 				STACK1[++indexS1] = parseArray[op];

  148. 				break;

  149. 

  150. 			default :

  151. 				if('a'<=parseArray[op] && parseArray[op]<='z')

  152. 				{

  153. 					//识别数学函数关键词

  154. 					indexKey = 0;

  155. 					while(KEY_WORDS[indexKey] != null)

  156. 					{

  157. 						cp=op;

  158. 						kp=0;

  159. 

  160. 						tmpKeyCharArray = KEY_WORDS[indexKey].toCharArray();

  161. 						tmpKeyCharArrayLen = tmpKeyCharArray.length;

  162. 

  163. 						//比对关键词字母

  164. 						while(

  165. 							(kp < tmpKeyCharArrayLen) &&

  166. 							(cp < parseArrayLen)      &&

  167. 							(parseArray[cp] == tmpKeyCharArray[kp])

  168. 						){

  169. 							cp++;

  170. 							kp++;

  171. 						}

  172. 						//验证关键词结尾

  173. 						if(

  174. 								(kp == tmpKeyCharArrayLen) && 

  175. 								(

  176. 										(tmpKeyCharArrayLen == parseArrayLen)      ||

  177. 										(parseArray[cp]<'a' || parseArray[cp]>'z')

  178. 								)		

  179. 						)

  180. 						{

  181. 							op=cp;

  182. 							break;

  183. 						}

  184. 						indexKey++;

  185. 					}

  186. 					//构建伪双目

  187. 					if(KEY_WORDS[indexKey] != null)

  188. 					{

  189. 						STACK2[indexS2++]='.';

  190. 						STACK2[indexS2++]=' ';

  191. 						//伪双目入栈

  192. 						while('A'<=STACK1[indexS1] && STACK1[indexS1]<='Z')

  193. 						{

  194. 							STACK2[indexS2++] = STACK1[indexS1--];

  195. 						}

  196. 						STACK1[++indexS1] = (char)(indexKey+65);

  197. 						continue;

  198. 					}

  199. 					else

  200. 					{

  201. 						//无法识别的数学函数

  202. 						System.out.println("Unrecognized math function\n");

  203. 						System.exit(1);

  204. 					}

  205. 

  206. 				}

  207. 				else if(('0'<=parseArray[op] && parseArray[op]<='9') || (parseArray[op]=='.'))

  208. 				{

  209. 					//浮点数入栈

  210. 					while(

  211. 							(op < parseArrayLen) &&

  212. 							(

  213. 								('0'<=parseArray[op] && parseArray[op]<='9') || 

  214. 								(parseArray[op]=='.')

  215. 							)

  216. 					){

  217. 						STACK2[indexS2++] = parseArray[op++];

  218. 					}

  219. 					

  220. 					if(

  221. 							(op < parseArrayLen) &&

  222. 							('a'<=parseArray[op] && parseArray[op]<='z')

  223. 					){

  224. 						//缺少必要的运算符

  225. 						System.out.println("Missing required operator\n");

  226. 						System.exit(1);

  227. 					}

  228. 					op--;

  229. 					STACK2[indexS2++] = ' ';

  230. 				}

  231. 				else

  232. 				{

  233. 					//无法识别的运算符

  234. 					System.out.println("Unrecognized operator\n");

  235. 					System.exit(1);

  236. 				}

  237. 				break;

  238. 			}

  239. 			op++;

  240. 		}

  241. 

  242. 		//验证括号是否闭合

  243. 		if(brackets !=0)

  244. 		{

  245. 			System.out.println("The brackets '(' are not closed\n");

  246. 			System.exit(1);

  247. 		}

  248. 

  249. 		//收尾逆波兰

  250. 		while(indexS1 !=0)

  251. 		{

  252. 			STACK2[indexS2++] = STACK1[indexS1--];

  253. 		}

  254. 		STACK2[indexS2] = ' ';

  255. 

  256. 		//计算逆波兰

  257. 		op=0;

  258. 		while(STACK2[op] != ' ')

  259. 		{

  260. 			switch(STACK2[op])

  261. 			{

  262. 			case 'A':

  263. 				STACK3[indexS3] = Math.E;

  264. 				break;

  265. 			case 'B':

  266. 				STACK3[indexS3] = Math.PI;

  267. 				break;

  268. 			case 'C':

  269. 				if(STACK3[indexS3] <0)

  270. 				{

  271. 					//负数没有平方根

  272. 					System.out.println("Negative numbers have no square root\n");

  273. 					System.exit(1);

  274. 				}

  275. 				STACK3[indexS3 - 1] = Math.sqrt(STACK3[indexS3]);

  276. 				indexS3--;

  277. 				break;

  278. 			case 'D':

  279. 				if(STACK3[indexS3] <0)

  280. 				{

  281. 					//负数没有对数

  282. 					System.out.println("Negative numbers are not logarithmic\n");

  283. 					System.exit(1);

  284. 				}

  285. 				STACK3[indexS3 - 1] = Math.log10(STACK3[indexS3]);

  286. 				indexS3--;

  287. 				break;

  288. 			case 'E':

  289. 				if(STACK3[indexS3] <0)

  290. 				{

  291. 					//负数没有自然对数

  292. 					System.out.println("Negative numbers have no natural logarithms\n");

  293. 					System.exit(1);

  294. 				}

  295. 				STACK3[indexS3 - 1] = Math.log(STACK3[indexS3]);

  296. 				indexS3--;

  297. 				break;

  298. 			case 'F':

  299. 				STACK3[indexS3 - 1] = Math.sin(STACK3[indexS3]);

  300. 				indexS3--;

  301. 				break;

  302. 			case 'G':

  303. 				STACK3[indexS3 - 1] = Math.cos(STACK3[indexS3]);

  304. 				indexS3--;

  305. 				break;

  306. 			case 'H':

  307. 				if(STACK3[indexS3] == Math.PI/2)

  308. 				{

  309. 					//90度没有正切值

  310. 					System.out.println("The pi/2 has no tangent\n");

  311. 					System.exit(1);

  312. 				}

  313. 				STACK3[indexS3 - 1] = Math.tan(STACK3[indexS3]);

  314. 				indexS3--;

  315. 				break;

  316. 			case 'I':

  317. 				STACK3[indexS3 - 1] = Math.asin(STACK3[indexS3]);

  318. 				indexS3--;

  319. 				break;

  320. 			case 'J':

  321. 				STACK3[indexS3 - 1] = Math.acos(STACK3[indexS3]);

  322. 				indexS3--;

  323. 				break;

  324. 			case 'K':

  325. 				STACK3[indexS3 - 1] = Math.atan(STACK3[indexS3]);

  326. 				indexS3--;

  327. 				break;

  328. 			case 'L':

  329. 				STACK3[indexS3 - 1] = Math.toRadians(STACK3[indexS3]);

  330. 				indexS3--;

  331. 				break;

  332. 			case 'M':

  333. 				STACK3[indexS3 - 1] = Math.abs(STACK3[indexS3]);

  334. 				indexS3--;

  335. 				break;

  336. 			case 'N':

  337. 				STACK3[indexS3 - 1] = Math.round(STACK3[indexS3]);

  338. 				indexS3--;

  339. 				break;

  340. 			case 'O':

  341. 				STACK3[indexS3 - 1] = Math.floor(STACK3[indexS3]);

  342. 				indexS3--;

  343. 				break;

  344. 			case 'P':

  345. 				STACK3[indexS3 - 1] = Math.ceil(STACK3[indexS3]);

  346. 				indexS3--;

  347. 				break;

  348. 			case 'Q':

  349. 				STACK3[indexS3 - 1] = Math.exp(STACK3[indexS3]);

  350. 				indexS3--;

  351. 				break;

  352. 			case 'R':

  353. 				STACK3[indexS3 - 1] = Math.sinh(STACK3[indexS3]);

  354. 				indexS3--;

  355. 				break;

  356. 			case 'S':

  357. 				STACK3[indexS3 - 1] = Math.cosh(STACK3[indexS3]);

  358. 				indexS3--;

  359. 				break;

  360. 			case 'T':

  361. 				STACK3[indexS3 - 1] = Math.tanh(STACK3[indexS3]);

  362. 				indexS3--;

  363. 				break;

  364. 			case 'U':

  365. 				STACK3[indexS3 - 1] = Math.log(STACK3[indexS3]+Math.sqrt(STACK3[indexS3]*STACK3[indexS3]+1));

  366. 				indexS3--;

  367. 				break;

  368. 			case 'V':

  369. 				STACK3[indexS3 - 1] = Math.log(STACK3[indexS3]+Math.sqrt(STACK3[indexS3]*STACK3[indexS3]-1));

  370. 				indexS3--;

  371. 				break;

  372. 			case 'W':

  373. 				STACK3[indexS3 - 1] = Math.log((1+STACK3[indexS3])/(1-STACK3[indexS3]))/2;

  374. 				indexS3--;

  375. 				break;

  376. 			case 'X':

  377. 				STACK3[indexS3 - 1] = (int)(STACK3[indexS3]);

  378. 				indexS3--;

  379. 				break;

  380. 			case 'Y':

  381. 				STACK3[indexS3 - 1] = Math.cbrt(STACK3[indexS3]);

  382. 				indexS3--;

  383. 				break;

  384. 			case 'Z':

  385. 				//随机数生成器

  386. 				if(STACK3[indexS3] <0)

  387. 				{

  388. 					//负数不能作为随机数上限

  389. 					System.out.println("A negative number can not be used as a random upper bound");

  390. 					System.exit(1);

  391. 				}

  392. 				else if(STACK3[indexS3] <2)

  393. 				{

  394. 					//小于2的随机数为0~1之间的小数

  395. 					STACK3[indexS3 - 1] = Math.random();

  396. 				}

  397. 				else

  398. 				{

  399. 					STACK3[indexS3 - 1] = (int)(Math.random() * (STACK3[indexS3]));

  400. 				}

  401. 				indexS3--;

  402. 				break;

  403. 			case '+':

  404. 				STACK3[indexS3 - 1] += STACK3[indexS3];

  405. 				indexS3--;

  406. 				break;

  407. 			case '-':

  408. 				STACK3[indexS3 - 1] -= STACK3[indexS3];

  409. 				indexS3--;

  410. 				break;

  411. 			case '*':

  412. 				STACK3[indexS3 - 1] *= STACK3[indexS3];

  413. 				indexS3--;

  414. 				break;

  415. 			case '%':

  416. 			case '/':

  417. 				if(STACK3[indexS3] != 0)

  418. 				{

  419. 					if(STACK2[op] == '%')

  420. 					{

  421. 						//取余数

  422. 						STACK3[indexS3 - 1]=(int)STACK3[indexS3 - 1] % (int)STACK3[indexS3];

  423. 					}

  424. 					else

  425. 					{

  426. 						STACK3[indexS3 - 1] /= STACK3[indexS3];

  427. 					}

  428. 

  429. 				}

  430. 				else

  431. 				{

  432. 					//除数不能为零

  433. 					System.out.println("Divisor is zero error\n");

  434. 					System.exit(1);

  435. 				}

  436. 				indexS3--;

  437. 				break;

  438. 			case '^':

  439. 				if(STACK3[indexS3 - 1]==0 && STACK3[indexS3]<0)

  440. 				{

  441. 					//除数不能为零

  442. 					System.out.println("Function pow's divisor is zero error\n");

  443. 					System.exit(1);

  444. 				}

  445. 				STACK3[indexS3 - 1] = Math.pow(STACK3[indexS3 - 1], STACK3[indexS3]);

  446. 				indexS3--;

  447. 				break;

  448. 			case '!':

  449. 				if(STACK3[indexS3] <0)

  450. 				{

  451. 					//负数没有阶乘

  452. 					System.out.println("Negative numbers have no factorial\n");

  453. 					System.exit(1);

  454. 				}

  455. 				STACK3[indexS3]=fact((long)(STACK3[indexS3]));

  456. 				break;

  457. 			default :

  458. 				//字符串转浮点

  459. 				di=0;

  460. 				ni=1;

  461. 				while('0'<=STACK2[op] && STACK2[op]<='9')

  462. 				{

  463. 					di=10*di+(STACK2[op])-'0';

  464. 					op++;

  465. 				}

  466. 				if(STACK2[op] == '.')

  467. 				{

  468. 					op++;

  469. 					while('0'<=STACK2[op] && STACK2[op]<='9')

  470. 					{

  471. 						di=10*di+(STACK2[op])-'0';

  472. 						op++;

  473. 						ni *= 10;

  474. 					}

  475. 				}

  476. 				STACK3[++indexS3] = di/ni;

  477. 				break;

  478. 			}

  479. 			op++;

  480. 		}

  481. 

  482. 		//判断结果是否异常或溢出

  483. 		if( Double.isInfinite((float)STACK3[indexS3]) || Double.isNaN((float)STACK3[indexS3]) )

  484. 		{

  485. 			System.out.println("Overflow or illegal operation is calculated");

  486. 			System.exit(1);

  487. 		}

  488. 

  489. 		//返回计算结果

  490. 		//return STACK3[indexS3];

  491. 

  492. 		//打印中缀式

  493. 		System.out.printf("OriginalExp: %s\n", expression);

  494. 

  495. 		//打印后缀式

  496. 		System.out.printf("Revpolish:   ");

  497. 

  498. 		op = 0;

  499. 		while(op != indexS2)

  500. 		{

  501. 			if(STACK2[op]=='.' && STACK2[op+1]==' ')

  502. 			{

  503. 				op++;

  504. 

  505. 			}

  506. 			else if('A'<=STACK2[op] && STACK2[op]<='Z')

  507. 			{

  508. 				System.out.printf("%s ", KEY_WORDS[STACK2[op]-65]);

  509. 

  510. 			}

  511. 			else

  512. 			{

  513. 				System.out.printf("%c", STACK2[op]);

  514. 

  515. 				if(

  516. 				    STACK2[op] == '+' ||

  517. 				    STACK2[op] == '-' ||

  518. 				    STACK2[op] == '*' ||

  519. 				    STACK2[op] == '/' ||

  520. 				    STACK2[op] == '%' ||

  521. 				    STACK2[op] == '^' ||

  522. 				    STACK2[op] == '!'

  523. 				)

  524. 				{

  525. 					System.out.printf(" ");

  526. 				}

  527. 			}

  528. 			op++;

  529. 		}

  530. 		System.out.printf("%c", '\n');

  531. 

  532. 		//打印计算结果

  533. 		System.out.printf("Result:      %.12f\n", STACK3[indexS3]);

  534. 		return 0.0f;

  535. 	}

  536. 

  537. 

  538. 	/**主函数入口

  539. 	 * @param args

  540. 	 */

  541. 	public static void main(String[] args)

  542. 	{

  543. 		//抛出使用说明

  544. 		if (args.length != 1 || args[0].equals("-h") || args[0].equals("--help"))

  545. 		{

  546. 			System.out.println(HELP_INFORMATION);

  547. 			return;

  548. 		}

  549. 

  550. 		//调用计算核心

  551. 		JCalcCore(args[0]);

  552. 		return;

  553. 	}

  554. }
复制代码
1

评分人数

收藏 分享

返回列表