Java string 点位符用法

前言

Hello！大家好，又来到白哥的小学三年级课堂。今天白哥就来和大家探讨一下Java字符串使用中的一些方法细节。敲黑板，画重点，有人问，咦？白哥开始讲Java了，哈哈哈，没错，在疫情的那些百无聊赖的日子里，白哥，哈哈哈，拓展了Java“业务”，那么今天就请大家随白哥一起进入白哥的小学三年级课堂，来领略一下Java字符串的灵活与风骚。

一、String类

我们知道Java中char型只能存一个字符，不能存字符串。而字符串在Java语言中作为对象来处理，可以通过java.lang包中的String类来创建字符串对象。

import java.util.Scanner;

/**
 * @author Zenan
 */
public class zenanjava2 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String s=new String("/*字符串*/");//开始已经定义确定的字符串
        String s1=new String(in.next());//用户输入想要的字符串
        System.out.println("s = " + s);
        System.out.println("s1 = " + s1);
    }
}

二、字符串处理方法细节

到这里，我们就要进入今天的真正主题了，白哥将为大家带来十二种字符串处理的方法细节，让大家真正玩转Java字符串。话不多说，进入正题。

1. 测字符串长度

使用 Str.length()方法

String k;
        System.out.println("给字符串赋值(测长度):\n");
        k = in.next();
        int length_k = k.length();
        System.out.println("长度为：length_k = " + length_k);

运行结果

2. 搜索某个字符(串)在字符串中的位置

这里提供两个函数(方法)，先介绍indexOf()方法，indexOf()可以找到要找的字符(串)最早出现的位置，而另外一个方法 lastIndexOf()可以找到要找的字符(串)最终一次出现的位置…听到这是不是用些，嗯~~~，不用担心，看代码！

/*使用IndexOf()方法*/
        System.out.println("输入要查找的字符串：\n");
        String indexOf_k = in.next();
        System.out.println("输入要查找的字符串:\n");
        String indexOf_k1 = in.next();
        int indexOf_b = indexOf_k.indexOf(indexOf_k1);
        System.out.println("要找的字符串（最先出现的）位置indexOf_b = " + indexOf_b);

        /*使用LastIndexOf()方法*/
        System.out.println("输入要查找的字符串：\n");
        String lastindexOf_k = in.next();
        System.out.println("输入要查找的字符串:\n");
        String lastindexOf_k1 = in.next();
        int lastindexOf_b = lastindexOf_k.lastIndexOf(lastindexOf_k1);
        System.out.println("要找的字符串（最先出现的）位置lastindexOf_b = " + lastindexOf_b);

运行结果

注意因为lastIndexOf()方法原理是从后向前检索，
故有.length=.lastIndexOf("");

例如

System.out.println("输入要查找的字符串：\n");
        String lastindexOf_k = in.next();
        int lastindexB = lastindexOf_k.length();
        int lastindexB1 = lastindexOf_k.lastIndexOf("");
        System.out.println(lastindexB);
        System.out.println(lastindexB1);

运行结果

3、 定位某个位置是什么字符

使用 Str.charAt(int n)函数(方法)

System.out.println("输入要查找的字符串：\n");
        String charAt_k = in.next();
        System.out.println("输出第几个位置的字符：\n");
        int charAt_n = in.nextInt();
        char mychar = charAt_k.charAt(charAt_n);
        System.out.println("第" + charAt_n + "位置的字符为:" + "mychar = " + mychar);

运行结果

输出第几个位置时注意，位置起始为0，不为1

4、 获取子字符串

使用 Str.subString()函数(方法)

有两种使用方法，第一种 substring(int n),仅输入从某一位开始，获取从该位开始到字符串结束的所有字符

String substring_k = "hello world";
        String substring_k1 = substring_k.substring(3);
        System.out.println("子字符串为:substring_k1 = " + substring_k1);

