字符串常见算法

最新推荐文章于 2024-07-13 15:29:04 发布

Mr.易湿

最新推荐文章于 2024-07-13 15:29:04 发布

阅读量1.4k

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/m0_54397364/article/details/126569808

版权

java 专栏收录该内容

93 篇文章 0 订阅

订阅专栏

一、java.lang.String  类：不可变的字符序列
     String str1="abc";
     String str2=new String("abc");
     二者区别:
     str1：代表一个对象，至少在内存中开辟一块内存空间（栈中开辟存放对象的引用，“xxx”在字符串池中查找是否有，没有则开辟，反之不需要）
     str2：代表一个对象，至少在内存中开辟两块内存空间
二、String类的常用方法：
    1．获取字符串的方法:
    ①.String concat (String str):串接字符串
    ②String substring(int beginIndex):获取字符串的子串
     String substring(int beginIndex,endIndex):包含头不包含尾
    ③String toLowerCase()和String toUpperCase():转换为小写/大写
    ④String trim():删除首尾空格或制表符
    2．搜索方法:
    ①int indexOf(int ch) :获取指定字符在字符串中的位置,若没有指定的字符，返回-1
    int indexOf (int ch，int fromIndex):从指定位置开始搜索
    int indexOf (String str)
    int indexOf (String str, int fromIndex)
    int lastIndexOf (int ch):反向获取指定字符位置
    3.判断方法:
    ①boolean equals (0bject obj):判断是否相等
    boolean equalsIgnoreCase(String str):判断是否相等,不考虑大小写
    ②boolean contains (String str):判断是否包含某字符串
    ③boolean startsWith(String str)和boolean endsWith(String str)：判断是否已指定字符串开始/结尾
    ④boolean isEmpty()：判断字符串是否为空
    4、其他方法

①length()：返回字符串长度

②char charAt(int index)：返回索引处的字符

③将字符数组转换为字符串
         构造器：
                String(char[] ch)
                String(char[] ch,offset,count)：将数组中一部分转换为字符串
        静态方法：
                static String copyValueOf(char[] ch)
                static String copyValueOf(char[] ch,offset,count)
                static String ValueOf(char[])
        将字符串转换为字符数组：char[] toCharArray()
④String replace(char oldCahr， char newCahr) :替换字符串中字符
 String replace(String oldStr，String oldStr):替换字符串中字符串
