黑马程序员——14，String相关知识点

标签：黑马程序员

------<ahref="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

              黑马程序员——14，String相关知识点

/*

下面介绍的是String类相关方法的知识点

*/

class  Zifuchuan
{
         public   static   void main(String[] args) //主函数
         {
       String  a="yiersan";//这里的a是一个引用型变量，而"yi"是一个对象
                   /*
                   这句话在内存中只有一个对象"yiersan"
                   字符串一旦被初始化了就不会被改变了
 
        */
                   String  b=new String("yiersan");//这句话在内存中有两个对象其中一个是"yiersan"另外一个是new  String()
       String  c="yiersan";//这里的c与前面的a指向的是同一个对象"yiersan"
                   /*
                   因为字符串一旦被初始化了就不会被改变了,而前面已经在内存中定义了对象"yiersan"
        */
       String  d="yiersansi";
       System.out.println("a==b----"+(a==b));
       System.out.println("a==c----"+(a==c));
       System.out.println("a==d----"+(a==d));
                   System.out.println("a.equals(b)----"+a.equals(b));
                   /*
                   equals这个方法原本是定义在Object类里面用来比较地址值
                   但是String类中复写了这个方法，功能变成比较字符串内容是否是一样的。
 
                   */
         }
}
/*
  以上代码编译运行结果如下：
  a==b----false
  a==c----true
  a==d----false
  a.equals(b)----true
 
*/

——————分割线————

/*

String里面定义了很多有用的方法

以下介绍一些关于String类的常用的方法

为了方便说明举一个具体的例子

*/

class  Zifuchuan2
{
         public   static void main(String[] args) //主函数
         {
       String a="yiersansiwuliou";
                   //字符串中的角标都是从0开始累加
       soc(a.length());//这句话打印的是15
                   //a.length()返回的是字符串的长度
 
       soc(a.charAt(5));//这句话打印的是a
                  /*
                   a.charAt(5)返回的是字符串中角标为5的字符
       // soc(a.charAt(50));//这句话就会出现角标越界的异常
                   */
 
      soc(a.indexOf('i'));//这句话打印的是1
             // a.indexOf('i')返回字符串中的'i'第一次出现位置的角标
 
       soc(a.indexOf("iw"));//这句话打印的是8
 
          
                   soc(a.indexOf('i',4));//这句话打印的是8
                   /*
                   a.indexOf('i',4)的功能是：
                   在字符串中从角标为4的字符开始往后搜索第一个会出现的字符'i'搜
                   索到之后再把对应的角标返回
       */
                   soc(a.indexOf("iw",4));//这句话打印的是8
 
              soc(a.indexOf('d',4));//这句话打印的是-1
                    //a.indexOf('d',4)这句话没有找到想要找的字符就会返回-1
   
              //以下是反向搜索：
        soc(a.lastIndexOf('i',6));//这句话打印的是1
        soc(a.lastIndexOf('i'));//这句话打印的是12
                    soc(a.lastIndexOf("iw"));//这句话打印的是8
                    soc(a.lastIndexOf("wi"));//这句话打印的是-1
        soc(a.lastIndexOf("iw",11));//这句话打印的是8
 
 
 
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj );
         }
}

——————分割线————

/*
还是介绍一些String类里面常用的方法
*/
 
class  Zifuchuan3
{
         public  static   void  main(String[] args) //主函数
         {
       String a="yiersansiwuliou";
       String  b="";
                   String  c=" ";
       soc(a.isEmpty());//这句话打印的是false
                   //a.isEmpty()功能：检测字符串是否为有内容,若是返回true否则返回false
       soc(b.isEmpty());//这句话打印的是true
       soc(c.isEmpty());//这句话打印的是false
 
                   soc(a.startsWith("yi"));//这句话打印的是true
                   //a.startsWith("yi")功能是检测字符串是否是以yi开头，若是返回true否则返回false
                   soc(a.startsWith("y"));//这句话打印的是true
 
        soc(a.endsWith("ou"));//这句话打印的是true
                   //a.endsWith("ou")功能是检测字符串是否是以ou结尾，若是返回true否则返回false
       //soc(a.endsWith('u'));//这句话编译不通过
 
       soc(a.contains("san"));//这句话打印的是true
                   //a.contains("san")功能是检测字符串中是否含有san,若是返回true否则返回false
       //soc(a.contains('s'));//这句话编译不通过
 
       soc(a.equals("san"));//这句话打印的是false
                   //a.equals("san")功能是检测字符串内容与san是否相等，若是返回true否则返回false
                   //equals方法原本是Object类中的方法，是判断地址值是否相等的，这里就被复写掉了
    
            soc(a.equalsIgnoreCase("yieRsansiWulIou"));//这句话打印的是true
       /*
                  a.equalsIgnoreCase("yieRsansiWulIou")功能是:
                   不区分大小写检测字符串与yieRsansiWulIou是否相等，若是返回true否则返回false
                   */
 
         }
         public  static void  soc(Object  obj)
         {
             System.out.println(obj );
         }
}

