package homework_0724.p2_myarray;

import java.util.Arrays;

/**
 * @author WanJl
 * @version 1.0
 * @title MyArray
 * @description
 * @create 2026/7/27
 */
public class MyArray {
    //内部真正存储数据的数组
    private int[] data;
    //当前已存储的元素个数（不是数组长度）
    private int size;

    /**
     * 无参构造，默认初始化容量为 10 的数组
     */
    public MyArray() {
        this.data=new int[10];
    }

    /**
     * 指定初始容量，如果传入的容量 ≤ 0，则使用默认容量 10
     * @param capacity
     */
    public MyArray(int capacity) {
        if (capacity<=0) {
            this.data=new int[10];
        }else {
            this.data=new int[capacity];
        }
    }

    /**
     * 1. 添加元素 — add(int element)
     * 如果内部数组已满，自动扩容为当前容量的 1.5 倍（data.length * 3 / 2）
     * 扩容步骤：创建新数组 → 复制旧元素 → 替换 data 引用
     * 将新元素存入 data[size]，size 自增 1
     * @param element
     */
    public void add(int element){
        int[] newArr;
        if(size>=data.length){  //内部数组已满--已存储元素等于数组长度
            newArr=new int[data.length*3/2];
        }else {
            newArr=new int[data.length];
        }
        //复制旧数组的元素到新数组
        for (int i = 0; i < size; i++) {
            newArr[i]=data[i];
        }
        //插入最新元素到数组末尾
        newArr[size]=element;
        //元素个数++
        size++;
        //替换 data 引用
        this.data=newArr;
    }

    /**
     * 2. 获取元素 — get(int index)
     * 下标越界时输出 "下标越界，无法获取元素"，返回 -1
     * 否则返回 data[index]
     * @param index
     * @return
     */
    public int get(int index){
        if (index>=size){
            System.out.println("下标越界，无法获取元素");
            return -1;
        }
        return data[index];
    }

    /**
     * 3. 修改元素 — set(int index, int element)
     * 下标越界时输出 "下标越界，无法修改元素"
     * 否则将 data[index] 赋值为 element
     * @param index
     * @param element
     */
    public void set(int index, int element){
        if (index>=size){
            System.out.println("下标越界，无法修改元素");
        }else {
            //完成赋值
            data[index]=element;
        }
    }

    /**
     * 9. 删除指定位置的元素 — remove(int index)
     * 下标越界时输出 "下标越界，无法删除元素"，返回 -1
     * 否则：保存被删除的值 → 后面元素前移一位 → size-- → 返回被删除的值
     * @param index
     * @return
     */
    public int remove(int index){
        if (index>=size){
            System.out.println("下标越界，无法删除元素");
            return -1;
        }
        //保存被删除的值
        int del=data[index];
        //建立新的数组
        int[] newArr=new int[data.length];
        //循环--复制旧数组的Index之前的元素到新数组的对应位置
        for (int i = 0; i < size-1; i++) {
            if (i<index){
                newArr[i]=data[i];
            }else {
                newArr[i]=data[i+1];
            }
        }
        //新数组替换旧数组
        data=newArr;
        //size-1
        size--;
        return del;
    }

    /**
     * 11. 数组排序 — sort(boolean ascending)
     * true 升序，false 降序
     * 使用冒泡排序，只对 data[0] ~ data[size-1] 排序
     * @param ascending
     */
    public void sort(boolean ascending){
        for (int i = 0; i < size-1; i++) {
            for (int j = 0; j < size-1-i; j++) {
                if (ascending){
                    if (data[j]>data[j+1]){
                        exchange(j, j+1);
                    }
                }else {
                    if (data[j]<data[j+1]){
                        exchange(j, j+1);
                    }
                }
            }
        }
    }

    /**
     * 私有的交换函数
     * @param a 索引值1
     * @param b 索引值2
     */
    private void exchange(int a,int b){
        int t=data[a];
        data[a]=data[b];
        data[b]=t;
    }


    /**
     * print()
     * 遍历输出格式：[元素1, 元素2, 元素3, ...]
     * 空数组输出 []
     */
    public void print(){
        if (size>0){
            System.out.print("[");
            for (int i = 0; i <size; i++) {
                System.out.print(data[i]);
                if (i<size-1)
                    System.out.print(", ");
            }
            System.out.println("]");
        }else {
            System.out.println("[]");
        }
    }

    /**
     * 返回 size 属性值
     * @return
     */
    public int size(){
        return this.size;
    }
}