学习内容

1, 不可变类和不可变对象

不可.变类(immutable class):由final修饰的类,它是最终类,不能有子类.

不可变对象(immutable object):由final修饰的对象,被final修饰后,这个对象的所有属性值都不能在被改变.
最终变量:被final修饰的变量,其取值在初始化之后就不能再更改.

2, String实例

以String s = "Hello";为例,描述其内部过程.

将"Hello"赋值给 s 时,首次-会在String常量池中查找是否有相应的String实例的存在.

若存在,直接赋给s,没有的话,会构造string实例并添加到String 常量池中,并返回该实例的地址.

最后把返回的String实例的地址赋给s,这时就说,s指向实例.

3,StringBuffer 类

1、StringBuffer类直接继承了AbstractStringBuilder ( 从 JDK 1.5 开始 )

2、StringBuffer 类是最终类 ( final class )

3、StringBuffer 实例中的实例变量可变

Buffer的实例方法

StringBuffer类中定义的实例方法会直接修改当前的stringBuffer实例,所以说String Buffer实例是可变的.(即字符缓冲区中的内容是可变的).

buffer.inset(4,' '); 在指定处插入新的内容 //插入字符 buffer.inset(start,"韩");在指定索引处插入新内容 //插入字符串

buffer.delete(start,end); 删除start和end之间的内容.

buffer.deleteCharAt(); 删除指定索引处的单个字符

buffer.setCharAt(index,"X"); 替换指定位置的单个字符

buffer.replace(start,end," XXX "); 使用指定内容替换[start,end]之间的内容.

buffer.lastIndexOf( x );查找指定内容最后出现的位置.

buffer.reverse();反转字符缓冲区

buffer.append("好好学习,改变自己"); 在末尾追加内容.

比较字符序列

注:StringBuffer和Stringbuilder都没有重写Object的equals方法.

如何比较:

将StringBuffer和StringBuilder转换为String实例,通过String类提供的ontentEquals来比较.

String类提供了contentEquals(CharSequence)和contentEquals(StringBuffer) 方法比较字符序列是否相等.

问题

​ 字符转换、默认字集转换这些在平时工作中用的地方多否？

作业

方法重载：

public class MethodOverloading {

    public static void main(String[] args) {
        System.out.println(MethodOverloading.equal(new int[]{1, 2, 3}, new int[]{1, 2, 3}));
        System.out.println(MethodOverloading.equal(new char[]{'1', '2'}, new char[]{'1', '2'}));
    }

    public static boolean equal(int[] first, int[] second) {
        if (first.length != second.length) {
            return false;
        }
        if (first.length == 0) {
            return true;
        }
        for (int i = 0; i < first.length; i++) {
            if (first[i] != second[i]) {
                return false;
            }
        }
        return true;
    }

    public static boolean equal(char[] first, char[] second) {
        if (first.length != second.length) {
            return false;
        }
        if (first.length == 0) {
            return true;
        }
        for (int i = 0; i < first.length; i++) {
            if (first[i] - second[i] > 0) {
                return false;
            }
        }
        return true;
    }
}

可变长度参数：

public class VariableArityMethods {
    public static void main(String[] args) {
        MathHelper mathHelper = MathHelper.getInstance();
        System.out.println(mathHelper.max(99L, 77, 66, 'x'));
        System.out.println(mathHelper.min(99L, 77, 66, 'x'));
        System.out.println(mathHelper.max(1.2E-2, 99L, 77, 66, 'x'));
        System.out.println(mathHelper.min(1.2E-2, 99L, 77, 66, 'x'));
    }
}
class MathHelper {

    public static MathHelper getInstance() {
        return new MathHelper();
    }
    public long max(long... values) {
        // 找出参数中的最大值并返回
        long tempMax = Long.MIN_VALUE;
        for (long l : values) {
            if (l > tempMax) {
                tempMax = l;
            }
        }
        return tempMax;
    }
    public double max(double... values) {
        // 找出参数中的最大值并返回
        double tempMax = Double.MIN_VALUE;
        for (double v : values) {
            if (v > tempMax) {
                tempMax = v;
            }
        }
        return tempMax;
    }
    public long min(long... values) {
        // 找出参数中的最小值并返回
        long tempMin = Long.MAX_VALUE;
        for (long l : values) {
            if (l < tempMin) {
                tempMin = l;
            }
        }
        return tempMin;
    }
    public double min(double... values) {
        // 找出参数中的最小值并返回
        double tempMin = Double.MAX_VALUE;
        for (double v : values) {
            if (v < tempMin) {
                tempMin = v;
            }
        }
        return tempMin;
    }
}

吐槽

​ 今天听的还不是很懂，下午有打瞌睡了QAQ.