java -的字符串hei

字符串的不可变

String 对象是不可变的。查看 JDK 文档你就会发现，String 类中每一个看起来会修改 String 值的方法，实际上都是创建了一个全新的 String 对象，以包含修改后的字符串内容。而最初的 String 对象则丝毫未动。

其实程序当中所有的双引号字符串都是String 类的对象，即使没有new

特点：

字符串的那日容勇不可变

正是因为字符串不可改变，所以字符是可以共享使用的。

字符串效果是相当于char字符数组，

public class sevenseven {
    public static void main(String[] args) {
        String x = "abcd";
//        每当把 String 对象作为方法的参数时，都会复制一份引用，
//        而该引用所指向的对象其实一直待在单一的物理位置上，从未动过。
        String X = x.toUpperCase();
        System.out.println(x);
        System.out.println(X);
    }
}
/*
abcd
ABCD
 */

public class DemoString {
    public static void main(String[] args) {
        String str1 = new String();
        System.out.println(str1);
//        单引号括起来才是字符，双引号括起来是字符串
        char[] chararray = { 'A' , 'B'};
        String str2 = new String(chararray);
        System.out.println(str2);

        byte[] bytearray = { 99,49,49};
        String str3 = new String(bytearray);
        System.out.println(str3);

//        直接创建
        String str5 = "qqqq";
        System.out.println(str5);
    }
}

结果：

AB
c11
qqqq

字符串的存储

public class DemoString {
    public static void main(String[] args) {
        String str1 ="abc";
        String str2 ="abc";

        char[] charArray = {'a','b','c'};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str3 == str2);
    }
}
//结果:
//        true
//        false
//        false

StringBuilder

用于创建最终的String,可以使用append等方法修改字符串

如果使用String的重载方法+ 的话，每次加都需要建立新的String对象，性能不高

使用 StringBuilder 类的场景：在频繁进行字符串运算（如拼接、替换、和删除等），
并且运行在单线程的环境中，则可以考虑使用 StringBuilder，如 SQL 语句的拼装、JSON 封装等。

StringBuilder 提供了丰富而全面的方法，包括 insert()、replace()、substring()，甚至还有reverse()，但是最常用的还是 append() 和 toString()。还有 delete()

public class sevenseven {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("how ");
        stringBuilder.append("to  ");
        stringBuilder.append("say");
        System.out.println(stringBuilder);
        stringBuilder.delete(0,1);//按字符算
        System.out.println(stringBuilder);
        stringBuilder.deleteCharAt(1);//按字符位置索引
        System.out.println(stringBuilder);

        System.out.println(stringBuilder.reverse());//字符反向
    }
}

字符处理操作：

方法	参数，重载版本	作用
构造方法	默认版本，String，StringBuilder，StringBuffer，char数组，byte数组	创建String对象
length()		String中字符的个数
charAt()	int索引	获取String中索引位置上的char
getChars()，getBytes()	待复制部分的开始和结束索引，复制的目标数组，目标数组的开始索引	复制char或byte到一个目标数组中
toCharArray()		生成一个char[]，包含String中的所有字符
equals()，equalsIgnoreCase()	与之进行比较的String	比较两个String的内容是否相同。如果相同，结果为true
compareTo()，compareToIgnoreCase()	与之进行比较的String	按词典顺序比较String的内容，比较结果为负数、零或正数。注意，大小写不等价
contains()	要搜索的CharSequence	如果该String对象包含参数的内容，则返回true
contentEquals()	与之进行比较的CharSequence或StringBuffer	如果该String对象与参数的内容完全一致，则返回true
isEmpty()		返回boolean结果，以表明String对象的长度是否为0
regionMatches()	该String的索引偏移量，另一个String及其索引偏移量，要比较的长度。重载版本增加了“忽略大小写”功能	返回boolean结果，以表明所比较区域是否相等
startsWith()	可能的起始String。重载版本在参数中增加了偏移量	返回boolean结果，以表明该String是否以传入参数开始
endsWith()	该String可能的后缀String	返回boolean结果，以表明此参数是否是该字符串的后缀
indexOf()，lastIndexOf()	重载版本包括：char，char与起始索引，String，String与起始索引	如果该String并不包含此参数，就返回-1；否则返回此参数在String中的起始索引。lastIndexOf()是从后往前搜索
matches()	一个正则表达式	返回boolean结果，以表明该String和给出的正则表达式是否匹配
split()	一个正则表达式。可选参数为需要拆分的最大数量	按照正则表达式拆分String，返回一个结果数组
join()（Java8引入的）	分隔符，待拼字符序列。用分隔符将字符序列拼接成一个新的String	用分隔符拼接字符片段，产生一个新的String
substring()（即subSequence()）	重载版本：起始索引；起始索引+终止索引	返回一个新的String对象，以包含参数指定的子串
concat()	要连接的String	返回一个新的String对象，内容为原始String连接上参数String
replace()	要替换的字符，用来进行替换的新字符。也可以用一个CharSequence替换另一个CharSequence	返回替换字符后的新String对象。如果没有替换发生，则返回原始的String对象
replaceFirst()	要替换的正则表达式，用来进行替换的String	返回替换首个目标字符串后的String对象
replaceAll()	要替换的正则表达式，用来进行替换的String	返回替换所有目标字符串后的String对象
toLowerCase()，toUpperCase()		将字符的大小写改变后，返回一个新的String对象。如果没有任何改变，则返回原始的String对象
trim()		将String两端的空白符删除后，返回一个新的String对象。如果没有任何改变，则返回原始的String对象
valueOf()（static）	重载版本：Object；char[]；char[]，偏移量，与字符个数；boolean；char；int；long；float；double	返回一个表示参数内容的String
intern()		为每个唯一的字符序列生成一个且仅生成一个String引用
format()	要格式化的字符串，要替换到格式化字符串的参数	返回格式化结果String

