java三大特殊类：String，Object，包装类

一.String类

1.String类的两种实例化方式：

直接赋值：

String str="Holle";
    直接赋值并没有开辟新的堆内存空间,是因为String类的设计使用了共享设计模式
在JVM底层实际上会自动维护一个对象池(字符串对象池)，如果现在采用了直接
赋值的模式进行String类的对象实例化操作，那么该实例化对象(字符串内容)将自动
保存到这个对象池之中。如果下次继续使用直接赋值的模式声明String类对象，此时
对象池之中如若有指定内容，将直接进行引用;如若没有，则开辟新的字符串对象而后
将其保存在对象池之中以供下次使用。

->传统方法(构造方法)：

String str=new String("Holle");
    使用String构造方法会开辟两块堆内存空间，并且其中一块堆内存将成为垃圾空间造成空间浪费。
    构造方法实例化的字符串常量并没有保存在对象池中，必须要有public String intern();方法才能入池。

->两种方式的区别

a.直接赋值：只会开辟一块堆内存空间，并且该字符串对象可以自动保存在对象池中以供下次使用。
b.构造方法：会开辟两块堆内存空间，其中一块成为垃圾空间，不会自动的保存在对象池中，可以使用intern()方法手工入池。

2.字符串相等比较：

对于基本数据类型比较，用"=="来比较，对于字符串用字符串提供的equals方法比较。

若两个内容一样的字符串使用"=="比较，则比较的是两个对象所保存的内存地址数值。

str和str1是两个不同的对象，就会有不同的地址，那么他们的地址数值肯定不相等，比较的不是字符串的内容，所以不能用"=="来比较两个字符串，因为他们地址本来就不相等。要想比较两个字符串的内容则要使用String类提供的equals()方法.

3.字符串不可变：

字符常量不可变：所有的语言对于字符串的底层实现，都是字符数组，数组最大的缺陷就是长度固定，
在定义字符串常量时，它的内容不可变。当字符串修改时，其实是字符串的引用一直在变，而且会产生大量的垃圾空间。

如：

String str="hello";
str=str+" world";
str+="!!!";
System.out.println(str);  //hello world!!!

4.字符与字符串：

字符串就是字符数组，在String类里面支持有字符数组转换成字符串以及字符串变为字符。

(1)将字符数组中的所有内容变成字符串：
      public String(char value[]);//构造方法
(2)将部分字符数组中的内容变为字符串：
      public String(char value[]，int offset,int count);//构造方法
(3)取的索引位置的字符，索引从0开始：
      public charAt(int index);    //普通方法
(4)将字符串变为字符数组返回：
      public char[].toCharArray();  //普通方法

示例：字符串和字符数组的转换：

class TestString{
    public static void main(String[] args){
        String str="holleworld";
        //字符串变为字符数组
        byte[] data=str.toCharArray();
        for(int i=0;i<data.length;i++)
        {
            data[i]-=32;
            System.out.print(data[i]+",");
        }

        //字符数组变为字符串
        System.out.println(new String(data));
     }
} 

5.字节与字符串：

字节常用于数据传输以及编码转换的处理：

(1)将字符数组中的所有内容变成字符串：
      public String(char value[]);//构造方法
(2)将部分字符数组中的内容变为字符串：
      public String(char value[]，int offset,int count);//构造方法
(3)取的索引位置的字符，索引从0开始：
      public charAt(int index);    //普通方法
(4)将字符串变为字符数组返回：
      public char[].toCharArray();  //普通方法

示例：字符串和字节数组的相互转换

class TestString{
    public static void main(String[] args){
        String str="holleworld";
        //字符串变为字节数组
        byte[] data=str.getBytes();
        for(int i=0;i<data.length;i++)
        {
            data[i]-=32;
            System.out.print(data[i]+",");
        }
        //字节数组变为字符串
        System.out.println(new String(data));
     }
} 

6.字符串比较

String类提供的比较的方法：

(1)区分大小写的比较：
      public boolean equals(Object anObject);                    //普通方法
(2)不区分大小写的比较：
      public boolean equalsIgnoreCase(String anotherString);     //普通方法
(3)比较两个字符串大小关系：
      public int compareTo(String anotherString);                //普通方法
      compareTo()比较返回一个整形：相等：0 ，大于：大于0  ，小于：小于0

示例1：是否区分大小写

String str="holle";
String str1="Holle";
System.out.println(str.equals(str1));            //false  区分大小写
System.out.println(str.equalsIgnore(str1));      //true    不区分大小写

