关于String和StringBuffer的使用

java本身提供了n多对象方便我们进行开发,这些对象都是遵从着面向对象思想而出现的,后期再讲就不再讲思想了,而是不断学习这些对象的使用.我们的学习重点已经开始从面向对象思想转移到了面向对象的使用上来了,讲一个对象,什么时候用,怎么用.

常用的对象和方法必须会.

不能进行查手册.

java对字符串进行了封装成了对象.

String 描述java字符串的类.

String str = “abc”;  是一个对象，String是个类。

String str1 = new String(“a”)

String类的特点：

字符串对象一旦被初始化就不会被改变。

String a= “abc”;

a = “nba”;

system.out.println(a);   打印出了nba，你就说字符串a是可以改变的。

这种想法其实是错误的，一开始a指向abc，后来又new 了一个对象，s指向nba。

仅仅是指向改变了，但是对象abc的内容没有改变。

Stirng a = “abc”;

String b =”abc”

System.out.println(a==b);

虽然是两个对象，但是这里打印的还是true，因为内存中有个String对象的常量池。池中没有就建立，池中有就直接用。

java.lang 是java的核心包，不需要你导入，就自动导入了。String就是核心类，在lang包中

API文档中:

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

 public class StringDemo {
     public static void main(String [] args){
         stringDemo2();
     }

     public static void stringDemo2(){
         String s = "abc";
         String s1 = new String("abc");
         System.out.println(s==s1);
     }
 }  输出结果是：false

解释:

为什么是false呢？
第一种是在String常量池中创建了一个对象。
第二种new是在堆内存中创建了两个对象。

String类中的equals覆写了Object的equals，建立了自己的判断内容，就是比较字符串内容。

String s = new String();

String s = "";

建立数组对象最简单的就是用String s = "";

一般建立一个字符串就用String s = "";

但是也有要用String s = new String();的情况，因为可以向括号中传值

比如如下代码:

    public static void btyeStringArr(){
        byte[] arr = {97,98,99,100};
        String s1 = new String(arr);
        System.out.println("s1="+s1);
    }

打印出来的就是S1=abcd；

这个就是把字节数组变成字符串。现在可能用不到，到最后就会用到了。

字符本身就是字符串中的单元。

     public static void btyeStringArr1(){
         char[] arr = {'w','a','p','q','x'};
         String s = new String(arr);// String s = new String(arr,1,3);输出：s=apq
         System.out.println("s="+s);
     }

关于String s = new String(arr,1,3);的解释

public String(byte[] bytes,
              int offset,
              int length)
通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
参数：
bytes - 要解码为字符的 byte
offset - 要解码的第一个 byte 的索引
length - 要解码的 byte 数 

* 按照面向对象的思想对字符串进行功能分类。
* "abcd"
*
* 1,获取：
* 1.1 获取字符串中字符的个数(长度).
* int length();
* 1.2 根据位置获取字符。
* char charAt(int index);
* 1.3 根据字符获取在字符串中的第一次出现的位置.
* int indexOf(int ch)
* int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
* int indexOf(String str);
* int indexOf(String str,int fromIndex);
* 根据字符串获取在字符串中的第一次出现的位置.
* int lastIndexOf(int ch)
* int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
* int lastIndexOf(String str);
* int lastIndexOf(String str,int fromIndex);
* 1.4 获取字符串中一部分字符串。也叫子串.
* String substring(int beginIndex, int endIndex)//包含begin 不包含end 。
* String substring(int beginIndex);

lastIndexOf(??)返回指定字符在此字符串中最后一次出现处的索引。

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

另外有startWith()和endWith()两个方法。前缀后缀的判断。

* 2，转换。
* 2.1 将字符串变成字符串数组(字符串的切割)
* String[] split(String regex):涉及到正则表达式.
* 2.2 将字符串变成字符数组。
* char[] toCharArray();
* 2.3 将字符串变成字节数组。
* byte[] getBytes();
* 2.4 将字符串中的字母转成大小写。
* String toUpperCase():大写
* String toLowerCase():小写
* 2.5 将字符串中的内容进行替换
* String replace(char oldch,char newch);
* String replace(String s1,String s2);
* 2.6 将字符串两端的空格去除。
* String trim();
* 2.7 将字符串进行连接 。
* String concat(string);
*
* 3，判断
* 3.1 两个字符串内容是否相同啊？
* boolean equals(Object obj);
* boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。
* 3.2 字符串中是否包含指定字符串？
* boolean contains(string str);
* 3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。
* boolean startsWith(string);
* boolean endsWith(string);

* 4，比较。
* compareTo