当需要改变字符串的内容时，String 类的方法都会返回一个新的 String 对象。同时，如果内容不改变，String 方法只是返回原始对象的一个引用而已。这可以节约存储空间以及避免额外的开销。

字符串格式化输出

System.out.format()

/*
首先将 name 的值插入到 %s 的位置，然后将 age 的值插入到 %d的位置。这些占位符叫做格式修饰符，
它们不仅指明了插入数据的位置，同时还指明了将会插入什么类型的变量，以及如何格式化。
 */

public class FormatOutput {
    public static void main(String[] args) {
        String name = "quan";
        int age = 23;
//        最老的方式
        System.out.println(name + age);
//        新方式
        System.out.format("how to say %s -- %d \n",name,age);

        System.out.printf("how to say %s -- %d",name,age);
    }
}
/*
quan23
how to say quan -- 23
how to say quan -- 23
 */

格式化修饰符

ForMatter

/*
下面通过ForMatter格式话的字符串都存在内部的StringBuffer中
必须通过formatter.toString()进行统一输出
格式：
    %[argument_index$][flags][width][.precision]conversion
    argument_index$：指定对应的内容参数位置，默认按照顺序依次对应。
    flags：格式控制。
    width：区域宽度。
    .precision：对于浮点型数据，表示显示的小数位数；对于字符串数据，表示显示的字符数量。
    conversion：类型转换字符。
 */

格式控制

/*
默认右对齐
有负号 - 左对齐
+       正数前显示正号，负数前显示负好
空格      正数前希纳是控制，负号前显示负好
0       使用0填充剩余位置
逗号      每三位数字添加一个逗号
 */

public class ForMatterT2 {
    private double sum = 0;
    //创建ForMatter 对象f
    private Formatter f = new Formatter(new StringBuilder());
    public  ForMatterT2(){
        f.format("%-15s  %5s %10s%n","item","num","Price");
        f.format("%-15s  %5s %10s%n","++++++","++++++","++++++");
    }

    public void add(String name,int q,double p){
        f.format("%-15.15s  %5d %10.2f%n",name,q,p);
        sum += p*q;
    }

    //最后的结账，得出总价格
    public String build(){
        f.format("%-15s  %5s %10s%n","++++++","++++++","++++++");
        f.format("%-15.15s  %5s %10.2f%n","sum","",sum);
//        最后结算统一输出ForMatter 对象里面的所有的格式化字符串
        f.format("%-15.15s  %5s %,10.2f%n","sum","乘上12038",sum*12038);//逗号      每三位数字添加一个逗号
        return f.toString();
    }

    public static void main(String[] args) {
        ForMatterT2 f2 = new ForMatterT2();
//        加入商品价格字符串
        f2.add("bag",1,45);
        f2.add("big",1,30);
        //一定要使用toString 才能将f里面的格式进行输出
        System.out.println(f2.build());
    }
}
/*
item               num      Price
++++++           ++++++     ++++++
bag                  1      45.00
big                  1      30.00
++++++           ++++++     ++++++
sum                         75.00
sum                    902,850.00
 */

conversion：类型转换字符。

d	整型（十进制）
c	Unicode字符
b	Boolean值
s	String
f	浮点数（十进制）
e	浮点数（科学计数）
x	整型（十六进制）
h	散列码（十六进制）
%	字面值“%”

意，程序中的每个变量都用到了 b 转换。虽然它对各种类型都是合法的，但其行为却不一定与你想
象的一致。对于 boolean 基本类型或 Boolean 对象，其转换结果是对应的 true 或 false。
但是，对其他类型的参数，只要该参数不为 null，其转换结果永远都是 true。即使是数字 0，
转换结果依然为 true，而这在其他语言中（包括C），往往转换为 false。

String.format()

/*
String.format() 是一个 static 方法，它接受与 Formatter.format() 方法一样的参数
，但返回一个 String 对象。
当你只需使用一次 format() 方法的时候，String.format() 用起来很方便。
 */

public class OneFormatException extends Exception{
    public OneFormatException(String name,String how){
        super(String.format("warn  %s   %s",name,how));
    }

    public static void main(String[] args) {
        try{
            throw new OneFormatException("quan","testsomethings");
        }catch (OneFormatException e){
            System.out.println(e);
        }
    }

}
/*
bytes.OneFormatException: warn  quan   testsomethings
 */