——————分割线——————

/*

   String类相应的转换方法或者是构造函数

         为了方便看懂，直接用例子说明

*/

class  Zifuchuan4
{
         public  static void  main(String[] args) //主函数
         {
       char[] a={'y','i','e','r','s','a','n','s','i','w','u','l','i','o','u'};
       //这是一个字符数组，里面装着一堆的字符
                   byte[]  b={2,25,46,85,76,95};
       String  c="qibajioushi";
                   String  d="25648612";
 
 
       //用String类中的构造函数把字符数组转成字符串：
                   String  stra=new String(a);
                   //把字符数组a里面的一堆字符按照顺序串成字符串"yiersansiwuliou"，并且用引用型变量stra指向该字符串
       soc(stra);//打印的是"yiersansiwuliou"
       String  stra2=new  String(a,3,9);
                   //把字符数组a中的角标3开始的字符按顺序串成字符串，该字符串的长度是9，然后并且用引用型变量strb指向该字符串
                   soc(stra2);//打印的是"rsansiwul"
      
            //将字节数组转化成字符串：
       soc(new  String(b));//注意：打印的不是数字组成的字符串，而是对应编码表的符号！！！
       soc(new  String(b,2,4));//注意：打印的不是数字组成的字符串，而是对应编码表的符号！！！
                   //对应编码表可以自定义
       
       //用String类中的静态方法把字符数组转成字符串：
      soc(String.valueOf(a));//打印的是"yiersansiwuliou"
            soc(String.copyValueOf(a));//打印的是"yiersansiwuliou"
           soc(String.copyValueOf(a,3,9));//"rsansiwul"
      //也可以放数字进去
      soc(String.valueOf(12));//打印的是12
            soc(String.valueOf(15.4));//打印的是15.4
      //soc(String.copyValueOf(b,2,4));//这句话编译不通过
 
      char[]   shuzhuc=c.toCharArray();//把字符串c转变成一堆字符数组
      for(int x=0;x<shuzhuc.length;x++)
            {
                     
                 soc("shuzhuc="+shuzhuc[x]);//逐个打印字符数组shuzhuc
            }
               
 
       byte[]   shuzhud=d.getBytes();
        
                 
      for(int x=0;x<shuzhud.length;x++)
            {
                     
                 soc("shuzhud="+shuzhud[x]);//逐个打印字符数组shuzhud
            }
 
 
 
 
 
 
         }
         public  static void  soc(Object  obj)//soc打印方法
         {
             System.out.println(obj );
         }
 
}
/*
以上代码编译运行结果如下：
yiersansiwuliou
rsansiwul
[1].UL_
.UL_
yiersansiwuliou
yiersansiwuliou
rsansiwul
12
15.4
shuzhuc=q
shuzhuc=i
shuzhuc=b
shuzhuc=a
shuzhuc=j
shuzhuc=i
shuzhuc=o
shuzhuc=u
shuzhuc=s
shuzhuc=h
shuzhuc=i
shuzhud=50
shuzhud=53
shuzhud=54
shuzhud=52
shuzhud=56
shuzhud=54
shuzhud=49
shuzhud=50
*/

————————分割线——————

/*

以下介绍String类中的替换与切割方法

*/