public int compareTo(String anotherString)
按字典顺序比较两个字符串。
该比较基于字符串中各个字符的 Unicode 值。按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；

基本数值，如果能参与比较用的是大于小于这样的操作运算符号完成的。
对象的比较用的是方法完成的，字符串本身就是对象。

String s = "abcea";

System.out.println("lastIndex:"+s.lastIndexOf('a'));从后向前数a第一出现的角标。lastIndexOf角标也是从前数的。

System.out.println("index:"+s.indexOf('k'));如果不存在该字符就会输出-1.index的这个作用比较重要。

subString()

返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。

System.out.println("subString:"+s.substring(2, 4));输出 ce。

这是有原因的：substring(2,s.length());不需要进行s.length()-1;

split()函数的使用用法。点“.”正好是正则表达式中第一个规则，这个地方要用转意字符。

         String s = "zhangsan.lisi.wangwu.fengliu";
         String[] arr = s.split("\\.");

         char[] chs = s.toCharArray();
         for(int x=0;x<chs.length;x++){
             System.out.print(chs[x]+" ");
         }
 输出：z h a n g s a n , l i s i , w a n g w u , f e n g l i u

        s = "ab你";四个字节，a，b两个字节。一个汉字两个字节。
        byte[] bytes = s.getBytes();
        for(int x=0;x<bytes.length;x++){
            System.out.print(bytes[x]+" ");
        }
输出：97 98 -60 -29

老美码表ascii，中国的是GB2312（按照一个中文两个字节编写的，而且这两个字节中的最高位是1，所以“你”输出的 是负数）.

System.out.println(String.valueOf(4)+1);                     System.out.println(“”+4+1);

valueOf(int i)是String类的静态方法，返回：int 参数的字符串表示形式。

不管valueOf中的参数是什么类型的，valueOf()的返回值都是String类型的。

inern()   intern():对字符串池进行操作、

例子一:

 /*
  * 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。
  * {"nba","abc","cba","zz","qq","haha"}
  *
  * 思路：
  * 1,对数组排序。可以用选择，冒泡都行。
  * 2,for嵌套和比较以及换位。
  * 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。
  *   字符串对象怎么比较呢？爽了，对象中提供了用于字符串对象比较的功能。
  */
 public class StringTest_1 {

     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] + "]");
         }
     }
 }

例子二:

 /*
  * 2，一个子串在整串中出现的次数。
  * "nbaernbatynbauinbaopnba"
  * 思路：
  * 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。
  * 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，
  * 而剩余字符串的起始位是出现位置+子串的长度.
  * 3,以此类推，通过循环完成查找，如果找不到就是-1，并对每次找到用计数器记录。
  */
 public class StringTest_2 {
     public static void main(String[] args) {
         String str = "nbaernbatnbaynbauinbaopnba";
         String key = "nba";

         int count = getKeyStringCount_2(str,key);
         System.out.println("count="+count);
     }

     public static int getKeyStringCount_2(String str, String key) {
         int count = 0;
         int index = 0;

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

             index = index + key.length();
             count++;
         }
         return count;
     }
     /**
      * 获取子串在整串中出现的次数。
      */
     public static int getKeyStringCount(String str, String key) {
         //1,定义计数器。
         int count = 0;
         //2，定义变量记录key出现的位置。
         int index = 0;
         while((index = str.indexOf(key))!=-1){
             str = str.substring(index+key.length());
             count++;
         }
         return count;
     }
 }

上面的两个方法getKeyStringCount_2(String str, String key)和getKeyStringCount(String str, String key)

这两个方法实现的功能是一样的，但是下面的这个方法是有点缺陷的。因为str= str.substring(index+key.length()); 这句话会在内存中的常量池中多出许多字符串对象常量，造成内存的浪费。

上面的这种方法就避免了内存的浪费。

例子3:

 /*
  * 3，两个字符串中最大相同的子串。
  * "qwerabcdtyuiop"
  * "xcabcdvbn"
  * 思路：
  * 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。
  * 如果存在，短的那个字符串就是最大子串。
  * 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。
  * 如果存在就已找到，就不用再找了。
  */
 public 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++){　　　　　　　　　　//a和b一个控制最短字符串的最前面的”指针”，一个控制最短字符串中最后面的”指针”。

                 String sub = min.substring(a, b);
 //                System.out.println(sub);
                 if(max.contains(sub))
                     return sub;
             }
         }
         return null;
     }
 }

如果把sub输出的话，结果：
xcabcdvbn
xcabcdvb
cabcdvbn
xcabcdv
cabcdvb
abcdvbn
xcabcd
cabcdv
abcdvb
bcdvbn
xcabc
cabcd
abcdv
bcdvb
cdvbn
xcab
cabc
abcd

