Java的String类以及Java基本数据类型对象包装类

**

String类

**
字符串是一个类，是一个常量，定义后就不可更改，存放在方法区中的常量池中。Strng s1 = “abc”;s1=”kk”; ，更改是的是s1的值，而字符串类”abc”并未被更改。

String s1 = “abc”;

String s2 = new String(“abc”);

System.out.println(s1 == s2); //为false

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

                                                                           该方法用于判断字符串内容是否相同

s1和s2的区别：

s1在内存中有一个对象。s2在内存中有两个对象。s2中 newString()为一个对象，”abc”是一个字符串对象

7.1String类常见操作

String类适用于描述字符串事物，那么它就提供了多个方法对字符串进行操作

字符串的常见操作：

1） 获取

字符串中包含的字符数，即字符串的长度：

intlength()

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

charcharAt(int index)

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

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)返回ch在字符串中最后一次出现的位置

2） 判断

字符串中是否包含某一个子串：

boolean contains(str);

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

符串当中。所以也可以用于判断是否包含字符串，而且可以获取出现的

位置

字符中是否有内容：

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

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

boolean startsWith(str);

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

boolean endsWith(str);

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

boolean equals(str);

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

boolean equalsIgnoreCase();

3） 整体转换

将字符数组转成字符串：

构造函数：String(char[])

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

静态方法：staticString copyValueOf(char[]);

      static StringcopyValueOf(char[] data,int offset,int count);

      static StringvalueOf(char[]);

将字符串转成字符数组：

char[] toCharArray();

将字节数组转成字符串：

String(byte[])

String(byte[],offset,count)  将字节数组中的一部分转成字符串

将字符串转成字节数组：

byte[] getBytes();

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

static String valueOf(int);

static String valueOf(double);

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

4） 替换

String replace(oldchar,newchar); //替换后变成新字符串，并不是将原字符串直接修改

5） 切割

String[] split(regex);

6） 子串

获取字符串中的一部分：

Stringsubstring(begin);

Stringsubstring(begin,end); 包含头(s[begin])，不包含尾(s[end])

7） 追加、转换，去除空格，比较

将指定字符串连接到此字符串的结尾

Stringconcat(String str)

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

String toUpperCase();

String toLowerCase();

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

String trim();

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

intcompareTo(string); （按字典顺序比较两个字符串）返回值为0表示相等

代码示例：

class StringMethodDemo 
{
    public static void method_7()
    {
        String s= "   Hello Java   ";
        sop(s.toLowerCase());              //转换成小写
        sop(s.toUpperCase());              //转成大写
        sop(s.trim());                     //去除两边的空格
        String s1 = "abc";
        String s2 = "aaa";
        sop(s1.compareTo(s2));             //比较字符串内容是否相同       
    }
    public static void method_sub()             //获取子串
    {
        String s = "abcdef";
        sop(s.substring(2));                //从指定位置开始到结尾.如果角标不存在，会出现字符串角标越界异常
        sop(s.substring(2,4));              //包含头(s[2])，不包含尾(s[4])
    }
    public static void method_split()           //切割
    {
        String s = "zhangsan,lisi,wangwu";     
        String[] arr=s.split(",");          //得到一个以名字为元素的字符数组
    }
public static void method_replace()                 //替换
    {
        String s = "hello java";
        String s1 = s.replace('a','n');     //如果要替换的字符不存在，返回的还是原串
        sop("s="+s);                        //字符串一旦被创建就不会改变
        sop("s1="+s1);
    }
    public static void method_trains()          //整体转换
    {
        char[] arr = {'a','b','c','d','e','f'};
        String str = new String(arr,1,3);   //结果为bcd
        sop("str="+str);
    }
    public static void method_is()              //判断
    {
        String str = "ArrayDemo.java";
        sop(str.startsWith("Array"));       //判断文件名称是否是Array单词开头
        sop(str.endsWith(".java"));         //判断文件名称是否是.java的文件
        sop(str.contains("Demo"));      //判断文件中是否包含Demo
    }
    public static void method_get()             //获取
    {
        String str = "abcdeakpf";
        sop(str.length());
        sop(str.charAt(4));                  //当访问到字符串中不存在的角标时，
//会发生StringIndexOutOfBoundsException
        sop(str.indexOf('a',3));             //如果没有找到，返回-1
        sop(str.lastIndexOf("a"));
    }
    public static void main(String[] args) 
    {
        method_get();
    }
    public static void sop(Object obj)           //打印输入的任何类型数据
    {
        System.out.println(obj);
    }

7.2StringBuffer

StringBuffer即字符串缓冲区，是一个容器，可以对字符串内容进行增删。

特点：

1）而且长度是可以变化的；

2）可以直接操作多个数据类型；

3）最终会通过toString方法变成字符串

功能：

C create U update R read D delete

1） 存储；

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

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

2） 删除；

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

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

3） 获取；

char charAt(index)

int indexOf(String str)

int lastIndexof(String str)

int length()

String substring(int start,int end)

4） 修改；

StringBuffer replace(start,end,String str)

void setCharAt(index,char ch) 没有返回值

5） 反转

StringBuffer reverse();

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

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

JDK1.5版本之后出现了StringBuilder。

构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。该类被设计用作StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

StringBuffer和StringBuilder的区别：

StringBuffer是线程同步，即不能同时对StringBuffer进行多个操作，有锁，不会出现安全问题

StringBuilder是线程不同步，多用于单线程，无锁，效率高

8.基本数据类型对象包装类

基本数据类型 引用数据类型

