字符串类与基本数据包装类

# String类

## 特点
字符串最大的特点就是：一旦被初始化就不可以被改变
```java
String s1 = "abc";
s1 = "kk";
```
所谓不能改变，指的是字符串的值不能改变，"abc"是一个对象。这个对象的值不能改变，也就是说是字符串常量，s1是一个类类型变量，它可以指向任何对象，其值可以改变,上面的s1的值变成了kk，不是字符串变了，而是变量指向了kk这个对象

## 创建字符串的两种方式的区别
```java
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
s1==s2;//false
s1.equals(s2);//true
s1==s3;//true
```
s1和s2使用起来是一样的

但是是有区别的,区别是s1在内存中有一个对象："abc"，s2在内存中有两个对象："abc"和s2所指向的new对象

s1和s2是两个不同的对象，s1是指向了"abc"对象，s2是新建了一个对象，所以==是不相等的

字符串常量，在创建之后，如果还有变量在创建相同的常量，那么在内存中是让变量直接指向已有的常量，不会在创建常量，因为已经有了而且字符串的值不会改变，所以为了节省空间，就不再重新创建一个常量了，所以s1和s3指向同一个字符串常量对象，故其地址值是相同的

## 字符串练习

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

```java
/*
思路：
    1、定义一计数器
    2、获得字符串第一次在另个字符中出现的位置
    3、从第一次出现的位置后剩余的字符串中继续获取字符串出现的次数，每出现一次，计数器就加一次
    4、当获取不到时候，计数停止
*/
class  CountTest
{
    public static void main(String[] args) 
    {
        String s="Hllello Worlld!";
        sop("s="+s);
     
        sop("count="+count(s,"ll"));
    }
 
    public static int count(String s,String key)
    {
        int count=0;//定义计数器
        int index=0;//定义获取角标变量
        while((index=s.indexOf(key,index))!=-1)//如果包含，则继续
        {
            index=index+key.length();//从找到的子串位置后一位开始获取
            count++;
        }
        return count;
    }
 
    private static  void sop(Object obj)
    {
        System.out.println(obj);
    }
 
}
```

### 将一个字符串反转
```java
/*
思路：
    1、将字符串转换为字符数组
    2、将数组反转
    3、将字符数组转换为字符串
*/
class ReverseTest 
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        String s="abca dv daf";
        sop(s);
         
//      ReverseString r=new ReverseString();
 
        sop(new ReverseString().reverseString(s));
    }
 
}
class ReverseString
{
     
    public static String  reverseString(String s,int start,int end)
    {
        //将字符串变为字符数组
        char[] ch=s.toCharArray();
 
        //将数组进行反转
        charReverse(ch,start,end);
         
        //将字符数组变为字符串
        return new String().valueOf(ch);
 
    }
    //反转整个字符串
    public static String reverseString(String s)
    {
        return reverseString(s,0,s.length());
    }
     
    //反转指定字符数组位置
    private static void charReverse(char[] ch,int start,int end)
    {
        for (int x=start,y=end-1; x<y;x++,y--)
        {
            swap(ch,x,y);
        }
    }
     
    //交换相应数组元素
    private static  void swap(char[] ch, int start,int end)
    {   
        char temp=ch[start];
        ch[start]=ch[end];
        ch[end]=temp;
    }
}
```

### 获取两个字符串中最大相同子串
```java
/*
 
思路：
    1、将短的一个字符串与长的进行比较，如果没有，则将短串的字串按长度递减的方式获取
    2、将每次获取的子串，去长串中判断是否包含，包含即找到。
*/
class  MaxSubstring
{
    public static void main(String[] args)
    {
        String s1="HelloafsfWorldcgagb!";
        String s2="fWorldafdffsfsfsfsfdc";
        sop(getMaxSubstring(s1,s2));
    }

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++)//依次递减短字符串子串
            {
                String temp=min.substring(y,z);//获取短字符串子串
                if(max.contains(temp))//如果长串包含，则表示找到
                    return temp;
            }
        }
        return "没有相同的字符串";
    }

//打印输出
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
```

### 对一个字符串中的字符进行自然排序
```java
/*
思路：
    1、将字符串转换为字符数组。
    2、对字符数组进行选择、冒泡排序
    3、将排好序的字符数组转换为字符串
*/

class  RaturalSortString
{
    public static void main(String[] args)
    {
        String s="vcz1bdaA+cs";
        sop(s);//打印原字符串

sop(raturalSortString(s));//打印排序后的字符串

sop(getLowerCaseString(raturalSortString(s)));//打印排序后的小写字母部分
    }

//取出有序字符串中的小写字母部分
    public static String getLowerCaseString(String s)
    {
        int[] arr=lowerCaseIndex(s);

return s.substring(arr[0],arr[1]);
    }
    //对字符串中的小写字母进行自然排序的方法
    public static String raturalSortString(String s)
    {
        //将字符串转换为字符数组
        char[] arr = s.toCharArray();

//将字符数组进行排序
        selectSortArray(arr);

//将排序好的字符数组转换为字符串返回
        return new String(arr);
    }

//对数组进行选择排序
    private static void selectSortArray(char[] arr)
    {
        for (int x=0; x<arr.length-1; x++)
        {
            for (int y=x+1;y<arr.length ; y++)
            {
                if(arr[x]>arr[y])
                    swap(arr,x,y);
            }
        }
    }

//交换数组两元素
    private static void swap(char[] arr ,int x,int y )
    {
        arr[x]=(char)(arr[x]^arr[y]);
        arr[y]=(char)(arr[x]^arr[y]);
        arr[x]=(char)(arr[x]^arr[y]);
    }

//判断小写字母部分在有序字符串中的位置，并将第一个的位置和最后一个的位置存在一个数组中，返回数组
    private static int[] lowerCaseIndex(String s)
    {
        //将字符串转换为字符数组
        char[] arr = s.toCharArray();

int x=0;
        for(;arr[x]<'a';x++);
            int y=arr.length-1;
        for(;arr[y]>'z';y--);
            int[] a = {x,y+1};

return a;
    }
    //打印
    private static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
```
# StringBuffer
## 概述
StringBuffer是一个容器，字符串的组成原理就是通过该类实现的。StringBuffer可以对字符串内容进行增删改查等操作，很多方法和String相同。

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