例子4:

 /*
  * 4，模拟一个trim功能一致的方法。去除字符串两端的空白
  * 思路：
  * 1，定义两个变量。
  * 一个变量作为从头开始判断字符串空格的角标。不断++。
  * 另一个变量作为从尾开始判断字符串空格的角标。不断--。
  * 2,判断到不是空格为止，取头尾之间的字符串即可。
  */
 public class StringTest_4 {
     public static void main(String[] args) {
         String s = "    ab   c     ";

         s = myTrim(s);
         System.out.println("-" + s + "-");
     }

     public static String myTrim(String s) {
         int start = 0, end = s.length() - 1;

         while (start <= end && s.charAt(start) == ' ') {
             start++;
         }
         while (start <= end && s.charAt(end) == ' ') {
             end--;
         }
         return s.substring(start, end + 1);
     }
 }

为什么java中明明有这些方法还要对这些功能进行理解自己编写。

java当中确实是封装实现这些功能了，但是别的语言中没有这么完善，比如对网页中客户输入数据的校验基本上都是在客户端进行的，javasript中没有这么好的方法的提供，都要你自己去写。所以这些都要会。

StringBuffer 字符串缓冲区对象。

其实就是个容器，就对数据进行临时存储。

StirngBuffer是可变长的，数组是定长的，数组是存储相同类型数据，StringBuffer可以存储不同类型的对象。

既然是一个容器对象，应该具备什么功能呢？

append()

其实它还是个数组

StringBuffer()
          构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。

/*

* StringBuffer:就是字符串缓冲区。

* 用于存储数据的容器。

* 特点：

* 1，长度是可变的。

* 2，可以存储不同类型数据。

* 3，最终要转成字符串进行使用。

* 4，可以对字符串进行修改。

*

*

* 既然是一个容器对象。应该具备什么功能呢？

* 1，添加：

*                             StringBuffer append(data);

*                             StringBuffer insert(index,data);

* 2，删除：

*                             StringBuffer delete(start,end):包含头，不包含尾。

*                             StringBuffer deleteCharAt(int index):删除指定位置的元素

* 3，查找：

*                             char charAt(index);

*                             int indexOf(string);

*                             int lastIndexOf(string);

* 4，修改：

*                             StringBuffer replace(start,end,string);

*                             void setCharAt(index,char);

*

* 增删改查 
C(create)U(update)R(read)D(delete)

* reverse()
                                                                                  将此字符序列用其反转形式取代。

*

*

*/

StringBuffer()
          构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。

StringBuffer(int capacity)
          构造一个不带字符，但具有指定初始容量的字符串缓冲区。

如果StringBuffer中存储的数据过多可以初始化一个刚刚好的,这样可以节省创建新数组和延长的动作.

/*

* jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder

*

* 不同的是：

* StringBuffer是线程同步的。通常用于多线程。

* StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。

*

* jdk升级：

* 1，简化书写。

* 2，提高效率。

* 3，增加安全性。

*/

 class StringBuffer jdk1.0
 {
     object lock;
     public   StirngBuffer append(int x)
     {
         synchronized(lock)
         {
         }
     }

     public synchronized StringBuffer delete(int start,int end)
     {
         synchronized(lock)
         {
         }
     }
 }

每次调用 一次append和delete方法就要判断一次锁.效率非常的慢.

后期出现StringBulider就是为了解决单线程效率低的问题.

将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。

 public class StringBuilderTest {
     public static void main(String[] args) {
         int[] arr = {3,1,5,3,8};
         String s = arrayToString_2(arr);

         System.out.println(s);
     }
     public static String arrayToString_2(int[] arr){
         StringBuilder sb = new StringBuilder();
         sb.append("[");
         for (int i = 0; i < arr.length; i++) {
             if(i!=arr.length-1)
                 sb.append(arr[i]+", ");
             else
                 sb.append(arr[i]+"]");
         }
         return sb.toString();
     }

     /**
      * 将一个int数组变成字符串。
      */
     public static String arrayToString(int[] arr){

         String str = "[";
         for (int i = 0; i < arr.length; i++) {
             if(i!=arr.length-1)
                 str+=arr[i]+", ";
             else
                 str+=arr[i]+"]";
         }
         return str;
     }
 }

