黑马程序员-java基础之字符串类和基本数据类

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

一String

    1概述：String类代表字符串。Java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String对象是不可变的，所以可以共享。

String s1="abc"; 

String s2=new String("abc");

s1和s2的区别：

s1在字符串常量池中创建了一个abc字符串

s2在堆中创建了两个对象一个是默认对象一个是字符串对象。

2构造方法：

将字节数组或者字符数组转成字符串。

String s1 = new String();//创建了一个空内容的字符串。

String s2 = null;//s2没有任何对象指向，是一个null常量值。

String s3 = "";//s3指向一个具体的字符串对象，只不过这个字符串中没有内容。

//一般在定义字符串时，不用new。

String s4 = new String("abc");

String s5 = "abc"; 一般用此写法

new String(char[]);//将字符数组转成字符串。

new String(char[],offset,count);//将字符数组中的一部分转成字符串。

3一般方法

1 获取：

    1：获取字符串的长度。length();

    2：指定位置的字符。char charAt(int index);

    3：获取指定字符的位置。如果不存在返回-1，所以可以通过返回值-1来判断某一个字符不存在的情况。

           int indexOf(int ch);//返回第一次找到的字符角标

           int indexOf(int ch,int fromIndex); //返回从指定位置开始第一次找到的角标

           int indexOf(String str); //返回第一次找到的字符串角标

           int indexOf(String str,int fromIndex);

           int lastIndexOf(int ch);

           int lastIndexOf(int ch,int fromIndex);

           int lastIndexOf(String str);

           int lastIndexOf(String str,int fromIndex);

    4：获取子串。

           String substring(int start);//从start位开始，到length()-1为止.

           String substring(int start,int end);//从start开始到end为止。//包含start位，不包含end位。

           substring(0,str.length());//获取整串

2 判断：

    1：字符串中包含指定的字符串吗？

           boolean contains(String substring);

    2：字符串是否以指定字符串开头啊？

           boolean startsWith(string);

    3：字符串是否以指定字符串结尾啊？

           boolean endsWith(string);

    4：判断字符串是否相同

           boolean equals(string);//覆盖了Object中的方法，判断字符串内容是否相同。

    5：判断字符串内容是否相同，忽略大小写。

           boolean equalsIgnoreCase(string) ;

3 转换：

1：通过构造函数可以将字符数组或者字节数组转成字符串。

    2：可以通过字符串中的静态方法，将字符数组转成字符串。

           static String copyValueOf(char[] );

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

           static String valueOf(char[]);

           static String valueOf(char[],int offset,int count);

3：将基本数据类型或者对象转成字符串。

           static String valueOf(char);

           static String valueOf(boolean);

           static String valueOf(double);

           static String valueOf(float);

           static String valueOf(int);

           static String valueOf(long);

           static String valueOf(Object);

    4：将字符串转成大小写。

           String toLowerCase();

           String toUpperCase();

5：将字符串转成数组。

           char[] toCharArray();//转成字符数组。

           byte[] getBytes();//可以加入编码表。转成字节数组。

    6：将字符串转成字符串数组。切割方法。

           String[] split(分割的规则-字符串);

7：将字符串进行内容替换。注意：修改后变成新字符串，并不是将原字符串直接修改。

           String replace(oldChar,newChar);

           String replace(oldstring,newstring);

    8： String concat(string); //对字符串进行追加。

    9：String trim();//去除字符串两端的空格

10: int compareTo();//如果参数字符串等于此字符串，则返回值 0；如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。

代码练习1==与equals的区别

class StringDemo

{

      public static void main(String[] args)

{

String s = "abc";//创建一个字符串对象在常量池中。           

             //创建两个对象一个new一个字符串对象在堆内存中。

String s1 = new String("abc");          

             System.out.println(s==s1);//false

//string类中的equals复写Object中的equals建立了string类自己的判断字符

//串对象是否相同的依据。

             //其实就是比较字符串内容

             System.out.println(s.equals(s1))//true;

      }

}

代码练习2将字节数组或者字符数组转成字符串可以通过String类的构造函数完成

public class StringConstructorDemo

{

      public static void main(String[] args)

{

      char[] arr = {'w','a','p','q','x'};

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

      System.out.println("s="+s)

}

}

代码练习3给定一个字符串数组。按照字典顺序进行从小到大的排序

