java常用类

常用类

Object

equals方法：

源码分析：

/**
 * 判断两个对象是否相等
 * @param obj
 * @return
 */
public boolean equals(Object obj) {
    //返回（this:当前对象  ==  obj:参数对象）
    return (this == obj);
}

练习：

@Test
public void test(){
    //创建Object对象
    Object object = new Object();
    //创建Object对象
    Object object1 = new Object();

    //通过对象调用Object方法;
    // object与object1对象地址不同
    System.out.println(object.equals(object1));
  

}

hashCode方法：

源码分析

/**
 * 返回该对象的hash码值
 * @return
 */
public native int hashCode();

练习：

@Test
public void test(){
    //创建Object对象
    Object object = new Object();
    //创建Object对象
    Object object1 = new Object();

    //通过对象调用Object方法;
    // object与object1对象地址不同
    /**
     * equals：两个对象之间做判断
     *      底层使用 == ，比较两个对象的hash码值
     */
    System.out.println(object.equals(object1));


    //返回object对象的hash码值：1323468230
    System.out.println(object.hashCode());

    //返回object1对象的hash码值：1645995473
    System.out.println(object1.hashCode());

}

toString方法

源码分析

/**
 * 输出对象的具体信息
 * @return
 */
public String toString() {
    /**
     * getClass().getName():获取该对象的包.类名称
     * Integer.toHexString(hashCode()):输出对象的hash
     */
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

练习：

@Test
public void test(){
    //创建Object对象
    Object object = new Object();

    System.out.println(object.toString());

    //java.lang.Object@4ee285c6
    //java.lang.Object
    System.out.println(Integer.toHexString(hashCode()));

}

String，StringBuffer，StringBuilder

String：字符串常量（不可变的字符串），每次操作String对象都会创建出一个新的字符串对象，为了改变值的目的，消耗内存，效率不高；安全，

StringBuffer：字符串变量（可变字符串），

StringBuilder：字符串变量（可变字符串）；

String

String是一个类，被final修饰的最终类，不能被继承

public final class String

String（字符串）的值存储到char类的数组中。

/**
* 被final修饰成为常量数组，值一旦定义好之后不能被修改
* private : 其他类无法访问该数组
* private final：保证数据的安全性
*/
private final char value[];

toString方法

/**
 * String重写父类中的toString方法
 * @return 返回当前对象数据
 */
public String toString() {
    return this;
}

charAt方法

源码分析：

/**
 * 返回索引处的char元素
 * @param index 索引
 * @return 数组对于的索引值
 */
public char charAt(int index) {
    //(index < 0):索引不能为负数
    //(index >= value.length):索引不能超过自身长度
    if ((index < 0) || (index >= value.length)) {
        //抛出异常（StringIndexOutOfBoundsException）
        throw new StringIndexOutOfBoundsException(index);
    }

    return value[index];
}

练习

@Test
public void test(){
    String string = "zhangsan";

    System.out.println(string.charAt(4));

}

concat方法

源码分析：

/**
 * 字符串拼接
 * @param str 为字符串
 * @return
 */
public String concat(String str) {
    //将参数字符串长度赋值给一个变量otherLen
    int otherLen = str.length();
    //判断长度等于0返回该对象
    if (otherLen == 0) {
        return this;
    }

    //将value数组的长度赋值给变量len
    int len = value.length;
    //将原来的数据以及长度赋值给一个新char数组buf[]
    char buf[] = Arrays.copyOf(value, len + otherLen);
    //将char数组的值转换为字符串
    str.getChars(buf, len);
    //创建新对象返回拼接字符串结果
    return new String(buf, true);
}

练习:

@Test
public void test(){
    String string = "zhangsan";

    System.out.println(string.concat("zhangsan"));

}

equals方法

源码分析：

/**
     * equals方法重写父类Object类的equals方法
     * 字符串与对象做比较
     * @param anObject 对象
     * @return
     */
    public boolean equals(Object anObject) {
        //this:当前对象 ==  anObject:参数中的对象，比较是是对象hash码值
        if (this == anObject) {
            return true;
        }

        //判断anObject是不是String的实例化对象
        if (anObject instanceof String) {
            //将anObject进行强转为String类型，交给anotherString
            String anotherString = (String)anObject;
            //字符串数组的长度赋值给变量n
            int n = value.length;
//            当前对象与参数中的值的长度作比较
            if (n == anotherString.value.length) {
                //将原数据复制给v1[]
                char v1[] = value;
                //将参数中的数据复制给v2[]
                char v2[] = anotherString.value;

                int i = 0;
                while (n-- != 0) {
                    //循环判断两个数组之间的每一个元素是否相等
                    if (v1[i] != v2[i])
                        return false;//如果不相等返回false
                    i++;
                }
                //循环结束没有问题返回true
                return true;
            }
        }
        return false;
    }

练习：

@Test
public void test(){
    String string = "zhangsan";

    System.out.println(string.equals("zhangsan"));


}

subString方法

源码分析

/**
 * 从字符串中截取一个子字符串
 * @param beginIndex 开始索引
 * @param endIndex 结束索引
 * @return
 */
public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) { // 开始索引不能小于0，不能为负数
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) { // 结束索引不能大于数组的长度
        throw new StringIndexOutOfBoundsException(endIndex);
    }

    //结束索引 - 开始索引 结果交给一个变量sublen
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {//索引差不能为负数
        throw new StringIndexOutOfBoundsException(subLen);
    }

    /**
     * 核心
     */
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);

    /**
     * 三目运算符相当于if语句
     */
    if ((beginIndex == 0) && (endIndex == value.length)){//开始索引等于0 并且 结束索引等于最大长度，返回当前对象
        this;
    }else {
        new String(value, beginIndex, subLen);//返回新创建的String对象
    }
}

练习：

@Test
public void test(){
    String string = "zhagnsan";

    //substring：从字符串中截取一个子字符串
    System.out.println(string.substring(2, 6));
}

@Test
public void test(){
    String string = "zhagnsan";
    //toCharArray:将字符串转换为一个数组
    char[] a = string.toCharArray();

    System.out.println(Arrays.toString(a));
    //将字符串中字母转换为大写
    System.out.println(string.toUpperCase());
}