String常用方法

String s1="abc" s1是一个类类型的变量，"abc"是一个对象

字符串一旦初始化就不可以被改变

String s2=new String("abc") s1在内存中是一个对象，s2在内存中是两个对象

String覆写了Object的equals方法，比较的是两个字符串是否相等。

将此 String 与另一个 String 比较，不考虑大小写：boolean equalsIgnoreCase(str)

字符串常见操作

1.获取

    字符串长度：                 int length();

    根据位置获取位置上的某个字符：      char charAt(int index);

    根据字符ch获取在字符串中的位置： int indexOf(int ch);

    字符串str              int indexOf(String str);

    反向索引 int lastIndexOf(int ch);

2.判断

    是否包含某一子串：             boolean contains(String str)

    是否有内容：                  boolean isEmpty()；

    是否以指定内容开头：           boolean startsWith(String str)；

    是否以指定内容结尾： 　　　　　  boolean endsWith(String str)；

    if(str.indexOf("aa")!=-1), 既可判断，又可以获取位置、

3.转换

    　　 字符数组转换为字符串

        构造函数：String(char[] value)

        String(char[] value, int offset, int count)：字符数组中一部分转换为字符串

        静态方法：static String copyValueOf(char[] data)

        static String copyValueOf(char[] data, int offset, int count)

        static String valueOf(char[] data):返回 char 数组参数的字符串表示形式。 [*]

    字符串转换为字符数组[☆]

        char[] toCharArray() :将此字符串转换为一个新的字符数组。

    字节数组转换为字符串

        String(byte[] bytes)

    字符串转换为字节数组

        byte[] getBytes(),字符串和字节数组在转换过程中可以指定编码表。

    返回 int 参数的字符串表示形式：static String valueOf(int i) //String.valueOf(3);3+"" [*]

4.替换

    String replace(char oldChar, char newChar);

    如果替换的字符不存在，则返回原串，String s1="hello java";

    String s2=s1.replace(‘a‘,‘n‘);

5.切割

    String[] split(String regex);

    ps：String s="zhangsan,lisi,wangwu";

        String[] arr=s.plit(",");

6.子串

    String substring(int beginIndex)

    String substring(int beginIndex, int endIndex) //包含头不包含尾，如果角标不存在，会发生角标越界异常

7.转换，比较，去空格

    转换大小写

         String toUpperCase()

         String toLowerCase()     

    去除两头空格

         String trim()

         ps： s.trim();

    两字符串自然顺序的比较

         int compareTo(String anotherString)

         ps: String s1="a1c"; //1的ASCII为49

              String s2="aaa";

              sop(s1.compareTo(s2));//返回-48

1.增

面盘理论

    StringBuffer sb=new StringBuffer();

    StringBuffer sb1=new StringBuffer(34);

    sb==sb1 是一个对象。添加了还是那个面盆。

    特点1.长度可变2.可以操作多种数据类型3.最终会通过toString方法变成字符串。

    sb.append("ad").append("true").append("false")支持方法调用链，生成一个长串。

    StringBuffer insert(int index, 数据) 将数据插入指定位置。

2.删

删完后还是那个面盆

    StringBuffer delete(int start,int end)         含头不含尾

    StringBuffer deleteCharAt(int index)         删除指定位置的数据

    sb.delete(0,sb.length());                    清空缓冲区

3.获取

    char charAt(int index);

    int indexOf(String str);

    int lastIndexOf(int ch);

    int length();

    String substring(int start,int end)

4.修改[☆]

    StringBuffer replace(int start,int end, String str) 含头不含尾，替换为str；

    void setCharAt(int index, char ch)                 替换指定位置字符，不打印

5.翻转

    StringBuffer reverse()

JDK1.5之后出现了StringBuilder，此次升级时为了提高效率。

StringBuffer是线程同步的，多线程用建议用StringBuffer

StringBuilder是线程不同步的 ，单线程效率高

升级三因素：提高效率，简化书写，提高安全性

