import java.util.Arrays;
import java.util.List;

public class ArrayAnalysis {
    public static void main(String[] args) {
        // 声明Array
        int[] intArray = {1, 2, 3, 3, 9, 5, 4, 8};
        String[] stringArray = new String[10];
        int[][] intArray2D = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        // 打印Array
        System.out.println(intArray);  // 打印出intArray的地址
        System.out.println(Arrays.toString(intArray));  // 打印出inArray的内容
        System.out.println(Arrays.deepToString(intArray2D));  // 打印出intArray2的内容
        System.out.println(intArray[1]);  // 打印出索引为1处的元素

        // 排序Array
        Arrays.sort(intArray);  // 这行代码会直接修改intArray，返回值为void

        // 浅拷贝Array
        int[][] newIntArray2D = Arrays.copyOf(intArray2D, intArray2D.length);  // 第二个参数的意思是截取Array中前intArray2.length个元素。这里是浅拷贝。
        intArray2D[0][0] = -99;
        System.out.println(Arrays.deepToString(newIntArray2D));  // [[-99, 2, 3], [4, 5, 6], [7, 8, 9]]
        // 深拷贝Array
        newIntArray2D = Arrays.stream(intArray2D).map(arr -> Arrays.copyOf(arr, arr.length)).toArray(int[][]::new);
        intArray2D[0][0] = 99;
        System.out.println(Arrays.deepToString(newIntArray2D));  // [[-99, 2, 3], [4, 5, 6], [7, 8, 9]]

        // 将int[]转化为List<Integer>
        List<Integer> myList = Arrays.stream(intArray).boxed().toList();
        System.out.println(myList);  // [1, 2, 3, 3, 4, 5, 8, 9]
    }
}

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayListAnalysis {
    public static void main(String[] args) {
        ArrayList<Integer> integerList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));
        ArrayList<Integer> newIntegerList = integerList;  // 这里是直接传递引用
        System.out.println(integerList);  // 由于ArrayList类重写了Object类中的toString()方法，所以这里直接打印出元素
        
        // List的增删查改
        integerList.set(0, 100);
        integerList.add(99);
        integerList.remove(0);
        System.out.println(integerList.get(integerList.size() - 1));
        System.out.println(newIntegerList);
        
        // List<Integer>转化为基本数据类型int[]
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        int[] arr = list.stream().mapToInt(Integer::intValue).toArray();
        
        // List<int[]>转化为基本数据类型int[][]
        List<int[]> list2D = new ArrayList<>();
        list2D.add(new int[] {1, 2, 3});
        list2D.add(new int[] {4, 5, 6});
        int[][] arr2D = list2D.toArray(new int[2][]);  //或 list2D.toArray(int[][]::new)
    }
}

public final class String implements java.io.Serializable, Comparable<String>, CharSequence

String str1 = "Hello";
String str2 = "Hello";
System.out.println(str1 == str2);  // true

String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println(str1 == str2);  // false

StringBuilder sb = new StringBuilder("Hello, World");

import java.util.Objects;

class Student {
    private String name;
    private String address;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name) && Objects.equals(address, student.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, address); // 保证相同name和address的Student对象哈希码一致
    }
}

import java.util.Arrays;

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

        String[] myArray = {"item1", "item2"};
        System.out.println(myArray[0]);  // Show the first element of myArray.
        System.out.println(myArray);  // Show the hash code of the memory address of an array object.
        System.out.println(Arrays.toString(myArray));  // Show all of the items in String daya type of an Array.
        System.out.println(myArray.length);  // Show the length of a String[]. 
        
    }
}

import java.util.Arrays;

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

        char[] charArray = s.toCharArray();
        Arrays.sort(charArray);  // Sort an Array.
    }
}

