Java基础-13-处理字符串

Java基础-基本数据类型常用API

基本数据类型常用API

1、String（概述）

String s = new String () ; //和 String s = ""; 一样 String s1 = "abc"; //s1是一个类类型变量，"abc"是一个对象 字符串最大特点：一旦被初始化就不能改变了。 //思考 String s1 ="abc"; s1 = "kk"; System.out.println(s1); //输出的却是kk //为什么?"abc"没变，只是s1变了，指向了"kk"的地址。

class StringDemo
{
    public static void main(String[]args)
    {
        String s1 = "abc";
        String s2 = new String ("abc");
        /*
         * s1和s2有什么区别？
         * s1在内存中有一个对象
         * s2在内存中有两个对象，自己 new了一个，构造函数传进来了一个。
         * */
        System.out.println(s1==s2); //false
        System.out.println(s1.equals(s2));  //true，原因：String类复写了Object类中equals方法，该方法用于判断字符串是否相同。
    }
}

输出结果：

false
true

2、String（常见功能-获取和判断）

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);//true，因为字符串："abc"常量存储在常量池中

String类适用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。

常见的操作有哪些？

• （1）、获取

（1.1）、字符串中包含的字符数，也就是字符串的长度。

    int length();   //获取长度

（1.2）、根据位置获取位置上的某个字符。

    char charAt(int index);    

（1.3）、根据字符获取该字符在字符串中的位置。

    int indexOf(int ch); //返回的是ch在字符串中的第一次出现处的索引。ch是字符自动转成ASII码的形式传入到函数中
    int indexOf(int ch, int fromIndex);  //从fromIndex指定位置开始，获取ch在字符串中第一次出现的位置。
    int indexOf(String str);  //返回的是str在字符串中第一次出现处的索引。

• （2）、判断

（2.1）、字符串中是否包含某一个子串。

    boolean contains(String str);  //特殊之处，indexOf(str)可以索引str第一次出现位置，如果返回-1，
    //表示该str不在字符串中存在，所以，也可以用于对指定判断是否包含,例如if(str.indexOf("aa")!=-1)
    //而且该方法既可以判断，又可以获取出现的位置。

（2.2）、字符串中是否有内容。

    boolean isEmpty();//原理就是判断长度是否为0

（2.3）、字符串是否以指定内容开头。

    boolean startWith(String str);

（2.4）、字符串是否是以指定内容结尾。

    boolean endsWith(String str);

（2.5）、判断字符串内容是否相同，复写了Object类中的equals方法。

    boolean equals(str);

（2.6）、判断内容是否相同，并忽略大小写

    boolean equalsIgnoreCase();

3、String（常见的功能）

• （3）、转换

（3.1）、将字符数组转成字符串：

String(char[] Value);//分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String (char[] Value,int offset,int count); //分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
//也就是讲字符数组中的一部分转成字符串。

（3.2）、将字符串转成字符数组。

char [] toCharArray();

（3.3）、将字节数组转成字符串

String(byte[] bytes)//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

（3.4）、将字符串转成字节数组

byte[] getBytes();  //使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

（3.5）、将基本数据类型转成字符串

static String valueOf(int value);//int可以换成别的类型：boolean,char,char[],double,float,long,Object.
static String valueOf(char[] data, int offset,int count);//返回 char 数组参数的特定子数组的字符串表示形式。

• （4）、替换：

  String repalce(char oldchar,char newchar);//返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
  

• (5)、切割：

  String[] split(String regex); //根据给定正则表达式的匹配拆分此字符串。
  

• (6)、子串：获取字符串中的一部分。

  String substring(int beginIndex);//返回一个新的字符串，它是此字符串的一个子字符串。
  String substring(int beginIndex,int endIndex);//返回一个新字符串，它是此字符串的一个子字符串。
  

• （7）、转换、去除空格、比较：

（7.1）、将字符串转成大写或者小写：

    String toUpperCase();//使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
    String toLowerCase();//使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

（7.2）、将字符串两端的多个空格去除：

    String trim();//返回字符串的副本，忽略前导空白和尾部空白。

