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

最新推荐文章于 2023-04-23 20:49:18 发布

原创最新推荐文章于 2023-04-23 20:49:18 发布 · 765 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#黑马程序员

Java学习笔记专栏收录该内容

40 篇文章

订阅专栏

------<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类中的转换大小写，去除前后端空格，比较

</pre><pre name="code" class="java">/*
   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

*/