笔记: JavaSE day15 笔记

第十五天课堂笔记

数组

可变长参数★★★

方法 : 返回值类型方法名(参数类型参数名 , 参数类型 … 可变长参数名){}
方法体 : 变长参数相当于一个数组
一个数组最多只能有一个可变长参数, 并放到列表的最后
parameter : 方法参数

数组相关算法★★

冒泡排序
- 由小到大: 从前向后两两比较,将大的通过交换放到后面
- 轮数 : n个数 ,就是n-1轮
- 每一轮判断次数: 第i轮 , n - i 次
选择排序
- n个元素, 进行n-1轮排序
- 每一轮获取最小元素和第i个位置上的元素进行互换
插入排序
- 数组分为已排序 , 未排序两部分
- 遍历未排序的部分, 依序插入到已排序的部分中
- 当前未排序数组第一个值j 的前一个就是已排序的最后一个 => i = j - 1
- while循环向前找,知道找到在已排序数组对应的索引值 , 只要j对应的值小, 就让判断的那个i值向后移动

代码如下

    /**
     * 插入排序
     *
     * @param arrs : 数组
     */
    private static void insertSort(int[] arrs) {
        // 未排序数组的循环遍历
        for (int j = 1; j < arrs.length; j++) {
            // 定义指针 => 已排序数组最后面的指针
            int i = j - 1;
            int temp = arrs[j];  // 获取i当前的数
            while (i >= 0 && temp < arrs[i]) {
                arrs[i + 1] = arrs[i];  // 将值后移
                i--;  // 继续判断前一个值
            }
            arrs[++i] = temp;  // 将j值插入到对应的位置
        }
    }

二分查找算法
- 前提 : 数组有序
- 定义双指针 , 始终与中间元素比较, 相等找到了, 否则把范围缩小一半继续查找

代码如下

   /**
     * 二分查找target
     *
     * @param arrs   : 数组
     * @param target : 目标值
     * @return : 返回索引值
     */
    private static int getBinarySearch(int[] arrs, int target) {
        int i = 0, j = arrs.length - 1; // 定义索引
        while (i <= j) {
            int mid = (i + j) >>> 1; // 获取中间值
            if (arrs[mid] == target) {
                return mid;
            } else if (arrs[mid] < target) {
                // 动i
                i = mid + 1;
            } else if (target < arrs[mid]) {
                // 动j
                j = mid - 1;
            }
        }
        return -1;
    }

使用递归实现

   /**
     * 使用递归实现
     *
     * @param arrs   : 数组
     * @param target : 目标值
     * @param start  : 开始至
     * @param end    : 结束值
     * @return : 返回索引
     */
    private static int binSeaGetTargetRecur(int[] arrs, int target, int start, int end) {
        if (start >= end) {
            return -1;
        }
        int mid = (start + end) >>> 1;
        if (arrs[mid] == target) {
            return mid;
        }
        if (arrs[mid] < target) {
            return binSeaGetTargetRecur(arrs, target, mid + 1, end);
        } else {
            return binSeaGetTargetRecur(arrs, target, start, mid);
        }
    }

Arrays类的常用方法★★★

asList() : 将数据转换为集合
int binarySearch(int[] arrs , int key) ; 二分查找
copeOf() : 复制数组
- 定义一个新数组, 把数组中的数据复制到新数组中,返回新数组
- 新数组长度可以更大,也可以更小
- 长度更大, 把新数组索引复制给数组, => 数组扩容
fill() : 填充
sort() : 排序
stream() : 根据数组生成stream流
tostring() : 数组连接字符串
代码如下

public static void main(String[] args) {
        // 定义一个数组
        int[] arrs = new int[]{1, 3, 5, 2, 5, 8, 4, 67, 3, 6};
        // asList(T... a) 返回由指定数组支持的固定大小的列表。
        List<int[]> list = Arrays.asList(arrs);
        System.out.println("list = " + list);
        //binarySearch(byte[] a, byte key)  :使用二进制搜索算法搜索指定值的指定字节数组。
        int target = 131;
        int i = Arrays.binarySearch(arrs, target);
        System.out.println("i = " + i);
        // copyOf(boolean[] original, int newLength) : 填充，以使副本具有指定的长度 : 数组扩容。
        int[] ints = Arrays.copyOf(arrs, arrs.length * 2);
        arrs = ints;
        System.out.println("Arrays.toString(arrs) = " + Arrays.toString(arrs));
        int[] ints1 = Arrays.copyOf(arrs, 5);
        System.out.println("Arrays.toString(ints1) = " + Arrays.toString(ints1));
        // copyOfRange(int[] original, int from, int to) : 将指定数组的指定范围复制到新数组中。
        int[] ints2 = Arrays.copyOfRange(arrs, 2, 5);
        System.out.println("Arrays.toString(ints2) = " + Arrays.toString(ints2));
        //fill(int[] a, int fromIndex, int toIndex, int val) : 将指定的int值分配给指定的int数组的指定范围的每个元素。
        Arrays.fill(arrs, 1, 3, 999);
        System.out.println("Arrays.toString(arrs) = " + Arrays.toString(arrs));
        //hashCode(int[] a) 根据指定数组的内容返回哈希码。
        System.out.println("Arrays.hashCode(arrs) = " + Arrays.hashCode(arrs));
        //parallelSort(int[] a)按照数字顺序排列指定的数组。
        Arrays.parallelSort(arrs);
        System.out.println("Arrays.toString(arrs) = " + Arrays.toString(arrs));
        //sort(int[] a, int fromIndex, int toIndex)按升序排列数组的指定范围。
        Arrays.sort(ints1);
        System.out.println("Arrays.toString(ints1) = " + Arrays.toString(ints1));
    }