⑤String[l split (String r):根据指定符号切割

package API.Test;

import org.junit.Test;

/*
一、java.lang.String  类：不可变的字符序列
     String str1="abc";
     String str2=new String("abc");
     二者区别:
     str1：代表一个对象，至少在内存中开辟一块内存空间（栈中开辟存放对象的引用，“xxx”在字符串池中查找是否有，没有则开辟，反之不需要）
     str2：代表一个对象，至少在内存中开辟两块内存空间
二、String类的常用方法：
    1．获取字符串的方法:
    ①.String concat (String str):串接字符串
    ②String substring(int beginIndex):获取字符串的子串
     String substring(int beginIndex,endIndex):包含头不包含尾
    ③String toLowerCase()和String toUpperCase():转换为小写/大写
    ④String trim():删除首尾空格或制表符
    2．搜索方法:
    ①int indexOf(int ch) :获取指定字符在字符串中的位置,若没有指定的字符，返回-1
    int indexOf (int ch，int fromIndex):从指定位置开始搜索
    int indexOf (String str)
    int indexOf (String str, int fromIndex)
    int lastIndexOf (int ch):反向获取指定字符位置
    3.判断方法:
    ①boolean equals (0bject obj):判断是否相等
    boolean equalsIgnoreCase(String str):判断是否相等,不考虑大小写
    ②boolean contains (String str):判断是否包含某字符串
    ③boolean startsWith(String str)和boolean endsWith(String str)：判断是否已指定字符串开始/结尾
    ④boolean isEmpty()：判断字符串是否为空
    4、其他方法

①length()：返回字符串长度

②char charAt(int index)：返回索引处的字符

③将字符数组转换为字符串
         构造器：
                String(char[] ch)
                String(char[] ch,offset,count)：将数组中一部分转换为字符串
        静态方法：
                static String copyValueOf(char[] ch)
                static String copyValueOf(char[] ch,offset,count)
                static String ValueOf(char[])
        将字符串转换为字符数组：char[] toCharArray()
④String replace(char oldCahr， char newCahr) :替换字符串中字符
 String replace(String oldStr，String oldStr):替换字符串中字符串
⑤String[l split (String r):根据指定符号切割
* */
public class StringTest {
    @Test
    public void test() {
        String str1 = "abc";
        String str2 = new String("abc");
        System.out.println(str1 == str2);//false
        String str3 = "abc";
        System.out.println(str1 == str3);
        System.out.println(str2 == str3);
        System.out.println(str3 == str2.intern());
    }
    @Test
    public void test2(){
        String str="abc";
        String str2= str.concat("def");
        System.out.println(str2);
        String str3=str2.substring(2);//从第二个索引位置开始
        System.out.println(str3);
        String str4= str2.substring(2,4);
        System.out.println(str4);

        String str5="aBc";
        String str6= str.concat("dEf");
        System.out.println(str6.toLowerCase());
        System.out.println(str6.toUpperCase());
        System.out.println(str2.trim());
    }
    @Test
    public void test3(){
        String str="abcdef";
        int str1=str.indexOf('d');
        System.out.println(str1);
        int str2=str.indexOf('c',2);
        System.out.println(str2);
        System.out.println(str.indexOf("de"));
        System.out.println(str.indexOf("ef",2));
        System.out.println(str.lastIndexOf("bc",5));
    }
    @Test
    public void test4(){
        String str1="abcdef";
        String str2="aBcdef";
        boolean boo=str1.equals(str2);
        System.out.println(str1.equals(str2));
        System.out.println(str1.equalsIgnoreCase(str2));
        System.out.println(str1.contains("ef"));
        System.out.println(str2.contains("ab"));
        System.out.println(str1.startsWith("abc"));
        System.out.println(str2.endsWith("ef"));
    }
    @Test
    public void test5(){
        String str="abcdef";
        System.out.println(str.length());
        char ch=str.charAt(0);
        System.out.println(ch);
        //将字符数组转换为字符串
        char[] chars={'a','b','c','d','e','f'};
        String str1=new String(chars);
        System.out.println(str1);
        //从第几个位置开始转换，转换几个
        String str2=new String(chars,1,3);
        System.out.println(str2);
        System.out.println("------------------------------");
        String str3=String.copyValueOf(chars);
        System.out.println(str3);
        String str4=String.copyValueOf(chars,0,3);
        System.out.println(str4);
        System.out.println("---------------------------------");
        String str5= String.valueOf(chars);
        System.out.println(str5);
        String str6= String.valueOf(chars,1,3);
        System.out.println(str6);
        System.out.println("---------------------------------");
        //将字符串转换为字符数组：char[] toCharArray()
        char[] chs= str.toCharArray();
        for (char c : chs) {
            System.out.println(c);
        }
    }
    /**
     * ④String replace(char oldCahr， char newCahr) :替换字符串中字符
     *  String replace(String oldStr，String oldStr):替换字符串中字符串
     * ⑤String[] split (String r):根据指定符号切割
     */

    @Test
    public void test6(){
        String str="abcdef,cbcbcb";
        String str1=str.replace('b','B');
        System.out.println(str1);
        String str2=str.replace("cb","TTT");
        System.out.println(str2);
        String[] strings= str.split(",");
        for (String string : strings) {
            System.out.println(string);
        }

    }
}

Exer：

1、模拟一个trim方法，去除字符串两端的空格。
2、将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为"abfedcg
3、获取一个字符串在另一个字符串中出现的次数。比如:获取"ab”在“abRAcadeabkebftabtskab”中出现的次数
4、获取两个字符串中最大相同子串。
 比如: str1 = “abcoerthelloyuiodef“; str2 =”cvhellobnm”(提示:将短的那个串进行长度依次递减的子串与较长的串比较。)
5、对字符串中字符进行自然顺序排序。
提示:
字符串变成字符数组。
对数组排序，选择，冒泡，Arrays.sort();
将排序后的数组变成字符串。

package API.Test;
/*
* 1、模拟一个trim方法，去除字符串两端的空格。
2、将一个字符串进行反转。将字符串中指定部分进行反转。比如将“abcdefg”反转为"abfedcg
3、获取一个字符串在另一个字符串中出现的次数。比如:获取"ab”在“abRAcadeabkebftabtskab”中出现的次数
4、获取两个字符串中最大相同子串。
 比如: str1 = “abcoerthelloyuiodef“; str2 =”cvhellobnm”(提示:将短的那个串进行长度依次递减的子串与较长的串比较。)
5、对字符串中字符进行自然顺序排序。
提示:
字符串变成字符数组。
对数组排序，选择，冒泡，Arrays.sort();
将排序后的数组变成字符串。

* */
public class StringTest2 {
    public static void main(String[] args) {
        System.out.println(myTrim("  abcdef   "));
        System.out.println(revString("abcdef",2,5));
        System.out.println(getCount("ab","abjskhfkdghabdksjfhab"));
        System.out.println(getMaxStr("abcoerthelloyuiodef","cvhellobnm"));
    }
    public static String myTrim(String str){
        char[] chars=str.toCharArray();
        int start=0;
        int end=chars.length-1;
        while (start<=end && chars[start]==' '){
            start++;
        }
        while (start<=end && chars[end]==' '){
            end--;
        }
        return str.substring(start,end+1);
    }
    //字符串的指定部分反转
    public static String revString(String str,int start,int end){
           char[] chars= str.toCharArray();
           for (int i=start, j=end;i<j; i++,j--){
               char ch=chars[i];
               chars[i]=chars[j];
               chars[j]=ch;
        }
           return new String(chars);

    }
    //获取一个字符串在另一个字符串中出现的次数
    public static int getCount(String str1,String str2){
        int count=0;
        int index=0;
        int fromIndex=0;
        while ((index=str2.indexOf(str1,fromIndex))!=-1){
            count++;
            //fromIndex=index+str1.length();
            fromIndex=index+1;
        }
        return count;
    }
    //获取两个字符串中最大相同子串
    public static String getMaxStr(String str1,String str2){
        String maxStr=str1.length()>str2.length()?str1:str2;
        String minStr=str1.length()>str2.length()?str2:str1;
        int minLength=minStr.length();
        for (int i = 0; i < minLength; i++) {
            for (int x=0,y=minLength-i;y<=minLength;x++,y++){
                String subStr=minStr.substring(x,y);
                if (maxStr.contains(subStr)){
                    return subStr;
                }
            }
        }
        return null;
    }
}