5329人阅读
java（35）
什么是流：
流是一个抽象的概念。当Java程序需要从数据源读取数据时，会开启一个到数据源的流。数据源可以是文件，内存或者网络等。同样，当程序需要输出数据到目的地时也一样会开启一个流，数据目的地也可以是文件、内存或者网络等。流的创建是为了更方便地处理数据的输入输出。
流分为字节流和字符流。字节流也称为原始数据，需要用户读入后进行相应的编码转换。而字符流的实现是基于自动转换的，读取数据时会把数据按照JVM的默认编码自动转换成字符。
字节流由InputStream和OutputStream处理，而字符流由Reader和Writer处理。Reader和Writer是Java后加入的处理类，出于让数据的处理更方便的目的。
字节流处理类概述：
字节流的处理类有很多，他们都继承自InputStream或者OutputStream抽象类。
先谈谈输入流，输入流中跟数据源直接接触的类有：FileInputStream和ByteArrayInputStream，他们分别实现了从文件或者内存中的字节数组读入数据到输入流。
其他的输入流处理类都是装饰类（Decorator模式），下面对他们进行一下简单介绍：
BufferedInputStream： 提供了缓冲功能。
DataInputStream: 允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
PipedInputStream: 允许以管道的方式来处理流。当连接到一个PipedOutputStream后，它会读取后者输出到管道的数据。
PushbackInputStream: 允许放回已经读取的数据。
SequenceInputStream: 能对多个inputstream进行顺序处理。
基本上每个输入流类都有一个相应的输出流类，提供相应的输出流处理。
同样，跟数据目的地直接接触的类有：FileOutputStream和ByteArrayOutputStream，前者实现了把数据流写入文件的功能，后者实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用toByteArray() 和
toString() 获取数据。
下面对其它的装饰类做一下简单介绍：
BufferedOutputStream： 提供了缓冲功能的输出流，在写出完成之前要调用flush来保证数据的输出。
DataOutputStream: 数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。
PipedOutputStream: 允许以管道的方式来处理流。可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入PipedOutputStream 对象，并由其他线程从连接的
PipedInputStream 读取。
PrintStream: 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。我们经常用到的System.out或者System.err都是PrintStream。
字符流处理类概述：
跟数据源直接接触的类：
CharArrayReader: 从内存中的字符数组中读入数据，以对数据进行流式读取。
StringReader：从内存中的字符串读入数据，以对数据进行流式读取。
FileReader：从文件中读入数据。注意这里读入数据时会根据JVM的默认编码对数据进行内转换，而不能指定使用的编码。所以当文件使用的编码不是JVM默认编码时，不要使用这种方式。要正确地转码，使用InputStreamReader。
BufferedReader：提供缓冲功能，可以读取行：readLine();
LineNumberReader: 提供读取行的控制：getLineNumber()等方法。
InputStreamReader: 字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。
根数据目的相关的类：
CharArrayWriter：把内存中的字符数组写入输出流，输出流的缓冲区会自动增加大小。输出流的数据可以通过一些方法重新获取。
StringWriter: 一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。
FileWriter：把数据写入文件。
BufferedWriter：提供缓冲功能。
OutputStreamWriter：字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。
PrintWriter: 向文本输出流打印对象的格式化表示形式。
Writer或者OutputStream中的flush(): 刷新该流的缓冲，用于确保数据的输出。
&close(): 关闭流并释放与之关联的所有系统资源
其实大家看到下面的图应该就很明白了。
看到这里相信大家对字节流、字符流有一个大致认识了，也对操作流的类有了一个清晰的认识，下面还是通过写代码的方式让大家理解如何操作的。
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
package test.
import java.io.BufferedR
import java.io.F
import java.io.FileInputS
import java.io.FileR
import java.io.IOE
import java.io.InputS
import java.io.InputStreamR
import java.io.RandomAccessF
import java.io.R
public class ReadFromFile {
* 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
* @param fileName 文件的名
public static void readFileByBytes(String fileName){
File file = new File(fileName);
InputStream in =
System.out.println(&以字节为单位读取文件内容，一次读一个字节：&);
// 一次读一个字节
in = new FileInputStream(file);
while((tempbyte=in.read()) != -1){
System.out.write(tempbyte);
in.close();
} catch (IOException e) {
e.printStackTrace();
System.out.println(&以字节为单位读取文件内容，一次读多个字节：&);
//一次读多个字节
byte[] tempbytes = new byte[100];
int byteread = 0;
in = new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while ((byteread = in.read(tempbytes)) != -1){
System.out.write(tempbytes, 0, byteread);
} catch (Exception e1) {
e1.printStackTrace();
} finally {
if (in != null){
in.close();
} catch (IOException e1) {
* 以字符为单位读取文件，常用于读文本，数字等类型的文件
* @param fileName 文件名
public static void readFileByChars(String fileName){
File file = new File(fileName);
Reader reader =
System.out.println(&以字符为单位读取文件内容，一次读一个字节：&);
// 一次读一个字符
reader = new InputStreamReader(new FileInputStream(file));
while ((tempchar = reader.read()) != -1){
//对于windows下，/r/n这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉/r，或者屏蔽/n。否则，将会多出很多空行。
if (((char)tempchar) != '\r'){
System.out.print((char)tempchar);
reader.close();
} catch (Exception e) {
e.printStackTrace();
System.out.println(&以字符为单位读取文件内容，一次读多个字节：&);
//一次读多个字符
char[] tempchars = new char[30];
int charread = 0;
reader = new InputStreamReader(new FileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while ((charread = reader.read(tempchars))!=-1){
//同样屏蔽掉/r不显示
if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != '\r')){
System.out.print(tempchars);
for (int i=0; i& i++){
if(tempchars[i] == '\r'){
System.out.print(tempchars[i]);
} catch (Exception e1) {
e1.printStackTrace();
}finally {
if (reader != null){
reader.close();
} catch (IOException e1) {
* 以行为单位读取文件，常用于读面向行的格式化文件
* @param fileName 文件名
public static void readFileByLines(String fileName){
File file = new File(fileName);
BufferedReader reader =
System.out.println(&以行为单位读取文件内容，一次读一整行：&);
reader = new BufferedReader(new FileReader(file));
String tempString =
int line = 1;
//一次读入一行，直到读入null为文件结束
while ((tempString = reader.readLine()) != null){
//显示行号
System.out.println(&line & + line + &: & + tempString);
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null){
reader.close();
} catch (IOException e1) {
* 随机读取文件内容
* @param fileName 文件名
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile =
System.out.println(&随机读取一段文件内容：&);
// 打开一个随机访问文件流，按只读方式
randomFile = new RandomAccessFile(fileName, &r&);
// 文件长度，字节数
long fileLength = randomFile.length();
// 读文件的起始位置
int beginIndex = (fileLength & 4) ? 4 : 0;
//将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes = new byte[10];
int byteread = 0;
//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//将一次读取的字节数赋给byteread
while ((byteread = randomFile.read(bytes)) != -1){
System.out.write(bytes, 0, byteread);
} catch (IOException e){
e.printStackTrace();
} finally {
if (randomFile != null){
randomFile.close();
} catch (IOException e1) {
* 显示输入流中还剩的字节数
* @param in
private static void showAvailableBytes(InputStream in){
System.out.println(&当前字节输入流中的字节数为:& + in.available());
} catch (IOException e) {
e.printStackTrace();
public static void main(String[] args) {
String fileName = &C:/temp/newTemp.txt&;
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
二、将内容追加到文件尾部
package test.
import java.io.FileW
import java.io.IOE
import java.io.RandomAccessF
public class AppendToFile {
* A方法追加文件：使用RandomAccessFile
* @param fileName 文件名
* @param content 追加的内容
public static void appendMethodA(String fileName, String content){
// 打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile = new RandomAccessFile(fileName, &rw&);
// 文件长度，字节数
long fileLength = randomFile.length();
//将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch (IOException e){
e.printStackTrace();
* B方法追加文件：使用FileWriter
* @param fileName
* @param content
public static void appendMethodB(String fileName, String content){
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);
writer.write(content);
writer.close();
} catch (IOException e) {
e.printStackTrace();
public static void main(String[] args) {
String fileName = &C:/temp/newTemp.txt&;
String content = &new append!&;
//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName, &append end. /n&);
//显示文件内容
ReadFromFile.readFileByLines(fileName);
//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName, &append end. /n&);
//显示文件内容
ReadFromFile.readFileByLines(fileName);
二、文件的各种操作类
package test.
import java.io.BufferedR
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.FileW
import java.io.InputS
import java.io.InputStreamR
import java.io.PrintW
public class FileOperate {
public FileOperate(){
* 新建目录
public void newFolder(String folderPath)
String filePath = folderP
filePath = filePath.toString();
File myFilePath = new File(filePath);
if(!myFilePath.exists())
myFilePath.mkdir();
System.out.println(&新建目录操作 成功执行&);
catch(Exception e)
System.out.println(&新建目录操作出错&);
e.printStackTrace();
* 新建文件
public void newFile(String filePathAndName, String fileContent)
String filePath = filePathAndN
filePath = filePath.toString();
File myFilePath = new File(filePath);
if (!myFilePath.exists())
myFilePath.createNewFile();
FileWriter resultFile = new FileWriter(myFilePath);
PrintWriter myFile = new PrintWriter(resultFile);
String strContent = fileC
myFile.println(strContent);
resultFile.close();
System.out.println(&新建文件操作 成功执行&);
catch (Exception e)
System.out.println(&新建目录操作出错&);
e.printStackTrace();
* 删除文件
public void delFile(String filePathAndName)
String filePath = filePathAndN
filePath = filePath.toString();
File myDelFile = new File(filePath);
myDelFile.delete();
System.out.println(&删除文件操作 成功执行&);
catch (Exception e)
System.out.println(&删除文件操作出错&);
e.printStackTrace();
* 删除文件夹
public void delFolder(String folderPath)
delAllFile(folderPath); //删除完里面所有内容
String filePath = folderP
filePath = filePath.toString();
File myFilePath = new File(filePath);
if(myFilePath.delete()) { //删除空文件夹
System.out.println(&删除文件夹& + folderPath + &操作 成功执行&);
System.out.println(&删除文件夹& + folderPath + &操作 执行失败&);
catch (Exception e)
System.out.println(&删除文件夹操作出错&);
e.printStackTrace();
* 删除文件夹里面的所有文件
* @param path String 文件夹路径 如 c:/fqf
public void delAllFile(String path)
File file = new File(path);
if(!file.exists())
if(!file.isDirectory())
String[] tempList = file.list();
File temp =
for (int i = 0; i & tempList. i++)
if(path.endsWith(File.separator))
temp = new File(path + tempList[i]);
temp = new File(path + File.separator + tempList[i]);
if (temp.isFile())
temp.delete();
if (temp.isDirectory())
//delAllFile(path+&/&+ tempList[i]);//先删除文件夹里面的文件
delFolder(path+ File.separatorChar + tempList[i]);//再删除空文件夹
System.out.println(&删除文件操作 成功执行&);
* 复制单个文件
* @param oldPath String 原文件路径 如：c:/fqf.txt
* @param newPath String 复制后路径 如：f:/fqf.txt
public void copyFile(String oldPath, String newPath)
int bytesum = 0;
int byteread = 0;
File oldfile = new File(oldPath);
if (oldfile.exists())
//文件存在时
InputStream inStream = new FileInputStream(oldPath); //读入原文件
FileOutputStream fs = new FileOutputStream(newPath);
byte[] buffer = new byte[1444];
while ( (byteread = inStream.read(buffer)) != -1)
bytesum += //字节数 文件大小
System.out.println(bytesum);
fs.write(buffer, 0, byteread);
inStream.close();
System.out.println(&删除文件夹操作 成功执行&);
catch (Exception e)
System.out.println(&复制单个文件操作出错&);
e.printStackTrace();
* 复制整个文件夹内容
* @param oldPath String 原文件路径 如：c:/fqf
* @param newPath String 复制后路径 如：f:/fqf/ff
public void copyFolder(String oldPath, String newPath)
(new File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹
File a=new File(oldPath);
String[] file=a.list();
File temp=
for (int i = 0; i & file. i++)
if(oldPath.endsWith(File.separator))
temp=new File(oldPath+file[i]);
temp=new File(oldPath+File.separator+file[i]);
if(temp.isFile())
FileInputStream input = new FileInputStream(temp);
FileOutputStream output = new FileOutputStream(newPath + &/& +
(temp.getName()).toString());
byte[] b = new byte[1024 * 5];
while ( (len = input.read(b)) != -1)
output.write(b, 0, len);
output.flush();
output.close();
input.close();
if(temp.isDirectory())
//如果是子文件夹
copyFolder(oldPath+&/&+file[i],newPath+&/&+file[i]);
System.out.println(&复制文件夹操作 成功执行&);
catch (Exception e)
System.out.println(&复制整个文件夹内容操作出错&);
e.printStackTrace();
* 移动文件到指定目录
* @param oldPath String 如：c:/fqf.txt
* @param newPath String 如：d:/fqf.txt
public void moveFile(String oldPath, String newPath)
copyFile(oldPath, newPath);
delFile(oldPath);
* 移动文件到指定目录
* @param oldPath String 如：c:/fqf.txt
* @param newPath String 如：d:/fqf.txt
public void moveFolder(String oldPath, String newPath)
copyFolder(oldPath, newPath);
delFolder(oldPath);
public static void main(String args[])
String aa,
boolean exitnow=
System.out.println(&使用此功能请按[1] 功能一：新建目录&);
System.out.println(&使用此功能请按[2] 功能二：新建文件&);
System.out.println(&使用此功能请按[3] 功能三：删除文件&);
System.out.println(&使用此功能请按[4] 功能四：删除文件夹&);
System.out.println(&使用此功能请按[5] 功能五：删除文件夹里面的所有文件&);
System.out.println(&使用此功能请按[6] 功能六：复制文件&);
System.out.println(&使用此功能请按[7] 功能七：复制文件夹的所有内容&);
System.out.println(&使用此功能请按[8] 功能八：移动文件到指定目录&);
System.out.println(&使用此功能请按[9] 功能九：移动文件夹到指定目录&);
System.out.println(&使用此功能请按[10] 退出程序&);
while(!exitnow)
FileOperate fo=new FileOperate();
BufferedReader Bin=new BufferedReader(new InputStreamReader(System.in));
String a=Bin.readLine();
int b=Integer.parseInt(a);
case 1:System.out.println(&你选择了功能一 请输入目录名&);
aa=Bin.readLine();
fo.newFolder(aa);
case 2:System.out.println(&你选择了功能二 请输入文件名&);
aa=Bin.readLine();
System.out.println(&请输入在&+aa+&中的内容&);
bb=Bin.readLine();
fo.newFile(aa,bb);
case 3:System.out.println(&你选择了功能三 请输入文件名&);
aa=Bin.readLine();
fo.delFile(aa);
case 4:System.out.println(&你选择了功能四 请输入文件名&);
aa=Bin.readLine();
fo.delFolder(aa);
case 5:System.out.println(&你选择了功能五 请输入文件名&);
aa=Bin.readLine();
fo.delAllFile(aa);
case 6:System.out.println(&你选择了功能六 请输入文件名&);
aa=Bin.readLine();
System.out.println(&请输入目标文件名&);
bb=Bin.readLine();
fo.copyFile(aa,bb);
case 7:System.out.println(&你选择了功能七 请输入源文件名&);
aa=Bin.readLine();
System.out.println(&请输入目标文件名&);
bb=Bin.readLine();
fo.copyFolder(aa,bb);
case 8:System.out.println(&你选择了功能八 请输入源文件名&);
aa=Bin.readLine();
System.out.println(&请输入目标文件名&);
bb=Bin.readLine();
fo.moveFile(aa,bb);
case 9:System.out.println(&你选择了功能九 请输入源文件名&);
aa=Bin.readLine();
System.out.println(&请输入目标文件名&);
bb=Bin.readLine();
fo.moveFolder(aa,bb);
case 10:exitnow=
System.out.println(&程序结束，请退出&);
default:System.out.println(&输入错误.请输入1-10之间的数&);
System.out.println(&请重新选择功能&);
catch(Exception e)
System.out.println(&输入错误字符或程序出错&);
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：192704次
积分：2369
积分：2369
排名：第11232名
原创：67篇
评论：48条
(7)(8)(1)(2)(2)(1)(45)(4)JAVA程序中如何输出一个字符串中相同字符的个数_百度知道
JAVA程序中如何输出一个字符串中相同字符的个数
提问者采纳
数组可以是任何长度，并且结尾空字符串将被丢弃根据匹配给定的正则表达式来拆分此字符串，那么模式将被应用尽可能多的次数，或者由此字符串末尾终止，数组的长度将不会大于 n，那么模式将被应用尽可能多的次数。此方法返回的数组包含此字符串的子字符串。如果该限制 n 大于 0。如果表达式不匹配输入的任何部分，则模式将被最多应用 n-1 次。limit 参数控制模式应用的次数，而且数组的最后一项将包含所有超出最后匹配的定界符的输入，那么所得数组只具有一个元素，每个子字符串都由另一个匹配给定表达式的子字符串终止。如果 n 为 0。数组中的子字符串按它们在此字符串中出现的顺序排列。如果 n 为非正，而且数组可以是任何长度，即此字符串，因此影响所得数组的长度
其他类似问题
为您推荐：
java程序的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁编写一个字符界面的Java Application程序，接受用户输入的字符，_java吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：475,761贴子：
编写一个字符界面的Java Application程序，接受用户输入的字符，收藏
才开始学 表示完全写不出来
三叔正版授权网游公测！
这么简单的东西！
Scanner sca = new Scanner(System.in);
劝你找本专业书或者视频看看吧，多找找度娘谷歌什么的，对我等菜鸟是很有帮助的！
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或MyEclipse设置java文件每行字符数（自动换行）
window-&preferences-&java-&code
style-&formatter-&edit-&line
wrapping-&maximum line width ，
自己新建一个profile，然后设置maximum line width
值，然后点“apply”,再点击“确定”。自己设置的profile（轮廓）便可以应用于自己的文件。用ctrl+shift+F格式化代码时，每行代码字符数便是刚才设置的maximum
line width 值。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。用Java写的一个实现大数计算器的类
为了练习一下Java，今天写了一个能进行大数计算的类，只需要调用本类的一个方法，以算数表达式为参数，方法就可返回计算结果。
import java.math.BigI
import java.util.EmptyStackE
import java.util.HashM
import java.util.S
* 该类实现对大值数进行简单计算的功能
class BigNumCalculator {
private S //要计算的表达式
private S//结算结果
Stack//操作数栈
Stack//操作符栈
HashMap prect_ //操作符和优先级之间的映射关系
* 无参构造函数
public BigNumCalculator() {
this.operand = new Stack();
this.operator = new Stack();
prect_map = new HashMap();
prect_map.put("+", new Integer(1));
prect_map.put("-", new Integer(1));
prect_map.put("*", new Integer(2));
prect_map.put("/", new Integer(2));
* 对输入的表达式进行简单的检查。合法字符：数字、+、-、*、/、(、)之外是否还包含别的字符）
* 返回值：如果表达式不包含非合法字符，则返回true,否则返回false
* 调用本类函数:无
private void check()throws ExpressionException {
if(!this.input.matches("[\\d\\+\\-\\*/()]*"))//用正则表达式检查表达式是否合法,如果不合法，抛出表达式不合法异常，不懂正则表达式的参考此处：点击打开链接
throw new ExpressionException("Expressions contain only numbers,+,-,*,/");
* 函数功能：比较两个操作符的优先级
* 参数：要比较的两个操作符
* 返回值：如果1、第一个操作符优先级比第二个低，返回负值；
2、优先级相同，返回0；
3、第一个操作符比第二个操作符高，返回正值
* 调用本类函数：无
private int compOperator(String op1, String op2) {
return this.prect_map.get(op1).intValue() - this.prect_map.get(op2).intValue();
* 函数功能：将两个指定的大数对象，按指定的操作符进行运算，得出结果
* 参数：要计算的两个大数类对象，和字符串表示的操作符
* 返回值：返回一个大整数类对象，表示操作结果
* 调用本类函数：无
private BigInteger compute(BigInteger bi1, BigInteger bi2, String operator) {
switch(operator.charAt(0)) {
case '+': return bi1.add(bi2);
case '-': return bi1.subtract(bi2);
case '*': return bi1.multiply(bi2);
case '/': return bi1.divide(bi2);
* 函数功能：根据输入的表达式，计算出用字符串表示的结果
* 参数：一个String对象，表示要计算的表达式
* 返回值：一个String对象，表示结算得到的结果
* 异常抛出：如果表达式不合法，则抛出相应的异常
* 调用本类中的函数：check(),compOperator(),compute()
public String calculate(String input) throws ExpressionException{
input = "(" + input + ")";//将传进来的表达式字符串赋值给类成员，之所以给表达式包上一层括号，上为了方便最后得到一个结果
this.input =
this.check(); //检查表达式是否合法
StringBuffer sb = new StringBuffer(); //解析表达式时用来存储数字
for(int j = 0; j < input.length(); j ++) {
String tmp = "" + input.charAt(j);//将当前正解析的字符转化为字符串
if(tmp.matches("\\d")) {//当前解析的是数字
sb.append(tmp.charAt(0));
else if(tmp.charAt(0) == '(') {//当前解析的是'('
//(前面必定紧挨着操作符，所以不需要将操作数进行压栈，因为StringBuffer对象必为空
this.operator.push(tmp);
else if(tmp.matches("[\\+\\-\\*/]{1}")) {//当前解析的是+、-、*、/
//遇到操作符，将之前的字符串变换为一个大数，压入操作数栈中，并将存储数字的StringBuffer对象清空
BigInteger biTemp = new BigInteger(sb.toString());
this.operand.push(biTemp);
sb.delete(0, sb.length());
/*执行操作符栈中优先级低于或等于当前操作符的操作
* 首先从操作符栈中弹出一个操作符，
* 然后从操作数栈中弹出两个操作数
* 执行操作后将结果压入操作数栈中
while(!this.operator.empty()) {
String topOperator = this.operator.pop();
if(topOperator.equals("(")) {//如果遇到"(",停止处理
this.operator.push(topOperator);
pOperator(tmp, topOperator) <= 0) {//如果栈中的操作符优先级比当前解析的操作符优先级高或相等
BigInteger bi1 = this.operand.pop();
BigInteger bi2 = this.operand.pop();
this.operand.pute(bi1, bi2, topOperator));
else {//如果栈中的操作符比当前解析的操作符优先级低
this.operator.push(topOperator);//将弹出的操作符重新压入操作符栈
this.operator.push(tmp);//将当前操作符压入操作符栈
else {//如果当前解析的右括号)
//将之前的字符串变换为一个大数，压入操作数栈中，并将存储数字的StringBuffer对象清空
BigInteger biTemp = new BigInteger(sb.toString());
this.operand.push(biTemp);
sb.delete(0, sb.length());
String topOperator = this.operator.pop();
while(!topOperator.equals("(")) {
BigInteger bi1 = this.operand.pop();
BigInteger bi2 = this.operand.pop();
this.operand.pute(bi1, bi2, topOperator));
topOperator = this.operator.pop();
catch(EmptyStackException e) {
throw new ExpressionException();
if(!this.operator.empty() || this.operand.size() != 1)
throw new ExpressionException();
this.output = this.operand.pop().toString();
return this.
上面的类中引用了自己编写的一个异常类：
* 自己编写的一个异常类，如果表达式不合法，则抛出该异常
class ExpressionException extends Exception {
private static final long serialVersionUID = 1L;
public ExpressionException(String msg) {
super(msg);
public ExpressionException() {
super("parsing fault");
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'}