黑马程序员——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);
}
}