正则表达式：

/*
在java中 \\:我要插入一个正则表达式的反斜线，后面的字符具有特殊意义
eg: 想表达一位数字 \\d
eg:普通的反斜线： \\\
一个或多个之前的表达式”，应该使用 +
? 可能存在，
\\W，它的意思是一个非单词字符
（如果 W 小写，\\w，则表示一个单词字符
注意：换行符和制表符致谢的只需要单反斜杠\n \t
 */

public class StringMatch{
    public static void main(String[] args) {
        System.out.println("-23232".matches("-?\\d+"));
        //(-|\+)?\d+ 可能以加号或者减号开头的数字
        System.out.println("+23232".matches("(-|\\+)?\\d+"));
        System.out.println("-23232".matches("(-|\\+)?\\d+"));
        System.out.println("23232".matches("(-|\\+)?\\d+"));
    }

}// all true

public class StringMatch{
    private static String something = "blic static String format(String format, Object... args)" +
            " {return new Formatter().format(format, args).toString()}";
    public static void splitA(String regex){
        System.out.println(Arrays.toString(something.split(regex)));
    }

    public static void main(String[] args) {

        splitA(" ");//以空格分割
        splitA("}");
        splitA("\\W+");//\\W，它的意思是一个非单词字符
        splitA("\\W");//\\W，它的意思是一个非单词字符

    }

}
/*
[blic, static, String, format(String, format,, Object..., args), {return, new, Formatter().format(format,, args).toString()}]
[blic static String format(String format, Object... args) {return new Formatter().format(format, args).toString()]
[blic, static, String, format, String, format, Object, args, return, new, Formatter, format, format, args, toString]
[blic, static, String, format, String, format, , Object, , , , args, , , return, new, Formatter, , , format, format, , args, , toString]
 */

查找并替换：

    public static void main(String[] args) {

      String someth = "{return new Formatter().{format(format";
        System.out.println(someth.replaceFirst("\\{","lalala "));
        System.out.println(someth.replaceAll("format|Format"," rerere "));

    }
    /*
    lalala return new Formatter().{format(format
{return new  rerere ter().{ rerere ( rerere
     */

Pattern 和Matcher

用 static Pattern.compile() 方法来编译你的正则表达式即可。它会根据你的 String 类型的正则表达式生成一个 Pattern 对象

把你想要检索的字符串传入 Pattern 对象的 matcher() 方法。matcher() 方法会生成一个 Matcher 对象

public class TestRegularExpression {
    public static void main(String[] args) {
        String[] argss ={"abcabcdaefafeabc", "abc+","(abc+)"};
        if (argss.length < 2) {
            System.out.println(
                    "Usage:\njava TestRegularExpression " +
                            "characterSequence regularExpression+");
            System.exit(0);
        }
        System.out.println("Input: \"" + argss[0] + "\"");
        for (String arg : argss) {
            System.out.println(
                    "Regular expression: \"" + arg + "\"");
            Pattern p = Pattern.compile(arg);//创建匹配模式p
            Matcher m = p.matcher(argss[0]); //通过匹配模式对象的方法matcher创建匹配器m
            while (m.find()) {//find是否可以匹配得到，返回布尔值
                System.out.println(
                        "Match \"" + m.group() + "\" at positions " +
                                m.start() + "-" + (m.end() - 1));
            }
        }
    }
}

Pattern 对象表示编译后的正则表达式
已编译的 Pattern 对象上的 matcher() 方法，加上一个输入字符串，从而共同构造了一个 Matcher 对象
static boolean matches(String regex, CharSequence input)

matcher对象中的方法：

boolean find() 尝试找到匹配模式的输入序列的下一个子序列。
boolean lookingAt() 尝试将输入序列从区域开头开始与模式相匹配。
boolean matches() 尝试将整个区域与模式进行匹配
String group() 返回与上一个匹配匹配的输入子序列。  

正则表达式的组：

（A（B）C）:

0 组：ABCD

1 组：BC

2组：C

public class MatcherTest {
    public static void main(String[] args) {
        String string="BCCDIJFOIWJoefjlwfeDBCCjwoiCCfj";
        String strP = "(B(CC))";
        Pattern p = Pattern.compile(strP);
        Matcher m = p.matcher(string);
        while (m.find()){
            System.out.println(m.group());//返回前一次匹配操作第0组
            System.out.println(m.groupCount());//返回该匹配器的模式中的分组数目
            System.out.println(m.group(2));//返回前一次匹配操作期间指定的组号
            System.out.println(m.start(1));//返回在前一次匹配操作中寻找到的组的起始索引
            //返回在前一次匹配操作中寻找到的组的最后一个字符索引加一的值。
            System.out.println(m.end(1));//
            System.out.println(m.matches());//全员匹配
        }
    }

}
/*
BCC
2
CC
0
3
false
BCC
2
CC
20
23
false
 */

替换操作

reset()

通过 reset() 方法，可以将现有的 Matcher 对象应用于一个新的字符序列：

正则表达式与 Java I/O