（7.3）、对两个字符串进行自然顺序比较：

    int compareTo(String anotherString);//按字典顺序比较两个字符串。

测试代码：

class StringMethodDemo
{
    public static void method_get()
    {
        String  str = "abcdeakpf";
        System.out.println("str:"+str);

        //长度
        System.out.println("str的长度："+str.length());

        //根据索引获取字符
        System.out.println("str中4号角标的字符是："+str.charAt(4));//当访问到字符串中不存在的角标时，会发生报错

        //根据字符获取索引
        System.out.println("str中a从第3位开始第一次出现的位置"+str.indexOf('a',3));//如果没有找到，返回-1

        //反向索引一个字符出现的位置
        System.out.println("str方向索引a第一次出现的位置是："+str.lastIndexOf('a'));
    }
    public static void method_is()
    {

        String str = "ArrayDemo.java";
        System.out.println("str:"+str);

        //判断文件名称是否是Array单词开头。
        System.out.println("str是否是以Array开头:"+str.startsWith("Array"));

        //判断文件名称是否是.java文件
        System.out.println("str字符串是否是以.java结尾："+str.endsWith(".java"));

        //判断文件名称是否包含Demo
        System.out.println("str字符串是否包含字符串Demo："+str.contains("Demo"));
    }
    public static void method_trans()
    {
        char[] arr= {'a','b','c','d','e','f'};
        System.out.println("原字符数组输出是abcdef");
        //将字符数组转成字符串
        String s = new String (arr,1,3);
        System.out.println("把字符数组的2到4的字符转成字符串s："+s);
    }
    public static void method_replace()
    {
        String s = "hello java";
        String s1 = s.replace('a','!');//如果要替换的字符不存在，那么结果还是原字符串
        System.out.println("原字符串s是："+s);
        System.out.println("替换把原字符串s中的a替换成了！的新字符串s1是："+s1);
    }
    public static void method_split()
    {
        String s = "zhangsan,lisi,wangwu";
        String [] arr = s.split(",");
        System.out.println("原字符串s是："+s);
        System.out.println("去除原字符串中的，后的新字符串是：");
        for(int x = 0;x<arr.length;x++)
        {
            System.out.println(arr[x]);
        }
    }
    public static void method_sub()
    {
        String s = "abcdefasde";
        System.out.println("原字符串s是："+s);

        //从指定位置开始到结尾，若角标不存在，会出现字符串角标越界异常
        System.out.println("输出从3开始的子字符串是："+s.substring(3));
        System.out.println("输出从3开始到6结束的子字符串是："+s.substring(3,5));
    }
    public static void method_7()
    {
        String s = "       Hello     Java       ";
        System.out.println("原字符串s是："+s);

        System.out.println("原字符串按小写输出是："+s.toLowerCase());
        System.out.println("原字符串按大写输出是："+s.toUpperCase());
        System.out.println("去掉原字符串中前后空格后输出事："+s.trim());

        String s1 = "abc";
        String s2 = "aaa";
        System.out.println("s1和s2字符串分别为"+s1+"..."+s2);
        System.out.println("他们比较的结果s1.compareTo(s2)是："+s1.compareTo(s2));

    }
}
class StringDemo
{
    public static void main(String []args)
    {
        StringMethodDemo.method_get();
        System.out.println();
        StringMethodDemo.method_is();
        System.out.println();
        StringMethodDemo.method_trans();
        System.out.println();
        StringMethodDemo.method_replace();
        System.out.println();
        StringMethodDemo.method_split();
        System.out.println();
        StringMethodDemo.method_sub();
        System.out.println();
        StringMethodDemo.method_7();

    }
}

输出结果：

str:abcdeakpf
str的长度：9
str中4号角标的字符是：e
str中a从第3位开始第一次出现的位置5
str方向索引a第一次出现的位置是：5

str:ArrayDemo.java
str是否是以Array开头:true
str字符串是否是以.java结尾：true
str字符串是否包含字符串Demo：true

