Java的常用类02

String类的其他功能

替换功能

String replace(char old,char new)

String replace(String old,String new)

去出字符串两边空格

String trim()

按字典顺序比较两个字符串

int compareTo(String str)

int compareToIgnoreCase(String str)

StringBuffer类

概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题

线程安全的可变字符序列

构造方法

public StringBuffer()

public StringBuffer(int capacity)

public StringBuffer(String str)

成员方法

添加功能

public StringBuffer append(String str)

public StringBuffer insert(int offset,String str)

删除功能

public StringBuffer deleteCharAt(int index)

public StringBuffer delete(int start,int end)

替换功能

public StringBuffer replace(int start,int end,String str)

反转功能

public StringBuffer reverse()

截取功能（注意该几个方法的返回值与上面不同，这几个返回的是字符）

public String substring(int start)

public String substring(int start,int end)

//String，StringBuffer和StringBuilder的区别
/*
    三者的共同之处：都是final类，不允许被继承，主要是从性能和安全性上考虑的
    StringBuffer和StringBuilder共同之处：
    有几乎相同的对字符串的处理方法
    
    区别：
    1、运行速度，StringBuilder>StringBuffer>String
    因为String为字符串常量，而StringBuilder和StringBuffer均为字符串常量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以直接更改的，没有像String那样有创建和回收的过程
    2、在线程安全上，StringBuilder是线程不安全的，且不同步的，数据不安全
                StringBuffer是线程安全的，且同步的，数据安全
       如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键，所以可以保证线程是安全的，但StringBuilder的方法则没有该关键字，所以不能保证线程安全，可能会出现一些错误的操作
*/
​
class demo{
    public static void main(String[] args){
        String s1="hello";
        String s2="world";
        System.out.println(s1+"--"+s2);
        change(s1,s2);
        System.out.println(s1+"--"+s2);
        
        StringBuffer sb1=new StringBuffer("hello");
        StringBuffer sb2=new StringBuffer("world");
        System.out.println(sb1+"--"+sb2);
        change01(s1,s2);
        System.out.println(sb1+"--"+sb2);
    }
    
    public static void change(String s1,String s2){
        s1=s2;
        s2=s1+s2;
    }
    public static void change01(String s1,String s2){
        sb1=sb2;
        sb2.append(sb1);
    }
}
​
//返回
hello--world
hello--world
hello--world
hello--worldworld
    
    //原因
    /*
        String作为参数传递
            传递的是值，对外面本身变量的值没有任何因相关
        StringBuffer作为参数传递
            只有当谁有操作的时候，那个StringBuffer才会变化
    */

数组高级（排序和查找）

排序

冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在最大索引处

选择排序

从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

查找

基本查找 数组元素无序

二分查找 数组元素有序

Arrays类

概述

针对数组进行操作的工具类

提供了排序，查找等功能

成员方法

public static String toString(int[] a)

public static void sort(int[] a)

public static int binarySearch(int[] a,int key)

基本类型包装类

概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用操作之一：用于基本数据类型与字符串之间的转换

基本类型和包装类的对应：

Byte,Short,Integer,Long,Float,Double,Character,Boolean

Integer类

概述

Integer类在对象中包装了一个基本类型int的值

该类提供了多个方法，能在int类型和String类型之间互相转换，还提供了处理int类型时非常有用的其他一些常量和方法

构造方法

public Integer(int value)

public Integer(String s)

成员方法

int类型和String类型的相互转换：

public int intValue()

public static int parseInt(String s)

public static String toString(int i)

public static Integer valueOf(int i)

public static Integer valueOf(String s)

常用的基本进制转换：

public static String toBinaryString(int i)

public static String toOctalString(int i)

十进制到其他进制：

public static String toString(int i,int radix)

其他进制到十进制：

public static int parseInt(String s,int radix)

新特性

JDK1.5以后，简化了定义方式

Integer x=new Integer(4);可以直接写成

Integer x=4; //自动装箱

x=x+5; //自动拆箱。通过intValue方法

需要注意：

在使用时，Integer x=null;上面的代码就会出现NullPointerException

面试题

//第一题：
Integer i=1;
i+=1;
//做了哪些事情
​
//第二题：
public class Demo01 {
    public static void main(String[] args) {
        Integer int01=new Integer(127);
        Integer int02 = new Integer(127);
        System.out.println(int01==int02);
        System.out.println(int01.equals(int02));
​
        System.out.println("----------------------");
​
        Integer int011=new Integer(128);
        Integer int022 = new Integer(128);
        System.out.println(int011==int022);
        System.out.println(int011.equals(int022));
​
        System.out.println("----------------------");
​
        Integer int03=127;
        Integer int04=127;
        System.out.println(int03==int04);
        System.out.println(int03.equals(int04));
        //System.out.println(Integer.valueOf(128));
​
        System.out.println("-------------------");
​
        Integer int05=128;
        Integer int06=128;
        int int07=128;
​
        System.out.println(int05==int06);
        System.out.println(int05.equals(int06));
        System.out.println(int07==int06);
    }
}
​
​
//结果
false
true
----------------------
false
true
----------------------
true
true
-------------------
false
true
true
    
/*
    重点是int03==int04居然是true
    理论上应该是比较的是地址，但是Integer底层写了IntegerCache
    它会打开一个IntegerCache缓存区，存放大于IntegerCache.low，小于IntegerCache.high的值
    而这个范围是-128~127
    在这个区间的值会放到返回区里，所以比较结果为true
    
    而只要超过这个界限，第二个就无法拿到缓存，只能创建新对象，地址不一致，所以int05==int06返回false
    int06==int07返回true是因为自动拆箱，所以比较没有问题
    
    不仅仅是Integer还有Long、Character、Short、Byte中的valueOf都有相似的缓存，有一点点的不同
*/

Character类

概述

character类在对象中包装一个基本类型char的值

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然

构造方法

public Character(char value)

成员方法

public static boolean isUpperCase(char ch)

public static boolean isLowerCase(char ch)

public static boolean isDigit(char ch)

public static char toUpperCase(char ch)

public static char toLowerCase(char ch)