黑马程序员---操作字符串、封装基本数据

------- android培训、java培训、期待与您交流！ ----------

36、             字符串（String类）

1、 字符串是一个特殊的对象。
2、 字符串一旦被初始化就不可以被改变。

字符串最大的特点就是：一旦被初始化，就不能改变。

这里面改变的是s1变量（确切的说是s1引用的地址改变了），而不是“abc”这个对象
3、 String
str1 = new String(“abc”)与String str = “abc”的区别
str1在内存中有两个对象，str在内存中有一个对象。
4、 字符串常见的操作
1、 获取：
1.1字符串中包含的字符数，也就是字符串的长度
  int length( )：获取长度
1.2根据位置，获取位置上某个字符
  char charAt(int index)
1.3根据字符获取该字符在字符串中的位置
  int indexOf(int ch):返回的是ch在字符串中第一次出现的位置
   int indexOf(int ch,int fromIndex):从formIndex指定位置开始，获取ch在字符串中出现的位置
   int indexOf(String str):返回的是str在字符串中第一次出现的位置
   int indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置
   int lastIndexOf(int ch):返回ch在字符串中最后出现的位置
      2、判断
2.1、字符串中是否包含某一个子串
    boolean contains(str):
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1，表示该str不存在字符串中，所以它也可以用于对指定判断是否包含。
if(str.indexOf(“aa”)!=-1)
而且该方法既可以判断，又可以获取str出现的位置
        2.2、字符串中是否有内容
                    boolean isEmpty( )：原理就是判断长度是否为0.
        2.3、字符串是否以指定内容开头
                    boolean startsWith(str);
2.4、字符串是否以指定内容结尾
        boolean endsWith(str);
        2.5、判断字符串内容是否相同，复写了Object类中的equals方法
                    boolean equals(str)；
        2.6、判断内容是否相同，并忽略大小写
                    boolean equalsIgnoreCase( );
      3、转换
        3.1、将字符数组转成字符串
                    构造函数：String(char[
])
                                   String(char[ ],offset,count):将字符数组中的一部分转成字符串
                    静态方法：static
String copyValueOf(char[ ]data)
                                   static String copyValueOf(char[ ]data,int offset,int count)
                                   static String valueOf(char[ ]data);
        3.2、将字符串转成字符数组(比较重要)
                    Char[ ] toCharArray( )
        3.3、将字节数组转成字符串
                    String(byte[ ])
                    String(byte[ ],offset,count)，将字节数组中的一部分装换成字符串
        3.4、将字符串转换成字节数组
                    Byte[ ] getBytes( );
                    注意：字符串和字节数组在互相转换的过程中，是可以指定编码表的！
        3.5、将基本数据类型转成字符串
                    static String valueOf(int)
static String valueOf(double)
                    //3+””；等价String.valueOf(3)；只不过后面一种方式更加正规一些
      4、替换
        String replace(oldchar , newchar)
      5、切割
        String[ ] split(regex);
      6、子串：获取字符串中的一部分。
        String substring(begin)
        String substring(begin,end)
      7、转换，去除空格，比较
        7.1、将字符串转成大写或小写
                    String toUpperCase( )
                    String toLowerCase( )
        7.2、将字符串两端的空格去除
                    String trim( )
        7.3、将两个字符串进行自然顺序的比较
                    int compareTo( );

示例代码：

package day28;

publicclass
StringMethodDemo {

        publicstaticvoid
method_get(){

                  String str="abcdefabd";

                  //长度

                  sop(str.length());

                  //根据索引获取字符

                  sop(str.charAt(4));//

//                sop(str.charAt(40));当访问到字符串中不存在的角标时

//                会发生StringIndexOfBoundsException

                  //根据字符获取索引

                  //如果没有找到返回-1

                  sop(str.indexOf('a',6));//这里的7都是角标位置，返回的值也是角标位置

                  //反响索引一个字符在字符串中出现的位置

                  sop(str.lastIndexOf('a'));

                  

        }

        publicstaticvoid
method_is(){

                  String str="ArrayDemo.java";

                  //判断文件名称是否是Array单词开头

                  sop(str.startsWith("Array"));

                  //判断文件名称是否是.java的文件

                  sop(str.endsWith(".java"));

                  //判断文件名中是否包含demo

                  sop(str.contains("Demo"));

        }

        publicstaticvoid
method_trans(){

                  char[]arr
= {'a','b','c','d','e','f'};

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

                  sop(s);

                  String s1 ="sdfsdfsdf";

                  char[]chs
= s1.toCharArray();

                  for(int
x=0;x<chs.length;x++){

                           sop("ch="+chs[x]);

                  }

        }

        publicstaticvoid
method_replace(){

                  String s ="hello java";

                  //字符串一旦被初始化就不能改变,所以s1与s的结果不一样

                  String s1 = s.replace('e','l');

                  //如果要替换的字符串不存在，结果返回的还是原串

                  //String s1 = s.replace('e', 'l');

                  String s2 = s.replace("java","text");

                  sop("s="+s);

                  sop("s1="+s1);

                  sop("s2="+s2);

        }

        publicstaticvoid
method_split(){

                  String s ="zhangsan,lisi,wangwu";

                  String []arr=s.split(",");

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

                           sop(arr[i]);

                  }

        }

        publicstaticvoid
method_sub(){

                  String s="abcdef";

                  //从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常

                  sop(s.substring(2));

                  //包含头，不包含尾  s.substring(0,s.lenght())获取整个字符串

                  sop(s.substring(2, 4));

        }

        publicstaticvoid
