黑马程序员——43，String，StringBuffer ，基本数据类型包装对象

----------- android培训、java培训、java学习型技术博客、期待与您交流！------------

黑马程序员——43，String，StringBuffer ，基本数据类型包装对象
一：String----》

String是字符串类，建立对象时候一般都是直接指定，例如，String s=”哈哈，haha”;正因为String是一个类，所以，字符串”哈哈，haha”是一个对象！这就衍生出一个特点：字符串在内存中，一旦被初始化就不能被修改了。

String s1=”hjk”;

String s2=”hjk”;

其中s1和s2应用变量指向的是同一个对象！

String s3=new String(“hjk”);//这样也可以建立String类的对象，不过注意的是这句话中有两个对象，一个是”hjk”，另外一个是new String()

在java中==往往是用来比较基本数据类型的大小或者对象是否是同一个。

而equals方法原本是定义在Object类中的用来比较地址值，但是，String类中却将其覆盖了，对于String来说，equals方法是用来比较字符串内容是否相等的。

另外String还有一些常用的方法（与正则表达式相关的方法这里不列出，后面介绍正则表达式会说道的）：

public   char   charAt(int   index)   //返回第index位的字符

public   int     compareTo(String   anotherString) //按照字典顺序与指定字符串做逐位比较

public   int     indexOf(String   str)  //返回指定子字符串第一次在字符串中出现的位置，没有的话返回-1

public   int    indexOf(String  str, int  fromIndex)//从指定位置开始搜索，返回子字符串在字符串中第一次出现的位置

public   boolean   equalsIgnoreCase(String   anotherString)//忽略大小写，比较字符串内容是否相等

public   boolean   equals(Object   anObject)//通常是和指定字符串比较内容是否相等

public   int   lastIndexOf(String   str)//反向搜索指定子字符串第一次出现的位置

public  int  lastIndexOf(String  str, int  fromIndex)//从fromIndex位开始反向搜索子字符串第一次出现的位置

public   int   length()//返回字符串长度

public   boolean    isEmpty()/判断是否为空，当且仅当长度为0时返回true，注意在字符串中空格也是有意义的，其长度不为0

public   boolean   startsWith(String   prefix)//判断是否是以指定子字符串开始

public   boolean    endsWith(String   suffix)//判断是否是以指定子字符结束

public   int    hashCode()//返回字符串哈希值

public   boolean   contains(CharSequence s)    //判断是否含有指定字符或者字符串

public  String   substring(int   beginIndex)//获取指定位到末尾的子字符串，注意这是获取不是切割

public   String   substring(int  beginIndex，int  endIndex)//获取从beginIndex位到endInedx-1位的子字符串

public   String   toLowerCase()//把字符串转成小写再返回

public  String   toUpperCase()//把字符串转成大写再返回

public   String   trim()//切除前后端的空白再返回字符串

public   byte[]   getBytes()//转成对应的字节数组再返回

以下是字符串构造函数和数组转成字符串的一些小知识点：

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));//这句话编译不通过

//toCharArray方法把字符串转变成字符数组
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
*/

二：StringBuffer----》

字符串缓冲区StringBuffer，相当于一个容器，长度可以变化，用来装字符串的，线程同步。

后面jdk1.5版本出现的StringBuilder在功能上和前者一样，只不过是线程不同步的。

版本升级的原因：提高安全性，提高效率，简化书写。

常用的构造函数是：

public    StringBuffer()//建立不带参数的字符串缓冲区，初始容量16个字符

public    StringBuffer(int   capacity)//建立指定初始容器的字符串缓冲区

public    StringBuffer(String   str)//建立字符串缓冲区，并把指定字符串放进去

相关常用方法用介绍（soc是打印方法）：

StringBuffer  a=new   StringBuffer();//StringBuffer是一个容器，长度可以变化
StringBuffer  a2=  a.append(26);//把26添加进去容器里面再返回容器
//判断a与a2是否是同一个对象
soc("a==a2---"+(a==a2));//a==a2---true
//可以往里面添加的东西可以有不同类型的
a.append("卡卡").append(false).append(10);//形成调用链
//都是以字符串的形式打印
soc(a);//26卡卡false10

简单理解就是append方法其实就是添加进缓冲区的东西连成一串字符串了，而且装进字符串缓冲区的东西都可以理解为连成一串字符串。

还有很多方法，下面列举的只是一些常用的方法：

public  int  indexOf(String  str, int  fromIndex)//从第fromIndex位搜索子字符串第一次出现在字符串的位置

public    int   indexOf(String   str)//搜索子字符串在字符串中第一次出现的位置

public  void  getChars(int  srcBegin, int  srcEnd, char[]  dst, int  dstBegin)//把字符串的第srcBegin位到第srcEnd-1位的字符拿出来，在dst字符数组第dstBegin位开始存放

public   String   substring(int   start)//从第start位到结尾获取子字符串

public  String  substring(int  start, int  end)//获取第start位到第end-1位的子字符串

public   char   charAt(int   index)//返回第index位的字符

public   StringBuffer  replace(int  start, int  end, String  str)//把第start位到第end-1位替换成指定字符串str

public    StringBuffer   reverse()//反转

public  void  setCharAt(int  index, char  ch)//设定第index位的字符为ch（角标越界会抛异常）

public  StringBuffer  insert(int  offset, String  str)//在第offset位插入指定字符串str

public  StringBuffer  delete(int  start, int  end)//把第start位到第end-1位删除

public   StringBuffer    deleteCharAt(int   index)//删除第index位字符

三：基本数据类型的包装对象----》

基本数据类型都有其对应的包装对象：

byte ----Byte

short----Short

int----Integer

long----Long

boolean----Boolean

float----Float

double----Double

char---- Character

基本数据类型转成字符串：

1，基本数据类型+’””

2，基本数据类型包装类.toString(基本数据类型值)

例如：Integer.toString(62);

字符串转成基本数据类型（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");//数字格式异常，运行出问题

十进制转其他进制：

String k=Integer.toBinaryString(17);//把十进制的17转成二进制

System.out.println(k); //10001

String k2=Integer.toHexString(17); //把十进制的17转成十六进制

System.out.println(k2);// 11

String k3=Integer.toOctalString(17); //把十进制的17转成八进制

System.out.println(k3);//21

其他进制转成十进制：

int x= Integer.parseInt("110",16);//把十六进制的110转成十进制

System.out.println(x); //272

int x2=Integer.parseInt("110",2); //把2进制的110转成十进制

System.out.println(x2); //6

int x3=Integer.parseInt("110",8); //把8进制的110转成十进制

System.out.println(x3); //72

基本数据类型对象包装的jdk1.5版本新特性（数据拆包与装包，常量池相关）：

class  Zfclx5
{
Public   static   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范围就不会再新建对象，
因为对于Integer,虚拟机事先存放在常量池的数据-128至+127,如果数值超过了范围就需要再新建对象。
对于其他基本数据类型也是类似的原理。
*/

}
public    static  void  soc(String  str)
{
System.out.println(str);
}
}

----------- android培训、java培训、java学习型技术博客、期待与您交流！------------