第二种 substring(int n,int m),指截取从第n位开始，到第m位结束的子字符串

String substring_k2 = substring_k.substring(1, 6);
        System.out.println("子字符串为:substring_k2 = " + substring_k2);

运行结果

5、去除空格（只能出去字符串【首尾】多余的空格）

使用函数(方法) Str.trim()

String trim_k = "   hello  world    ";
        System.out.println("原字符串：weitrim_k = " + trim_k);
        trim_k = trim_k.trim();
        System.out.println("去空格后字符串: trim_k = " + trim_k);

运行结果

6、替换字符

使用函数(方法) Str.replace(str,str)

String replace_k = "hello world";
        System.out.println("原字符串：replace_k = " + replace_k);
        replace_k = replace_k.replace("llo", "W");/*可以将字符（串）替换成字符(串)*/
        System.out.println("变换后的字符串  + replace_k =" + replace_k);
        replace_k = replace_k.replace("o", "q");
        System.out.println("变换后的字符串  + replace_k =" + replace_k);

运行结果

7、判断字符串的开始和结束字符是否正确

使用函数(方法) Str.startsWith()和Str.endsWith()判断开始和结束

String startsWith_k = "hello wourld";
        boolean startsWith_b = startsWith_k.startsWith("hello");
        boolean startWith_b1 = startsWith_k.startsWith("hllo");
        boolean startWith_b2 = startsWith_k.endsWith("l");
        System.out.println("是否以'hello'开始:startsWith_b = " + startsWith_b);
        System.out.println("是否以'hllo'开始:startWith_b1 = " + startWith_b1);
        System.out.println("是否以‘l’结束:startWith_b2 = " + startWith_b2);

运行结果

开始(结束)字符串正确则返回boolean型true,否则返回boolean型false。

8、比较字符串大小的的方法

由于这个问题涉及到循序渐进的过程，所以先来介绍判断两个字符(串)是否一样的函数(方法)。

使用Str.equals()和Str.equalsIgnoreCase()函数(方法)

Str.equals()可以真正的讨论到两字符串是否一样，
而Str.equalsIgnoreCase()则忽略大小写进行讨论

例Str.equals(str)

System.out.println("输入要比较的字符串：\n");
        String equals_k = in.next();
        System.out.println("输入第二个:\n");
        String equals_k1 = in.next();
        boolean equals_b = equals_k.equals(equals_k1);
        System.out.println("两个字符串是否一样:\nequals_b = " + equals_b);
        for (; true; ) {
            int i = 0;
            System.out.println("是否继续测试:(继续测试请按1，不测请按2):\n");
            i = in.nextInt();
            if (i == 1) {
                System.out.println("输入要比较的字符串：\n");
                equals_k = in.next();
                System.out.println("输入第二个:\n");
                equals_k1 = in.next();
                equals_b = equals_k.equals(equals_k1);
                System.out.println("两个字符串是否一样:\nequals_b = " + equals_b);
            } else {
                break;
            }
        }

白哥的代码写为循环形式是为了进行多次测试，核心只有前6行，有兴趣的小盆友可以测试一下白哥的代码，相信你会有别样的收获

运行结果

例Str.equalsIgnoreCase(str) 与Str.equals()一样，核心只有前6行，有兴趣的小盆友可以测试一下白哥的代码，相信你会有别样的收获

System.out.println("输入要比较的字符串：\n");
        String equals_k = in.next();
        System.out.println("输入第二个:\n");
        String equals_k1 = in.next();
        boolean equals_b = equals_k.equalsIgnoreCase(equals_k1);
        System.out.println("两个字符串是否一样:\nequals_b = " + equals_b);
        for (; true; ) {
            System.out.println("输入要比较的字符串：\n");
            equals_k = in.next();
            System.out.println("输入第二个:\n");
            equals_k1 = in.next();
            equals_b = equals_k.equalsIgnoreCase(equals_k1);
            System.out.println("两个字符串是否一样:\nequals_b = " + equals_b);
            System.out.println("是否继续测试:(继续测试请按1，不测请按2):\n");
            int i;
            i = in.nextInt();
            if (i == 2) {
                break;
            }
        }

