黑马----String,StringBuffer,基本数据类型对象包装类浅记

---------------------- android培训、java培训、期待与您交流！ ----------------------

 

一.String：

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

String str="abc";//str是一个类类型变量，所以“abc”是一个对象
 
String str1=new String("abc");
public final class String

String s=new String();
String s1="";
===============================
String类适用于描述字符串事物

那么它就提供了多个方法对字符串进行操作

常见的操作有哪些？

1.获取

    1.1字符串中的包含的字符数，也就是字符串的长度
   

         int length();获取长度
   

    1.2根据位置获取位置上某个字符

         char charAt(int index);
    

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

         int indexOf(int ch);//返回的是ch在字符串中第一次出现的位置
         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);反向索引

2.判断
   2.1字符串中是否包含某一个子串
        

         boolean contains(str);  
 

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

   2.2字符串中是否有内容 
  

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

   2.3字符串是否是以指定内容开头
  

        boolean startsWith(str);
 

   2.4字符串是否是以指定内容结尾
 

        boolean endsWith(str);
  

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

        boolean equals(str);

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

        boolean equalsIgnoreCase（）；
3.转换
   3.1将字符数组转成字符串
  

           构造函数：String（char[]）
                             String(char[],offset,count):将字符数组中的一部分转成字符串
 
            静态方法：
                            static String copyValueOf(char[]);
                            static String copyValueOf(char[] data,int offset, int count);
                            static String valueOf(char[]);

     3.2将字符串转成字符数组

            char[] toCharArray();

 

    3.3将字节数组转成字符串
         

           String（byte[]）;
           String（byte[],offset,count）；:将字节数组中的一部分转成字符串
 
     3.4将字符串转成字节数组
    

           byte[] getBytes（）；
 

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

           static String valueOf(int);
           static String valueOf(double);
   特殊：字符串和字节数组在转换过程中，是可以指定编码表的

4.替换：
           String replace(char oldchar,char newchar);
            注意：如果要替换的字符不存在，就返回原串
5.切割

      String[] split(regex);

6.子串：获取字符串中的一部分

      String substring(int begin); 
      String substring(int beginIndex,int endIndex)//包含头，不包含尾

7.转换：去除空格，比较
 

      7.1 将字符串转成大写或者小写
   

           String toUpperCase();
           String toLowerCase();
 

      7.2将字符串两端的多个空格去除
   

           String trim();
 

     7.3对两个字符串进行自然顺序比较
 

            int compareTo(string);

 

8字符串练习：
（1.）模拟一个trim方法，去除字符串两端的空格
  思路：
  1.）判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止
    结尾处判断空格也是如此
  2.）当开始和结尾都判断到不是空格时，就是要获取的字符串
class StringTest
{
     public static void sop(String str)
     {

           System.out.println(str);

     }
     public static void main(String[] args)
     {
        String s="    ab cd     ";
        sop("("+s+")");
        s=myTrim(s);
        sop("("+s+")");

     }
     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);
     }
}
（2）将一个字符串进行反转，将字符串中指定部分进行反转，“abcdefg”;abfedcg
   思路：
  1.）曾经学习过对数组的元素进行反转，
  2.）将字符串变成数组，对数组反转，
  3.）将反转后的数组变成字符串
  4.）只要将或反转的部分的开始和结束位置作为参数传递即可。
class StringTest
{ 
     public static void sop(String str)
     {
          System.out.println(str);

      }
      public static void main(String[] args)
      {
         String s="      ab cd     ";
         sop("("+s+")");
         sop("("+reverseString(s,6,9)+")");
         sop("("+reverseString(s)+")");

      }

 

 public static String reverseString(String s,int start,int end)
  {
      char[] chs=s.toCharArray();
      reverse(chs,start,end);
      return new String(chs);
   }
   public static String reverseString(String s)
   {
           return reverseString(s,0,s.length());

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

        }

 

    }
    private static void swap(char[] arr,int x,int y)
    {
      char temp=arr[x];
      arr[x]=arr[y];
      arr[y]=temp;

 

     }
}
(3.)获取一个字符串在另一个字符串中出现的次数
  “abkkcdkkefkkskk”
  思路：
  1.)定义一个计数器
  2.)获取kk第一次出现的位置
  3.)从第一次出现位置后剩余的字符串中继续获取kk出现的位置,每获取一次就计数一次
  4.)当获取不到时，计数完成，
class StringTest2
{
 public static int getSubCout(String str,String key)
        {
  int count=0;
  int index=0;
  while((index=str.indexOf(key)!=-1))
  {
    sop("str="+str);
   str=str.substring(index+key.length());
   count++;

  }
  return count;
 }
 
 public static void main(String[] args)
 {
  String str="abkkcdkkefkkskk";
  sop("count="+getSubCount(str,"kk"));

         }
 public static void sop(String str)
 {

  System.out.println(str);

 }
}

