Java中关于字符串的操作

1.String类

在Java语言中将字符串作为对象来管理，因此可以像创建其他类对象一样来创建字符串对象

String 被修饰为final,所以是不能被继承的

immutable 是指不可改变的
比如创建了一个字符串对象
String garen =“盖伦”;
不可改变的具体含义是指：
不能增加长度
不能减少长度
不能插入字符
不能删除字符
不能修改字符
一旦创建好这个字符串，里面的内容 永远 不能改变

String 的表现就像是一个常量

1.1 创建字符串

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        //1. String(char a[])
        char []a={'a','b','c','d','e','f','g','h'};
        String s1=new String(a);//等价于String s=new String("abcdefgh");

        //2. String(char a[],int offset,int length)
        //offset:表示开始截取字符串的位置
        //length:表示截取字符串的长度
        String s2=new String(a,2,4);

        //3.
        String s3,s4;
        s3="fdsfsafsdfsaf";
        s4="fdsafinf;dsiant";
        System.out.println(s2);
    }
}

1.2 获取字符串信息

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {

        char []a={'a','b','c','d','e','f','a','g','h'};
        String s=new String(a);
        //1.获取字符串长度
        int len=s.length();


        //2.字符串查找
        //indexOf():返回的是搜索的字符或者字符串首次出现的位置
        //lastIndeof():方法返回的是搜索字符或者字符串最有一次出现的位置
        int id1=s.indexOf("a");
        int id2=s.lastIndexOf("a");


        //3.获取指定索引位置的字符
        //charAt()
        char ch=s.charAt(4);
    }
}

1.3 字符串操作

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {

        char []a={' ','a','b','c',' ','d','e','f','a','g','h'};
        String s=new String(a);
        //1.获取子字符串
        //substring(int beginIndex):从beginIndex指定某一索引处开始截取字符串
        String t=s.substring(5);

        //substring(int beginIndex,int endIndex):
        //返回的是某一索引位置开始截取到某一索引位置结束的字串
        String tt=s.substring(2,4);




        //2.去除空格
        //trim()方法返回字符串的副本，忽略前导空格和尾部空格
        //只是前导和后导
        String ttt=s.trim();


        //3.字符串替换
        //replace()方法可以实现将指定的字符或字符串替换成新的字符或者字符串
        //replace(char oldChar,char newChar)
        //多次出现会全部替换
        String tttt=s.replace("a","A");

        //4.判断字符串的开始和结尾
        //startsWith()  endsWith() 分别用于判断字符串是否以指定的内容开始或结束，返回都是boolean类型
        boolean flag1=s.startsWith("a");
        boolean flag2=s.endsWith("h");


        //5.判断字符串是否相等
        //对字符串对象进行比较不能简单地使用比较运算符"=="，因为比较运算符比较的是两个字符串的地址是否相等，即使俩个
        //字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false
        //5.1 equals()方法
        String str=new String("abcde");
        boolean flag3=s.equals(str);//如果俩个字符串具有相同的字符和长度，则会返回true
        //5.2 s.equalsIgnoreCase(str);是忽略大小写的比较是否相同

        //6. 按字典顺序比较两个字符串
        //compareTo() >返回正整数  =返回0  <返回负整数
        int ha=s.compareTo(str);


        //7. 字母大小写转换
        //数字或非字符不受影响
        String t1=s.toLowerCase();
        String t2=s.toUpperCase();

        //8. 字符串分割
        //使用split()方法可以使字符串按指定的分割字符或字符串对内存进行分割，并将分割后的结果
        //存在放在字符串数组中，
        //该方法可根据给定的分割符对字符串进行拆分
        //split(String signt)
        //该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数
        //split(String signt,int limit)
        String ss="192.168.0.1";
        //按照"."进行两次分割，使用转义字符"\\"
        String []array=ss.split("\\.");
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        System.out.println(flag3);
    }
}

1.4 格式化字符串

String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。熟悉C语言的同学应该记得C语言的sprintf()方法，两者有类似之处。

String.format()字符串常规类型格式化的两种重载方式

format(String format, Object… args) 新字符串使用本地语言环境，制定字符串格式和参数生成格式化的新字符串。

format(Locale locale, String format, Object… args) 使用指定的语言环境，制定字符串格式和参数生成格式化的字符串。

转换符	详细说明	示例
%s	字符串类型	“你好啊伙计”
%c	字符类型	‘m’
%b	布尔类型	true
%d	整数类型	（十进制） 88
%x	整数类型	（十六进制） FF
%o	整数类型	（八进制） 77
%f	浮点类型	8.888
%a	十六进制浮点类型	FF.35AE
%e	指数类型	9.38e+5
%g	通用浮点类型（f和e类型中较短的）	不举例(基本用不到)
%h	散列码	不举例(基本用不到)
%%	百分比类型	％(%特殊字符%%才能显示%)
%n	换行符	不举例(基本用不到)
%tx	日期与时间类型（x代表不同的日期与时间转换符)	不举例(基本用不到)

