黑马程序猿——15,String,StringBuffer,基本数据类型包装对象

Posted zhchoutai

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了黑马程序猿——15,String,StringBuffer,基本数据类型包装对象相关的知识,希望对你有一定的参考价值。

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

??????????

????????????? ??????黑马程序猿——15,String。基本数据类型包装对象

/*
   字符串相关的练习
*/
 
/*
    求两个字符串中最大的同样子串。
         思路:1。将短的子串依照长度递减的方式获取
               2,将每次获取到的子串去长串中推断是否包含
 
*/
class Zfclx
{
         public  static void  main(String[] args)
         {
 
                   String  a="kjesqwersjfnqwg";
                   String  b="ccaaqwerxyhs";
            String c= zichuan(b,a);
            String d= zichuan2(b,a);
                   System.out.println("c="+c);
         }
   
   public  static  String  zichuan(String  s1,String  s2)
         {       
       if( s1.length()<s2.length())
                   {
                      String s3="  ";
                      s3=s1;
                      s1=s2;
                      s2=s3;
                   }
                   String  op="";//这里设定一个变量,用来存储返回的字符串
                    String[][] ui=new  String[s2.length()][];
 
      w: for(int x=0;x<s2.length();x++)
                    {
                             for(int y=0,z=s2.length()-1-x; z!=s2.length();y++,z++)
                             {
                                 if(s1.contains(s2.substring(y,z+1)))
                                      {
                                           op=s2.substring(y,z+1);
                                                soc(op);
                                                
                                               break   w ;//找到之后直接跳出循环
                                              
                                      }
                             }
                    
                     }
                     return  op;
           }
          public static  String   zichuan2(String  s1,String s2)
         {       
                    String max="";
                    String min="";
         max =( s1.length()<s2.length())?s2:s1;
                     min = ( s1.length()<s2.length())?s1:s2;
        
                   String  op="";
                    String[][] ui=new  String[min.length()][];
 
      w: for(int x=0;x<min.length();x++)
                    {
                             for(int y=0,z=min.length()-1-x; z!=min.length();y++,z++)
                                      //定义y在左边指示。定义z在右边指示
                             {
                                 if(max.contains(min.substring(y,z+1)))
                                      {
                                           op=min.substring(y,z+1);
                                                soc(op);
                                                
                                               break  w ;
                                              
                                      }
                             }
                    
                     }
                     return  op;
           }
        
         public  static void  soc(Object  obj)
         {
              System.out.println(obj);    
         }
 
}
/*
以上代码编译执行结果例如以下:
qwer
qwer
c=qwer
*/

——————切割线——————

?

?

/*
   StringBuffer字符串缓冲区的方法介绍
         注意:StringBuilder是jdk1.5之后出现的,也相当于一个容器,
               其功能和StringBuffer几乎相同,可是。
                     StringBuffer是线程同步的(一个线程执行完之后下一个线程才干够进来执行)
                     StringBuilder是线程不同步的(能够多个线程同一时候对其执行)
 
         版本号升级因素:提高效率,简化书写。提高安全性
*/
 
class Zfclx3
{
         public  static void main(String[] args)
         {
                   StringBuffer  a=new   StringBuffer();//StringBuffer是一个容器,长度能够变化
                   StringBuffer  a2=  a.append(26);//把26加入进去容器里面再返回容器
       soc("a==a2---"+(a==a2));//推断a与a2是否是同一个对象。打印的是a==a2---true
       
                   a.append("卡卡").append(false).append(10);//调用链
                   soc(a);//都是以字符串的形式打印26卡卡false10
 
                   a.insert(2,"神");//插入操作。在第二位插入
       soc(a);//打印26神卡卡false10
                   //a.insert(200,"神");//角标越界异常
 
                   a.delete(5,5);//相当于没有操作
                   soc("a---------------"+a);
                   //打印a---------------26神卡卡false10
 
 
                   a.delete(5,7);//剪切第5位到第6位,注意:不包含第七位
       soc("剪切后的a="+a);//打印的是剪切后的a=26神卡卡lse10
                   //a.delete(0,a.length());//清空缓冲区(清空了容器内部)
       
                   a.deleteCharAt(2);//删除第二位字符
                   soc("a.deleteCharAt(2)----"+a);
 
                   //a.charAt(2);//获取第二位字符
                   //a.indexOf("0");//查找字符串中字符0的位置
                   //a.substring(0,a.length());//获取从第0位到a.length()-1位的字符串
 
                   a.replace(0,3,"kkkk");//把字符串中的第1位到第2位(不包含第3位)替换成kkkk
                   soc("replace---"+a);
 
 
       StringBuffer  a3=new  StringBuffer("hsjd");//容器里面装的是字符串hsjd
                   soc("a3="+a3);//打印的是hsjd
       soc2(a3);
 
        a3.setCharAt(0,‘n‘);//该方法没有返回值,改动完之后就没有返回了
                   soc(a3.toString());
 
                   a3.reverse();//反转
                   soc("reverse---"+a3);
       
                   StringBuffer  a4=new StringBuffer("abcdefgh");
                   char[]  charsz=new char[8];
                   a4.getChars(2,5,charsz,1);
                   /*
                   获取字符串中第2位到第4位字符(不包含第5位)
                   然后从charsz数组的第1位開始存放
 
         */
       for(  int  x=0;  x<charsz.length;   x++ )
                   {
                        System.out.println("charsz["+x+"]="+charsz[x]);                      
                   }
 
         }
         public  static void  soc(Object   obj)
         {
               System.out.println(obj);
          
         }
         public  static void  soc2(Object  obj)
         {
                   StringBuffer  a= (StringBuffer)obj;//父类强制转换成子类
                   a.deleteCharAt(0);
               System.out.println(a);
          
         }
 
}
/*
  以上代码编译执行结果:
 a==a2---true
26卡卡false10
26神卡卡false10
a---------------26神卡卡false10
剪切后的a=26神卡卡lse10
a.deleteCharAt(2)----26卡卡lse10
replace---kkkk卡lse10
a3=hsjd
sjd
njd
reverse---djn
charsz[0]=
charsz[1]=c
charsz[2]=d
charsz[3]=e
charsz[4]=
charsz[5]=
charsz[6]=
charsz[7]=
*/