运行结果

接下来讨论比较比较两个字符串大小的函数(方法) 使用 compareTo()函数 (方法)

Str.compareTo(str)返回值为int型，若为负，则前一字符串小于后一字符串 ,若为正，则前一字符串大于后一字符串,若为0，则相等。

for (; true; ) {
            System.out.println("输入要比较的字符串：\n");
            String compare_k = in.next();
            System.out.println("输入第二个:\n");
            String compare_k1 = in.next();
            int i = compare_k.compareTo(compare_k1);
            System.out.println("两个字符串是否一样:\n i = " + i);
            System.out.println("是否继续测试:(继续测试请按1，不测请按2):\n");
            int j;
            j = in.nextInt();
            if (j == 2) {
                break;
            }
        }

运行结果

9、大写变小写，小写变大写

使用 toLowerCase()将大写变小写，用toupperCase()将小写变大写

String toLowerCase_k = "abc   ABC";
        System.out.println("原字符串:toLowerCase_k = " + toLowerCase_k);
        toLowerCase_k = toLowerCase_k.toLowerCase();
        System.out.println("大写变小写后:toLowerCase_k = " + toLowerCase_k);

        System.out.println();
        String toupperCase_k = "ABC   abc";
        System.out.println("原字符串:toupperCase_k = " + toupperCase_k);
        toupperCase_k = toupperCase_k.toUpperCase();
        System.out.println("小写变大写后:toupperCase_k = " + toupperCase_k);

运行结果

10、 分割字符串

使用Str.split("\分隔符"，int n)函数(方法)

注意因为没有指定的分隔符故使用字符串中的字符作为分隔符，可以指定多个分隔符用|连接，如 “，|.”指用‘，’和‘.’ 分隔字符串。

/*先定义一个字符串*/
 String split_k = "abc ABC hello.would";

Str.split()有两种用法，一种Split("\字符")，指见到这个字符就进行分隔，另一种是Split("\字符"，int n),指见到指见到这个字符就进行分隔，但只将字符串分隔为n段，分隔成n段后则见到这个字符不进行分隔。

由于分隔后字符串被分隔为多个字符串，则用String[] split_k这个字符串数组存每一个字符串。

System.out.println("原字符串为:split_k = " + split_k);
        System.out.println("用空格分隔后：");
        String[] split_k1 = split_k.split("\\ ");
        for (String a : split_k1) {
            System.out.println("[" + a + "]");
        }


        System.out.println("用空格分隔为两段:");
        split_k1 = split_k.split("\\ ", 2);
        for (String a : split_k1) {
            System.out.println("[" + a + "]");
        }


        System.out.println("用‘，’和空格一起分隔：");
        split_k1 = split_k.split("\\.| ");
        for (String a : split_k1
        ) {
            System.out.println("[" + a + "]");
        }


        System.out.println("用‘，’和空格一起分隔为两段:");
        split_k1 = split_k.split("\\.| ", 2);
        for (String a : split_k1
        ) {
            System.out.println("[" + a + "]");
        }


        System.out.println("用‘，’和空格一起分隔为三段:");
        split_k1 = split_k.split("\\.| ", 3);
        for (String a : split_k1
        ) {
            System.out.println("[" + a + "]");
        }


        System.out.println("用‘，’和空格一起分隔为四段:");
        split_k1 = split_k.split("\\.| ", 4);
        for (String a : split_k1
        ) {
            System.out.println("[" + a + "]");
        }


        System.out.println("用‘，’和空格一起分隔为五段:");
        **/*因为最多分隔4段，故分为5段与分为4段，输出结果一样*/**
        split_k1 = split_k.split("\\.| ", 5);
        for (String a : split_k1
        ) {
            System.out.println("[" + a + "]");
        }

