常用对象API_String类

在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

String类的特点：

字符串对象一旦被初始化就不会被改变

package com.monfolld;

public class StringDemo {
    public static void main(String[] args){
        stringDemo2();
    }
    public static void stringDemo1(){
        String s="abc";//abc存储在字符串常量池中
        //s="nba";
        String s1="abc";
        System.out.println(s==s1);
    }
    public static void stringDemo2(){
        String s="abc";            //常量池中创建一个对象
        String s1=new String("abc");  //创建两个对象，一个new另一个在堆内存中
        System.out.println(s==s1);
        System.out.println(s.equals(s1));  //比较字符串内容，equals复写了Object中的equals建立了String类自己的判断字符串对象是否相同的依据
    }
}

Sting类构造函数

和其它对象一样，可以使用关键字和构造方法来创建 String 对象

public static void  stringConstructDemo2(){
        char[] arr={'w','a','p','q','x'};
        String s=new String(arr);
        System.out.println("s"+s);
    }

常见功能

获取

/*按照面向对象的思想对字符串进行功能分类*/
/*"abcd"*/
/*
* 1.获取：
* 1.1获取字符串中字符的个数（长度）
*   int length();
* 1.2根据位置获取字符
*   char charAT(int index);
* 1.3根据字符获取字符串中的第一次出现位置
*   int indexOf(int ch);
*   int indexOf(int ch,int fromIndex);从指定位置进行ch的查找第一次出现的位置
*   int indexOf(String str);
*   int indexOf(String str,int fromIndex);
*   根据字符串中获取字符串中的第一次出现位置
*   int lastindexOf(int ch);
*   int lastindexOf(int ch,int fromIndex);从指定位置进行ch的查找第一次出现的位置
*   int lastindexOf(String str);
*   int lastindexOf(String str,int fromIndex);
* 1.4获取字符串中的一部分字符串，也叫子串
*   String substring(int beginIndex,int endIndex);
*   String substring(int beginIndex);

 String s="abcde";
        System.out.println("length:"+s.length());
        System.out.println("char:"+s.charAt(2));
        System.out.println("index:"+s.indexOf('c'));//可以根据-1，判断字符串是否存在
        System.out.println("lastindex:"+s.lastIndexOf('a'));
        System.out.println("substring:"+s.substring(2,4));//从beginIndex处开始，直到索引endIndex-1字符

转换

* 2.转换:
* 2.1将字符串变成字符串数组（字符串的切割）
*   String[] split(String regex);涉及到正则表达式
* 2.2将字符串变成字符数组
*   char[] toCharArray(])
* 2.3将字符串变成字节数组
*   byte[] getBytes();
* 2.4将字符串中的字母转成大小写
*   String toUpperCase();大写
*   String toLowerCase();小写
* 2.5将字符串中的内容进行替换
*   String replace(char oldch,char newch)
*   String replace(String s1,String s2)
* 2.6将字符串两端空格去除
*   String trim();
* 2.7将字符串进行连接
*   String concat(String str);*/

String s="张三,李四,王五";
        String[] arr=s.split(",");
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        char[] chs=s.toCharArray();
        for (int i=0;i<chs.length;i++){
            System.out.println(chs[i]);
        }
        s="ab你";

        byte[] bytes=s.getBytes();
        for (int i=0;i<bytes.length;i++){
            System.out.println(bytes[i]);
        }
        System.out.println("Abc".toUpperCase());
        System.out.println("Abc".toLowerCase());

        String s1="java";
        String s2=s1.replace('a','z');//常量池改变会信创建一个
        System.out.println(s1==s2);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("java".replace('a','o'));

        System.out.println("-"+"    ab   c    ".trim()+"-");

        System.out.println("abc".concat("kk"));

判断

* 3.1两个字符串内容是否相同
*   boolean equals(Object obj);
*   boolean equalsIgnoreCase(string str)忽略大小写，比较字符串内容
* 3.2字符串中是否包含指定字符串
*   boolean contains(string str)
* 3.3字符串是否以指定字符串开头，是否以指定字符串结尾
*   boolean startsWith(string);
*   boolean endsWith(string);*/

  String s="abc";
        System.out.println(s.equals(("ABC".toLowerCase())));
        System.out.println(s.equalsIgnoreCase("ABC"));
        System.out.println(s.contains("cc"));

        String str="ArrayDemo.java";
        System.out.println(str.startsWith("Array"));
        System.out.println(str.endsWith(".java"));
        System.out.println(str.contains("Demo"));

比较

* 4.比较
* 4.1字符串对象比较
*   int compareTo(String anotherString) */

 System.out.println("abc".compareTo("aqz"));

intern方法

返回字符串对象的规范表示。

最初为空的字符串池由String类String 。