/**

* 两个字符串中最大相同子串<br>

* <b>思路</b><br>

* 获取短的字符串的子串，按长度递减的方式<br>

* 判断子串是否contains在较长串中<br>

* 如果包含，则返回子串，即最大子串<br>

* */

public class MaxSameString {

    public static void main(String[] args) {

        String s1="sdfhellofsda";

        String s2="sdhellodsd";

        System.out.println(getMaxSameString(s1,s2));

    }

    public static String getMaxSameString(String s1,String s2){

        String max="",min="";

        max=(s1.length()>s2.length())?s1:s2;

        min=(max==s1)?s2:s1;

        for (int i = 0; i < min.length(); i++) {

            for (int j = 0,k=min.length()-i; k!=min.length()+1; j++,k++) {

                String temp=min.substring(j,k);

                //System.out.println(temp);

                if (max.contains(temp)) {

                    return temp;

                }

            }

        }

        return null;//执行不到，但是必须加上。    

    }

}

import java.util.Arrays;

/**

* 获取一个字符串在另一个字符串中出现的次数<br>

* <b>思路：</b><br>

* 1.定义一个计数器，<br>

* 2.获取key第一次出现的位置<br>

* 3.从第一次出现位置后剩余的字符串中继续获取key出现的位置<br>

* 每 获取一次就计数一次 <br>

* 4.当获取不时，计数完成<br>

* 不建议使用切的形式ps:kkddkk,是2个字符串，kkddkkff，切后是三个字符串

* */

public class CountStringDemo {

    public static int getCount(String str,String key){

        int count=0;

        int index=0;

        while ((index=str.indexOf(key))!=-1) {

            str=str.substring(index+key.length());

            System.out.println("str=.."+str);

            count++;

        }

        return count;

    }

    public static void main(String[] args) {

        String s="kkddkk";

        System.out.println(getCount_2(s, "kk"));

        System.out.println(Arrays.toString(s.split("kk")));

    }

    public static int getCount_2(String str,String key){

        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;

    }

}

/**

* 除字符串空格<br>

* <b>思路：</b><br>

* 通过charAt()来判断所在位置是否是空格，是空格则指针向前或向后一位判断<br>

* 同过substring（start，end）方法来生成指针所在空间内的字符串。

* */

public class MyTrimTest {

    public static void main(String[] args) {

        String s=" a bfd ";

        String s1=myTrim(s);

        sop(s);

        sop(s1);

    }

    private static void sop(String str) {

        System.out.println(str);

    }

    public static String myTrim(String str){

        int start=0,end=str.length()-1;

                while (start<=end&&str.charAt(start)==‘ ‘)

                    start++;

                while (start<=end&&str.charAt(end)==‘ ‘)

                    end--;

                return str.substring(start, end+1);            

    }

}

/**

* 将字符串翻转<br>

* <b>思路：</b><br>

* 将字符串变成数组<br>

* 将数组翻转<br>

* 将数组变成字符串<br>

* */

public class ReverseSrting {

    public static void main(String[] args) {

        String s="fjadsfgjreog";

        String s1=revStr(s);

        String s2=revStr(s,3,8);//从start到end之间翻转，含头不含尾

        sop(s);

        sop(s1);

        sop(s2);

    }

    private static String revStr(String str, int i, int j) {

        char[] arr=str.toCharArray();

        reverse(arr,i,j);

        return new String(arr);

    }

    private static void reverse(char[] arr, int i, int j) {

        for (int start = i,end=j-1; start < end; start++,end--) {

            swap(arr,start,end);

        }

    }

    private static void sop(String s) {

        System.out.println(s);

    }

    public static String revStr(String str){

        /*char[] arr=str.toCharArray();

        reverse(arr);

        return new String(arr);    */

        return revStr(str, 0, str.length());

    }

    /*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 swap(char[] arr, int start, int end) {

        arr[start]=(char) (arr[start]^arr[end]);

        arr[end]=(char) (arr[start]^arr[end]);

        arr[start]=(char) (arr[start]^arr[end]);

        /*char temp=arr[start];

        arr[start]=arr[end];

        arr[end]=temp;*/

    }

}