这个代码白哥讨论了七种情况，几乎涵盖了Str.split()的所有用法，同学们仔细品，先想出每种情况的答案，然后看接下来的运行结果

运行结果

好了，到这里Java字符串的基本函数(方法)，白哥已经为大家介绍完了，白哥呢也是看到好多小伙伴意犹未尽呀！那接下来就是高级一点的字符串方法啦！一起来学习吧！

11. 格式化字符串

使用 Str.format()函数(方法)

格式为 String 标识符=string.format("%内容的格式",要转换为string格式的内容)，即可将内容转变为string格式

我们先以日期和时间的格式化为例，要进行日期，时间的格式化，Java中给出了日期和时间的对象Date，所以我们需要先创建一个Date对象，再引用它。

Date date = new Date();       //创建一个Date(时间)对象

输出当前的日期（年-月-日）

Date date = new Date();                         //创建一个Date(时间)对象
        String year = String.format("%tY", date);        //%tY 是Date对象中年份的内容的格式
        String mouth = String.format("%tm", date);       //%tm 是Date对象中月份的内容的格式
        String day = String.format("%td", date);         //%td 是Date对象中日的内容的格式
        String all = String.format("%tc", date);         //%tc 是Date对象中所有日期和时间的内容的格式
        System.out.println("year = " + year);
        System.out.println("mouth = " + mouth);
        System.out.println("day = " + day);
        System.out.println("all = " + all);

运行结果(这是白哥此时的时间，你运行的不一定一样哦！！)

输出当前的时间（小时:分钟:秒）

String hour = String.format("%tH", date);         //%tH 是Date对象中小时的内容的格式
        String minute = String.format("%tM", date);       //%tM 是Date对象中分钟的内容的格式
        String second = String.format("%tS", date);       //%tS 是Date对象中秒的内容的格式
        System.out.println("hour = " + hour);
        System.out.println("minute = " + minute);
        System.out.println("second = " + second);
        String all1 = String.format("%tF", date);            //%tF 以年-月-日的格式输出   2020-4-12
        String all2 = String.format("%tT", date);            //%tT 以时:分:秒格式输出    22:15:05
        String all3 = String.format("%tr", date);            //%tr 以12小时制输出    10:15:05   下午
        System.out.println("all1 = " + all1);
        System.out.println("all2 = " + all2);
        System.out.println("all3 = " + all3);

运行结果(这是白哥此时的时间，你运行的不一定一样哦！！)

讨论完日期时间之后，我们讨论其他格式如整形，实型，字符型，注意他们的格式符与C语言一致分别为%d,%f,%s。

String format_k = String.format("%d", 200 / 2);        //因为200/2为整形数据，所以格式符%d要与其匹配
        String format_k1 = String.format("%b", 3 > 5);         //同理于布尔类型匹配
        System.out.println("format_k = " + format_k);
        System.out.println("format_k1 = " + format_k1);

12、字符串生成器

首先定义字符串生成器

StringBuilder builder = new StringBuilder("");

我们知道定义好的字符串如果要加入新的内容可以用"+"来连接，可是如果要连接的数目非常多，则会导致时间过长，系统开销大，例如

String build_k = "";
        long starTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            build_k = build_k + i;
        }
        long endTime = System.currentTimeMillis();
        long time = endTime - starTime;
        System.out.println("string消耗时间:time = " + time);
        starTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            builder.append(i);
        }
        endTime = System.currentTimeMillis();
        time = endTime - starTime;
        System.out.println("Builder消耗时间: time = " + time);

运行结果

由图就可以看出，往String类型中添加多个信息时，时间空间消耗巨大，而用StringBuiler时则会快很多，意思是当我们需要对字符串不断的增加信息时我们需要使用StringBuilder去节约空间时间，所以我们很有必要学习字符串生成器

