字符串类String
实例79 创建字符串类
package Chapter06.string;
public class StringDemo_01 {
public static void main(String[] args) {
String str0, str1, str2, str3, str4, str5, str6, str7;
byte B_array[] = { (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd',
(byte) 'e', (byte) 'f' };
char C_array[] = { '大', '家', '好', '谢', '谢', '你' };
StringBuffer sb = new StringBuffer("早上好");
str0 = new String("Goodbye"); // 根据指定的信息创建一个新的String对象
str1 = new String(); // 创建一个新的空序列String对象
str2 = new String(B_array); // 根据指定的字符集字节数组创建一个新的String对象
str3 = new String(C_array); // 根据指定的字符数组创建一个新的String对象
str4 = new String(sb); // 根据指定的字符串缓冲区参数创建一个新的String对象
str5 = new String(B_array, 1, 4); // 从B_array数组中获取以下标为1开始,下标为4-1结束之间的字节创建一个新的String对象
str6 = new String(C_array, 0, 3); // 从C_array数组中获取以下标为0开始,下标为3-1结束之间的字符创建一个新的String对象
str7 = new String(str2); // 根据指定的字符串对象创建一个新的String对象
System.out.println("创建字符串类的方法一:str0=" + str0);
System.out.println("创建字符串类的方法二:str1=" + str1);
System.out.println("创建字符串类的方法三:str2=" + str2);
System.out.println("创建字符串类的方法四:str3=" + str3);
System.out.println("创建字符串类的方法五:str4=" + str4);
System.out.println("创建字符串类的方法六:str5=" + str5);
System.out.println("创建字符串类的方法七:str7=" + str6);
System.out.println("创建字符串类的方法八:str8=" + str7);
}
}
实例80 如何使用charAt方法计算重复字符
package Chapter06.string;
import java.util.Scanner;
public class StringDemo_02 {
public static void main(String[] args) {
System.out.println("String类中的charAt方法的使用实例如下:");
String str = "ifsagdsfdsdfdfsa";
System.out.println("请输入一个字符:");
Scanner sc = new Scanner(System.in); // 创建Scanner对象
char ch = sc.next().charAt(0); // 从键盘中输入的字符串中选取第一个字符
int num = 0; // 计算字符数量和
for (int i = 0; i < str.length(); i++) { // 利用for循环依次获取字符与字符ch进行比较,如果相等,num自动加1
if (str.charAt(i) == ch)
num++;
}
System.out.println("该字符串中" + ch + "的数量为:" + num);
}
}
实例81 按字母顺序比较大小
package Chapter06.string;
public class StringDemo_03 {
public static void main(String[] args) {
String str0 = "girl"; // 创建String类对象str0,并对其进行初始化
String str1 = "gOod"; // 创建String类对象str1,并对其进行初始化
int n = str0.compareTo(str1); // 使用compareTo方法进行两个字符串的比较
int n1 = str0.compareToIgnoreCase(str1); // 使用compareToIgnoreCase方法进行两个字符串的比较
System.out.println("使用compareTo方法比较的结果如下:");
System.out.println(n > 0 ? str0 + "大于" + str1 : str0 + "小于" + str1);
System.out.println("使用compareToIgnoreCase方法比较的结果如下:");
System.out.println(n1 > 0 ? str0 + "大于" + str1 : str0 + "小于" + str1);
}
}
实例82 首尾相连
package Chapter06.string;
public class StringDemo_04 {
public static void main(String[] args) {
System.out.println("String类的concat方法使用的示例如下:");
String s = "abcd";
String s1 = "efgh";
String s2 = "ijklm";
s = s.concat(s1); // 调用concat方法,将s1追加到s的后面
s = s.concat(s2); // 调用concat方法,将s2追加到s的后面
System.out.println("最后的结果是 s=" + s);
}
}
实例83 字符串间的比较
package Chapter06.string;
public class StringDemo_05 {
public static void main(String[] args) {
String str = "admin";
String str1 = "admin";
String str2 = "ADMIN";
System.out.println("使用equals判断两个字符串是否相等:");
if (str.equals(str1)) {// 在不忽略大小写的情况下比较str和str1是否相等
System.out.println(str + "与" + str1 + "相等吗?结果为true");
} else {
System.out.println(str + "与" + str1 + "相等吗?结果为false");
}
if (str.equals(str2)) {// 在不忽略大小写的情况下比较str和str2是否相等
System.out.println(str + "与" + str2 + "相等吗?结果为true");
} else {
System.out.println(str + "与" + str2 + "相等吗?结果为false");
}
System.out.println("\n使用equalsIgnoreCase判断两个字符串是否相等:");
if (str.equalsIgnoreCase(str1)) {// 在忽略大小写的情况下比较str和str1是否相等
System.out.println(str + "与" + str1 + "相等吗?结果为true");
} else {
System.out.println(str + "与" + str1 + "相等吗?结果为false");
}
if (str.equalsIgnoreCase(str2)) {// 在忽略大小写的情况下比较str和str2是否相等
System.out.println(str + "与" + str2 + "相等吗?结果为true");
} else {
System.out.println(str + "与" + str2 + "相等吗?结果为false");
}
}
}
实例84 字符集的解码方法
package Chapter06.string;
public class StringDemo_06 {
public static void main(String[] args) throws Exception {
// ISO8859-1:拉丁文
System.out.println("ISO8859-1字符集与gb2312之间的转换:");
String str = new String("大家好".getBytes("gb2312"), "ISO8859-1"); // 将gb2312字符集转码为ISO8859-1字符集
String str1 = new String(str.getBytes("ISO8859-1"), "gb2312"); // 将ISO8859-1字符集转码为gb2312字符集
System.out.println("ISO8859-1字符集:" + str + "\ngb2312字符集:" + str1);
// KOI8:俄文
System.out.println("\nKOI8字符集与gb2312之间的转换:");
String str2 = new String("你好".getBytes("gb2312"), "KOI8"); // 将gb2312字符集转码为KOI8字符集
String str3 = new String(str2.getBytes("KOI8"), "gb2312"); // 将KOI8字符集转码为gb2312字符集
System.out.println("KOI8字符集:" + str2 + "\ngb2312字符集:" + str3);
// Big5:繁体中文
System.out.println("\nBig5字符集与gb2312之间的转换:");
String str4 = new String("谢谢你".getBytes("gb2312"), "Big5"); // 将gb2312字符集转码为Big5字符集
String str5 = new String(str4.getBytes("Big5"), "gb2312"); // 将Big5字符集转码为gb2312字符集
System.out.println("Big5字符集:" + str4 + "\ngb2312字符集:" + str5);
// ISO8859-5:西里尔文
System.out.println("\nISO8859-5字符集与gb2312之间的转换:");
String str6 = new String("美丽的中国".getBytes("gb2312"), "ISO8859-5"); // 将gb2312字符集转码为ISO8859-5字符集
String str7 = new String(str6.getBytes("ISO8859-5"), "gb2312"); // 将ISO8859-5字符集转码为gb2312字符集
System.out.println("ISO8859-5字符集:" + str6 + "\ngb2312字符集:" + str7);
}
}
实例85 寻找指定字符第一次出现的位置
package Chapter06.string;
public class StringDemo_07 {
public static void main(String[] args) {
System.out.println("String类的indexOf方法的使用示例如下:");
String str = "Looking for the first time in the specified character position";
int a = str.indexOf("f".codePointAt(0)); // 返回第一次出现指定字符的Unicode代码处的索引
int b = str.indexOf("a"); // 返回字符a第一次出现的位置
int c = str.indexOf("p".codePointAt(0), 3); // 返回从指定的索引开始搜索,第一次出现指定字符的Unicode代码的索引
int d = str.indexOf("m", 5); // 返回指定字符从指定的索引处开始,第一次出现的索引
System.out.println("a = " + a + " str.charAt(a)=" + str.charAt(a));
System.out.println("b = " + b + " str.charAt(b)=" + str.charAt(b));
System.out.println("c = " + c + " str.charAt(c)=" + str.charAt(c));
System.out.println("d = " + d + " str.charAt(d)=" + str.charAt(d));
}
}
实例86 寻找指定字符最后出现的位置
package Chapter06.string;
public class StringDemo_08 {
public static void main(String[] args) {
System.out.println("String类的lastIndexOf方法的使用示例如下:");
String str = "Characters to find the specified location last seen";
int a = str.lastIndexOf("d".codePointAt(0)); // 返回最后一次出现指定字符的Unicode代码处的索引
int b = str.lastIndexOf("a"); // 返回字符a最后一次出现的位置
int c = str.lastIndexOf("i".codePointAt(0), 23);// 返回从指定的索引向前开始搜索,最后一次出现指定字符的Unicode代码的索引
int d = str.lastIndexOf("e", 25);// 返回指定字符从指定的索引处从右向左开始搜索,最后一次出现的索引
System.out.println("a = " + a + " str.charAt(a)=" + str.charAt(a));
System.out.println("b = " + b + " str.charAt(b)=" + str.charAt(b));
System.out.println("c = " + c + " str.charAt(c)=" + str.charAt(c));
System.out.println("d = " + d + " str.charAt(d)=" + str.charAt(d));
}
}
实例87 我究竟有多长
package Chapter06.string;
public class StringDemo_09 {
public static void main(String[] args) {
System.out.println("String类的length方法的使用示例如下:");
String str = "kdflsakflsdfjsahdksl;fjsksdlkf;fl";
int len = str.length();
System.out.println("字符串:\n" + str + "的长度为:" + len);
}
}
实例88 替换指定的字符
package Chapter06.string;
public class StringDemo_10 {
public static void main(String[] args) {
String str = "我很欣赏你,因为你是个好人";
String newStr = str.replace('你', '他'); // 调用replace方法,将字符串str中的字符'你'换成'他'
System.out.println("替换前的字符串的内容如下:\n " + str);
System.out.println("\n替换后的字符串的内容如下:\n " + newStr);
}
}
实例89 分割字符串
package Chapter06.string;
public class StringDemo_11 {
public static void main(String[] args) {
String str = "One:and:Two:is:Three";
String[] s = str.split(":");
String[] s1 = str.split(":", 2);
String[] s2 = str.split(":", 6);
String[] s3 = str.split(":", -2);
System.out.println("str.split(\":\")的结果如下:");
for (int i = 0; i < s.length; i++) {
System.out.print(" " + s[i]);
}
System.out.println("\nstr1.split(\":\",2)的结果如下:");
for (int i = 0; i < s1.length; i++) {
System.out.print(" " + s1[i]);
}
System.out.println("\nstr2.split(\":\",6)的结果如下:");
for (int i = 0; i < s2.length; i++) {
System.out.print(" " + s2[i]);
}
System.out.println("\nstr3.split(\":\",-2)的结果如下:");
for (int i = 0; i < s3.length; i++) {
System.out.print(" " + s3[i]);
}
}
}
实例90 如何使用substring方法截取子串
package Chapter06.string;
public class StringDemo_12 {
public static void main(String[] args) {
String str = "I am a student and he is a teacher";
String sub1 = str.substring(19); // 返回一个从指定索引处开始截取的新字符串
String sub2 = str.substring(0, 14); // 返一个从索引为0开始截取到索引为14结束的新字符串
System.out.println("str.substring(19)的结果为:\n " + sub1);
System.out.println("str.substring(0, 14)的结果为:\n " + sub2);
}
}
实例91 分解字符串
package Chapter06.string;
public class StringDemo_13 {
public static void main(String[] args) {
String str = "abcdefghijklmnopqrstuvwxyz";
char[] arr = str.toCharArray(); // 调用String类的toCharArray方法,将字符串转换成字符数组
System.out.println("char型数组arr中的数组元素如下:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
if ((i + 1) % 7 == 0)
System.out.println();
}
}
}
实例92 字母大小写转换
package Chapter06.string;
public class StringDemo_14 {
public static void main(String[] args) {
String s = "HELLO KITTY";
String s1 = "good morning";
System.out.println("大写字母变成小写字母:" + s.toLowerCase());
System.out.println("小写字母变成大写字母:" + s1.toUpperCase());
}
}
实例93 去除多余的空白
package Chapter06.string;
public class StringDemo_15 {
public static void main(String[] args) {
String str = " 你好 ";
String str1 = str.trim(); //将指定字符串的首尾的空白字符去掉
System.out.println("字符串str的字符长度为:"+str.length());
System.out.println("字符串str1的字符长度为:"+str1.length());
}
}
实例94 原始数组类型的String形式
package Chapter06.string;
public class StringDemo_16 {
public static void main(String[] args) {
char[] ch = { 'a', 'A', 'b', 'B', 'c' };
String sb = String.valueOf(true); // boolean转换成String
String sf = String.valueOf(12.50f); // float转换成String
String sd = String.valueOf(15269.00012); // double转换成String
String sc = String.valueOf('\"'); // char转换成String
String si = String.valueOf(456); // int转换成String
String sl = String.valueOf(100202l); // long转换成String
String sch = String.valueOf(ch); // 字符数组转换成String
String sch1 = String.valueOf(ch, 1, 3); // 将部分字符数组转换成String
System.out.println("boolean数据的字符串表示形式:" + sb);
System.out.println("float数据的字符串表示形式: " + sf);
System.out.println("double数据的字符串表示形式: " + sd);
System.out.println("char数据的字符串表示形式: " + sc);
System.out.println("int数据的字符串表示形式: " + si);
System.out.println("long数据的字符串表示形式: " + sl);
System.out.println("字符数组的字符串表示形式: " + sch);
System.out.println("部分字符数组的字符串表示形式: " + sch1);
}
}
实例95 Java合法标识符
package Chapter06.string;
public class StringDemo_17 {
public static boolean isIdentifier(String s) {
// 如果字符串为空或者长度为0,返回false
if ((s == null) || (s.length() == 0)) {
return false;
}
// 字符串中每一个字符都必须是Java标识符的一部分
for (int i = 0; i < s.length(); i++) {
if (!Character.isJavaIdentifierPart(s.charAt(i))) {
return false;
}
}
return true;
}
public static void main(String[] args) {
System.out.println("\"test_1\" 是一个标识符吗? "
+ StringDemo_17.isIdentifier("test_1"));
System.out.println("\"test.1\" 是一个标识符吗? "
+ StringDemo_17.isIdentifier("test.1"));
System.out.println("\"$test\" 是一个标识符吗? "
+ StringDemo_17.isIdentifier("$test"));
System.out.println("\"\u0391test\" 是一个标识符吗? "
+ StringDemo_17.isIdentifier("\u0391test"));
System.out.println("\"\0$var-2\" 是一个标识符吗? "
+ StringDemo_17.isIdentifier("\0$var-"));
}
}
实例96 显示一周各星期的名称
package Chapter06.string;
public class StringDemo_18 {
public static void main(String[] args) {
String week = "日一二三四五六";
System.out.println("第一种方法:");
for (int i = 0; i < week.length(); i++) { // 通过charAt方法获取单个字符
System.out.print("星期" + week.charAt(i) + " ");
}
System.out.println("\n第二种方法:");
for (int i = 0; i < week.length(); i++) { // 通过substring方法获取单个字符
String c = week.substring(i, i + 1);
System.out.print("周" + c + " ");
}
}
}
实例97 构造空心方框
package Chapter06.string;
import java.util.Scanner;
public class StringDemo_19 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入宽为:");
int w = sc.nextInt() ;// 从键盘中获取w的值
System.out.println("请输入高为:");
int h = sc.nextInt(); // 从键盘中获取h的值
drawArea(w, h);
}
public static void drawArea(int w, int h) {
for (int i = w; i > 0; i--) { // 画长度为w的第一条边
System.out.print("#");
}
System.out.println();
for (int i = h - 2; i > 0; i--) { // 画由"#"和空格组成的空心框
System.out.print("#");
for (int j = w - 2; j > 0; j--) {
System.out.print(" ");
}
System.out.print("#");
System.out.println();
}
for (int i = w; i > 0; i--) { // 画长度为w的第二条边
System.out.print("#");
}
System.out.println();
}
}
实例98 这一天是星期几
package Chapter06.string;
import java.util.Scanner;
public class StringDemo_20 {
public static void main(String[] args) {
System.out.println("请输入参数,多个参数以逗号分开:");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String arr[] = str.split(",");
switch (arr.length) {// 根据数组的长度来决定掉用哪个方法
case 1:
System.out.println(arr[0] + "年是"
+ year(Integer.valueOf(arr[0]).intValue()));
break;
case 2:
System.out.println(arr[0]
+ "年"
+ arr[1]
+ "月有"
+ month(Integer.valueOf(arr[0]).intValue(), Integer
.valueOf(arr[1]).intValue()) + "天");
break;
case 3:
System.out.println(arr[0]
+ "年"
+ arr[1]
+ "月"
+ arr[2]
+ "日是星期"
+ day(Integer.valueOf(arr[0]).intValue(), Integer.valueOf(
arr[1]).intValue(), Integer.valueOf(arr[2])
.intValue()));
break;
default:
System.out.println("您输入的参数有误!");
}
}
public static String year(int y) {// 判断该年是不是闰年
String leap = (y % 400 == 0 || y % 4 == 0 && y % 100 != 0) ? "闰年"
: "平年";
return leap;
}
public static int month(int y, int m) {// 计算指定年份的某个月有多少天
System.out.println(m);
int days = 0;
String leap = year(y);
if (m > 7) {
if (m % 2 == 0) {
days = 31;
} else {
days = 30;
}
} else {
if (m % 2 == 0) {
days = 31;
} else {
days = 30;
}
if (m == 2 && leap.equals("闰年")) {
days = 29;
} else if (m == 2 && leap.equals("平年")) {
days = 28;
}
}
return days;
}
public static String day(int y, int m, int d) {// 求出某年某月某日的这一天是星期几
if (m == 1 || m == 2) {
m += 12;
y--;
}
int week = d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400
+ 1;
week = week % 7;
String w = "日一二三四五六".substring(week, week + 1);
return w;
}
}
实例99 大小写互换
package Chapter06.string;
public class StringDemo_21 {
public static void main(String[] args) {
String str = "Miss Li is a Teacher,Cycling to work every morning";
System.out.println("原字符串如下:\n " + str);
char arr[] = str.toCharArray(); // 将字符串转化成char型数组
for (int i = 0; i < arr.length; i++) {
if (arr[i] >= 65 && arr[i] < 91) { // 判断是否是大写字母
arr[i] = (arr[i] + "").toLowerCase().charAt(0); // 如果是将当前字符的值由大写变小写
} else if (arr[i] >= 97 && arr[i] < 123) { // 判断是否是小写字母
arr[i] = (arr[i] + "").toUpperCase().charAt(0); // 如果是将当前字符的值由小写变大写
}
}
String s = new String(arr); // 将char型数组转换成字符串
System.out.println("大小写字母互换后的字符串如下:\n " + s);
}
}
实例100 输出指定范围的素数
package Chapter06.string;
public class StringDemo_22 {
static int[] a = null;
static int b = 0;
private static boolean isPrime(int n){//判断n是素数的方法
for(int i=2;i<n;i++){
if(n%i==0)
return false;
}
return true;
}
public static void main(String[] args) {
System.out.println("50和" + "300之间的所有素数如下:");
for(int i=50;i<=300;i++){
if(isPrime(i)==true){
System.out.print(i+"\t");
b++;
if(b%5==0){
System.out.println();
}
}
}
}
}
实例101 我出现了几次
package Chapter06.string;
public class StringDemo_22 {
static int[] a = null;
static int b = 0;
private static boolean isPrime(int n){//判断n是素数的方法
for(int i=2;i<n;i++){
if(n%i==0)
return false;
}
return true;
}
public static void main(String[] args) {
System.out.println("50和" + "300之间的所有素数如下:");
for(int i=50;i<=300;i++){
if(isPrime(i)==true){
System.out.print(i+"\t");
b++;
if(b%5==0){
System.out.println();
}
}
}
}
}
实例102 算术表达式求值器
package Chapter06.string;
public class StringDemo_24 {
public static final int NULL_MARK = 0; // 标记为空或者结束符
public static final int SEPARATION_MARK = 1; // 标记为分隔符
public static final int VAR_MARK = 2; // 标记为变量
public static final int NUM_MARK = 3; // 标记为数字
public static final int GRAMMAR_Exception = 0; // 语法错误
public static final int UNEND_Exception = 1; // 括号没有结束错误
public static final int NULLEXP_Exception = 2; // 表达式为空错误
public static final int BYZERO_Exception = 3; // 被0除错误
public static final String[] MESSAGES_Exception = { "语法错误", "大括号没有成对错误",
"表达式为空错误", "被0除错误" };
public static final String END = "\0"; // 表达式的结束标记
private String expre; // 表达式字符串
private int position; // 求值器当前指针在表达式中的位置
private String current; // 求值器当前处理的标记
private int currentType; // 求值器当前处理标记的类型
private double varArray[] = new double[26]; // 变量的数组
/** 求值一个表达式,返回表达式的值。 */
public double analysis(String str) throws Exception {
double result;
this.expre = str;
this.position = 0;
// 获取第一个标记
this.getMark();
if (this.current.equals(END)) {
// 没有表达式异常
this.proce_Exception(NULLEXP_Exception);
}
result = this.proce_Evalua(); // 处理赋值语句
// 处理完赋值语句,应该就是表达式结束符,如果不是,则返回异常
if (!this.current.equals(END)) {
this.proce_Exception(GRAMMAR_Exception);
}
return result;
}
private double proce_Evalua() throws Exception {
double result; // 结果
int var_Index; // 变量下标
String oldMark; // 旧标记
int oldMarkType; // 旧标记的类型
// 如果标记类型是变量
if (this.currentType == VAR_MARK) {
// 保存当前标记
oldMark = new String(this.current);
oldMarkType = this.currentType;
// 取得变量的索引,本求值器只支持一个字目的变量,
// 如果用户的变量字母长度大于1,则取第一个字母当作变量
var_Index = Character.toUpperCase(this.current.charAt(0)) - 'A';
// 获得下一个标记
this.getMark();
// 如果当前标记不是等号=
if (!this.current.equals("=")) { // 判断当前表达式是否是赋值运算
this.rollBack(); // 回滚
// 不是一个赋值语句,将标记恢复到上一个标记
this.current = new String(oldMark);
this.currentType = oldMarkType;
} else {
// 如果当前标记是等号=,即给变量赋值,形式如a = 3 + 5;
// 则计算等号后面表达式的值,然后将得到的值赋给变量
this.getMark();
// 因为加减法的优先级最低,所以计算加减法表达式。
result = this.arith_AddExpre();
// 将表达式的值赋给变量,并存在实例变量vars中。
this.varArray[var_Index] = result;
return result;
}
}
return this.arith_AddExpre(); // 调用arith_AddExpre方法,进行加减法计算表达式的值。
}
private double arith_AddExpre() throws Exception {
char op; // 操作符
double result; // 结果
double partialResult; // 当前子表达式的结果
result = this.arith_MulExpre(); // 调用arith_MulExpre方法获取当前子表达式的值
// 当前标记的第一个字母是加减号,则继续进行加减法运算。
while ((op = this.current.charAt(0)) == '+' || op == '-') {
this.getMark(); // 取下一个标记
partialResult = this.arith_MulExpre(); // 调用arith_MulExpre方法获取当前子表达式的值
switch (op) {
case '-':
// 如果是减法,则用已处理的子表达式的值减去当前子表达式的值
result = result - partialResult;
break;
case '+':
// 如果是加法,用已处理的子表达式的值加上当前子表达式的值
result = result + partialResult;
break;
}
}
return result;
}
private double arith_MulExpre() throws Exception {
char op; // 运算符
double result; // 表达式结果
double currentResult; // 子表达式的结果
// 用指数运算计算当前子表达式的值
result = this.indexExpre();
// 如果当前标记的第一个字母是乘、除或者取模运算符,则继续进行乘除法运算。
while ((op = this.current.charAt(0)) == '*' || op == '/' || op == '%') {
this.getMark(); // 取下一个标记
// 用指数运算计算当前子表达式的值
currentResult = this.indexExpre();
switch (op) {
case '*':
// 如果是乘法,则用已处理子表达式的值乘以当前子表达式的值
result = result * currentResult;
break;
case '/':
// 如果是除法,判断当前子表达式的值是否为0,如果为0,则抛出被0除异常
// 除数不能为0
if (currentResult == 0.0) {
this.proce_Exception(BYZERO_Exception);
}
// 除数不为0,则进行除法运算
result = result / currentResult;
break;
case '%':
// 如果是取模运算,也要判断当前子表达式的值是否为0
// 如果为0,则抛出被0除异常
if (currentResult == 0.0) {
this.proce_Exception(BYZERO_Exception);
}
// 进行取模运算
result = result % currentResult;
break;
}
}
return result;
}
private double unaryOperator() throws Exception {
double result; // 表达式结果
String op; // 运算符
op = "";
// 如果当前标记类型为分隔符,而且分隔符的值等于+或者-。
if ((this.currentType == SEPARATION_MARK) && this.current.equals("+")
|| this.current.equals("-")) {
op = this.current;
this.getMark();
}
// 用括号运算计算当前子表达式的值
result = this.parenthesis();
if (op.equals("-")) {
// 如果操作符为-,则表示负数,将子表达式的值变为负数
result = -result;
}
return result;
}
private double parenthesis() throws Exception {
double result; // 表达式结果
if (this.current.equals("(")) { // 如果当前标记为左括号,则表示是一个括号运算
this.getMark(); // 取下一个标记
result = this.arith_AddExpre(); // 调用arith_AddExpre方法
// 判断括圆括号是否匹配,如果当前标记不等于右括号,抛出括号不匹配异常
if (!this.current.equals(")")) {
this.proce_Exception(UNEND_Exception);
}
this.getMark(); // 否则取下一个标记
} else {
// 如果标记不是左括号,表示不是一个括号运算,则调用varNumber方法
result = this.varNumber();
}
return result;
}
private double varNumber() throws Exception {
double result = 0.0; // 结果
switch (this.currentType) {
case NUM_MARK:
// 如果当前标记类型为数字
try {
// 将数字的字符串转换成数字值
result = Double.parseDouble(this.current);
} catch (NumberFormatException exc) {
this.proce_Exception(GRAMMAR_Exception);
}
this.getMark(); // 取下一个标记
break;
case VAR_MARK:
// 如果当前标记类型是变量,则取变量的值
result = this.seekVar(current);
this.getMark();
break;
default:
this.proce_Exception(GRAMMAR_Exception);
break;
}
return result;
}
private double seekVar(String vname) throws Exception {
// 判断是否有语法异常发生,如果变量的第一个字符不是字母,则抛出语法异常
if (!Character.isLetter(vname.charAt(0))) {
proce_Exception(GRAMMAR_Exception);
return 0.0;
}
// 从实例变量数组varArray中取出该变量的值
return varArray[Character.toUpperCase(vname.charAt(0)) - 'A'];
}
private double indexExpre() throws Exception {
double result; // 表达式结果
double currentResult; // 子表达式的值
double ex; // 指数的底数
int t; // 指数的幂
result = this.unaryOperator(); // 调用unaryOperator方法,获取当前表达式中的底数值
if (this.current.equals("^")) { // 如果当前标记为"^"运算符,则为指数计算
// 获取下一个标记,即获取指数的幂
this.getMark();
currentResult = this.indexExpre();
ex = result;
if (currentResult == 0.0) {
// 如果指数的幂为0,则指数的值为1
result = 1.0;
} else {
// 否则,指数的值为个数为指数幂的底数相乘的结果。
for (t = (int) currentResult - 1; t > 0; t--) {
result = result * ex;
}
}
}
return result;
}
private void rollBack() {
if (this.current == END) {
return;
}
// 求值器当前指针往前移动
for (int i = 0; i < this.current.length(); i++) {
this.position--;
}
}
private void proce_Exception(int errorType) throws Exception {
// 遇到异常情况时,根据错误类型,取得异常提示信息,将提示信息封装在异常中抛出
throw new Exception(MESSAGES_Exception[errorType]);
}
private void getMark() {
// 设置初始值
this.currentType = NULL_MARK;
this.current = "";
// 判断表达式是否结束,如果求值器当前指针等于字符串的长度则表示表达式已经结束
if (this.position == this.expre.length()) {
this.current = END; // 如果表达式已经结束,则设置当前标记的置为END。
return;
}
while (this.position < this.expre.length() // 当遇到表达式中的空白符则跳过
&& Character.isWhitespace(this.expre.charAt(this.position))) {
++this.position;
}
if (this.position == this.expre.length()) { // 判断当前表达式是否结束
this.current = END;
return;
}
char currentChar = this.expre.charAt(this.position); // 取得求值器当前指针指向的字符
if (isSepara(currentChar)) { // 如果当前字符是一个分隔符,则认为这是一个分隔符标记,
this.current += currentChar; // 给当前标记和标记类型赋值,并将指针后移
this.position++;
this.currentType = SEPARATION_MARK;
} else if (Character.isLetter(currentChar)) {// 判断当前字符是否是一个字母
while (!isSepara(currentChar)) { // 依次求值该变量的组成部分,直到遇到一个分隔符为止
this.current += currentChar;
this.position++;
if (this.position >= this.expre.length()) {
break;
} else {
currentChar = this.expre.charAt(this.position);
}
}
this.currentType = VAR_MARK; // 设置标记类型为变量
} else if (Character.isDigit(currentChar)) { // 判断当前字符是否是一个数字
while (!isSepara(currentChar)) { // 依次求值该数字的组成部分,直到遇到一个分隔符为止
this.current += currentChar;
this.position++;
if (this.position >= this.expre.length()) {
break;
} else {
currentChar = this.expre.charAt(this.position);
}
}
this.currentType = NUM_MARK; // 设置标记类型为数字
} else {
// 如果是无法识别的字符,则设置表达式结束
this.current = END;
return;
}
}
private boolean isSepara(char c) {
if ((" +-/*%^=()".indexOf(c) != -1))
return true;
return false;
}
public static void main(String[] args) throws Exception {
StringDemo_24 sd24 = new StringDemo_24();
double a = 15.0, b = 7.0;
String express1 = "a = 15.0";
System.out.println("表达式1:(\"a = 15.0\") = " + sd24.analysis(express1));
String express2 = "b = 7.0";
System.out.println("表达式2:(\"b = 7.0\") = " + sd24.analysis(express2));
String express3 = "(a+b) * (a-b)";
System.out.println("表达式3:(\"(" + a + "+" + b + ") * (" + a + "-" + b
+ ")\") = " + sd24.analysis(express3));
String express4 = "2*6-7/2";
System.out.println("表达式4:(\"2*6-7/2\") = " + sd24.analysis(express4));
String express5 = "(8-3)*((a+b)/(a-b))";
System.out.println("表达式5:(\"(8-3)*((" + a + "+" + "+" + b + ")/(" + a
+ "-" + b + "))\") = " + sd24.analysis(express5));
String express6 = "13 % 2";
System.out.println("表达式6:(\"13%2\") = " + sd24.analysis(express6));
String express7 = "4^3 * 8 + 2";
System.out
.println("表达式7:\"3^2 * 5 + 4\") = " + sd24.analysis(express7));
}
}
实例103 字符串对齐调整器
package Chapter06.string;
public class StringDemo_25 {
public static final int LEFT = 0; // 左对齐格式
public static final int CENTER = 1; // 居中格式
public static final int RIGHT = 2; // 右对齐格式
private int format; // 当前对齐格式
private int maxLength; // 一行的最大长度
/** 默认构造函数 */
public StringDemo_25() {
// 默认为居中对齐,一行的最大长度为80
this.format = CENTER;
this.maxLength = 80;
}
/** 构造一个字符串对齐器,需要传入一行的根据最大长度和对齐的格式。 */
public StringDemo_25(int maxLength, int format) {
this(); // 首先构造一个默认字符串对齐器
// 根据传入参数修改字符串对齐器的属性
this.setFormat(format);
this.setMaxLength(maxLength);
}
/** 将字符串按指定的对齐格式进行齐 */
public String format(String s) {
StringBuffer where = new StringBuffer();
// 获得一个新长度为行最大长度和s长度的较小值
int wLength = Math.min(s.length(), this.maxLength);
String w = s.substring(0, wLength); // 根据新长度从待对齐的字符串s中获取一个子串
switch (this.format) { // 根据对齐模式,选择空格的合适的位置
case RIGHT:
// 如果是右对齐,则空格放在左边
addSpace(where, maxLength - wLength);
// 将字符串添加在右边
where.append(w);
break;
case CENTER:
// 居中对齐,将空格字符平均分在字符串两边。
int start = where.length();
addSpace(where, (maxLength - wLength) / 2);
where.append(w);
addSpace(where, (maxLength - wLength) / 2);
// 调整舍入误差
addSpace(where, maxLength - (where.length() - start));
break;
case LEFT:
// 右对齐,将空格字符放在字符串右边。
where.append(w);
addSpace(where, maxLength - wLength);
break;
}
// 如果原字符串的长度大于一行的最大长度,则将余下部分放入下一行
if (s.length() > wLength) {
String remainStr = s.substring(wLength);
where.append("\n" + this.format(remainStr));
}
return where.toString();
}
/** 追加空格字符。 */
protected final void addSpace(StringBuffer to, int howMany) {
for (int i = 0; i < howMany; i++)
to.append(" ");
}
public int getFormat() {
return format;
}
/** 设置对齐的格式 */
public void setFormat(int format) {
switch (format) {
case LEFT:
case CENTER:
case RIGHT:
this.format = format;
break;
default:
System.out.println("无效的对齐格式");
}
}
public int getMaxLength() {
return maxLength;
}
/** 设置字符串一行中最多可以显示的字符数 */
public void setMaxLength(int maxLength) {
if (maxLength < 0) {
System.out.println("最大长度的值必须大于0.");
} else {
this.maxLength = maxLength;
}
}
public static void main(String[] args) {
System.out.println("字符的居中对齐方式如下:");
StringDemo_25 formatter = new StringDemo_25(15, StringDemo_25.CENTER);// 一行最多15个字符,居中显示
System.out.println(formatter.format("123456"));
System.out.println(formatter.format(Integer.toString(56)));
System.out.println(formatter.format("abcdefghijklmnopqrstuvwxyz"));
System.out.println("\n字符的左对齐方式如下:");
formatter = new StringDemo_25(15, StringDemo_25.LEFT); // 一行最多15个字符,左对齐显示
System.out.println(formatter.format("&%54$$"));
System.out.println(formatter.format(Integer.toString(83)));
System.out.println(formatter.format("abcdefghijklmnopqrstuvwxyz"));
System.out.println("\n字符的右对齐方式如下:"); // 一行最多15个字符,右对齐显示
formatter = new StringDemo_25(15, StringDemo_25.RIGHT);
System.out.println(formatter.format("123456"));
System.out.println(formatter.format(Integer.toString(8)));
System.out.println(formatter.format("abcdefghijklmnopqrstuvwxyz"));
}
}
实例104 字符串的加密
package Chapter06.string;
import java.security.MessageDigest;
public class StringDemo_26 {
private final static String[] hexArray = { "0", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "a", "b", "c", "d", "e", "f" }; // 存储十六进制值的数组
/** 根据指定的字符串,创建加密后的字符串 */
public static String createEncrypPassword(String string) {
return encrypByMD5(string);
}
/** 检验输入的密码是否正确 */
public static boolean verificationPassword(String password, String string) {
if (password.equals(encrypByMD5(string))) {
return true;
} else {
return false;
}
}
/** 对指定的字符串进行MD5加密 */
private static String encrypByMD5(String originString) {
if (originString != null) {
try {
// 创建具有MD5算法的信息摘要
MessageDigest md = MessageDigest.getInstance("MD5");
// 使用指定的字节数组对摘要进行最后更新,然后完成摘要计算
byte[] results = md.digest(originString.getBytes());
// 将得到的字节数组变成字符串返回
String resultString = byteArrayToHex(results);
return resultString.toUpperCase();
} catch (Exception ex) {
ex.printStackTrace();
}
}
return null;
}
/** 将字节数组转换成16进制,并以字符串的形式返回 */
private static String byteArrayToHex(byte[] b) {
StringBuffer resultSb = new StringBuffer();
for (int i = 0; i < b.length; i++) {
resultSb.append(byteToHex(b[i]));
}
return resultSb.toString();
}
/** 将一个字节转换成16进制,并以字符串的形式返回 */
private static String byteToHex(byte b) {
int n = b;
if (n < 0)
n = 256 + n;
int d1 = n / 16;
int d2 = n % 16;
return hexArray[d1] + hexArray[d2];
}
public static void main(String[] args) {
String password = StringDemo_26.createEncrypPassword("hahaxiao1984");
System.out.println("对password=hahaxiao1984使用MD5算法加密后的字符串如下:\n "
+ password);
String string = "hahaxiao1999";
System.out.println("hahaxiao1999是正确的密码吗?"
+ StringDemo_26.verificationPassword(password, string));
string = "hahaxiao1984";
System.out.println("hahaxiao1984是正确的密码吗?"
+ StringDemo_26.verificationPassword(password, string));
}
}
实例105 使用正则表达式验证电话号码的格式
package Chapter06.string;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class StringDemo_27 {
private static String REG_EXP = "^([0-9]{3}-?[0-9]{8})|([0-9]{4}-?[0-9]{7})$";
/** 使用String类中的matches方法利用正则表达式匹配的方法 */
public static boolean useMatches(String phoneNum) {
if (phoneNum != null) {
return phoneNum.matches(REG_EXP);
} else {
return false;
}
}
/** 使用Pattern的compile方法和Matcher的matcher方法共同匹配 */
public static boolean usePattern(String phoneNum) {
Pattern p = Pattern.compile(REG_EXP);
// 创建一个Matcher,并进行精确匹配
Matcher m = p.matcher(phoneNum);
return m.matches();
}
public static void main(String[] args) {
String phoneNum = "210-12345678";
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.useMatches(phoneNum));
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.usePattern(phoneNum));
phoneNum = "210-12345678";
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.useMatches(phoneNum));
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.usePattern(phoneNum));
phoneNum = "0439-1234567";
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.useMatches(phoneNum));
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.usePattern(phoneNum));
phoneNum = "010-88888888888";
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.useMatches(phoneNum));
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.usePattern(phoneNum));
phoneNum = "04ff-666ab##5";
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.useMatches(phoneNum));
System.out.println(phoneNum + " 是一个合法的电话号码格式吗? "
+ StringDemo_27.usePattern(phoneNum));
}
}