原字符数组输出是abcdef
把字符数组的2到4的字符转成字符串s：bcd

原字符串s是：hello java
替换把原字符串s中的a替换成了！的新字符串s1是：hello j!v!

原字符串s是：zhangsan,lisi,wangwu
去除原字符串中的，后的新字符串是：
zhangsan
lisi
wangwu

原字符串s是：abcdefasde
输出从3开始的子字符串是：defasde
输出从3开始到6结束的子字符串是：de

原字符串s是：       Hello     Java       
原字符串按小写输出是：       hello     java       
原字符串按大写输出是：       HELLO     JAVA       
去掉原字符串中前后空格后输出事：Hello     Java
s1和s2字符串分别为abc...aaa
他们比较的结果s1.compareTo(s2)是：1

4、String（字符串练习1）

（1）模拟一个trim方法，去除字符串两端的空格。 思路：

1、判断字符串第1个位置是否是空格，如果是继续向下判断，直到不是空格为止，结尾处判断空格也是如此。
2、当开始和结尾都判断不是空格时，就是要获取的字符串。

图：

1.png

代码：

class StringTest
{

    public static String myTrim(String s )
    {

        int start = 0 ;
        int end = s.length()-1;
        while(start<=end && s.charAt(start)==' ')
        {
            start++;
        }
        while(start<=end && s.charAt(end)==' ')
        {
            end--;
        }

        return s.substring(start,end+1);
    }
public static void main(String[]args)
    {
        String s = "       abc        de      ";
        System.out.println(s);
        s =myTrim(s);
        System.out.println(s);

    }

}

输出结果：

       abc        de      
abc        de

（2）、将一个字符串进行反转，将字符串中指定部分进行反转，例如："abcdefg"---->"abfedcg"，把字符串中的"cdef"转换成了"fedc"。

思路： 1、曾经学习过对数组元素进行反转。 2、将字符串变成数组，对数组反转。 3、将反转后的数组变成字符串。 4、只要将要反转的部分的开始和结束位置作为参数传递即可。

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

    {
        String s = "abcdefg";
        System.out.println(reverseString(s));
        System.out.println(reverseString(s,2,5));


    }
    private static void swap(char []arr , int x ,int y)
    {
        char temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp ;
    }
    private static void reverse(char []arr) 
    {
        for(int start = 0 , end = arr.length-1;start<end;start++,end--)
        {
            swap(arr,start,end);
        }
    }

    private static void reverse(char []arr,int start,int end)//重载函数reverse
    {
        for(end = end-1;start<end;start++,end--)
        {
            swap(arr,start,end);
        }
    }

    //需求：将字符串反转
    public static String reverseString(String s)
    {
        char []chs = s.toCharArray();
        reverse(chs);
        return new String(chs);
    }

    //需求：反转abcdefg里的cdef
    public static String reverseString(String s ,int x , int y)
    {
        char []chs = s.toCharArray();
        reverse(chs,x,y);
        return new String(chs);

    }
}

输出结果：

gfedcba
abedcfg

5、String（字符串练习3）

（3）、获取一个字符串在另一个字符串中出现的次数。例如：abkkcdkkefkkskk中kk出现的次数 思路：

1、定义一个计数器。
2、获取kk第一次出现的位置。
3、从第一次出现位置后剩余的字符串中继续获取kk出现的位置，每获取一次就计数一次。
4、当获取不到时，计数完成。

class StringTest
{
    public static int getSubCount(String str , String key)
    {
        int count = 0 ;
        int index = 0;
        while((index = str.indexOf(key))!=-1)
        {
            System.out.println("str:"+str);
            str = str.substring(index+key.length());
            count++;
        }
        return count;
    }
    public static void main(String []args)
    {
         String s= "abkkcdkkefkkskk";
         System.out.println("count:"+getSubCount(s,"kk"));
    }
}

输出结果：

str:abkkcdkkefkkskk
str:cdkkefkkskk
str:efkkskk
str:skk
count:4

//方式2