class  Zifuchuan5
{
         public  static void  main(String[] args) //主函数
         {
        String a="yiersansiwuliou";
                    String b=a.replace('i','k');//把字符串中的字符i替换成字符k
                    String c=a.replace("yier","dada");//把字符串中的字符串yier替换成字符串dada
        
                    soc("a="+a);//打印的是a=yiersansiwuliou
                    soc("b="+b);//打印的是b=ykersanskwulkou
                    //因为字符串一旦建立被初始化之后就不可以更改了，所以才会出现这种情况
                    //实际内存里面就有两个对象了
                    soc("c="+c);
 
 
                    //以下是切割介绍：
                    System.out.println("下面是切割打印------");
                    //String[] sza= a.split('i');//这句话编译不通过,括号里面不能放字符，只能够放字符串
                    String[] sza=a.split("i");//这句话是可以编译通过的
                    for(int x=0; x<sza.length ;x++)
                    {
                         soc("sza---"+sza[x]);//逐个打印
                    }
        //soc("数组sza长度="+sza.length);//这句话打印的是数组sza长度=4
                    /*  //以下是关于切割另外的小知识点
                    String op="jkhsdjksdbfjkbwdgw";
        String[] szop=op.split("jk");
                    soc("数组szop长度="+szop.length);//这句话打印的是数组szop长度=4
 
                    String op2="jkhsdjkhsdjkbwdgw";
        String[] szop2=op2.split("jk");
                    soc("数组szop2长度="+szop2.length);//这句话打印的是数组szop2长度=4
                    */
 
       
                    String[] sza2= a.split("iw");
                    for(int x=0; x<sza2.length ;x++)
                    {
                         soc("sza2---"+sza2[x]);//逐个打印
                    }
 
                    System.out.println("-------下面是字符串的获取--------------------");
                    String d= a.substring(4);//获取字符串中角标4开头后面的字符串，这是获取不是切割
                    soc(d);//打印的是sansiwuliou
                    String e= a.substring(4,9);//获取字符串中从角标4到角标9的字符串，但是不包含角标9的字符
                    soc(e);//打印的是sansi
                    
 
 
 
         }
         public  static void  soc(Object  obj)//soc打印方法
         {
             System.out.println(obj );
         }
 
}
/*
以上代码编译运行结果如下：
a=yiersansiwuliou
b=ykersanskwulkou
c=dadasansiwuliou
下面是切割打印------
sza---y
sza---ersans
sza---wul
sza---ou
sza2---yiersans
sza2---uliou
-------下面是字符串的获取--------------------
sansiwuliou
sansi
 
*/

————————分割线——————

/*

  String类中的 转换大小写，去除前后端空格，比较

*/

class  Zifuchuan6
{
         public  static void  main(String[] args) //主函数
         {
        String a="yiersansiwuliou";
                    String a2="   yiersansi wu  liou ";
                    soc("a="+a+"--a2="+a2);
                    String b=a.toUpperCase();//把字符串yiersansiwuliou转成大写再返回大写的字符串
                    String c=b.toLowerCase();//把字符串yiersansiwuliou转成小写再返回小写的字符串
                    soc("b="+b);
                    soc("c="+c);
        String  e=a2.trim();//返回去除掉前后两端空格的字符串
                    soc("e="+e);
        
                    String f="asd";
                    String g="ahj";
                    int h=  f.compareTo(g);//返回的是int型变量
                    /*   为了方便解说，本人记f为前者，g为后者
                         f与g相比较，先从第一位开始比较，
                              接着第一次遇到不同字符的时候，就比较这两个不同字符对应编码表的数值大小
                              本例中，第一位都是a
                              接着前者的第二位是s
                              后者的第二位是h
                              就比较第二位字符对应编码表数值大小就可以了，后面位数的字符不用管
                              此时如果前者对应编码表数值大于后者就返回正数，如果相同返回0，否则返回负数
                    */
                    soc(h);
        
                    
 
         }
         public  static void  soc(Object  obj)//soc打印方法
         {
             System.out.println(obj );
         }
 
}
/*
以上代码编译运行结果：
a=yiersansiwuliou--a2=   yiersansi wu liou 
b=YIERSANSIWULIOU
c=yiersansiwuliou
e=yiersansi wu  liou
11
 
*/

黑马程序员——14，String相关知识点

标签：黑马程序员

原文地址：http://blog.csdn.net/dangaodeaiyi/article/details/47167911