     byte                    Byte

     short             Short

     int                       Integer

     long                    Long

     boolean           Boolean

     float                   Float

     double               Double

     char                    Character

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

可以通过对象中的属性和行为操作基本数据。用于基本数据类型和字符串类型之间做转换。

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

     1）基本类型数值+””

     2）用string类中非静态方法valueOf(基本类型数值);

     3）引用数据类型.toString(基本数据类型值)

        如：Integer.toString(34)    //将34整数变成”34”

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

1）xxx a =Xxx.parseXxx(String)

如：int a =Integer.parseInt(“123”); //必须传入数字格式的字符串

        double b = Double.parseDouble(“12.3”);

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

        Character没有parse方法

1） 如果字符串被Integer进行了对象的封装，可以使用另一个非静态的方法

intValue(); 将一个Integer对象转成基本数据类型值

Integer I = new Integer(“123”);

i.intValue()

十进制转成其他进制：

     toBinaryString();

     toHexString();

     toOctalString();

     toString(inti,int radix);     返回以radix为基数的i的值的字符串表现形式

其他进制转成十进制：

     parseInt(string,radix)

     如：int x =Integer.parseInt("110",2); //x=6. string为要转换的数，radix为此数的进制

比较Integer对象值的大小：

Integer.compareTo(another Integer) 大于为1，等于为0，小于为-1

JDK 1.5版本后出现的新特性：

Integer x = new Integer(4); //简化为： Integer x = 4; 自动装箱

x = x + 2 //Integer类型对象x 可以直接与int 2 进行计算。

                                                      x+2：x进行自动拆箱（x.intValue()），变成了int类型，和2进行加法运算，再将其和进行装箱赋给x

Integer a = 127;

Integer b = 127;

sop(“a==b:”+(a==b)); //结果为true，因为a和b指向了同一个Integer对象

因为当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间，仅针对采用简化方式书写的代码（如果用new Integer(127)赋值给a，b，则为false）

基本数据类型对象应用：

import java.util.Arrays;
class Test 
{
    private static final String SPACE_SEPARATOR = " ";
    public static void main(String[] args) 
    {
        String numStr = "20 78 -7 88 36 29";
        numStr = sortStringNumber(numStr);  
        System.out.println(numStr);
    }
    public static String sortStringNumber(String numStr)
    {
        //1，将字符串变成字符串数组
        String[] str_arr = stringToArray(numStr);
        //2，将字符串数组变成int数组
        int[] num_arr = toIntArray(str_arr);
        //3，对int数组排序
        mySortArray(num_arr);
        //4，将排序后的int数组变成字符串
        String temp = arrayToString(num_arr);
        return temp;
    }
    public static String[] stringToArray(String numStr)
    {
        String[] str_arr = numStr.split(SPACE_SEPARATOR);
        return str_arr;
    }
    public static int[] toIntArray(String[] str_arr)
    {
        int[] arr = new int[str_arr.length];
        for (int i = 0;i<arr.length ;i++ )
        {
            arr[i] = Integer.parseInt(str_arr[i]);
        }
        return arr;
    }
    public static String arrayToString(int[] num_arr)
    {
        StringBuilder sb = new 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();
    }
    public static void mySortArray(int[] num_arr)
    {
        Arrays.sort(num_arr);
    }
}