/*

* 基本数据类型对象包装类。

* 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。

* 用于描述该对象的类就称为基本数据类型对象包装类。

*

* byte                   Byte

* short      Short

* int                       Integer

* long                    Long

* float       Float

* double               Double

* char                   Character

* boolean             Boolean

*

* 该包装对象主要用基本类型和字符串之间的转换。

*

* 基本类型--->字符串

*                             1,基本类型数值+""

*                             2,用String类中的静态方法valueOf(基本类型数值);

*                             3,用Integer的静态方法valueOf(基本类型数值);

*

* 字符串--->基本类型

*                             1,使用包装类中的静态方法   xxx parseXxx("xxx类型的字符串");*****

*                                             int parseInt("intstring");

*                                             long parseLong("longstring");

*                                             boolean parseBoolean("booleanstring");

*                                             只有Character没有parse方法

*                             2,如果字符串被Integer进行对象的封装。

*                                             可使用另一个非静态的方法，intValue();

*                                             将一个Integer对象转成基本数据类型值。

*/

关于valueOf()方法：

String和几个包装类中都含有该方法，其中String类中对该方法的重载方法更多，其他包装类都是只有一个valueOf()方法。

下面做一个总结：

①   String类中：

static String	valueOf(boolean b)           返回 boolean 参数的字符串表示形式。 如果参数为 true，则返回一个等于 "true" 的字符串；否则，返回一个等于 "false" 的字符串。
static String	valueOf(char c)           返回 char 参数的字符串表示形式。 返回 char 参数的字符串表示形式。 一个长度为 1 的字符串，它包含参数 c 的单个字符。
static String	valueOf(char[] data)           返回 char 数组参数的字符串表示形式。 返回：一个 String，它包含字符数组的字符。
static String	valueOf(char[] data, int offset, int count)           返回 char 数组参数的特定子数组的字符串表示形式。
static String	valueOf(double d)           返回 double 参数的字符串表示形式。 该表示形式恰好是单参数的 Double.toString 方法返回的结果。
static String	valueOf(float f)           返回 float 参数的字符串表示形式。 该表示形式恰好是单参数的 Float.toString 方法返回的结果。
static String	valueOf(int i)           返回 int 参数的字符串表示形式。 该表示形式恰好是单参数的 Integer.toString 方法返回的结果。
static String	valueOf(long l)           返回 long 参数的字符串表示形式。 该表示形式恰好是单参数的 Long.toString 方法返回的结果。
static String	valueOf(Object obj)           返回 Object 参数的字符串表示形式。

valueOf()和toString()有点类似于互相反义词的意思。

各个包装类中都有valueOf()

各个类中都有toString()方法，toString()是Object类中就有的。

parseInt()  intValue()

各个包装类中都有对应的parseXxx()方法。（String类没有）

parseXxx()方法中的参数就是String类型。

各个包装类中都有对应的xxxVaule()方法。（String类没有）

xxxValue()方法中没有参数，都是由包装类对象进行调用的。

Integer类中的valueOf()方法：

static Integer	valueOf(int i)           返回一个表示指定的 int 值的 Integer 实例。 返回一个表示指定的 int 值的 Integer 实例。如果不需要新的 Integer 实例，则通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过缓存经常请求的值而显著提高空间和时间性能。
static Integer	valueOf(String s)           返回保存指定的 String 的值的 Integer 对象。 public static Integer valueOf(String s)                        throws NumberFormatException 返回保存指定的 String 的值的 Integer 对象。将该参数解释为表示一个有符号的十进制整数, 就好像将该参数赋予 parseInt(java.lang.String) 方法一样。结果是一个表示字符串指定的整数值的 Integer 对象。 换句话说，该方法返回一个等于以下值的 Integer 对象： new Integer(Integer.parseInt(s))

parseInt()方法等效于valueOf()方法。

parseDouble()  各种parseXxxx()……

System.out.println(Integer.MAX_VALUE);

负数的最高位是1，就是 因为取反造成的。

负数的二进制是正数取反加1得到的。

把基本类型转换成包装类型。

int num =4；

Integer I = new Integer（num）;利用包装类的构造方法。

该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型的非常有用的其他一些常量和方法。

Integer i = new Integer(5);

int x = i.parseInt("123");                             int x = Integere.parseInt("123");

这个地方用i来调用也不会访问5这个对象，parseInt是静态的，用Integere调用。

字符串转换成int对象.

Integer i = new Integer("123");

System.out.println(i.intvalue());

intValue()是普通方法，不是静态的方法，由对象调用。

Integer类就两个构造方法:

Integer(int value)
          构造一个新分配的
Integer 对象，它表示指定的 int 值。

Integer(String s)
          构造一个新分配的
Integer 对象，它表示 String 参数所指示的 int 值。