示例2：compareTo()方法

System.out.println(‘A’.compareTo("a"));     //-32
System.out.println(‘a’.compareTo("A"));     //32
System.out.println(‘A’.compareTo("A"));     //0

7.字符串查找

从一个字符串中判断指定内容是否存在：

(1)判断一个子字符串是否存在：
      public boolean contains(CharSequence s);   //普通方法
(2)从头开始查找指定字符串的位置，查到了返回位置的开始索引，查不到返回-1：
      public int indexOf(string str);            //普通方法
(3)从指定位置开始查找子字符串位置：
      public int indexOf(string str,int fromIndex);            //普通方法
(4)由后向前查找子字符串位置：
      public int lastIndexOf(String str);                        //普通方法
(5)从指定位置由后向前查找：
      public int lastIndexOf(String str,int fromIndex)             //普通方法
(6)判断是否以指定字符串开头：
      public boolean startsWith(Sting prefix);                     //普通方法
(7)从指定位置开始判断是否以指定字符串开头：                                    
      public boolean startsWith(String prefix,int toffset);        //普通方法
(8)判断是否以指定字符串结尾：
      public boolean enndsWith(String suffix);                      //普通方法

示例：

public class Test{
    public static void main(String[] args){
        String str="holleworld";
        System.out.println(str.contains("holle"));        //true   
        System.out.println(str.indexOf("world"));         //5   从w开始
        System.out.println(str.indexOf("world",4));       //5    
        System.out.println(str.lastIndexOf("holle"));     //0
        System.out.println(str.lastIndexOf("holle",7));   //0
        System.out.println(str.startsWith("holle"));      //true
        System.out.println(str.endsWith("holle"));        //false
}
}

8.字符串的替换

使用一个新的字符串替换掉已有的字符串数据：

(1)替换所有指定内容：
      public String replaceAll(String regex,String replacement);        //普通方法
(2)替换首个内容：
      public String replaceFirst(String regex,String replacement);    

示例：

String str="holleworld";
System.out.println(str.replaceAll("l","+"));     //ho++ewor+d
System.out.println(str.replaceFirst("l","+"));   //ho+leworld

8.字符串拆分

 将一个完整的字符串按照指定的分隔符划分为若干个子字符串：

(1)将字符串全部拆分：
      public String split(String regex);              //普通方法
(2)将字符串部分拆分，该数组长度就是limit极限：
      public String split(String regex,int limit);    //普通方法

示例：按空格全部拆分：

 String str="ho lle wor ld";
        String [] str1=str.split(" ");
        for(String s:str1){
            System.out.println(s);    
        }

运行结果：
ho
lle
wor
ld

9.字符串截取

从完整的字符串中截取一部分:

(1)从指定索引到结尾：
      public String substring(int beginIndex);         //普通方法
(2)截取部分内容：
      public String substring(int beginIndex,int endIndex);   //普通方法

示例：

String str="holleworld";
System.out.println(str.substring(3));  //leworld

10.字符串其他操作;

(1)去掉字符串中的左右空格：
     public String trim();
(2)字符串转大写：
     public String toUpperCase();
(3)字符串转小写：
     public String toLowerCase();
(4)字符串入池操作：
     public native String intern(); 
(5)字符串连接，等同于‘+’，不入池
     public String concat(String str);
(6)取得字符串长度：
     public int length();
(7)判断是否为空串，但不是null，而是长度为0
     public boolean isEmpty();

11.StringBuffer类

->由于String的不可更改性，为了方便字符串的修改，提供StringBuffer类

public synchronized StringBuffer append(各种数据类型 b)

示例：

StringBuffer sb=new StringBuffer("123");
sb.append("holle");
sb.append("world");
System.out.println(sb);   //123holleworld

->String和StringBuffer的相互转换：

(1)String变为StringBuffer:利用StringBuffer的构造方法或append()方法。
(2)StringBuffer变为String：调用toString()方法。

示例：

StringBuffer sb=new StringBuffer("123");
sb.append("holle");
sb.append("world");
String str=sb.toString();
System.out.println(str);   //123holleworld

->StringBuffer特有方法：

(1)字符串反转：
      public synchronized StringBuffer reverse();
(2)删除指定范围的数据：
      public synchronized StringBuffer delete(int start,int end);