class StringTest
{
    public static int getSubCount(String str , String key)//方式1
    {
        int count = 0 ;
        int index = 0;
        while((index = str.indexOf(key))!=-1)
        {
            System.out.println("str:"+str);
            str = str.substring(index+key.length());
            count++;
        }
        return count;
    }
    public static int getSubCount_2(String str , String key)//方式2
    {
        int count = 0 ;
        int index = 0;
        while((index = str.indexOf(key,index))!=-1)
        {
            System.out.println("index"+index);
            index = index+key.length();
            count++;
        }
        return count;
    }
    public static void main(String []args)
    {
         String s= "abkkcdkkefkkskk";
         System.out.println("count:"+getSubCount_2(s,"kk"));
    }
}

输出结果：

index2
index6
index10
index13
count:4

6、String（字符串练习4）

（4）、获取两个字符串中最大相同子串，第一个动作：将短的哪个串进行长度一次递减的子串打印。例如："abcwerthelloyuiodef"和"cvhellobnm"。 思路： 1、将短的哪个子串按照长度递减的方式获取。 2、将没获取到的子串去长串判断是否包含，如果包含，已经找到！

代码

class StringTest
{
    public static String getMaxSubString(String s1,String s2)
    {
        //添加代码区分s1和s2的长短。
        String max = "",min = "";
        max = (s1.length()>s2.length())?s1:s2;
        min = (max==s1)?s2:s1;
        System.out.println("max = "+max+" min = "+ min);

        for(int x = 0;x<min.length();x++)
        {
            for(int y = 0,z=min.length()-x;z!=min.length()+1;y++,z++)
            {
                String temp = min.substring(y,z);
                System.out.println(temp);
                if(max.contains(temp))
                    return temp;
            }
        }
        return "";
    }
    public static void main(String []args)
    {
        String s1 = "abcwerthelloyuiodef";
        String s2 = "cvhellobnm";
        System.out.println(getMaxSubString(s2,s1));
    }
}

输出结果:

max = abcwerthelloyuiodef min = cvhellobnm
cvhellobnm
cvhellobn
vhellobnm
cvhellob
vhellobn
hellobnm
cvhello
vhellob
hellobn
ellobnm
cvhell
vhello
hellob
ellobn
llobnm
cvhel
vhell
hello
hello

7、StringBuffer（常见功能-添加）

StringBuffer是一个字符串缓冲区，是一个容器，而且长度是可以变化的，可以直接操作多个数据类型，最终会通过toString方法变成字符串。

（1）、存储：