白哥在这里介绍3个处理字符串生成器的函数(方法)

1. StringBuilder.append(str) 对字符串生成器尾部增加信息
2. StringBuilder. insert(int n,str) 对某一位置处增加信息
3. StringBuilder.delete(int n,int m) 删除n到m-1处的信息
4. StringBuilder. tostring() 最后输出stringBuilder的结果时用tostring函数(方法)

StringBuilder builder1 = new StringBuilder("");
        builder1.append("hello");      /*用append做添加*/
        System.out.println("bulider1 = " + builder1);
        builder1.insert(5, in.next()); /*在某一位置插入数据时，不能在超越原来字符串长度的位置上插入，即原字符串为hello，
        则插入时位置不能超过5,否则报错*/
        System.out.println("bulider1 = " + builder1);
        builder1.delete(3, 6);         /*用dalete做添加*/
        System.out.println("bulider1 = " + builder1);   //两者一样都可以
        System.out.println("builder1.toString = " + builder1.toString());

运行结果

注意用字符串生成器输出时，System.out.println("bulider1 = " + builder1); 这样直接输出和用 System.out.println("builder1.toString = " + builder1.toString());这样使用builder1.toString()函数(方法)输出，结果是一样的。

三、总结

好了，到这里，朋友们，Java字符串应该已经对你没有一点阻碍了，下面就让白哥给你一波一锅汇，将金典浓缩起来，也许他就能成为考试时候的小抄。。。。嗯~~~~，好像是的。

*   str.length()                 str为待测字符串， 返回int值
     *   str.indexOf(str1)            str为待测字符串，str1为参数字符串(要搜索的字符串)，返回int值
     *   str.lastIndexOf(str1)        str为待测字符串，str1为参数字符串(要搜索的字符串)，返回int值
     *   str.charAT(int n)            str为待测字符串，n为参数(定位字符串中的位置)，返回char值
     *   str.substring(int n)         str为待测字符串，n为参数(定位字符串中的位置)，返回string值
     *   str.substring(int n,int m)   str为待测字符串，n与m为参数(定位字符串中的位置)，返回string值
     *   str.trim()                   str为待测字符串，返回string值
     *   str.replace(str1,str2)       str为待测字符串，将str中的str1替换为str2，返回string值
     *   str.startsWith(str1)         str为待测字符串，检验str是否以str1开始，返回boolean值
     *   str.endsWith(str1)           str为待测字符串，检验str是否以str1结束，返回boolean值
     *   str.equals(str1)             str为待测字符串，检验str是否与str1相等，返回boolean值
     *   str.equalsIgnoreCase(str1)   str为待测字符串，检验str是否与str1相等，返回boolean值
     *   str.compareTo(str1)          str为待测字符串，检验str与str1大小，返回int值
     *   str.tolowerCase()            str为待测字符串，返回string值
     *   str.toupperCase()            str为待测字符串，返回string值
     *   str.split("\\字符",int n)    str为待测字符串，以“字符”为分隔符，分隔为n段，返回string[]值
     *   string.format("%内容的格式",要转换为string格式的内容)   返回string值
     *   builder.append("str")        builder为待测字符串生成器，将str加入(添加)到builder中，直接记录在builder中，无返回
     *   builder.insert(int n,str)    builder为待测字符串生成器，将str加入(添加)到builder中的第n位置处，直接记录在builder中，无返回
     *   builder.delete(int n,int m)  builder为待测字符串生成器，将字符串生成器builder中n到m-1位置删除，直接记录在builder中，无返回

哈哈哈哈，有没有感觉要升华了，没有关系，多巩固才能让字符串的应用更加灵活。白哥呢，也会不定期的冒出来，为你传授一下人生哲学。好啦，欢迎来到白哥的小学三年级课堂，这期内容就是这样，期待下期还有你的身影。

参考资料

《Java从入门到精通》 明日科技 著 清华大学出版社