当调用intern方法时，如果池已经包含与equals(Object)方法确定的相当于此String对象的字符串，则返回来自池的字符串。 否则，此String对象将添加到池中，并返回对此String对象的引用。

对于任何两个字符串s和t ， s.intern() == t.intern()是true当且仅当s.equals(t)是true 。

例题

字符串数组排序

/*给定一个字符串数组，按照字典顺序进行从小到大的排序
*
* 思路：
* 1.对数组排序，可以选择，冒泡都行
* 2.for嵌套和比较以及换位
* 3.问题：以前排的是整数，比较用的比较运算符，现在是字符串对象
* 字符串对象怎么比较呢？对象中提供了用于字符串对象比较的功能*/

public class StringTest_1 {
    public static void main(String[] args){
        String[] arr={"nab","abc","cba","zz","qq","haha"};
        printArray(arr);
        sortString(arr);
        printArray(arr);
    }
    public static void printArray(String[] arr){
        System.out.println("[");
        for(int i=0;i<arr.length;i++){
            if (i!=arr.length-1)
                System.out.println(arr[i]+",");
            else
                System.out.println(arr[i]+"]");
        }
    }
    private static void sortString(String[] arr){
        for (int i=0;i<arr.length-1;i++){
            for (int j=i+1;j<arr.length;j++){
                if (arr[i].compareTo(arr[j])>0)
                    swap(arr,i,j);
            }
        }
    }
    private static void swap(String[]arr,int i,int j){
        String temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}

子串的次数

方法一:
/*一个字串在整串中出现的次数
* "nbaernbatynbauinabaopnba"
* 思路：
* 1.要查找的子串是否存在，如果存在获取其出现的位置，这个可以使用indexOf完成
* 2.如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该字串，而且剩余字符串的其实位置是出现位置+字串的长度
* 3.以此类推，通过循环完成查找，如果找不到就是-1，并对每次找到用计数器记录*/

public class StringTest_2 {
    public static void main(String[] args){
    String str="nbaernbatynbauinabaopnba";
    String key="nba";
    int count=getKeyStringCount(str,key);
    System.out.println("count="+count);
    }
    public static int getKeyStringCount(String str,String key){
        //定义计数器
        int count=0;
        //定义变量记录key出现的位置
        int index=0;

        while ((index=str.indexOf(key))!=-1){    //判断字符串是否有nba
            str=str.substring(index+key.length());//取子串
            count++;
        }
        return count;
    }
}

上面这个方法由于每次创建一个新的字符串，浪费资源，于是方法2进行优化

方法2:

从字符串中先找目标子串，找到了锁定该位置，从该位置继续往后寻找

public class StringTest_2 {
    public static void main(String[] args){
    String str="nbaernbatynbauinabaopnba";
    String key="nba";
    int count=getKeyStringCount_2(str,key);
    System.out.println("count="+count);
    }
   public static int getKeyStringCount_2(String str,String key){
        int count=0;
        int index=0;
        while ((index=str.indexOf(key,index))!=-1){
            index=index+key.length();
            count++;
        }
        return count;
    }
}

最大相同子串

/*两个字符串中最大相同的子串
* "qwerabcdtyuiop"
* "xcabcdvbn"
* 思路：
* 1.既然取得是最大子串，先看短的哪个字符串是否在长的哪个字符串中
* 如果存在，短的哪个字符串就是最大子串
* 2.如果不是，那就将短的那个子串进行长度递减的方式取子串，去长串中判断是否存在*/

public class StringTest_3 {
    public static void main(String[] args){
        String s1="qwerabcdtyuiop";
        String s2="xcabcdvbn";
        String s=getMaxSubstring(s1,s2);
        System.out.println("s="+s);
    }
    public static String getMaxSubstring(String s1,String s2){
        for (int i=0;i<s2.length();i++){
            for (int a=0,b=s2.length()-i;b!=s2.length()+1;a++,b++){
                String sub=s2.substring(a,b);
                if (s1.contains(sub))
                    return sub;
            }
        }
        return null;
    }
}

去除两端空白

/*模拟一个trim功能一致的方法，去除字符串两端的空白
* 思路：
* 1.定义两个变量
* 一个变量作为从头开始判断字符串空格的角标
* 一个变量作为从尾开始判断字符串空格的角标
* 2.判断到不是空格为止，取头尾之间的字符串即可
*/

public class StringTest_4 {
    public static void main(String[] args){
        String s="     ab    c    ";

        s=myTrim(s);
        System.out.println("-"+s+"-");
    }
    public static String myTrim(String s){
        int start=0,end=s.length()-1;
        while (start<=end&&s.charAt(start)==' '){
            start++;
        }
        while (s.charAt(end)==' '){
            end--;
        }
        return s.substring(start,end+1);
    }
}