/*

* 整数具备不同的进制体现。

*

* 十进制-->其他进制。

*                             toBinaryString

*                             toOctalString

*                             toHexString

*

* 其他进制-->十进制。

*                             parseInt("string",radix)

*

*/

十进制转换成其他进制.

System.out.println(Integer.toBinaryString(60));

System.out.println(Integer.toOctalString(60));

System.out.println(Integer.toHexString(60));

System.out.println(Integer.toString(60,16));

其他进制转换成十进制.

System.out.println(Integer.parseInt("3c",16));3c是16进制,然后转换成10进制.

int
num = 4;

num
= num + 5; 基本类型可以相互运算.对象是不行的.

Integer i =  4;//默认是i = new Integer(4);自动装箱 简化书写。

i
= i + 6;//本质上是 i = new
Integer(i.intValue() + 6);

//i.intValue() 自动拆箱

我的一个小发现,当我在Eclipse中输入自动装箱的语句Integer
i  = 
4;的时候，提示我把Integer改成int类型的，但是显然在java有了自动装箱技术之后这个提示是错误的，后来我调整Eclipse的编译环境。。。。。

具体的解决方法：

①  
Eclipse中项目“project”→JavaCompiler→Compiler
compliance settings 改成1.4之后的版本即可。

②  
Eclipse中“window”→java→Compiler→Compiler compliance level改成1.4之后的版本就可以。

关键是第一步，第一步改好了，第二步仍然是以前那样也不会报错。

但是仅仅改第二步.仍然会报错。

Integer a = new
Integer(128);

Integer
b = new Integer(128);

System.out.println(a==b);//false

System.out.println(a.equals(b));//true

Integer
x = 129;//jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享不会重新开辟空间。

Integer
y = 129;

System.out.println(x==y);//false         System.out.println(x.equals(y));//true

Integer
m = 127;//jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享不会重新开辟空间。

Integer
n = 127;

System.out.println(m==n);//true

System.out.println(m.equals(n));//true

以128为界限。

public static void
show(Object
a){//Object a = new Integer(55);

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

}

/*

* 对一个字符串中的数值进行从小到大的排序。

*

* "20 78 9 -7 88
36 29"

*

* 思路：

* 1，排序，我很熟。可是我只熟int。

* 2，如何获取到这个字符串中的这些需要排序的数值？

* 发现这个字符串中其实都是空格来对数值进行分隔的。

* 所以就想到用字符串对象的切割方法将大串变成多个小串。

* 3，数值最终变成小字符串，怎么变成一个int数呢？

* 字符串-->基本类型 可以使用包装类。

*/

关于思路：

一开始可能很难像老师那样建立一个很完整的思路，我觉得到目前为止大多数人都是碎片，所以先用文字的形式把自己的碎片记录下来，然后再去琢磨哪个是第一步，哪个是第二步。

要整理自己的思路。

System.out.println("100".compareTo("80"));//-7

字符串通过compareTo比较大小比较的是字典顺序，上面示例进行比较的时候，返回值是-7，始终比较的是数字的第一位的大小，返回的是第一位之间的差值。

System.out.println("100".compareTo("10"));//1

System.out.println("100".compareTo("1000"));//-1

System.out.println("100".compareTo("10000"));//-2

System.out.println("100".compareTo("100"));//0

import
java.util.Arrays;

public class WrapperTest {

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) {

//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 void mySortArray(int[] num_arr) {

Arrays.sort(num_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();

}

}

StringBufffer，数组，对象 都是容器。

加入数据，“zhangsan” true ，67, 三个数据数据类型不同，不能用数组作为集合，只能用StringBuffer或者是StringBuilder作为集合，但是这两个类型，最终转换成字符串才可以使用。

上面的数据封装成StringBuilder为“zhangsantrue67”

李四，23,都是（一个对象的）属性值所以用对象来封装，进行存储。

数值有很多用数组存储，数组有很多用二维数组进行存储。

数据有很多用对象存储，对象有很多用集合存储。（能存储对象的对象）

集合中实际上存储的是地址，对象已经创建完了，存储用改地址。

集合中地址是怎么存放的那就不一定了，每中容器有各自不同的特点。

数组能存储Person吗？

可以，类类型的数组。

但是人的数量可以是变化的，数组是固定长度的，集合是可变长度的。

集合类的由来：

对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。

就使用集合容器进行存储。

集合特点：

1，用于存储对象的容器。

2，集合的长度是可变的。

3，集合中不可以存储基本数据类型值。

部分容器有一些共性，就不断的向上抽取。

对体系的使用就是“看顶层用底层”

集合类是属于java中的工具，在java.util包中。

迭代器：取出集合中元素的方式。