method_7(){

                  String s="  hello java ";

                  sop(s.toUpperCase());

                  sop(s.toLowerCase());

                  sop(s.trim());

                  String s1="aef";

                  String s2="aag";

                  sop(s1.compareTo(s2));

        }

        publicstaticvoidsop(Object
obj){

                  System.out.println(obj);

        }

//      public static void main(Stringargs[]){

//                String s1 = "abc";

//                String s2 = new String("abc");

//                String s3 = "abc";

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

//                System.out.println(s1==s3);//true

//      }

        publicstaticvoid
main(String args[]){

                  method_get();

                  method_is();

                  method_trans();

                  method_replace();

                  method_split();

                  method_sub();

                  method_7();

        }

}

37、             StringBuffer类

字符串的组成原理就是通过该类实现的。
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(int index)
int indexOf(String str)
int lashIndexOf(String str)
int length()
String substring(int start,int end)
4、 修改
StringBuffer replace(start,end,string);
Void setCharAt(int index,char ch)
5、 反转
StringBuffer reverse( )
6、 将缓冲区中指定数据存储到指定字符数组中
Void getChars(int srcBegin , int srcEnd,char[] dst,int dstBegin)
 
      JDK1.5版本之后出现了StringBuilder。
      StringBuffer是线程同步的
      StringBuilder是线程不同步的
      开发的时候建议使用StringBuilder，因为StringBuilder操作字符串会更快

示例代码：

package day28;

/**面盆理论

 * StringBuffer相当于面盆，append等方法相当于添加作料*/

publicclass
StringBufferDemo {

        publicstaticvoid
sop(Object obj){

                  System.out.println(obj);

        }

        publicstaticvoid
method_add(){

                  StringBuffer sb =new
StringBuffer();

                  StringBuffer sb1 = sb.append(34);

                  //StringBuffer的append方法返回的对象，还是原来的对象，

                  //只不过改变了内容而已

                  sop("sb==sb1"+(sb==sb1));

                  sop(sb.toString());

                  sop(sb1.toString());

        }

        publicstaticvoid
method_delete(){

                  StringBuffer sb =new
StringBuffer("abcde");

                  sb.delete(1, 3);

                  /**

                   *清空缓冲区：

                   * sb.delete(0,sb.length());

                   *而sb=
new StringBuffer()虽然也能达到同样的目的

                   *但是，这个动作相当于将面盆丢了，重新换一个面盆

                   * */

                  sop(sb.toString());

        }

        publicstaticvoidmethod_update(){

                  StringBuffer sb =new
StringBuffer("abcde");

                  sb.replace(1, 4,"java");//不包含角标为4的字符

                  sop(sb);

                  sb.setCharAt(0,'k');

        }

        publicstaticvoid
main(String args[]){

                  method_add();

                  method_delete();

                  method_update();

                  StringBuffer sb =new
StringBuffer("abcdfeg");

                  char[]arr
=newchar[4];

                  //获取的字符从角标2到角标3为止，不包括角标4的字符

                  //如果插入到arr中的字符个数+起始角标>最大角标的时候，就发生角标越界

                  sb.getChars(2, 4, arr, 1);

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

                           sop("arr["+x+"]="+arr[x]);

                  }

        }

}
        为什么选择StringBuilder而不是StringBuffer？

1、StringBuffer需要判断锁，StringBuilder不需要判断锁，在单线程操作的时候效率高。

2、将 StringBuilder的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用StringBuffer；如果不想使用StringBuffer的话，也可以自己加锁来操作

Java的升级：

1、 提高效率

2、 简化书写

3、 提高安全性

38、             基本数据类型的包装类

Byte       byte
Short     short
Integet  int
Long      long
Boolean  Boolean
Float      float
Double   double
Character       char
基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。
1、基本数据类型转成字符串。
基本数据类型+””
基本数据类型.toString(基本数据类型值);
如：Integer.toString(34);//将34整数变成“34”
2、字符串转成基本数据类型
      xxx a = Xxx.parseXxx(String)
      Boolean b = Boolean.parseBoolean(“true”);
      Integer i = new Integer(“123”);int num = i.intValue( );
3、在整型数据中十进制转成其他进制
      toBinaryString( )、toHexString(
)、toOctalString( )
      其他进制转成十进制
      parseInt(string,radix),将string字符串转换成radix进制的数字（Integer）

示例代码：

package day28;

/**jdk1.5新特性：

 *自动拆装箱

 * */

publicclassIntegerDemo
{

    publicstaticvoid
sop(Object obj){

             System.out.println(obj);

    }

    publicstaticvoid
method(){

             //整数类型的最大值

             sop("int max="+Integer.MAX_VALUE);

             Integer a =new
Integer(123);

             Integer b =new
Integer("123");

             sop("a==b"+(a==b));//false

             //比较此对象与指定对象,当且仅当参数不为
null，并且是一个与该

             //对象包含相同int值的
Integer对象时，结果为 true。

             sop("a.equals(b)"+a.equals(b));//true

    }

    publicstaticvoid
main(String args[]){

             //Integer x = new Integer(4);

             //在新特性里面Integer
x = null可以为null，在使用的时候要判断

             //自动装箱。//new
Integer(4)

             Integer x =4;

             //x进行自动拆箱，变成int类型

             //和2进行加法运算,再将和进行装箱赋给x

             x=x/*x.intValue()*/+2;

             sop("x="+x);

             Integer a = 128;

             Integer b = 128;

             sop("a==b"+(a==b));//false

             Integer m = 127;

             Integer n = 127;

             sop("m==n"+(m==n));//true,因为a和b指向同一个Integer对象

             //因为当数值在byte范围内，对于新特性，如果该数值已经存在，则不会再开辟新的空间

    }

}
------- android培训、java培训、期待与您交流！ ----------