String类

01-String(概述)java.lang包

String类：字符串是一个特殊对象，一旦初始化就不可以被改变

         String s = “abc”;     s = “dada”;    

其实不是“abc”这个对象改变了，只是s指向了”dada”这个对象，“abc”还存在与内存中

public class StringDemo 

{

        static String s1 = "abc";  //s1是一个类类型变量，“abc”是一个对象

        static String s2 = new String("abc");  

       //s1和s2区别：s1在内存中有一个对象     s2在内存中有两个对象

      public static void main(String[] args) 

      {

           System.out.println(s1==s2);  //false 因为不是同一对象

           System.out.println(s1.equals(s2));  //String类复写了Object类中的equals方法

         //该方法用来判断两字符串是否相同，而不是比较地址值

       }

}

 

02-String(常见功能-获取和判断)

1:获取

  字符串中包含字符数，也就是字符串长度   int length();获取长度

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

  根据字符获取该字符在字符串中位置

  int indexOf(int ch);字符的哈希值   返回ch在字符串第一次出现位置，不存返回-1

 int indexOf(int ch，int fromIndex);  从fromIndex位置开始，获取ch位置

 int indexOf(String str);字符的哈希值   返回str在字符串第一次出现位置

 int indexOf(String str，int fromIndex);  从fromIndex位置开始，获取str位置

 int lastIndexOf(int ch); 反向索引一个字符出现的位置    

（begin,end）包含头，不包含尾。S.substring(0, s.length())   

2：判断

   字符串中是否包含某一子串   boolean contains(str);

        特殊之处：indexOf(str)可以索引str第一次出现位置，若果返回-1，表示不存在str

                  所以也可以用与对指定判断是否包含if(str.indexOf(“aa”)!=-1)

                  而且该方法既可以判断，也可以获取出现位置

   字符串中是否有内容         boolean isEmpty();  原理是判断长度是否为0

   字符串是否是以指定类容开头 boolean startsWith(str);

   字符串是否是以指定内容结尾 boolean endsWith(str);

   判断字符串内容是否相同     boolean equals(str);   复写Object类的equals方法

   判断内容是否相同，并忽略大小写  boolean equalsIgnoreCase();

public static void method_get()

{

        String str = "abcdefapf";

        sop(str.length());     //字符串长度

        sop(str.charAt(4));  //根据索引获取字符，当索引超出字符串时，会发生StringIndexOutOfBondsException

        sop(str.indexOf('a'));   

       sop(str.indexOf('a', 3));  //根据字符获取索引，从第三个开始查找      重载

       sop(str.lastIndexOf("a")); //反向索引一个字符出现的位置     重载

}

public static void method_is()

{

       String str = "StringDemo.java";

       sop(str.startsWith("String"));  //判断文件名称是否是以String开头

       sop(str.endsWith(".java"));     //判断文件名称是否是.java的文件

       sop(str.contains(".Demo"));      //判断文件是否包含Demo

}

 

 

03-String(常见功能-转换)

3：转换

   将字符数组转换成字符串

      构造函数：String(char[])   

String(char[],offset,count)将字符数组中从offset开始的count个数组转成字符串

      静态方法：

           Static String copyValueOf(char[]) 重载  static String valueOf(char[])

将字符串转成字符数组

            Char[] toCharArray();

将字符串转成字节数组String(byte [])   

String(byte[],offset,count)将字符数组中从offset开始的count个数组转成字符串

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

       Static String valueOf(int) /double  3+””=String.valueOf(3);

特殊：字符串和字符数组在转换过程中，是可以指定编码的

public static void method_trans()

{

       char[] arr = {'a','b','c','d','e','f','g'};

       String s = new String(arr,1,3);

       sop("s="+s);

}

04-String(常见功能-切割和替换)

  4、 替换

      String  replace(oldchar,newchar);

public static void method_replace()

{

      String s = "hello.java";

      String s1= s.replace('q', 'n'); //如果替换的字符不存在，返回的还是原字符串

      String s2= s.replace("java", "world"); 

      sop("s="+s);    //hello.java   字符串已被创建不被改变

      sop("s1="+s1); //

}

  5、 切割

      String[] split(regex);