对象数组

练习代码如下

/**
 * 对象数组练习题
 */
public class Test01ObjectArrs {
    public static void main(String[] args) {
        // 创建一个随机数组
        int m = 50; // 对象数组长度
        int size = 10; // 存入个数
        Student[] students = createObjectArrs(m, size);
        // 遍历
        // 统计不及格人数
        int count = 0; // 定义计数器变量
        for (int i = 0; i < size; i++) {
            System.out.println("students[i].toString() = " + students[i].toString());
            if (students[i].stuCourse < 60) {
                count++;
            }
        }
        System.out.println("count = " + count); // 不及格人的个数
        // 1 查看data数组中是否存在姓名为wangwu的同学
        students[size++] = new Student("王五", createCourse());
        String targetName = "王五";
        int isExist = isExist(size, students, targetName);
        System.out.println(isExist > 0 ? "存在" : "不存在");

        //2 从数组中删除姓名为zhaoliu的同学
        // 判断该姓名同学是否存在
        students[2].stuName = "张三";
        String deleteName = "张三";
        int isIndex = isExist(size, students, deleteName);
        System.out.println("isIndex = " + isIndex);
        if (isIndex > 0) {
            // 存在,即删除对象数组 下标为isIndex 的元素
            students = deleteObjectArr(size, students, isIndex);
            size--;  // 数组元素个数减一
            // 删除成功, 遍历展示
            for (int i = 0; i < size; i++) {
                System.out.println("students[i].toString() = " + students[i].toString());
            }
        } else {
            // 不存在不用删除
            System.out.println("不存在,不用删除");
        }
    }

    /**
     * 删除
     *
     * @param size        : 对象个数
     * @param students    : 对象数组
     * @param deleteIndex : 删除目标索引
     */
    private static Student[] deleteObjectArr(int size, Student[] students, int deleteIndex) {
        // 定义一个新数组
        Student[] smallStus = new Student[students.length];
        // 将数组 [0 , deleteIndex - 1) 复制给新数组 : deleteIndex - 1个元素
        System.arraycopy(students, 0, smallStus, 0, deleteIndex);
        // 将数组 [deleteIndex + 1 , size) 复制给新数组 size - deleteIndex - 1个元素
        System.arraycopy(students, deleteIndex + 1, smallStus, deleteIndex, size - deleteIndex - 1);
        // 将samllStu的索引值 赋值给 数组
        return smallStus;
    }

    /**
     * 判断是否存在
     *
     * @param size       : 对象个数
     * @param students   : 对象数组
     * @param targetName : 目标名字
     * @return : 返回索引值
     */
    private static int isExist(int size, Student[] students, String targetName) {
        for (int i = 0; i < size; i++) {
            if (students[i].stuName.equals(targetName)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 生成对象数组
     *
     * @param m    : 数组长度
     * @param size : 对象个数
     * @return : 返回对象数组
     */
    private static Student[] createObjectArrs(int m, int size) {
        Student[] students = new Student[m];
        for (int i = 0; i < size; i++) {
            students[i] = new Student(createName(), createCourse());
        }
        return students;
    }

    /**
     * 生成随机名字的方法
     */
    private static String createName() {
        int n = (int) (Math.random() * (4 - 2) + 2); // 随机生成名字长度
        char[] ch = {'国', '泰', '民', '安', '中', '华', '崛', '起', '繁', '容', '昌', '盛'};
        StringBuilder name = new StringBuilder();
        for (int i = 0; i < n; i++) {
            name.append(ch[(int) (Math.random() * 12)]);
        }
        return name.toString();
    }

    /**
     * 生成一个随机成绩
     */
    private static int createCourse() {
        return (int) (Math.random() * 100);
    }
}

class Student {
    // 定义实例变量
    String stuName;
    // 成绩
    double stuCourse;

    public Student() {
    }

    public Student(String stuName, double stuCourse) {
        this.stuName = stuName;
        this.stuCourse = stuCourse;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuCourse=" + stuCourse +
                '}';
    }
}