2021-11-15学习笔记

数组

数组概述

• 一次性声明大量的用于存储数据的变量
• 要存储的数据通常都是同类型的数据；例如：学生成绩

什么是数组

• 数组（array）是一种用于存储多个相同类型数据的存储模型

数组的特点

数组中存放的数据类型必须一致
数组是连续的
数组一旦创建，长度不可改变
数组是引用数据类型
数组是通过索引访问数据（索引从 0 开始）
数组通过 length 属性获取长度

数组的定义

1. int[] array ;
   int array[] ; (不推荐)
   声明数组
2. array = new int[3]
   创建一个长度为 3 的数组、并赋值给 array
   数组内容为 [0 , 0 , 0]
3. array = new int[] {1, 2, 3}
   创建一个长度为 3 的数组、且内容为 [1, 2, 3]
4. int[] array = new int[3] ;
   初始化一个长度为 3 的数组、且内容为 [0, 0, 0]
5. int[] array = new int[] {1, 2, 3}
   初始化一个长度为 3的数组，且内容为 [1, 2, 3]
6. int[] array = {1, 2, 3}
   初始化一个长度为3的数组、且内容为 [1, 2, 3]
7. int[] array ; array = {1, 2, 3} (错误写法)

byte、short、int、long数组默认值为 0
boolean 数组默认值为 false
char 数组默认值是 0 对应的 字符
浮点 数组 默认值 为 0.0
引用 数组 默认值为 null

方法

方法概述

• 方法（method) 是将具有独立功能的代码块组织成一个整体，使其具有特殊功能的代码集。

方法必须先创建才可以使用，该过程称为方法的定义
方法创建之后并不是直接运行的，需要手动使用才执行，该过程称为方法调用

方法的定义和调用

1. 方法定义

• 格式：publi static 返回值数据类型 方法名(数据类型 变量名){
  //方法体
  return 数据；
  }
  范例： public static int max(int a, int b) {
  return a > b ? a : b;
  }

2. 方法调用

• 格式 ：方法名 (参数){…}
• 范例 ： int max1 = MyUtils.max(3, 67);
  System.out.println(max1);
  }

public class MyUtils {
    //数组求和
    public static int sum(int[] array) {
        int sum = 0;
        for (int i : array) {
            sum += i;
        }
        return sum;
    }

    //求int数组中元素的最大值
    public static int max(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        return max;
    }

    //求int数组中元素的最小值
    public static int min(int[] array) {
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }
        }
        return min;
    }

    //求int数组中 指定元素第一次出现的位置，如果没有找到返回-1
    public static int indexOf(int[] array, int x) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == x) {
                return i;
            }
        }
        return -1;
    }

    //求int数组中 指定元素最后一次出现的位置，如果没有找到返回-1
    public static int lastIndexOf(int[] array, int x) {
        int index = -1;
        for (int i = array.length - 1; i >= 0; i--) {
            if (array[i] == x) {
                index = i;
                break;
            }
        }
        return index;
    }

    //求int数组中是否包含指定元素
    public static boolean has(int[] array, int x) {
        return indexOf(array, x) != -1;
/*        for (int i : array) {
            if (i == x)
                return true;
        }
        return false;*/
    }

    //打印int类型的数组数据
    public static void printArray(int[] array) {
        for (int i : array) {
            System.out.println(i);
        }
    }

    //定义一个方法 max , 求 两个 整数的 最大值 (三元运算符)
    public static int max(int a, int b) {
        return a > b ? a : b;
    }

    //定义一个方法 min , 求 两个 整数的 最小值 (三元运算符)
    public static int min(int a, int b) {
        return a < b ? a : b;
    }

    //定义一个方法 greatestCommonDivisor ，计算两个整数的 最大公约数
    public static int greatestCommonDivisor(int a, int b) {
        //调用max和min方法获取二者中的较大值和较小值
        int max = max(a, b);
        int min = min(a, b);
        int i = 1;
        while (true) {
            i = max % min;
            if (i == 0) return min;
            max = min;
            min = i;
        }
    }

    //定义一个方法 leastCommonMultiple, 计算两个整数的 最小 公倍数
    //最小公倍数 =   两个数的 积 / 最大公约束
    public static int leastCommonMultiple(int a, int b) {
        //调用greatestCommonDivisor方法获取两数的最大公约数
        return a * b / greatestCommonDivisor(a, b);
    }

    //封装一个 avg 方法， 用来 计算 int[] 数组的所有元素的平均值
    public static double avg(int[] array) {
        //调用sum(int array)方法获取数组的元素和
        return (double) sum(array) / array.length;
    }

    //封装一个 isLeapYear 方法， 判断 对应的年份是否是闰年
    public static void isLeapYear(int year) {
        //判断年份 能被 4整除 且不能被 100整除 或 能被 400整除，则代表是 闰年
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            System.out.println(year + "年是闰年！");
        } else {
            System.out.println(year + "年不是闰年！");
        }
    }

    //封装一个 isOdd 方法，判断一个数字是否是 奇数
    public static boolean isOdd(int num) {
        return num % 2 == 0;
    }

    //封装一个 isEven 方法，判断一个数字是否是 偶数
    public static boolean isEven(int num) {
        //调用isOdd方法，取相反值
        return !isOdd(num);
    }

    //封装一个 isPrimes 方法， 判断一个数字是否是 素数
    public static boolean isPrimes(int num) {
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0)
                return false;
        }
        return true;
    }

    //封装一个 bubbleSort 方法、实现 int[] 数组的冒泡排序
    public static void bubbleSort(int[] array) {
        //外层循环，控制整个数组的排序趟数
        //每排序一趟负责将最大数沉降到数组尾部
        for (int i = 1; i < array.length; i++) {
            //判断两个相邻索引处元素的大小
            for (int j = 0; j < array.length - i; j++) {
                //如果前者比后者大，交换数据
                if (array[j] > array[j + 1]) {
                    //使用异或运算交换二者数据
                    array[j] = array[j] ^ array[j + 1];
                    array[j + 1] = array[j] ^ array[j + 1];
                    array[j] = array[j] ^ array[j + 1];
                }
            }
        }
    }
}