Java 字符串处理

定义字符串：

在 Java 中定义一个字符串最简单的方法是用双引号把它包围起来。

这种用双引号括起来的一串字符实际上都是 String 对象，如字符串"Hello"在编译后即成为 String 对象。

因此也可以通过创建 String 类的实例来定义字符串。

不论使用哪种形式创建字符串，字符串对象一旦被创建，其值是不能改变的，但可以使用其他变量重新赋值的方式进行更改。

直接定义字符串：

String str="Hello Java";

或者：

String str;
str="Heilo Java";

用 String 类定义

在 Java 中每个双引号定义的字符串都是一个 String 类的对象。因此，可以通过使用 String 类的构造方法来创建字符串，该类位于 java.lang 包中，作用域是 final。

String 类的构造方法有多种重载形式，每种形式都可以定义字符串。下面介绍最常用的几种形式。

1. String()

初始化一个新创建的 String 对象，表示一个空字符序列。

2. String(String original)

初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列。换句话说，新创建的字符串是该参数字符串的副本。例如：

String str1=new String("Hello Java");
String str2=new String(str1);

这里 str1 和 str2 的值是相等的。

3. String(char[ ]value)

分配一个新的字符串，将参数中的字符数组元素全部变为字符串。该字符数组的内容已被复制，后续对字符数组的修改不会影响新创建的字符串。例如：

char a[]={'H','e','l','l','0'};
String sChar=new String(a);
a[1]='s';

上述 sChar 变量的值是字符串"Hello"。 即使在创建字符串之后，对 a 数组中的第 2 个元素进行了修改，但未影响 sChar 的值。

4. String(char[] value,int offset,int count)

分配一个新的 String，它包含来自该字符数组参数一个子数组的字符。offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。该子数组的内容已被赋值，后续对字符数组的修改不会影响新创建的字符串。例如：

 

char a[]={'H','e','l','l','o'};
String sChar=new String(a,1,4);
a[1]='s';

 上述 sChar 变量的值是字符串"Hello"。该构造方法使用字符数组中的部分连续元素来创建字符串对象。offset 参数指定起始索引值，count 指定截取元素的个数。创建字符串对象后，即使在后面修改了 a 数组中第 2 个元素的值，对 sChar 的值也没有任何影响。

连接字符串：

使用 concat() 方法

在 Java 中，String 类的 concat() 方法实现了将一个字符串连接到另一个字符串的后面。concat() 方法语法格式如下：

字符串 1.concat(字符串 2);

执行结果是字符串 2 被连接到字符串 1 后面，形成新的字符串。

例 2

如 concat() 方法的语法所示，concat() 方法一次只能连接两个字符串，如果需要连接多个字符串，需要调用多次 concat() 方法。

下面创建一个实例代码来演示如何使用 concat() 方法连接多个字符串。

public static void main(String[] args)
{
    String info="三国演义、";
    info=info.concat("西游记、");
    info=info.concat("水漭传、");
    info=info.concat("红楼梦");
    System.out.println(info);
    String cn="中国";
    System.out.println(cn.concat("北京").concat("海淀区").concat("人民公园"));
}

执行该段代码，输出的结果如下所示。

三国演义、西游记、水浒传、红楼梦
中国北京海淀区人民公园

连接其他类型数据

前面介绍的例子都是字符串与字符串进行连接，其实字符串也可同其他基本数据类型进行连接。如果将字符串同这些数据类型数据进行连接，此时会将这些数据直接转换成字符串。

例 3

编写一个 Java 程序，实现将字符串与整型、浮点型变量相连并输出结果。实现代码如下：