import java.util.ArrayList;

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

        ArrayList<String> myList = new ArrayList<String>();
        myList.add("A");
        myList.add("B");
        myList.add("C");
        System.out.println(myList.get(1));// "B"
        myList.remove(0);
    }
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<int, String> myHashTable = new HashMap<int, String>();
        myHashTable.put(0, "item1");
        System.out.println(myHashTable.get(0));
        myHashTable.remove(0);  // remove target item.
        myHashTable.clear();  // remove all items.
        myHashTable.keySet();  // java.util.HashMap$KeySet, used for loop through keys in a HashTable.
        myHashTable.values();  // java.uitl.HashMap$Values, used for loop through values in a HashTable.
        myHashTable.containsKey(0)  // to check if a key in a HashTable.
    }
}

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> myHashSet = new HashSet<String>();
        myHashSet.add("item1");
        myHashSet.add("item2");
        myHashSet.contains("item3");  // check if "item3" in myHashSet.
        myHashSet.remove("item2");
        myHashSet.clear();
        myHashSet.size();
        // myHashSet1.euqals(myHashSet2)  check if two HashSets have same items.
    }
}

enum myEnumName {
    CONSTANT1, CONSTANT2, CONSTANT3;
}

public class VolatileExample {
    private volatile boolean running = true;

    public void start() {
        new Thread(() -> {
            while (running) {
                // 执行任务
            }
        }).start();
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        example.start();
        Thread.sleep(1000);
        example.stop();  // 1秒后停止线程
    }
}

// FactoryMethodDemo.java
package com.example;

// Button 
interface Button {
    void paint();
}

// Windows Button
class WindowsButton implements Button {
    public void paint() {
        System.out.println("This is Windows button.");
    }
}

// Mac Button
class MacButton implements Button {
    public void paint() {
        System.out.println("This is Mac button.");
    }
}


// GUI Factory Button
interface GUIFactory {
    Button createButton();
}

// Windows Factory
class WindowsFactory implements GUIFactory {
    public Button createButton() {
        return new WindowsButton();
    }
}

// Mac Factory
class MacFactory implements GUIFactory {
    public Button createButton() {
        return new MacButton();
    }
}


public class FactoryMethodDemo {

    public static void main(String[] args) {

        // I don't need to specify a button. The factory will decide which button it is.
        GUIFactory factory1 = new WindowsFactory();
        Button newButton1 = factory1.createButton();
        newButton1.paint();

        GUIFactory factory2 = new MacFactory();
        Button newButton2 = factory2.createButton();
        newButton2.paint();
    }
}

public class User {
    private final String firstName; // 必需
    private final String lastName;  // 必需
    private final int age;          // 可选
    private final String phone;     // 可选
    private final String address;   // 可选

    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    // UserBuilder静态类
    public static class UserBuilder {
        private final String firstName;
        private final String lastName;
        private int age = 0;
        private String phone = "";
        private String address = "";

        public UserBuilder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }

        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public UserBuilder address(String address) {
            this.address = address;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }

    public static void main(String[] args) {
        User user = new User.UserBuilder("John", "Doe").age(30)
                            .phone("1234567890")
                            .address("Fake Address 1234")
                            .build();
    }
}

package com.example;

// 目标接口
interface Target {
    void request();
}

// 第三方类（被适配者）
class ThirdPartyClass {
    public void specifiedRequest() {
        // 第三方类的具体实现
    }
}

// 适配器类
class AdapterClass implements Target {
    private ThirdPartyClass thirdPartyClass;

    public AdapterClass(ThirdPartyClass thirdPartyClass) {
        this.thirdPartyClass = thirdPartyClass;
    }

    @Override
    public void request() {
        // 调用被适配者的方法，此处可以添加一些额外的处理
        thirdPartyClass.specifiedRequest();
    }
}

public class AdapterClinet {
    public static void main(String[] args) {
        ThirdPartyClass thirdPartyClass = new ThirdPartyClass();
        Target target = new AdapterClass(thirdPartyClass);
        target.request();
    }
}