StringBuffer append(data）;//data可以是很多类型：int,long,double,float,Object,char,char[],String,StringBuffer等
//将指定数据作为阐述添加到已有的数据结尾处。
StringBuffer insert(int index,data);//将数据作为参数的字符串表示形式插入指定的index位置的序列中。

（2）、删除：

StringBuffer delete(int start,int end);//移除此序列的子字符串中的字符。
StringBuffer deleteCharAt(int index);//删除指定位置的字符。

（3）、获取：

char charAt(int index);// 返回此序列中指定索引处的 char 值。
int indexOf(String str);//返回第一次出现的指定子字符串在该字符串中的索引。
int lastIndexOf(String str);//返回最右边出现的指定子字符串在此字符串中的索引。
int length();//返回长度（字符数）。
String substring(int start,int end);//返回一个新的 String，它包含此序列当前所包含的字符子序列。

（4）、修改：

StringBuffer replace(int start,int end,String str);//使用给定 String 中的字符替换此序列的子字符串中的字符。

（5）、反转：

StringBuffer reverse();//将此字符序列用其反转形式取代。

Eg:

class StringBufferDemo
{
    public static void main(String[]args)
    {
        StringBuffer sb = new StringBuffer();
        StringBuffer sb1 = sb.append(43);
        System.out.println("sb:"+sb.toString());
        System.out.println("sb1:"+sb1.toString());
        System.out.println("sb.equals(sb1):"+sb.equals(sb1));
        System.out.println("sb==sb1:"+(sb==sb1));
        //以上证明sb和sb1地址一致。

        //往缓冲区存东西
        sb.append("abc").append(true).append(34);
        sb.insert(1,"qq");
        System.out.println("sb:"+sb.toString());

        method_del();
        method_update();
    }
    public static void method_del()
    {
        StringBuffer sb2 = new StringBuffer("abcde");
        System.out.println("sb2:"+sb2.toString());

        sb2.delete(1,3);
        System.out.println("sb2.delete(1,3):"+sb2.toString());


        sb2.deleteCharAt(2);
        System.out.println("sb2.deleteCharAt(2):"+sb2.toString());

        //如何清空缓冲区
        sb2.delete(0,sb2.length());
        System.out.println("sb2.delete(0,sb2.length()):"+sb2.toString());

    }
    public static void method_update()
    {
        StringBuffer sb3 = new StringBuffer("abcde");
        System.out.println("sb3:"+sb3.toString());
        sb3.replace(1,4,"java");
        System.out.println("sb3.replace(1,4,\"java\"):"+sb3.toString());
        sb3.setCharAt(2, 'h');
        System.out.println("sb3.setCharAt(2, 'h'):"+sb3.toString());
    }
}

输出结果：

sb:43
sb1:43
sb.equals(sb1):true
sb==sb1:true
sb:4qq3abctrue34
sb2:abcde
sb2.delete(1,3):ade
sb2.deleteCharAt(2):ad
sb2.delete(0,sb2.length()):
sb3:abcde
sb3.replace(1,4,"java"):ajavae
sb3.setCharAt(2, 'h'):ajhvae

8、StringBuilder

JDK1.5版本之后出现了StringBuilder。

StringBuffer是线程同步的。
StringBuilder是线程不同步的。

将StringBuilder的实例用于多个线程是不安全的，如果需要这样的同步，则建议使用StringBuffer。 以后开发，建议使用StringBuilder（线程不同步）。

Java版本升级的三个因素：

（1）、提高效率。
（2）、简化书写。
（3）、提高安全性。

9、基本数据类型对象包装类

 基本数据类型  byte    short   int     long    boolean     float  double   char
 引用数据类型  Byte    Short   Integer Long    Boolean     Float   Double  Charactor

基本数据类型对象包装类的最常见作用：

就是用于基本数据类型和字符串类型间的转换，例如：

• 基本数据类型转成字符串：

  基本数据类型+" ";
  基本数据类型.toString(基本数据类型值);
  
  //例如
  Integer.toString(34);//将34整数变成"34"字符串
  

• 字符串转成基本数据类型

  //公式
  Xxx a = Xxx.parseXxx(String str);//把字符串转成Xxx（基本数据类型）的值。
  int a  = Integer.parseInt("123");//静态调用的方式。
  double b = Double.parseDouble("12.23");
  boolean b = Boolean.parseBoolean("false");
  int a  = Integer.parseInt("123");//静态调用的方式。
  //另一种非静态调用方式
  Integer i  = new Integer("123");
  int num = i.intValue();
  

• 十进制转成其他进制：

  static String toBinaryString(int i);//以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
  static String toHexString(int i );//以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
  static String toOctalString(int i );//以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
  其他进制转成十进制：
  static int parseInt(String str,int radix);//使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
  

测试代码：

class IntegerDemo
{
    public static void main(String[]args)
    {
        //整数类型的最大值
        System.out.println("Integer.MAX_VALUE:"+Integer.MAX_VALUE);

        //将一个字符串转成整数/长整数
        int num = Integer.parseInt("123");
        long x = Long.parseLong("123");
        System.out.println("int num:"+num+" long x:"+x);

        System.out.println("Integer.toBinaryString(6):"+Integer.toBinaryString(6));
        int y = Integer.parseInt("110",2);
        System.out.println("int y = Integer.parseInt(\"110\",2):"+y);
    }
}

输出结果：

Integer.MAX_VALUE:2147483647
int num:123 long x:123
Integer.toBinaryString(6):110
int y = Integer.parseInt("110",2):6