黑马程序员——【Java基础】——String、StringBuffer和基本数据包装类

类String------------------------------------------------

一、概述

　　（一）定义：String是字符串的类类型，用于描述字符串事物。

　　（二）特点：字符串对象一旦被初始化，就不会被改变。String类不能有子类。

　　（三）写法

　　1、Sting s= new String(“abc”) ;

　　2、String s = “abc”；

　　（四）细节

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

　　String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存中。

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

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

　　//string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。

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

二、字符串常用方法

　　（一）获取

　　　* int length() ：获取字符串的长度。

　　　* char charAt(int index)：返回指定索引index处的 char 值

　　　* 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)：//返回指定字符在此字符串中最后一次出现处的索引，即反向索引

　　（二）判断

　　　* Boolean contains(str)：判断字符串中是否包含str子串。

　　　　特殊之处：indexOf（str）可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中存在。所以，也可以用于对指定判断是否包含。

　　　　例如：if(str.indexOf(“aa”)!=-1）而且该方法既可以判断，又可以获取出现的位置。如果只为判断，用contains。

　　　* boolean isEmpty()：判断字符串是否为空（JDK1.6开始支持）。

　　　* boolean startsWith(String prefix)：字符串是否是以指定内容开头。

　　　* boolean endsWith(String suffix)：字符串是否是以指定内容结尾。

　　　* boolean equals(str)：判断字符串的内容是否相同，它覆写了Object类的方法。

　　　* boolean equalsIgnoreCase()：忽略大小写的比较。

　　（三）转换

　　　* char[] toCharArray()：将字符串转成字符数组。

　　　* 将字符数组转成字符串：

　　  　-构造函数：String (char[])；

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

 　　 　-静态方法：

      　　　static String copyValueOf(char[])；

      　　　staticString copyValueOf(char[] data,int offset ,int count )；

　　　　　static String valueOf(char[])；

　　　* 将字节数组转成字符串：

　　　　　String (byte[])；

　　　　　String(byte[], offset,count)；//将字节数组中的一部分转成字符串。count表示个数。

　　　* byte[] getBytes()：将字符串转成字节数组。

　　　* 将“基本数据类型”——“字符串”：

　　　　　static String valueOf(int)；

　　　　　static String valueOf(double)；

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

　　　* String concat(String str)：将字符串进行连接。

　　（四）替换

　　　* String replace(oldchar, newchar)：生成一个新的字符串，如果要替换的字符不存在，返回原字符串。

　　　* String replace(CharSequence target, CharSequence replcement):例如str.replace(“abc”, “qqq”);

　　（五）切割

　　　* String[] split(regex)：按照正则表达式regex的要求对字符串进行切割，返回字符串数组。

　　（六）子串（获取字符串中的一部分）

　　　* String subString(int beginIndex)：从beginIndex角标开始截取到字符串最后，获取截取的子串。

　　　* String substring(int beginIndex, int endIndex)：从beginIndex角标字符串到endIndex-1角标的字符串。

　　（七）转换，去除空格，比较

　　　* 将字符串转成大写或小写：StringtoUpperCase()、String toLowerCase()

　　　* 将字符串两端的多个空格去除：String trim()

　　　* 对两个字符串进行自然顺序的比较：int compareTo(String str);

 

类 StringBuffer ------------------------------------------------

一、概述

　　StringBuffer是一个类似于 String 的字符串缓冲区，可以看做一个容器。StringBuffer可以对字符串内容进行增、删、改、查等操作。

二、特点

　　1、长度是可变化的。（数组是固定的）

　　2、可以直接操作多种数据类型。（数组只能操作一个）

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

三、创建对象

　　StringBuffer sb = new StringBuffer();//初始容量为16个字符。

四、常见操作

　　（一）存储

　　　　StringBuffer append()：将指定数据作为参数添加到已有数据的结尾处。

　　　　StringBuffer insert(int offset ,数据)：可以将数据插入到指定offset位置。

　　（二）删除

　　　　StringBuffere delete(start,end)：删除缓冲区中的数据，包含start，不包含end。

　　　　StringBuffer deleteCharAt(index)：删除指定位置的字符。

　　　　清空缓冲区：对象.delete(0,对象.length());

　　（三）获取

　　　　char charAt(int index)；

　　　　int indexOf(String str)；

　　　　int lastIndexOf(String str)；

　　　　int length()；

　　　　String substring(int start, int end)；

　　（四）修改

　　　　StringBuffer replace(int start, int end, String str)；

　　　　void setCharAt(int index, char ch)；

　　（五）反转

　　　　StringBuffer reverse()；

　　（六）将缓冲区中指定数据存储到指定字符数组中

　　　　void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

五、JDK1.5新特点

　　1、在JDK1.5版本之后，为了提高缓冲区效率，出现了StringBuilder。其中，StringBuffer是线程同步的、用于多线程。StringBuilder是线程不同步的，应用于单线程，它的出现提高效率。

　　2、Java升级的理由：（1）提高效率。（2）简化书写。（3）提高安全性。

 

基本数据类型包装类 -------------------------------------

　　将基本数据类型封装成对象的好处，在于可以在对象中定义更多的功能方法操作该数据。基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。

一、基本数据类型——包装类

基本数据类型	对应包装类
byte	Byte
short	Short
int	Integer
long	Long
boolean	Boolean
float	Float
double	Double
char	Character

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

二、“基本数据类型”——“字符串”

　　1、基本数据类型+" "；

　　2、基本数据类型.toString(基本数据类型值)。如：Integer.toString(25);//将25整数变成"25"。

三、“字符串”——“基本数据类型”

　　1、规律格式：基本数据类型包装类.parse基本类型(string)；

　　2、代码格式：xxx a = Xxx.parseXxx(string)；//必须传入对应类型的字符串。

　　3、示例：

　　　　int a = Integer.parseInt("123")；//静态转换方法

　　　　Integer i = new Integer("123")；

　　　　int num = i.intValue()；//跟上面的静态方式的结果一样，但这种属于对象调用方式。

　　　　Boolean b = Boolean.parseBoolean("true")；

　　　　注意：在使用时，Integer x = null；上面的代码就会出现NullPointerException，要判断。

四、“十进制”——“其他进制”

　　toBinaryString()；

　　toHexString()；

　　toOctalString()；

五、其他进制转成十进制

　　parseInt(String , radix)；

　　如：int a= Integer.parseInt("110", 2)；

六、JDK1.5版本以后的新特性

　　Integer x=4；自动装箱。等效于Integer x=new Integer(4);

　　x = x+2；//进行自动拆箱。变成了int类型。和2进行相加。x的拆箱等价于x.intValue()。

七、补充

　　1、若：Integer m = 128；Integer n = 128；则：x==y，结果是false。

　　2、若：Integer a = 127；Integer b = 127；则：a==b，结果是true。因为a和b指向了同一个Integer对象。当数值在byte范围内，对于新特性，如果该值已存在，则不会再开辟新的空间。

八、练习

　　/*    对一个字符串中的数值进行从小到大的排序。"20 78 9 -7 88 36 29"

　　思路：

　　1.排序，熟悉

　　2.将字符串转为子串，获取字符串中需要排序的数值。发现原字符串是用空格分隔的，因此可以用字符串对象的切割方法将大字符串转化为小串。

　　3，如何将获取的数值字符串，转换为int类型。字符串-->基本数据类型，可以使用包装类。 */

import java.util.Arrays;
class wrapperClassDemo{
    private static final String SPACE_SEPARATOR = " ";    
    public static void main(String[] args) {
        String numStr = "20 78 9 -7 88 36 29";
        System.out.println(numStr);        
        numStr = sortStringNumber(numStr);
        System.out.println(numStr);
    }
　　// 字符串排序函数
    public static String sortStringNumber(String numStr){
        //将数字字符串转化为字符数组
        String[] str_arr = stringToArray(numStr);

        //将字符数组转化为int数组
        int[] num_arr = toIntArray(str_arr);

        //将int数组进行从小到大的排序
        mySortArray(num_arr);

        //将int数组转化为字符串
        String temp = numToString(num_arr);

        return temp;
    }
　　// 定义字符串转变成字符串数组函数
    public static String[] stringToArray(String numStr){
        String[] str_arr = numStr.split(SPACE_SEPARATOR);
        return str_arr;
    }
　　// 定义字符串数组转换为int[]数组
    public static int[] toIntArray(String[] str_arr){
        int[] int_arr =new int[str_arr.length];
        for (int i = 0;i<str_arr.length ;i++ ){
            int_arr[i] = Integer.parseInt(str_arr[i]);
        }
        return int_arr;
    }
　　// 对int[]进行排序
    public static void mySortArray(int[] num_arr){
        Arrays.sort(num_arr);
    }
　　// 定义int[]数组转为String函数
    public static String numToString(int[] num_arr){
//        StringBuffer sb = new StringBuffer();//多线程，用StringBuffer
        StringBuilder sb = new StringBuilder();//单线程，用StringBuilder
        for (int x= 0;x<num_arr.length ;x++ ){
            if (x!=num_arr.length-1)
                sb.append(num_arr[x]+SPACE_SEPARATOR);
            else
                sb.append(num_arr[x]);
        }
        return sb.toString();
    }
}