public static void main(String[] args)
{
    String book="三国演义";    //字符串
    int price=59;    //整型变量
    float readtime=2.5f;    //浮点型变量
    System.out.println("我买了一本图书，名字是："+book+"
价格是："+price+"
我每天阅读"+readtime+"小时");
}

述代码实现的是将字符串变量 book 与整型变量 price 和浮点型变量 readtime 相连后将结果输出。在这里定义的 price 和 readtime 都不是字符串，当它们与字符串相连时会自动调用自身的 toString() 方法将其转换成字符串形式，然后再参与连接运算。因此，程序运行后的结果如下所示：

我买了一本图书，名字是：三国演义
价格是：59
我每天阅读2.5小时

假设将本例中的输出语句修改为如下形式：

System.out.println("我买了一本图书，名字是："+book+"
 价格是："+price+"
我每天阅读"+(price+readtime)+"小时");

因为运算符具有优先级，而圆括号的优先级最高，所以先计算 price 与 readtime 的和，再将结果转换成字符串进行连接。此时的运行结果如下所示：

我买了一本图书，名字是：三国演义
价格是：59
我每天阅读61.5小时

获取字符串长度（length()）

在 Java 中，要获取字符串的长度，可以使用 String 类的 length() 方法，其语法形式如下：

字符串名.length();

例 1

在学生信息管理系统中对管理员密码有这样的规定，即密码长度必须大于 6 位且小于 12 位。因为密码太短容易被破解，太长的话又不容易记住。这就需要首先获取用户输入的密码字符串，然后调用 length() 方法获取长度，再做进一 步的长度判断，最终实现代码如下所示：

 public static void main(String[] args)
    {
        String sys="学生信息管理";//字义一个字符串表示系统名称
        System.out.println("欢迎进入《"+sys+"》系统");//输出系统名称
        System.out.println("请设置一个管理员密码：");
        Scanner input=new Scanner(System.in);
        String pass=input.next();//获取用户输入的密码
        int length=pass.length();//获取密码的长度
        if(length>6&&length<12)
        {
            System.out.println("密码长度符合规定。");
            System.out.println("已生效，请牢记密码："+pass);
        }
        else if(length>=12)
            System.out.println("密码过长。");
        else
            System.out.println("密码过短。");
    }

上述代码将用户输入的密码保存到字符串变量 pass 中，再调用 pass.length() 方法将长度保存到 length 变量，然后使用 if 语句根据长度给出提示。

运行程序，当输入的密码过短时，运行结果如下所示：

欢迎进入《学生信息管理》系统
请设置一个管理员密码：
123456
密码过短。

当输入的密码符合规定时，运行结果如下所示：

欢迎进入《学生信息管理》系统
请设置一个管理员密码：
abc12345678
密码长度符合规定。
已生效，请牢记密码：abc12345678

转换大小写（toLowerCase()和toUpperCase()）

String 类的 toLowerCase() 方法可以将字符串中的所有字符全部转换成小写，而非字母的字符不受影响。语法格式如下：

字符串名.toLowerCase()    //将字符串中的字母全部转换为小写，非字母不受影响

toUpperCase() 则将字符串中的所有字符全部转换成大写，而非字母的字符不受影响。语法格式如下：

字符串名.toUpperCase()    //将字符串中的字母全部转换为大写，非字母不受影响

例如：

String str="abcdef 我 ghijklmn";
System.out.println(str.toLowerCase());    //输出：abcdef 我 ghijklmn
System.out.println(str.toUpperCase());    //输出：ABCDEF 我 GHIJKLMN

例 1

下面的实例代码演示了如何对字符串应用大写和小写转换。

 

public static void main(String[] args)
{
    String en="The Day You Went Away";    //定义原始字符串
    System.out.println("原始字符串："+en);
    System.out.println("使用 toLowerCase() 方法之后为："+en.toLowerCase());
    System.out.println("使用 toUpperCase() 方法之后为："+en.toUpperCase());
    
    en="sun sun 是太阳，圆圆挂在 SKY 上";    //定义原始字符串
    System.out.println("原始字符串："+en);
    System.out.println("使用 toLowerCase() 方法之后为："+en.toLowerCase());
    System.out.printIn("使用 toUpperCase() 方法之后为："+en.toUpperCase());
    
    en="select id,name,sex,address,birthday from students";
    System.out.println("原始字符串："+en);    //定义原始字符串
    System.out.println("使用 toLowerCase() 方法之后为："+en.toLowerCase());
    System.out.println("使用 toUpperCase() 方法之后为："+en.toUpperCase());
}

代码比较简单，运行后的输出结果如下：

原始字符串：The Day You Went Away
使用 toLowerCase() 方法之后为：the day you went away
使用 toUpperCase() 方法之后为：THE DAY YOU WENT AWAY
原始字符串：sun sun 是太阳，圆圆挂在 SKY 上
使用 toLowerCase() 方法之后为：sun sun 是太阳，圆圆挂在 sky 上
使用 toUpperCase() 方法之后为：SUN SUN 是太阳，圆圆挂在 SKY 上
原始字符串：select id,name,sex,address,birthday from students
使用 toLowerCase() 方法之后为：select id,name,sex,address,birthday from students
使用 toUpperCase() 方法之后为：SELECT ID,NAME,SEX,ADDRESS,BIRTHDAY FROM STUDENTS

去除空格（trim()）

字符串中存在的首尾空格一般情况下都没有任何意义，如字符串" Hello"，但是这些空格会影响到字符串的操作，如连接字符串或比较字符串等，所以应该去掉字符串中的首尾空格，这需要使用 String 类提供的 trim() 方法。

trim() 方法的语法形式如下：

字符串名.trim()

使用 trim() 方法的示例如下：

String str=" hello ";
System.out.println(str.length());    //输出 9
System.out.println(str.trim().length());    //输出 5

提取子字符串（substring()）

String 类的 substring() 方法用于对字符串进行提取，该方法主要有两种重载形式，下面分别介绍。

1. substring(int beginIndex) 形式

此方式用于提取从索引位置开始至结尾处的字符串部分。调用时，括号中是需要提取字符串的开始位置，方法的返回值是提取的字符串。例如：

String str="我爱 Java 编程";
String result=str.substring(3);
System.out.println(result);    //输出：Java 编程

2. substring(int beginIndex，int endIndex) 形式

此方法中的 beginIndex 表示截取的起始索引，截取的字符串中包括起始索引对应的字符；endIndex 表示结束索引，截取的字符串中不包括结束索引对应的字符，如果不指定 endIndex，则表示截取到目标字符串末尾。该方法用于提取位置 beginIndex 和位置 endIndex 位置之间的字符串部分。

这里需要特别注意的是， 对于开始位置 beginIndex， Java 是基于字符串的首字符索引为 0 处理的，但是对于结束位置 endIndex，Java 是基于字符串的首字符索引为 1 来处理的，如图 1 所示。

图1 字符串中的字符索引

注意：substring() 方法是按字符截取，而不是按字节截取。

例 1

创建一个字符串，对它使用 substring() 方法进行截取并输出结果。示例代码如下：

 

public static void main(String[] args)
{
    String day="Today is Monday";    //原始字符串
    System.out.println("substring(0)结果："+day.substring(0));
    System.out.println("substring(2)结果："+day.substring(2));
    System.out.println("substring(10)结果："+day.substring(10));
    System.out.println("substring(2,10)结果："+day.substring(2,10));
    System.out.println("substring(0,5)结果："+day.substring(0,5));
}

输出结果如下所示：

substring(0)结果：Today is Monday
substring(2)结果：day is Monday
substring(10)结果：onday
substring(2,10)结果：day is M
substring(0,5)结果：Today

分割字符串（spilt()）

String 类的 split() 方法可以按指定的分割符对目标字符串进行分割，分割后的内容存放在字符串数组中。该方法主要有如下两种重载形式：

str.split(String sign)
str.split(String sign,int limit)

其中，str 为需要分割的目标字符串；sign 为指定的分割符，可以是任意字符串；limit 表示分割后生成的字符串的限制个数，如果不指定，则表示不限制，直到将整个目标字符串完全分割为止。

例 1

使用 split() 方法对字符串进行分割的实例如下：

public static void main(String[] args)
{
    String Colors="Red,Black,White,Yellow,Blue";
    String[] arr1=Colors.split(",");    //不限制元素个数
    String[] arr2=Colors.split(",",3);    //限制元素个数为3
    System.out.println("所有颜色为：");
    for(int i=0;i<arr1.length;i++)
    {
        System.out.println(arr1[i]);
    }
    System.out.println("前三个颜色为：");
    for(int j=0;j<arr2.length;j++)
    {
        System.out.println(arr2[j]);
    }
}

输出结果如下：

所有颜色为：
Red
Black
White
Yellow Blue
前三个颜色为：
Red
Black
White,Yellow,Blue

截取新闻标题

下面编写 Java 代码，实现使用字符串的 substring() 方法来截取新闻标题并以列表的形式显示的功能。代码如下：

public class Test09
{
    public static void main(String[] args)
    {
         String[] news=new String[]
         {
                "如何快速掌握Java",
                "听老王剖析Java中的运算符",
                "学习Java的十大忠告",
                "你所不知道的java网络编程技巧大全",
                "Java面试题大全",
         };    //定义存储新闻标题的数组
        String title="************* 新闻列表 *************";
        System.out.println(title.substring(10,30));
        System.out.println("----------------------------------------------");
        /*
        *循环遍历数组截取数组元素中的前10个字符作为列表展示
        */
        for(int i=0;i<news.iength;i++)
        {
            //判断数组元素的长度是否大于10，如果大于，则截取，否则全部显示
            if(news[i].length()>10)
            {
                System.out.println(news[i].substring{0,10)+"…";
            }
            else
            {
                System.out.println(news[i]);
            }
        }
    }
}

运行该程序，输出的结果如下所示。

************* 新闻列表 *************
如何快速掌握Java
听老王剖析java中…
学习Java的十大忠…
你所不知道的java…
Java面试题大全

字符串的替换（replace()、replaceFirst()和replaceAll()）

在 Java 中，String 类提供了 3 种字符串替换方法，分别是 replace()、replaceFirst() 和 replaceAll()，本文将详细介绍它们的使用方法。

replace() 方法

replace() 方法用于将目标字符串中的指定字符（串）替换成新的字符（串），其语法格式如下：

字符串.replace(String oldChar, String newChar)

其中，oldChar 表示被替换的字符串；newChar 表示用于替换的字符串。replace() 方法会将字符串中所有 oldChar 替换成 newChar。

例 1

创建一个字符串，对它使用 replace() 方法进行字符串替换并输出结果。代码如下：

public static void main(String[] args)
{
    String words="hello java,hello php";
    System.out.println("原始字符串是'"+words+"'");
    System.out.println("replace("l","D")结果："+words.replace("l","D"));
    System.out.println("replace("hello","你好")结果："+words.replace("hello","你好 "));
    words="hr's dog";
    System.out.println("原始字符串是'"+words+"'");
    System.out.println("replace("r's","is")结果："+words.replace("r's","is"));
}

输出结果如下所示：

原始字符串是'hello java,hello php'
replace("l","D")结果：heDDo java,heDDo php
replace("hello”,"你好")结果：你好 java,你好 php 原始字符串是"hr's dog'
replace("r's","is")结果：his dog

replaceFirst() 方法

replaceFirst() 方法用于将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串，其语法形式如下：

字符串.replaceFirst(String regex, String replacement)

其中，regex 表示正则表达式；replacement 表示用于替换的字符串。例如：

String words="hello java,hello php";
String newStr=words.replaceFirst("hello","你好 ");
System.out.println(newStr);    //输出：你好 java,hello ph

replaceAll() 方法

replaceAll() 方法用于将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串，其语法形式如下：

字符串.replaceAll(String regex, String replacement)

其中，regex 表示正则表达式，replacement 表示用于替换的字符串。例如：

String words="hello java,hello php";
String newStr=words.replaceAll("hello","你好 ");
System.out.println(newStr);    //输出：你好 java,你好 php

字符串的比较（equals()、equalsIgnoreCase()和compareTo()

equals() 方法

equals() 方法将逐个地比较两个字符串的每个字符是否相同。对于字符的大小写，也在检查的范围之内。equals() 方法的语法格式如下：

字符串1.equals(字符串2);

例如：

String str1="abc";
String str2=new String("abc");
String str3="ABC";
System.out.println(str1.equals(str2));    //输出 true
System.out.println(str1.equals(str3));    //输出 false

例 1

在第一次进入系统时要求管理员设置一个密码，出于安全考虑密码需要输入两次，如果两次输入的密码一致才生效，否则提示失败。具体实现代码如下：

public static void main(String[] args)
    {
        String sys="学生信息管理";
        System.out.println("欢迎进入《"+sys+"》系统");
        System.out.println("请设置一个管理员密码：");
        Scanner input=new Scanner(System.in);
        String pass=input.next();    //设置密码
        System.out.println("重复管理员密码：");
        input=new Scanner(System.in);
        String pass1=input.next();    //确认密码
        if(pass.equals(pass1))
        {   //比较两个密码
            System.out.println("已生效，请牢记密码："+ pass);
        }
        else
        {
            System.out.println("两次密码不一致，请重新设置。");
        }
    }

运行该程序，由于 equals() 方法区分大小写，所以当两次输入的密码完全一致时，equals() 方法返回 true，输出结果如下所示：

欢迎进入《学生信息管理》系统
请设置一个管理员密码：
abcdef
重复管理员密码：
abcdef
已生效，请牢记密码：abcdef

否则输出如图下所示的结果：

欢迎进入《学生信息管理》系统
请设置一个管理员密码：
abcdef
重复管理员密码：
aBcdef
两次密码不一致，请重新设置。

equalsIgnoreCase() 方法

equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同，唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。例如：

String str1="abc";
String str2="ABC";
System.out.println(str1.equalsIgnoreCase(str2));    //输出 true

例 2

在会员系统中需要输入用户名和密码进行检验，下面使用 equalsIgnoreCase() 方法实现检验登录时不区分用户名和密码的大小写，具体的代码实现如下所示。

public static void main(String[] args)
{
    String sys="学生信息管理";
    System.out.println("欢迎进入《"+sys+"》系统");
    System.out.println("请输入管理员名称：");
    Scanner input=new Scanner(System.in);
    String name=input.next();    //获取用户输入的名称
    System.out.println("请输入管理员密码：");
    input=new Scanner(System.in);
    String pass=input.next();    //获取用户输入的密码
    //比较用户名与密码，注意此处忽略大小写
    if(name.equalsIgnoreCase("admin")&&pass.equalsIgnoreCase("somboy"))
    {   //验证
        System.out.println("登录成功。");
    }
    else
    {
        System.out.println("登录失败。");
    }
}

在上述代码中，由于使用 equalsIgnoreCase() 方法进行比较，所以会忽略大小写判断。因此输入 ADMIN 和 SOMBOY 也会验证通过，如下所示：

欢迎进入《学生信息管理》系统
请输入管理员名称：
ADMIN
请输入管理员密码：
SOMBOY
登录成功。

否则输出结果如下所示：

欢迎进入《学生信息管理》系统
请输入管理员名称：
admin
请输入管理员密码：
sommboy
登录失败。

compareTo() 方法

compareTo() 方法用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。compareTo() 方法的语法格式如下：

str.compareTo(String otherstr);

它会按字典顺序将 str 表示的字符序列与 otherstr 参数表示的字符序列进行比较。如果按字典顺序 str 位于 otherster 参数之前，比较结果为一个负整数；如果 str 位于 otherstr 之后，比较结果为一个正整数；如果两个字符串相等，则结果为 0。

提示：如果两个字符串调用 equals() 方法返回 true，那么调用 compareTo() 方法会返回 0。

例 3

编写一个简单的 Java 程序，演示 compareTo() 方法比较字符串的用法，以及返回值的区别。代码如下：

public static void main(String[] args)
{
    String str="A";
    String str1="a";
    System.out.println("str="+str);
    System.out.println("str1="+str1);
    System.out.println("str.compareTo(str1)的结果是："+str.compareTo(str1));
    System.out.println("str1.compareTo(str)的结果是："+str1.compareTo(str));
    System.out.println("str1.compareTo('a')的结果是："+str1.compareTo("a"));
}

上述代码定义了两个字符串"A"和"a"， 然后调用 compareTo() 方法进行相互比较。最后一行代码拿"a"与"a"进行比较，由于两个字符串相同比较结果为 0。运行后的输出结果如下：

str=A
str1=a
str.compareTo(str1)的结果是：-32
str1.compareTo(str)的结果是：32
str1.compareTo('a')的结果是：0

查找字符串（indexOf()、lastlndexOf()和charAt()）

字符串查找分为两种形式：一种是在字符串中获取匹配字符（串）的索引值，另一种是在字符串中获取指定索引位置的字符。

根据字符查找

String 类的 indexOf() 方法和 lastlndexOf() 方法用于在字符串中获取匹配字符（串）的索引值。

1. indexOf() 方法

indexOf() 方法用于返回字符（串）在指 定字符串中首次出现的索引位置，如果能找到，则返回索引值，否则返回 -1。该方法主要有两种重载形式：

str.indexOf(value)
str.indexOf(value,int fromIndex)

其中，str 表示指定字符串；value 表示待查找的字符（串）；fromIndex 表示查找时的起始索引，如果不指定 fromIndex，则默认从指定字符串中的开始位置（即 fromIndex 默认为 0）开始查找。

例如，下列代码在字符串"Hello Java”中查找字母 v 的索引位置。

String s="Hello Java";
int size=s.indexOf('v');    //size的结果为8

上述代码执行后 size 的结果为 8，它的查找过程如图 1 所示。

图1 indexOf() 方法查找字符过程

例 1

编写一个简单的 Java 程序，演示 indexOf() 方法查找字符串的用法，并输出结果。代码如下：

public static void main(String[] args)
{
    String words="today,monday,sunday";
    System.out.println("原始字符串是'"+words+"'");
    System.out.println("indexOf("day")结果："+words.indexOf("day"));
    System.out.println("indexOf("day",5)结果："+words.indexOf("day",5));
    System.out.println("indexOf("o")结果："+words.indexOf("o"));
    System.out.println("indexOf("o",6)结果："+words.indexOf("o",6));
}

运行后的输出结果如下：

原始字符串是'today,monday,sunday'
indexOf("day")结果：2
indexOf("day",5)结果：9
indexOf("o")结果：1
indexOf("o",6)结果：7

2. lastlndexOf() 方法

lastIndexOf() 方法用于返回字符（串）在指定字符串中最后一次出现的索引位置，如果能找到则返回索引值，否则返回 -1。该方法也有两种重载形式：

str.lastIndexOf(value)
str.lastlndexOf(value, int fromIndex)

注意：lastIndexOf() 方法的查找策略是从右往左查找，如果不指定起始索引，则默认从字符串的末尾开始查找。

例 2

编写一个简单的 Java 程序，演示 lastIndexOf() 方法查找字符串的用法，并输出结果。代码如下：

public static void main(String[] args)
{
    String words="today,monday,Sunday";
    System.out.println("原始字符串是'"+words+"'");
    System.out.println("lastIndexOf("day")结果："+words.lastIndexOf("day"));
    System.out.println("lastIndexOf("day",5)结果："+words.lastIndexOf("day",5));
    System.out.println("lastIndexOf("o")结果："+words.lastIndexOf("o"));
    System.out.println("lastlndexOf("o",6)结果："+words.lastIndexOf("o",6));
}

运行后的输出结果如下：

原始字符串是'today,monday,Sunday'
lastIndexOf("day")结果：16
lastIndexOf("day",5)结果：2
lastIndexOf("o")结果：7
lastlndexOf("o",6)结果：1

根据索引查找

String 类的 charAt() 方法可以在字符串内根据指定的索引查找字符，该方法的语法形式如下：

字符串名.charAt(索引值)

charAt() 方法的使用示例如下：

String words="today,monday,sunday";
System.out.println(words.charAt(0));    //结果：t
System.out.println(words.charAt(1));    // 结果：o
System.out.println(words.charAt(8));    // 结果：n

校验文件名和邮箱地址

假设，在作业提交系统中学生需要录入提交的 Java 文件名称及要提交到的邮箱地址，那么就需要对学生输入的这些信息进行校验，判断输入是否有误。校验的规则为：录入的文件名称必须以“.java”结尾，录入的邮箱地址中必须包含有“@”符号和“.”符号，且“@”在“.”之前。

在这里使用 String 类中的 indexOf() 方法、charAt() 方法和 lastIndexOf() 方法来完成此程序。具体实现代码如下：

 

import java.util.Scanner;
public class Testl7
{
    public static void main(String[] args)
    {
        boolean filecon=false;    //判断文件名是否合法
        boolean emailcon=false;    //判断邮箱地址是否合法
        System.out.println("************ 欢迎进入作业提交系统 ************");
        Scanner input=new Scanner(System.in);
        System.out.println("请输入要提交的Java文件名称：");
        String name=input.next();    //获取输入的Java文件名
        System.out.println("请输入要提交到的邮箱地址：");
        String email=input.next();    //获取输入的邮箱地址
        //检查输入的文件名是否合法
        int index=name.lastIndexOf('.');    // 获取"n"所在的位置
        //判断合法
        if(index!=-1&&name.charAt(index+1)=='j'
                    &&name.charAt(index+2)=='a'
                    &&name.charAt(index+3)=='v'
                    &&name.charAt(index+4)=='a')
        {
            filecon=true;
        }
        else
        {
            System.out.println("输入的文件名无效！");
        }
        //检查邮箱地址是否合法
        if(email.indexOf('@')!=1&&email.indexOf('.')>email.indexOf('@'))
        {
            emailcon=true;
        }
        else
        {
            System.out.println("输入的邮箱地址无效!");
        }
        //输出校验的结果
        if(filecon&&emailcon)
        {
            System.out.println("作业提交成功!");
        }
        else
        {
            System.out.println("作业提交失败!");
        }
    }
}

运行该程序，当用户输入的文件名是以“.java”结尾，并且输入的邮箱地址中包含有“@”符号和符号，符号在符号之后，才能检测通过，打印“作业提交成功！”， 如下所示：

************ 欢迎进入作业提交系统 ************
请输入要提交的Java文件名称：
answer.java
请输入要提交到的邮箱地址：
answer@qq.com
作业提交成功!

否则，打印“作业提交失败！”，如下所示：

************ 欢迎进入作业提交系统 ************
请输入要提交的Java文件名称：
abcjava
请输入要提交到的邮箱地址：
abcjava@qqcom
输入的文件名无效！
输入的邮箱地址无效!
作业提交失败!

在该程序中，首先使用 lastlndexOf() 方法获取用户输入 Java 文件中的所在的位置。因为 Java 文件是以“.java”结尾的，因此，可以使用 charAt() 方法来检测“.”之后的字符串是否是 java，即通过如下所示的条件判断表达式即可判断出用户输入的 Java 文件名是否以“.java”结尾。

index!=-1&&name.charAt(index+1)='j'
         &&name.charAt(index+2)='a'
         &&name.charAt(index+3)='v'
         &&name.charAt(index+4)='a'

在检测邮箱地址是否合法时，首先使用了 indexOf() 方法判断用户输入的邮箱地址中是否含有符号，然后判断邮箱地址中的符号是否在“@”符 号之后，如果这两个条件都满足，则邮箱地址是合法的。

当文件名称和邮箱地址的检测都通过时，则打印“作业提交成功！”，否则打印“作业提交失败！”。

批量替换字符串

假设有一段文本里面有很多错误，如错别字。现在使用 Java 中的字符串替换方法对它进行批量修改和纠正，其中用到了 String 类的 replace() 方法、replaceFirst() 方法和 replaceAll() 方法。

创建一个 Java 类，然后在主方法 main() 中编写代码，具体代码如下所示。

public static void main(String[] args)
{
    //定义原始字符串
    String intro="今天时星其天，外面时下雨天。妈米去买菜了，漏网在家写作业。"+"语文作业时”其”写 5 行，数学使第 10 页。";
    //将文本中的所有"时"和"使"都替换为"是"
    String newStrfirst=intro.replaceAll("[时使]","是");
    //将文本中的所有"妈米"改为"妈妈"
    String newStrSecond=newStrFirst.replaceAll("妈米","妈妈");
    //将文本中的所有"漏网"改为"留我"
    String newStrThird=newStrSecond.replaceAll("漏网","留我");
    //将文本中第一次出现的"其"改为"期"
    String newStrFourth=newStrThird.repiaceFirst("[其]","期");
    //输出最终字符串
    System.out.println(newStrFourth);
}

运行该程序，输出的正确字符串内容如下：

今天是星期天，外面是下雨天。妈妈去买菜了，留我在家写作业。语文作业是”其”写 5 行，数学是第 10 页。

替换特殊字符

在本实例中为保证学生输入的 Java 文件名合格，将利用 StringBuffe r类实现对 Java 文件名中的特殊符号进行替换，包括将中文状态下的“。”和全角状态下的替换为英文状态下的。

在本例实现过程中主要使用了 StringBuffer 类的字符查找和替换方法，实现代码如下：

import java.util.Scanner;
public class Test2()
{
    public static void main(String[] args)
    {
        System.out.println("请输入你要提交的Java文件名称：");
        Scanner input=new Scanner(System.in);
        String fileName=input.next();    //获取用户输入的 java 文件名称
        //定义StringBuffer对象，字符串内容为用户输入的java文件名称
        StringBuffer file=new StringBuffer(fileName);
        //获取英文状态下的"."是否存在
        int index=file.lastIndexOf(".");
        //判断中文状态下的"。"和"."是否存在
        int errIndex1=file.lastIndexOf("。");
        int errIndex2=file.lastIndexOf(".");
        if(index!=-1&&file.substring(index+1,file.length()).equals("java"))
        {
            System.out.println("作业提交成功!");
        }
        else if(errIndex1!=-1&&file.substring(errIndex1+1,file.length()).equals("java"))
        {
            //将中文状态下的"。"改为英文状态下的"."
            file.setCharAt(errIndex1,'.');
            System.out.println("你的书写有误，已改正为："+file+"
提交成功！");
        }
        else if(errIndex2!=-1&&file.substring(errIndex2+1,file.length()).equals("java"))
        {
            //将全角状态下的"."改为英文状态下的"."
            file.setCharAt(errIndex2,'.');
            System.out.println("你的书写有误，已改正为："+file+"
提交成功！");
        }
        else
        {
            System.out.println("你提供的java文件名称有误，请核实！");
        }
    }
}

运行该程序，当用户录入的 Java 文件名称中的为中文状态的“。”和“.”时，修改为英文状态下的“.”，然后再进行提交，如下所示：

请输入你要提交的Java文件名称：
myexapmle。java
你的书写有误，已改正为：myexample.java

在该程序中，首先定义了一个 String 类型的变量，并赋值为用户输入的 Java 文件名称。 接着使用 StringBuffer 的 StringBuffer(String str) 构造函数将该变量的值作为 StringBuffer 对象的值，然后获取用户输入字符串中（英文和中文）的位置，紧接着使用多重 if 选择语句判断用户输入的字符串中是否包含英文状态下的，并且后面的字符串是否为“java”，如果条件成立，则表示用户输入的信息无误，提交成功；在 else if 中判断用户输入的字符串中是否包含中文状态下的“。”和“.”，并且“。”和后面的字符串为“java”，如果判断通过，则调用 StringBuffer 类中的 setCharAt() 方法修改“。”为“.”，再提交。

字符串的加密解密

为了保证程序的安全，经常采用数据加密的方法。Java 中提供了专门用于加密运算的类和接口。

除了使用加密类和接口外，还可以通过多种方式实现字符串的加密。其中常用的就是获取字符串的字节数组，之后对字节数组中的每个字节都进行运算，得到新的内容，这时所获得的字符串与原字符串将不相同，以此达到加密的效果；解密时再将加密字符串进行相反的运算，这样即可得到原字符串。

本实例简单介绍如何通过数据运算实现字符串的加密和解密，实现步骤如下。

(1) 创建一个静态的 encryptAndDencrypt() 方法，在该方法中传入两个参数。代码如下：

public static String encryptAndDencrypt(String value, char secret)
{
    byte[] bt=value.getBytes();    //将需要加密的内容转换为字节数组
    for(int i=0;i<bt.length;i++)
    {
        bt[i]=(byte)(bt[i]^(int)secret);    //通过异或运算进行加密
    }
    String newresult=new String(bt,0,bt.length);    //将加密后的字符串保存到 newresult 变量中
    return newresult;
}

上述代码首先将需要加密的内容转换为字节数组，接着遍历字节数组中的内容，在 for 语句中通过异或运算进行加密，然后将加密后的字符串保存到 newresult 变量中。最后返回 newresult 变量的值。

(2) 在 main() 方法中添加代码，接收用户在控制台输入的内容并输出，然后调用 encryptAndUncrypt() 方法对字符串分别进行加密和解密，并将加密和解密后的内容输出。代码如下：

public static void main(String[] args)
{
    Scanner scan=new Scanner(System.in);
    char secret='8';    //加密文字符
    System.out.println("请输入您想加密的内容：");
    String pass=scan.next();
    System.out.println("原字符串内容："+pass);
    String encryptResult=encryptAndDencrypt(pass,secret);
    System.out.println("加密后的内容："+encryptResult);
    String uncryptResult=encryptAndDencrypt(encryptResult,secret);
    System.out.println("解密后的内容："+uncryptResult);
}

(3) 执行上述代码进行测试，如下所示。

请输入您想加密的内容：
hello,java
原字符串内容：hello,java
加密后的内容：P]TTWRYNY
解密后的内容：hello,java

转载网址：http://c.biancheng.net/java/