public static void method_split()

{

      String s = "zhanhua,haha,lili";

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

      for(int x = 0;x<arr.length;x++)

      {

           sop(arr[x]);

      }

}

 

 

05-String(常见功能-比较和去除空格)

7、转换大小写  String toUpperCase()    String toLowerCase();

   将字符串两弹多个空格去除   String trim();

   对两个字符串进行自然顺序的比较  int comparaTo(string);

                          判断返回的数师傅大于0，大于就是大 =0就是相等

                          忽略大小写

 

06-String(字符串练习1)

1， 模拟一个trim方法，去除字符串两端空格

思路：

1 判断字符串第一个位置师傅为空格，如果是继续往下读，知道不是空格为止

结尾判断也是如此，只是方向相反

        2 当开始和结尾都判断到不是空格时，就要获取字符串   用substring（start,end+1）

// 1 模拟一个trim方法，去除字符串两端空格

public static String myTrim(String str)

{

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

        //此while执行完，start指到字符串第一个不是空格的字符

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

        start++;    //，除非字符串全部是空格，第一个判断才有用   

        //此while执行完，start指到字符串最后一个不是空格的字符    

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

          end--;      //这个while执行时，start已经指向第一个不是空格的字符，

         return str.substring(start,end+1);    //返回从start到end的字符子串；这个方法包括前，不包括后  +1

}

 

 

07-String(字符串练习2)

2 将字符串进行反转。将字符串指定部分进行反转  “abcdgr””rgdcba”

   思路：

      1 曾学习过对数组元素反转

      2 将字符串变成数组，对数组反转

      3 将翻转后数组编程字符串

      4 只要将被反转的部分的开始和结尾的位置作为参数传递即可（包含头不包含尾）

//2 将字符串反转 （指定的段位）  （先变成数组。 对数组反转，将数组变成字符串）

public static String reverseString(String str,int start,int end)

{

       char[] chs = str.toCharArray();       //将字符串转换成数组

        reverse(chs,start,end);                       //自定义方法   反转数组

        return new String(chs);       //将数组变成字符串    有构造方法

}

public static void reverse(char[] arr,int x,int y)

{           //循环交换数组中第一个和最后一个的位置

        for(int start=x,end=y-1;start<end;start++,end--)//-1 是为了遵循包含头不包含尾

        {

                swap(arr,start,end);

         }

}

public static void swap(char[] arr,int x,int y)

{                //自定义方法，交换一个数组中两个元素的位置

        char temp = arr[x];

        arr[x]=arr[y];

        arr[y]=temp;

}

//将字符串全部反转

public static String reverseString(String str)

{

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

}

 

 

08-String(字符串练习3)

3 获取一个字符串在另一个字符串中出现的次数

  思路： “askksaekkkerkkr”

1 定义一个计数器

2 获取kk第一次出现的位置

3 从第一次出现的位置后剩余字符串中继续查找kk出现的位置，获取一次就记数一次

4 当获取不到时，记数完成

//3  获取一个字符串在另一个字符串中出现次数

public static int getSubCount(String str,String key)

{

        int count=0,index =0;

        while((index=str.indexOf(key))!=-1)   //key出现的位置如果不等于-1 说明还没查完

        {

               sop("str="+str);

              str=str.substring(index+key.length()); // 获取字符串自定位置后的 字符子串

              count++;

        }

       return count;

}

// 3的第二种方式

public static int getSubCount_1(String str,String key)

{

       int count=0,index =0;

       while((index=str.indexOf(key,index))!=-1)   //key出现的位置如果不等于-1 说明还没查完

       {

             sop("index="+index);

              index = index+key.length();

             count++;

         }

         return count;

}

sop("count="+str.split("kk").length); 

 如果拿kk去切，当字符串kksdakkdas时会返回3   多一个空格前面

 

 

09-String(字符串练习4)