(3)插入数据：
      public synchronized StringBuffer insert(int offset,各种数据类型

示例：

StringBuffer sb=new StringBuffer("123");
sb.append("holle");
sb.append("world");
System.out.println(sb.reverse());   //dlrowelloh32

->String，StringBuffer，StringBuilder的区别：

String的内容不可修改，StringBuffer和StringBuilder的内容可修改
StringBuffer采用同步处理，属于线程安全操作；而StringBuilder采用线程不安全操作。

二.Object类

1.Object是java默认提供的一个类，java里除了Object类，所有的类都存在继承关系，默认会继承Object，

 所以对象都可以使用Object进行接收

class A{
    public A(){
        System.out.println("A");
    }
}
class B extends A{
    public B(){
         System.out.println("B");
    }
}
public class Test{
    public static void main(String[] args){
        Object obj=new B();     //通过Object来接收B类对象
        Object obj1=new A();    //通过Object来接收A类对象
 }
}

->Object中定义好了的方法：

(1)无参构造为子类服务：public Object();
(2)取得对象信息： public String toString();
(3)对象比较：public boolean equals(Object obj);

class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.age=age;
        this.name=name;
    }
}
public class Test{
    public static void fun(Object obj){
        System.out.println(obj.toString());   //默认输出调用对象
    }
    public static void main(String[] args){
        fun(new Person("zhangsan",25));   //Person@3ada9e37
    }
}

->对象的比较：

String类对象的比较使用的是equals()方法，实际上String类中的equals()方法就是覆写Object类中的equals()方法。

equals()方法的实现：

 public boolean equlas(Object obj){
	if(obj==this){
	      return ture;
	}
        if(!obj instanceof Person){
	      return false;
	}
	Person person=(Person)obj;//向下转型取得参数属性
	if(per.age==this.age){
	     if(per.equals(this.name)){return ture;}
	}
}

->Object类是所有类的父类，可以任意接收对象，也可以接收所有数据类型，包括：类，数组，接口。

     Object obj=new int[]{1,2,3,4,5};
      int[] data=(int[])obj;
      for(int i:data){  
          System.out.print(i+" ");   //1 2 3 4 5
      }

三.包装类

1.基本数据类型无法通过Object接收，包装类就是将基本数据类型的值封装在类中让Object接收

//Test就是int类型的包装类
//通过intValue实现基本数据类型变为对象的需求
public class Test{
    private int a;
    public Test(int a){
        this.a=a;
    }
    public int intValue(){
        return this.a;
    }
}

2.包装类类型

->对象型包装类(Object类的直接子类)：

 Boolean(bool的包装类),Character(char包装类)

->数值型包装类(Number类的直接子类)：

Integer(int),Short(short),Long(long),Byte(byte),Float(float)

3.拆箱与装箱

->拆箱与装箱概念

装箱：将基本数据类型变为包装类对象，利用包装类提供的构造方法实现装箱处理
拆箱：将包装类中包装的基本数据类型取出，利用Number类中提供的六中方法

示例：

Integer num=new Integer(5);         //装箱
int data=num.intValue();            //拆箱

JDK1.5以后自动拆装箱，使用包装类和使用基本数据类型一模一样。

示例：

Integer num=5;     //自动装箱

->规范：

所有相同类型的包装类对象的值比较，一律使用equals方法比较
对于Integer=?(自动装箱)-128~127之间的赋值，Integer对象会在Integer常量池产生，这个区间的Integer
可以使用==判断。这个区间以外的所有值在堆上产生，不会复用对象，使用equals()比较

->什么时候用Integer，什么时候用int：

a.所有的POJO类(简单java类)必须使用包装对象
b.所有的RPC方法的返回值和参数必须使用包装类型
c.所有局部变量使用基本数据类型

3.字符串与基本数据类型转换：(使用包装类提供的parsexx())

(1)字符串->基本数据类型：

字符串->Number(数值类型)会有转换异常(包含非数字都会有转换异常)
字符串->对象包装类型(Boolean,Character)不存在转换异常

示例1：String->int

String string="123";
int num=Integer.parseInt(string);
System.out.println(num);        //123

示例2：String->double

String string="123";
double num=Double.parseDouble(string);
System.out.println(num);         //123.0

示例3：String->Boolean

String string="true";
boolean num=Boolean.parseBoolean(string);
System.out.println(num);           //true

(2)基本数据类型->字符串

a.用“+”，任何数据类型使用了“+”连接空白字符串就变成了字符串类型
b.用new String(所有数据类型);