public class StringDemo3

{

      public static void main(String[] args)

{

             String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };

             printArray(arr);

             sortString(arr);

             printArray(arr);

      }

      public 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)//字符串比较用compareTo方法

                                  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;

      }

      public static void printArray(String[] arr) {

             System.out.print("[");

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

                    if (i != arr.length - 1)

                           System.out.print(arr[i] + ", ");

                    else

                           System.out.println(arr[i] + "]");

             }

      }

}

代码练习4一个子串在整串中出现的次数

public class StringDemo4

{

             public static void main(String[] args)

{

             String str = "nbaernbatnbaynbauinbaopnba";

             String key = "nba";

             int count = getKeyStringCount (str,key);

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

      }

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

             int count = 0;

             int index = 0;

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

{

                    index = index + key.length();

                    count++;

             }

             return count;

      }

}

代码练习5两个字符串中最大相同的子串。

class StringTest_3

{

      public static void main(String[] args)

{

             String s1 = "qwerabcdtyuiop";

             String s2 = "xcabcdvbn";

             String s = getMaxSubstring(s2, s1);

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

      }

      public static String getMaxSubstring(String s1, String s2)

 {

             String max = null,min = null;

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

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

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

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

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

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

                           String sub = min.substring(a, b);

//                         System.out.println(sub);

                           if(max.contains(sub))

                                  return sub;

                    }

             }

             return null;

      }

}

二StringBuffer

概述：StringBuffer是一个容器，字符串的组成原理就是通过该类实现的。StringBuffer可以对字符串内容进行增删改查等操作，很多方法和String相同。

特点：

1：可以对字符串内容进行修改。

2：是一个容器。

3：是可变长度的。

4：缓冲区中可以存储任意类型的数据。

5：最终需要变成字符串。

常用方法

1，添加。

    StringBuffer append(data):在缓冲区中追加数据。追加到尾部。

    StringBuffer insert(index,data):在指定位置插入数据。

2，删除。

    StringBuffer delete(start,end);删除从start至end-1范围的元素

    StringBuffer deleteCharAt(index);删除指定位置的元素

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

3，修改。

    StringBuffer replace(start,end,string);将start至end-1替换成string

    void setCharAt(index,char);替换指定位置的字符

    void setLength(len);将原字符串置为指定长度的字符串

4，查找。（查不到返回-1）

    int indexOf(string);返回指定子字符串在此字符串中第一次出现处的索引。

    int indexOf(string,int fromIndex);从指定位置开始查找字符串

    int lastIndexOf(string);返回指定子字符串在此字符串中最右边出现处的索引。

    int lastIndexOf(string,int fromIndex);从指定的索引开始反向搜索

5，获取子串。

    string substring(start);返回start到结尾的子串

    string substring(start,end);返回start至end-1的子串

6，反转。

    StringBuffer reverse();字符串反转

三StringBuilder

1概述：JDK1.5出现StringBuiler；构造一个其中不带字符的字符串生成器，初始容量为 16个字符。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。方法和StringBuffer一样；

StringBuilder和StringBuffer的区别

StringBuffer是同步的，效率低，线程安全。在多线程操作时，使用StringBuffer

StringBuilder是非同步的，效率高，线程不安全。在单线程操作时，使用StringBuilder

四基本数据包装类

1概述：为了更方便的操作每个基本数据类型，java将其封装成对象对外提供了很多的属性和方法供我们使用，将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能操作该数据。常用的操作之一：用于基本数据类型与字符串之间的转换。

2基本数据类型和对象类型的对应

       byte       Byte

       short      Short

       int    Integer

       long       Long

       float      Float

       double     Double

       boolean       Boolean

       char       Character

3自动拆装箱

在jdk1.5版本后，对基本数据类型对象包装类进行升级。在升级中，使用基本数据类型对象包装类可以像使用基本数据类型一样，进行运算。

    Integer i = new Integer(4); //1.5版本之前的写法；

    Integer i = 4; //自动装箱，1.5版本后的写法；

    i = i + 5;

    //i对象是不能直接和5相加的，其实底层先将i转成int类型，在和5相加。而转成int类型的操作是隐式的。自动拆箱：拆箱的原理就是i.intValue();i+5运算完是一个int整数。如何赋值给引用类型i呢？其实有对结果进行装箱。

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------