面盆理论：StringBuffer就是一个面盆，往里面加面，加水，还是这个盆，无论怎么改变，盆还是那个盆，StringBuffer还是那个StringBuffer，所以与字符串不同(字符串的值不可改变)StringBuffer无需创建多个StringBuffer对象去接受改变后的StringBuffer对象，只在原StringBuffer对象中改变即可

StringBuffer对象中的方法返回的还是StringBuffer对象，所以还能调用StringBuffer对象中的方法

# 基本数据类型包装类

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

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

## 基本数据类型转成字符串
* 基本数据类型+" "
* 基本数据类型.toString(基本数据类型值)

## 字符串转成基本数据类型
xxx a = Xxx.parseXxx(string);必须传入对应类型的字符串

如：int a=Integer.parseInt("123");这是静态方法

boolean b=Boolean.parseBoolean("true");

## 十进制转成其他进制
* String toBinaryString(int i)：转成二进制字符串
* String toHexString(int i)：转成十六进制字符串
* String toOctalString(int i)：转成八进制字符串

## 其他进制转成十进制

int parseInt(String s,int radix)

如：int a= Intager.parseInt("3c",16);

JDK1.5版本以后出现的新特性:自动装箱
Integer x=new Integer(4);等效于：Integer x=4;

还可以直接进行运算：x=x+2;x进行自动拆箱。变成了int类型。和2进行加法运算。再将和进行装箱赋给x。x的拆箱动作等效：x.intValue()。

## 练习
"12 0 99 -7 30 4 100 13 -6"

要求对字符串中的数值进行排序。生成一个数值从小到大新字符串

"-7 -6 0 4 12 13 30 99 100"
```java
/*
思路：
    1、将字符串切割为字符串数组
    2、将字符串数组转换为整数类型数组
    3、对整数类型数组进行冒泡排序
    4、将排序后的整数类型数组转换为字符串
*/

class  StringSort
{
    public static void main(String[] args)
    {
        String s="12 0 99 -7 30 4 100 13 -6";
        sop(s);

sop(stringSort(s));
    }

public static String stringSort(String s)
    {
        //将字符串切割成字符串数组
        String[] str=s.split(" ");

//将字符串数组转换为整数类型数组
        int[] arr=stringToInt(str);

// 对整数类型数组进行冒泡排序
        bubbleSort(arr);

//将排序后的整数类型数组转换为字符串
        return intToString(arr).toString();
    }

// 将字符串数组转换为整数类型数组方法
    private static int[] stringToInt(String[] str)
    {
        int[] arr=new int[str.length];
        for(int x=0;x<str.length;x++)
        {
            arr[x]=Integer.parseInt(str[x]);
//          sop(arr[x]);

}
    //  sop(arr);
        return arr;
    }

//对数组进行冒泡排序
    private static void bubbleSort(int[] arr)
    {
        for (int x=0;x<arr.length ;x++ )
        {
            for (int y=0;y<arr.length-x-1; y++)
            {
                if(arr[y]>arr[y+1])
                    swap(arr,y,y+1);
            }
        }
    //  sop(arr);
    }

//交换数组中的两元素
    private static void swap(int[] arr,int x,int y)
    {
        arr[x]=arr[x]^arr[y];
        arr[y]=arr[x]^arr[y];
        arr[x]=arr[x]^arr[y];
//      int temp=arr[x];
//      arr[x]=arr[y];
//      arr[y]=temp;
    }
    //将整数类型数组存放到一个StringBuiler容器中
    private static StringBuilder intToString(int[] arr)
    {
        StringBuilder sb=new StringBuilder();
        for (int x=0;x<arr.length-1; x++)
        {
            sb.append(arr[x]+" ");
        }
        sb.append(arr[arr.length-1]+"");

return sb;
    }

//打印字符串
    private static void sop(Object obj)
    {
        System.out.println(obj);
    }

//遍历数组
    private static void sop(int[] arr)
    {
        for (int x=0; x<arr.length;x++ )
        {
            System.out.print(arr[x]+"\t");
        }
        System.out.println();
    }
}
```
-separator-