——————切割线——————

?

/*
基本数据类型的对象包装类
 
byte       Byte
short      Short
int        Integer
long       Long
boolean    Boolean
float      Float
double     Double
char       Character
*/
 
 
class  Zfclx4
{
         public  static void main(String[] args)
         {
                   soc("Integer.MAX_VALUE="+Integer.MAX_VALUE);//打印整数类型的最大值
      
             /*
                    基本数据类型转成字符串:
                    基本数据类型+""
                    基本数据类型.toString(基本数据类型值);
                    比如:Integer.toString(25);
 
                    字符串转成数据类型:(除了char以外)
                    xxx  a=Xxx.parseXxx(String);
        比如:int  a= Integer.parseInt("26");//数字型的字符串转换成int型数据
                          double a=Double.parseDouble("26.23");
                               boolean  a=Boolean.parseBoolean("true");
                               short b=Short.parseShort("24");
 
                  
                   */
                   //int  b=Integer.parseInt("m123");//数字格式异常,执行出问题
                   //int  b=Integer.parseInt("0x123");//数字格式异常,执行出问题
       //int  b=Integer.parseInt("123");//数字格式异常。执行出问题
 
                   //十进制转其它进制:
      String  k=Integer.toBinaryString(36);
       soc("Integer.toBinaryString(36)="+k);
      String  k2=Integer.toHexString(36);
       soc("Integer.toHexString(36)="+k2);
      String  k3=Integer.toOctalString(36);
       soc("Integer.toOctalString(36)="+k3);
 
 
 
                   int  k6=Integer.parseInt("26");
                   soc("Integer.parseInt(\"26\")---"+k6);
 
                    //其它进制转成十进制
       int  x= Integer.parseInt("110",10);
                   soc("Integer.parseInt(\"110\",10)---"+x);
 
       int  x2=Integer.parseInt("110",2);
                   soc("Integer.parseInt(\"110\",2)---"+x2);
 
       int  x3=Integer.parseInt("110",8);
                   soc("Integer.parseInt(\"110\",8)---"+x3);
 
                   int  x4= Integer.parseInt("110",16);
                   soc("Integer.parseInt(\"110\",16)---"+x4);
 
                   int  x5= Integer.parseInt("1c",16);
                   soc("Integer.parseInt(\"1c\",16)---"+x5);
 
                   System.out.println("HelloWorld!");
         }
         public   static  void  soc(String   obj)
         {
               System.out.println(obj);        
         }
}
 
/*
   以上代码编译执行结果:
  Integer.MAX_VALUE=2147483647
Integer.toBinaryString(36)=100100
Integer.toHexString(36)=24
Integer.toOctalString(36)=44
Integer.parseInt("26")---26
Integer.parseInt("110",10)---110
Integer.parseInt("110",2)---6
Integer.parseInt("110",8)---72
Integer.parseInt("110",16)---272
Integer.parseInt("1c",16)---28
Hello World!
 
*/
 

?

/*

???? 基本数据类型对象包装的jdk1.5版本号新特性

*/

?

class  Zfclx5
{
         publicstatic void main(String[] args)
         {
                   //Integer   a= new  Integer(12);
                   Integer   a=12;//与上句效果一样,可是这里的12 是一个对象。!

! a=a+3;//这句话编译执行通过,这里的3是一个int型数据。 /* 这句话过程是这种: 先是a.intValue()+3 然后再把其和赋值给a。再封装成一个对象 */ Integer b=145; Integer c=145; soc("b==c---"+(b==c));//b==c---false //对象不一样 Integer b2=127; Integer c2=127; soc("b2==c2---"+(b2==c2));//b==c---true //对象同样 /* 这里为何会出现两种结果? 由于。在新特性中,假设数据没有超过byte范围且已经存在就不会再新建对象 假设数值超过了byte范围且已经存在就须要再新建对象 */ System.out.println("HelloWorld!"); } public static void soc(String str) { System.out.println(str); } }


以上是关于黑马程序猿——15,String,StringBuffer,基本数据类型包装对象的主要内容,如果未能解决你的问题,请参考以下文章

七python-PySpark篇(黑马程序猿-python学习记录)

黑马程序猿——JAVA基础——集合

黑马程序猿——26,基本数据操作流,字节数组操作流,转换流,编码表

黑马程序猿 ---------- Java网络技术之 ---正則表達式 (Day06)

黑马程序猿——JAVA高新技术——反射

黑马程序猿——————java基础