//演示
    String str=null;  
    str=String.format("Hi,%s", "小明");  
    System.out.println(str);  //Hi,小明
    str=String.format("Hi,%s %s %s", "小明","是个","大帅哥");            
    System.out.println(str); //Hi,小明 是个 大帅哥               
    System.out.printf("字母c的大写是：%c %n", 'C');  //字母c的大写是：C   
    System.out.printf("布尔结果是：%b %n", "小明".equal("帅哥"));  //布尔的结果是：false
    System.out.printf("100的一半是：%d %n", 100/2);  //100的一半是：50
    System.out.printf("100的16进制数是：%x %n", 100);  // 100的16进制数是：64
    System.out.printf("100的8进制数是：%o %n", 100);  //100的8进制数是：144
    System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85);  //50元的书打8.5折扣是：42.500000 元  
    System.out.printf("上面价格的16进制数是：%a %n", 50*0.85);  //上面价格的16进制数是：0x1.54p5   
    System.out.printf("上面价格的指数表示：%e %n", 50*0.85);  //上面价格的指数表示：4.250000e+01   
    System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85);  //上面价格的指数和浮点数结果的长度较短的是：42.5000   
    System.out.printf("上面的折扣是%d%% %n", 85);  //上面的折扣是85%   
    System.out.printf("字母A的散列码是：%h %n", 'A');//字母A的散列码是：41 

搭配转换符

标志	说明	示例	结果
+	为正数或者负数添加符号	(“%+d”,15)	+15
0	数字前面补0(加密常用)	(“%04d”, 99)	0099
空格	在整数之前添加指定数量的空格	(“% 4d”, 99)	99
,	以“,”对数字分组(常用显示金额)	(“%,f”, 9999.99)	9,999.990000
(	使用括号包含负数	(“%(f”, -99.99)	(99.990000)
#	如果是浮点数则包含小数点，如果是16进制或8进制则添加0x或0	(“%#x”, 99)(“%#o”, 99)	0x63 0143
<	格式化前一个转换符所描述的参数	(“%f和%< 3.2f”, 99.45)	99.450000和99.45
d,%2$s”, 99,”abc”)	99,abc

日期的格式化输出

标志	说明	示例
c	包括全部日期和时间信息	星期六 十月 27 14:21:20 CST 2007
F	“年-月-日”格式	2007-10-27
D	“月/日/年”格式	10/27/07
r	“HH:MM:SS PM”格式（12时制）	02:25:51 下午
T	“HH:MM:SS”格式（24时制）	14:28:16
R	“HH:MM”格式（24时制）	14:28

Date date=new Date();                                  
    //c的使用  
    System.out.printf("全部日期和时间信息：%tc%n",date);//全部日期和时间信息：星期三 九月 21 22:43:36 CST 2016        
    //f的使用  
    System.out.printf("年-月-日格式：%tF%n",date);//年-月-日格式：2016-09-21  
    //d的使用  
    System.out.printf("月/日/年格式：%tD%n",date);//月/日/年格式：16/10/21   
    //r的使用  
    System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);//HH:MM:SS PM格式（12时制）：10:43:36 下午  
    //t的使用  
    System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);  //HH:MM:SS格式（24时制）：22:43:36  
    //R的使用  
    System.out.printf("HH:MM格式（24时制）：%tR",date); //HH:MM格式（24时制）：22:43

1.4.1 格式化输出

如果不使用格式化输出，就需要进行字符串连接，如果变量比较多，拼接就会显得繁琐
使用格式化输出，就可以简洁明了

%s 表示字符串
%d 表示数字
%n 表示换行

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        String name ="盖伦";
        int kill = 8;
        String title="超神";

        //直接使用+进行字符串连接，编码感觉会比较繁琐，并且维护性差,易读性差
        String sentence = name+ " 在进行了连续 " + kill + " 次击杀后，获得了 " + title +" 的称号";

        System.out.println(sentence);

        //使用格式化输出
        //%s表示字符串，%d表示数字,%n表示换行
        String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
        System.out.printf(sentenceFormat,name,kill,title);
    }
}

1.4.2 printf和format

printf和format能够达到一模一样的效果，[如何通过eclipse查看java源码可以看到，在printf中直接调用了format

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        String name ="盖伦";
        int kill = 8;
        String title="超神";

        String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
        //使用printf格式化输出
        System.out.printf(sentenceFormat,name,kill,title);
        //使用format格式化输出
        System.out.format(sentenceFormat,name,kill,title);
    }
}

1.4.3 总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达