方法二：
class StringTest2
{
 public static int getSubCount_2(String str,String key)
 {
  int count=0;
  int index=0;
  while((index=str.indexOf(key,index))!=-1)
  {
   sop("index="+index);
   index=index+key.length();
   count++;
  }
  return count;
 }
 public static void main(String[] args)
 {
  String str="abkkcdkkefkkskk";
  sop("count="+getSubCount_2(str,"kk"));

 }
 public static void sop(String str)
 {

  System.out.println(str);
 }
)

(4.)获取两个字符串中最大相同子串，第一个动作：将短的那个串进行长度依次递减的子串打印
“abcwerthelloyuiodef”
  "cvhellobnm"
思路：
  1.)将短的那个子串按照长度递减的方式获取到，
  2.)将每获取到的子串去长串中判断是否包含，如果包含，已经找到了
class StringTest3
{
 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<s2.length();x++)
  {
   for(int y=0;z=min.length()-x;z!=min.length()+1;y++,z++)
   {
    String temp=min.substring(y,z);

    //sop(temp);
    if(max.contains(temp))
    return temp;

   }

  }

  return " ";
 }

 

 public static void main(String[] args)
 {
  String s1="cvhellobnm";
  String s2="abcwerthelloyuiodef";
  sop(getMaxSubString(s2,s1));

 }
 public Static void sop(String str)
 {

  System.out.println(str);
 }

}
========================================================
二.StringBuffer

特点：
1.长度是可变化的
2.可以直接操作多个数据类型
3.最终会通过tostring方法变成字符串

 

 

操作：

 

1.存储

      StringBuffer append();将指定数据作为参数添加到已胡数据结尾处
      StringBuffer insert(index,数据)：可以将数据插入到指定index位置

 2.删除

      StringBuffer delete(int start,int end );//删除缓冲区中的数据，包含Start，包含end
      StringBuffer deleteCharAt(index);//删除指定位置的字符

 3.获取
      char charAt( int index);
      int indexOf(String str);
      int lastIndexOf(String str);
      int length()
     String substring (int start ,int end);

 

4.修改

     StringBuffer replace(int start,int end String str);
     void setCharAt(int index,char ch);

5.反转

     StringBuffer reverse();

 

6.将缓冲区中指定数据存储到指定字符数组中
 

     void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
=======================================
JDK1.5版本之后出现了StringBuilder

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

StringBuilder是一个可变的字符序列，此类提供一个与StringBuffer兼容的API
但不保证同步，该类被设计用作StringBuffer的一个简易替换，用在字符缓冲区被单个
线程使用的时候，如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快

升级三个因素：
1.提高效率
2.简化书写
3.提高安全性
========================================
三.基本数据类型对象包装类
byte------Byte

short-----Short

 

long------Long

boolean---Boolean

float-----Float

double----Double

char------Character

int-------Integer(类)：在对象中包装了一个基本类型int的值，Integer类型的对象包含一个int类型的字段
                                此外，该类提供了多个方法，能在int类型和String类型之间互相转换，还提供了处理int类型时非常有用的其他一些常量和方法:
 static int MAX_VALUE:它表示int类型能够表示的最大值
 static int MIN_VALUE:它表示int类型能够表示的最小值
 static int SIZE:用来以二进制补码形式表示int值的比特位数
 static Class<Integer>TYPE:表示基本类型int 的Class实例

 

1.构造方法：Integer(int value):构造一个新分配的Integer对象，它表示指定的int值
                   Integer(String s):构造一个新分配的Integer对象 ，它表示String参数所指示的int值

2.基本数据类型对象包装类的最常见作用： 就是用于基本数据类型和字符串类型之间做转换

    1.)基本数据类型转成字符串：
         

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

   2.)字符串转成基本数据类型：

          xxx a=Xxx.parseXxx(String s);
          static int parseInt(String s);
          如：int num=Integer.parseInt("123");//必须传入数字格式的字符串
         double b=Double.parseDouble("12.23");
         boolean b=Boolean.parseBoolean("true");
         Integer i=new Integer("123");
         int num=i.intValue();

3）十进制转成其它进制：
  

        toBinaryString();
        toHexString();
        toOctalString();
4）其它进制转成十进制：
 

       parseInt(String s,int radix);

 

JDK1.5版本以后出现的新特性：

       Integer x=4；//自动装箱
       x=x+2;//x是一个对象，却可以直接进行运算，是因为x进行自动拆箱(x.intValue())，变成了int类型，和2进行加法运算再将和进行装箱赋给x。
注意：当数值在byte范围内，对于新特性，如果该数值已经存在，则不会再开辟新的空间。

 

 

 

--------------------- android培训、java培训、期待与您交流！ ---------------------