equals

比较两个对象的内容是否相同

public class Str {
    public static void main(String[] args) {
        // b重用a 所以二者相等
        String a = "aa"+"c";
        String b = "aa"+"c";
        System.out.println(a==b);
        // new string必定创建新的对象
        String s = new String("aa" + "c");
        String s1 = new String("aa" + "c");
        System.out.println(a==s);
        System.out.println(s1==s);
        // 字符串拼接
        /*
        *
        * 字符串String的拼接有：“+” 、 concat () 方式实现
        * 或者使用StringBuilder、StringBuffer类实现
        * 这几种方式性能的从低到高进行排序
        * 则顺序为：“+” < concat () < StringBuffer < StringBuilder
        * 使用"+"性能是最差的，应该避免使用！！！
        * +号的本质是 StringBuilder sb = new StringBuilder(a);
        *           sb.append("3");
        * +号连接字符串字面量“a”+“b” 本质就是“ab”
        * StringBuffer是线程安全的，而StringBuilder不是
        *
        * getByte()可以把字符串转成流
        * new String()可以把流转成字符串
        * a.codePointAt() 可以把字符转换成unicode码
        * */
    }

字符串变成字符流

public class strConcat {
    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
        tran("宝");
        long after = System.currentTimeMillis();
        System.out.println(after-begin);
    }
    public static void tran(String a){
        byte[] bytes = a.getBytes();
        System.out.println(Arrays.toString(bytes));
    }

空指针异常的原因

null 调用方法就会产生空指针异常

字符串排序

 public static void main(String[] args) {
        String a = "wang";
        String b = "abcd";
        int i = a.compareTo(b);
        // 该方法用来比较字符串的内容，而不是地址
        boolean equals = a.equals(b);
        System.out.println(i);
    }
字符排序根据abcd...的顺序，
a.compareTo(b)>0  a排序靠后 <0相反  =0二者相同

字符串的替换查找

 public static void main(String[] args) {
        String b = "add";
        String c = "d";
        // b.contains(c) 判断b中有没有c字符串  返回一个布尔值
        boolean contains = b.contains(b);
        // b.indexOf(c) 角标以0开始查找c字符串，如果没有匹配到内容，返回-1，如果找到，返回c字符串的位置
        int i = b.indexOf(c);
        System.out.println(i);
        // b.replace()  把指定的字符替换成所需的字符
        String replace = b.replace(c, "*");
        // b和c忽略大小写进行比较
        boolean b3 = b.equalsIgnoreCase(c);
         // 可以把任意数据类型转成字符串
        String a = String.valueOf("a");
        System.out.println(replace);
        System.out.println(contains);
    }

判断一个字符串在另一个字符串出现的次数

 public static int ccc(String str,String key){
        int count = 0;
        while (str.contains(key)){
           str = str.substring(str.indexOf(key) + key.length());
           count ++;
        }
        return count;
    }

数组

空数组的值
整形：0
浮点型：0.0
char：0对应的字符
boolean：false
引用类型为null

数组复制

public static void main(String[] args) {
        int [] arr1 = {1,8,5,2,3};
        int [] arr2 = new int[arr1.length+1];
        System.arraycopy(arr1,0,arr2, 0, arr1.length);
        System.out.println(Arrays.toString(arr2));
    }
system中的方法可以高效复制数组
 public static native void arraycopy(
     Object src,  int  srcPos, Object dest,
     int destPos, int length);
@param src 源数组
@param srcPos 在源数组中的起始位置
@param dest 目标数组
@param destPos 目标数据中的起始位置
@param length 要复制的数组元素的数量
arraycopy(老数组，老数组从哪里开始，新数组，新数组在哪里开始，复制的长度)

数组工具类

倒序排序
Arrays.sort(arr, Comparator.reverseOrder());
判断两个数组中的内容是否相同
Arrays.equals(arr, arr1)
int[] arr = {1,8,6,8,2,7,9};
        int[] arr1 = {5,5,5};
        int[] add = ArrayUtils.insert(5, arr, 6,6,6);
        int[] remove = ArrayUtils.remove(arr, 3);
        ArrayUtils.reverse(arr);
        int[] ints = ArrayUtils.addAll(arr, 1,5,8,9,6);
        System.out.println(Arrays.toString(ints));
        int[] clone = ArrayUtils.clone(arr);
        System.out.println(Arrays.toString(clone));
        System.out.println("=================");
        int[] subarray = ArrayUtils.subarray(arr1, 1, 2);
        System.out.println(Arrays.toString(subarray));
        ArrayUtils.shuffle(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(ArrayUtils.contains(arr, 11));
        System.out.println("=================");
        String str1 = "bao";
        String intern = str1.intern();
        System.out.println(str1 == intern);
    }

构造方法

1.代码块中的内容会被默认添加到构造方法的第一行，进行初始化功能，会在构造方法之前执行
    ·代码块的执行在构造方法之前
    ·代码块不能使用 有可能未赋值 的属性
    ·若代码块中有复制语句，代码块就会对属性进行赋值，从而盖掉初始值
    ·若代码块在赋值语句的前面，那么赋值语句中的值会覆盖代码块中的值，进而被参数覆盖

面向对象

1.权限修饰符

2.static

3.类加载过程

虚拟机把字节码文件加载到内存，产生类对象

0.递归的加载父类
1.分配空间
2.加载静态属性，如果有赋值语句，加载赋值语句
3.加载静态代码块，并且加载代码块中的语句
4.如果有静态属性没有赋值，此时完成对静态属性的赋值，没有赋值就是默认值
5.把类中的静态方法 (压入内存) 中
6.父类静态属性，静态代码块，代码块，构造方法，子类静态属性，静态代码块，代码块，构造方法

4.final

修饰的类不可以被继承，修饰的方法不可以被重写，修饰的变量变成常量
······赋值用法
1.声明时赋值
2.代码块中赋值
3.构造方法
······静态final
1.声明时赋值
2.静态代码块赋值

5.对象构建

6.内部类

成员内部类，静态内部类，局部内部类，匿名内部类

成员内部类
ICBCBank bank = new ICBCBank();
ICBCBank atm = bank.new ATM();
静态内部类
ICBCBank.ATM = new ICBCBank.ATM();

7.继承

abstract和final同时修饰类不可以
因为abstract中定义的方法就是让子类来实现的，而加了final这个类就不可以被继承，也就没有子类了
abstract和static同时修饰类可以

abstract和final同时修饰方法不可以
final方法不能被重写
abstract和static同时修饰方法不可以
静态方法不允许被重写

static和final可以同时修饰类和方法和属性

匿名内部类

Atm atm = new Atm(){
        重写方法---
    }

接口

接口与接口之间采用多继承，接口与类之间多实现
解耦合，提高扩展性，高聚合
里面的属性都是公开抽象方法
属性都是公开静态不可变的常量
接口中没有构造方法
内部类默认也是公开静态的

函数式接口，简化匿名内部类的书写

他只是创建了一个实现了接口的对象

数据处理函数

int[] arr = {1,3,5,7,9}
    1.聚合    
        int applyAsInt(int left, int right);
Arrays.stream(arr).reduce((sum, a) -> sum+=a)
    2.映射
        int applyAsInt(int operand);把一个流通过某种方法映射到一个新的数据流
Arrays.stream(arr).map(ss -> ss * 3).toArray()
    3.过滤
        boolean test(int value);把一个流通过某种方法过滤成一个流
Arrays.stream(arr).filter(s -> s>5).toArray()

Java 开发

Java