Java基本程序结构

字符串

== 和 equals的区别

对于基本数据类型来说，== 是比较值是否相等
对于引用数据类型来说，== 是比较两者在堆内存中存放的地址

public static void main(String[] args) {
    int m = 123;
    int n = 123;
    System.out.println(m == n); //true

    String x = "Test";
    String y = "Test";
    System.out.println(x == y); //true

    String z = new String("Test");
    System.out.println(x == z); //false
}

equals()

equals方法没有重写的时候，比较的还是对象在堆内存中的地址
Object.java类中的equals方法

public boolean equals(Object obj) {
    return (this == obj);
}

String.java类中重写了equals方法，比较的是值

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

public static void main(String[] args) {
    int m = 123;
    int n = 123;
    System.out.println(m == n); //true

    String x = "Test";
    String y = "Test";
    System.out.println(x.equals(y)); //true

    String z = new String("Test");
    System.out.println(x.equals(z)); //true
}

返回字符串中第一次出现的唯一字符的索引，没有返回-1

字符串转成字符数组

public int firstUniqChar(String s){
    char [] c = s.toCharArray();
    int [] count = new int[128];

    for (int i = 0; i < s.length(); i++) {
        count[c[i]]++;
    }

    for (int i = 0; i < s.length(); i++) {
        if (count[c[i]] == 1){
            return i;
        }
    }
    return -1;
}

数组

数组翻转

翻转数组，需要交换的次数是arr.length/2

int [] arr = {11,22,33,44,55,66};
int len = arr.length;
int temp;
for (int i = 0; i < len/2; i++) {
    temp = arr[len-1-i];
    arr[len-1-i] = arr[i];
    arr[i] = temp;
}

冒泡排序-升序

/**
 * 第一轮 把最大数放在最后
 * 第1次 arr[0]和arr[1]比较，如果arr[0] > arr[1]，则交换
 * 第2次 arr[1]和arr[2]比较，如果arr[1] > arr[2]，则交换
 * 第3次 arr[2]和arr[3]比较，如果arr[2] > arr[3]，则交换
 * 第4次 arr[3]和arr[4]比较，如果arr[3] > arr[4]，则交换
 * 第二轮 把第二大数放在倒数第二位
 * 第1次 arr[0]和arr[1]比较，如果arr[0] > arr[1]，则交换
 * 第2次 arr[1]和arr[2]比较，如果arr[1] > arr[2]，则交换
 * 第3次 arr[2]和arr[3]比较，如果arr[2] > arr[3]，则交换
 * 第三轮 把第三大数放在倒数第三位
 * 第1次 arr[0]和arr[1]比较，如果arr[0] > arr[1]，则交换
 * 第2次 arr[1]和arr[2]比较，如果arr[1] > arr[2]，则交换
 * 第四轮 把第四大数放在倒数第四位
 * 第1次 arr[0]和arr[1]比较，如果arr[0] > arr[1]，则交换
 */
 
int [] arr = {24,69,80,57,13};
int len = arr.length;
int temp;
for (int i = 0; i < len-1; i++) {
    for (int j = 0; j < len-1-i; j++) {
        if (arr[j] > arr[j+1]){
            temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

面向对象

递归：即方法自己调用自己

递归-阶乘

图片.png

//递归-阶乘
public int factorial(int n){
    if (n == 1){
        return 1;
    }
        return factorial(n-1) * n;
}