获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印

   “abcdahellodas”“dashellog”

思路：

   1 将短的那个子串按长度递减的方式取到

   2 将每次获取到的子串去长串中判断是否包含   如果包含，已经找到

//4 获取两个字符串中最大相同子串

public static String getMaxSubString(String s1,String s2)

{

           String max = "",min = "";

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

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

           //其实就是看短字符串的所有子串在长字符串中是否存在，这里递减找到的一定是最长的

           for(int x=0;x<min.length();x++)   //控制次数，次数是短字符串的长度

           {

                  for(int y=0, z=min.length()-x; z!=min.length()+1; y++,z++)   //循环找短字符串减少x个的所有子串  中是否有符合的

                  {

                          String temp = min.substring(y, z);      //获取短字符串中从y，到z的子串

                          if(max.contains(temp))  //if(s1.indexOf(temp)!=-1)  看max中是否包含temp

                          return temp;

                   }

             }

             return "";

}

 

 

10-StringBuffer(常见功能-添加)  java.lang包

  StringBuffer是字符串缓冲区，是一个容器类

   特点：长度可变化；

可以直接操作多个数据类型，数组一次只能一种；

最终会通过toString()方法变成字符串

 C   create   D  delete    U   update   R  read\

1  存储：

StringBuffer sb = new StringBuffer();

//方法调用链   每个方法执行返回的都是调用对象类对象

sb.append("dsa").append("dw").append(32); //append方法将数据添加到已有数据末尾处

sb.insert(1,"qq");   //将qq插入到index角标位     当角标超出时报StringIndexOutOfBoundException

                                 

11-StringBuffer(常见功能-删除和修改)

2 删除

sb.deleteCharAt(2);   //删除角标2出元素

sb.delete(1,3);    //删除1角标到2角标元素，不包含3

sb.delete(0,sb.length());   //清空所有元素  清空缓冲区

3 获取   

     Char charAt(index);

     Int indexOf(String str);

     Int lastIndexOf(String str);

     Int length();

    S tring  substing(start,end); 

4 修改

  StringBuffer replace(start,end,string);

  Void setCharAt(int index,Char ch);

5 反转   

  StringBuffer reverse();

     

6 将缓冲区 srcBegin 到 srcEnd 不包含end 的数据存入char[]数组的dstBegin角标开始

  Void  getChars(int srcBegin, int srcEnd, Char[] dst, int  dstBegin)

 

 

12-StringBuilder  JDK1.5版本后出现  

升级三要素（ 提高效率   简化书写 提高安全性）

StringBuffer   线程同步

StringBuilder  线程不同步    

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

以后开发建议使用StringBuilder

 

 

13 基本数据类型对象封装成类

 byte     Byte

 short     Short

 int       Integer

 long      Long

 boolean   Boolean

 float      Float

 double    Double

 char      Character

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

就是用具基本数据类型和字符串类型之间做转换

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

基本数据类型 + “”    基本数据类型.toString(基本数据类型值);

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

          xxx  a  =  Xxx。ParseXxx(String);

比如：int a = Integer.parseInt(“123”);  但是“a123”不行  格式不对

      double b = Double.parse(“12.23”);

      boolean b = Boolean.parseBoolean(“true”);

    对象调用：  int num = i.intValue();

5十进制转成其他进制   

       toBinaryString();   toHexString();  toOctalSrtring();   返回都是String

6 其他进制转成十进制

       parseInt(string,  radix);   将string转换成radix进制

 

 

14-基本数据类型对象包装类新特性

JDK1.5版本后出现新特性

Integerx = new Integer(4);可写成 Integer x = 4; //自动装箱

x =x /*x.intValue()*/+ 2;  //x+2:x进行自动拆箱，变成了int类型，和2进行运算，再将和惊醒装箱赋值

 

Integerm = 128;

Integern = 128;

System.out.println("m=n"+(m==n));//false

Integera = 127;

Integerb = 127;

System.out.println("a=b"+(a==b));//true因为a和b指向了同意个Integer对象。

                                  当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间