%n 和 \n 在java里在输出是一样的

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        int year = 2020;
        //总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达

        //直接打印数字
        System.out.format("%d\n",year);
        //总长度是8,默认右对齐
        System.out.printf("%8d\n",year);
        //总长度是8,左对齐
        System.out.format("%-8d%n",year);
        //总长度是8,不够补0
        System.out.format("%08d%n",year);
        //千位分隔符
        System.out.format("%,8d%n",year*10000);

        //小数点位数
        System.out.format("%.2f%n",Math.PI);

        //不同国家的千位分隔符
        System.out.format(Locale.FRANCE,"%,.2f%n",Math.PI*10000);
        System.out.format(Locale.US,"%,.2f%n",Math.PI*10000);
        System.out.format(Locale.UK,"%,.2f%n",Math.PI*10000);
    }
}

2.数字与字符串

2.1 数字转字符串

方法1： 使用String类的静态方法valueOf
方法2： 先把基本类型装箱为对象，然后调用对象的toString

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        int i=5;
        //方法1
        String s=String.valueOf(i);
        //方法2
        Integer it=i;
        String str=it.toString();
        System.out.println(it);

    }
}

2.2 字符串转数字

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        String str="999";
        String s="1.11";
        int i=Integer.parseInt(str);
        double j=Double.parseDouble(s);
        System.out.println(s);
        
        
        float f = 3.14f;
        //浮点数转字符串
        String s = String.valueOf(f);
        //字符串转浮点数
        f= Float.parseFloat(s);
         
        //如果字符串内容不是合法的数字表达，那么转换就会报错(抛出异常)
        Float.parseFloat("3.1a4");
    }
}

2.3 数学方法

package digit;
 
public class TestNumber {
 
    public static void main(String[] args) {
    	float f1 = 5.4f;
    	float f2 = 5.5f;
    	//5.4四舍五入即5
    	System.out.println(Math.round(f1));
    	//5.5四舍五入即6
    	System.out.println(Math.round(f2));
    	
    	//得到一个0-1之间的随机浮点数（取不到1）
    	System.out.println(Math.random());
    	
    	//得到一个0-10之间的随机整数 （取不到10）
    	System.out.println((int)( Math.random()*10));
    	//开方
    	System.out.println(Math.sqrt(9));
    	//次方（2的4次方）
    	System.out.println(Math.pow(2,4));
    	
    	//π
    	System.out.println(Math.PI);
    	
    	//自然常数
    	System.out.println(Math.E);
    }
}

3.字符

3.1 char对应的封装类

char对应的封装类是Character

public static void main(String[] args) {
        char c1 = 'a';
        Character c = c1; //自动装箱
        c1 = c;//自动拆箱
         
    }

3.2 Character常见的方法

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        System.out.println(Character.isLetter('a'));//判断是否为字母
        System.out.println(Character.isDigit('a')); //判断是否为数字
        System.out.println(Character.isWhitespace(' ')); //是否是空白
        System.out.println(Character.isUpperCase('a')); //是否是大写
        System.out.println(Character.isLowerCase('a')); //是否是小写

        System.out.println(Character.toUpperCase('a')); //转换为大写
        System.out.println(Character.toLowerCase('A')); //转换为小写

        //String a = 'a'; //不能够直接把一个字符转换成字符串
        String a2 = Character.toString('a'); //转换为字符串
    }
}

4.StringBuffer

StringBuffer是可变长的字符串

4.1 追加 删除 插入 反转

append追加
delete 删除
insert 插入
reverse 反转

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        String str1 = "let there ";

        StringBuffer sb = new StringBuffer(str1); //根据str1创建一个StringBuffer对象
        sb.append("be light"); //在最后追加

        System.out.println(sb);

        sb.delete(4, 10);//删除4-10之间的字符

        System.out.println(sb);

        sb.insert(4, "there ");//在4这个位置插入 there

        System.out.println(sb);

        sb.reverse(); //反转

        System.out.println(sb);
    }
}

4.2 长度 容量

为什么StringBuffer可以变长？
和String内部是一个字符数组一样，StringBuffer也维护了一个字符数组。 但是，这个字符数组，留有冗余长度
比如说new StringBuffer(“the”)，其内部的字符数组的长度，是19，而不是3，这样调用插入和追加，在现成的数组的基础上就可以完成了。
如果追加的长度超过了19，就会分配一个新的数组，长度比原来多一些，把原来的数据复制到新的数组中，看上去 数组长度就变长了
length: “the”的长度 3
capacity: 分配的总空间 19

注： 19这个数量，不同的JDK数量是不一样的

package com.company;

import java.util.*;

public class Main{
    public static void main(String[] args) {
        String str1 = "the";

        StringBuffer sb = new StringBuffer(str1);

        System.out.println(sb.length()); //内容长度

        System.out.println(sb.capacity());//总空间
    }
}

5. IStringBuffer接口

package character;
  
public interface IStringBuffer {
    public void append(String str); //追加字符串
    public void append(char c);  //追加字符
    public void insert(int pos,char b); //指定位置插入字符
    public void insert(int pos,String b); //指定位置插入字符串
    public void delete(int start); //从开始位置删除剩下的
    public void delete(int start,int end); //从开始位置删除结束位置-1
    public void reverse(); //反转
    public int length(); //返回长度
}