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

int a = 1;
int a1 = 2;
a == a1; // false

Dog d = new Dog();
Cat c = new Cat();
Cat c2 = new Cat();
Dog d2 = d;
d == c; // false; 因为两个实例对象不同
c == c2; // false; 因为引用 c 和 c2 指向不同实例
d == d2; // true; 因为引用 d 和 d2 指向同一实例

d.equals(c); // false
c.equals(c2); // false
d.equals(d2); // true

public boolean equals(Object anObject) {
    // 比较两个引用是否指向字符串常量池中同一个字符串常量（匿名对象）
	if (this == anObject) {
		return true;
	}
	// 比较两个 String 对象是否带有相同的字节组合
	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;
}

import java.util.Stack;

public class Demo {
    public static void main(String[] args) {
        System.out.println(ReverseAllStringWithStack("##We###Are###Family!###"));
    }

    public static String ReverseAllStringWithStack(String string) {
        // 如果 string 等于 null 或等于 "" 时，返回 string。
        if (string == null || string.length() == 0)
            return string;
        // 新建一个 Stack，用于存放 Character 类型。为什么存放 Character 而不是 char，
        // 因为泛型只能指定是类或接口类型，而不能是 primitive 主（基本）数据类型。
        Stack<Character> stringStack = new Stack<>();
        
        char[] array = string.toCharArray();//toCharArray() 将字符串转换成 char 类型数组
        // 使用 for-each 将数组中的元素 push（推）进 Stack
        for (Character c : array) {
            stringStack.push(c);
        }
        int length = string.length();// 数组的长度 length; 字符串的长度 length(); 集合的长度 size()
        // 利用 for 循环将元素从栈顶开始，依次弹出
        for (int i = 0; i < length; i++) {
            array[i] = stringStack.pop();
        }
        
        return new String(array);//String 的重载构造方法将 char[] 数组转换，返回一个实例化 String 对象
    }
}

public class Demo {
    public static void main(String[] args) {

        String s = "1" + "2" + "3";

        String s1 = "1";
        String s2 = s1 + "2";
        String s3 = s2 + "3";

        System.out.println(s);
        System.out.println(s3);
    }
}

// Can you spot the "memory leak"?
public class Stack {
  private Object[] elements;
  private int size = 0;
  private static final int DEFAULT_INITIAL_CAPACITY = 16;

  public Stack() {
       elements = new Object[DEFAULT_INITIAL_CAPACITY];
  }

  public void push(Object e) {
    ensureCapacity();
    elements[size++] = e;
  }

  public Object pop() {
    if (size == 0)
         throw new EmptyStackException();
    return elements[--size];
  }

/**
* Ensure space for at least one more element, roughly
* doubling the capacity each time the array needs to grow.
*/
  private void ensureCapacity() {
    if (elements.length == size)
         elements = Arrays.copyOf(elements, 2 * size + 1);
    }
}

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    public synchronized static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Sort {
   public static void main(String[] args) {
        int[] input = {5, 4, 7, 1, 6, 2, 8, 9, 10};
        // 此处调用方法，以调用冒泡排序为例
        bubbleSort(input);
        for (int i = 1; i <= input.length; i++) {
            System.out.println(input[i - 1]);
        }
    }
}