数组

数组的概念

当需要存储大量相同类型数据时，应该使用数组。

数组是一组连续的空间，用来存储相同类型的数据，在定义数组时，需要指定长度（长度固定）。

• 连续的空间
• 存储相同类型的数据
• 长度固定

数组的创建和组成

数组的创建：

语法：先定义变量，并分配空间（长度），再赋值使用。

int [] n = new int[5];

数组由于在内存分配一块连续的空间，所以数组的变量名表示该数组的地址（第一个元素的地址）。访问数组元素时，需用通过该地址，然后跳过一定的空间（用下标来表示），来访问其他元素。

所以访问第一个元素使用，使用n[0]，访问第5个元素，使用n[4]。

意味着数组的下标从0开始，最后一个是数组的长度-1。

数组的基本使用

数组中的元素如果没有赋值，有默认值。

数组的下标从0开始，最后一个是数组的长度-1。超出长度会出现下标越界异常（ArrayIndexOutOfBoundsException）。

public class Demo2 {
    public static void main(String[] args) {
        // 数组的使用
        int [] arr = new int[5];
        // 赋值
        arr[0] = 5;
        arr[1] = 6;
        arr[2] = 7;
        arr[4] = 9;
//        arr[5] = 10; // 会出现下标越界异常
        // 取值
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]); // 注意，数组中的元素如果没有赋值，有默认值
        System.out.println(arr[4]);
    }
}

数组的遍历

public class Demo3 {
    public static void main(String[] args) {
        // 数组的遍历
        int [] arr = new int[5];
        arr[0] = 10;
        arr[1] = 12;
        arr[2] = 5;
        arr[3] = 8;
        arr[4] = 9;
        // arr.length 表示数组的长度
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
public static void main(String[] args) {
        int [] arr = {3,4,5,6,7};
        // 第一种遍历方式
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        // 第二种遍历方式 foreach循环
        // n表示每一个元素的值
        for (int n : arr) {
            System.out.println(n);
        }
        // 第三种，用来打印输出数组中的每一个元素
        System.out.println(Arrays.toString(arr));
        String [] strArr = {"张三", "李四", "王五"};
        for (int i = 0; i < strArr.length; i++) {
            System.out.println(strArr[i]);
        }
        for (String string : strArr) {
            System.out.println(string);
        }
    }

案例：

public class Demo4 {
    public static void main(String[] args) {
        // 数组有100个元素，分别是1、3、5等奇数，求和
        int [] arr = new int[100];
        // 使用循环遍历赋值
        for (int i = 0; i < arr.length; i++) {
            // 0 = 1
            // 1 = 3
            // 2 = 5
            // 3 = 7
            arr[i] = i * 2 + 1;
        }
        int sum = 0; // 和值
        // 循环遍历求和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println(sum);
    }
}
public class Demo5 {
    public static void main(String[] args) {
        // 数组有10个元素，随机赋值为100以内的整数，遍历输出这些数字，并求和
        int [] arr = new int[10];
        // 随机赋值
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(100);
        }
        // 遍历输出并求和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            sum += arr[i];
        }
        System.out.println("和为：" + sum);
    }
}

数组的默认值

基本数据类型的数组默认值基本都是0。例如：

• int：0
• byte：0
• short：0
• long：0L
• float：0.0F
• double：0.0
• char：0
• boolean：false
• 其他的引用类型：null

public class Demo6 {
    public static void main(String[] args) {
        // 数组的默认值
        byte [] arr1 = new byte[1];
        System.out.println(arr1[0]);
        short [] arr2 = new short[1];
        System.out.println(arr2[0]);
        int [] arr3 = new int[1];
        System.out.println(arr3[0]);
        long [] arr4 = new long[1];
        System.out.println(arr4[0]);
        float [] arr5 = new float[1];
        System.out.println(arr5[0]);
        double [] arr6 = new double[1];
        System.out.println(arr6[0]);
        char [] arr7 = new char[1];
        System.out.println((int)arr7[0]);
        boolean [] arr8 = new boolean[1];
        System.out.println(arr8[0]); 
        String [] str = new String[1];
        System.out.println(str[0]);
    }
}

数组创建的各种方式

public class Demo7 {
    public static void main(String[] args) {
        // 数组的创建方式
        // 1、先声明，再分配空间
        int [] arr1;
        arr1 = new int[5];
        // 2、声明时分配空间
        int [] arr2 = new int[3];

        // 3、声明并赋值
        // 会自动根据后面的元素推断长度
        int [] arr3 = new int[] {1,2,3,4,5,6,7,8};

        // 4、针对第三种方式的简化版
        int [] arr4 = {1,2,3,4,5,6};

        // 注意，上面的第4种方式，只能在定义并赋值时使用，以下代码不能简化：
        int [] arr5;
        arr5 = new int[] {1,2,3,4,5};
        int [] arr6;
//        arr6 = {1,2,3,4}; // 不能简化，会报错
    }
}

课堂案例

public class Demo8 {
    public static void main(String[] args) {
//        int [] arr = {23,45,65,60,79};
//        double v = avg(arr);
//        System.out.println(v);

        int [] arr = {23,45,65,60,79};
        int num = 4;
        int index = search(arr, num);
        System.out.println(index);
    }

    /**
     * 求数组元素的平均值
     * @param arr 传入的数组
     * @return 平均值
     */
    public static double avg(int [] arr) {
        // 定义一个和值
        double sum = 0;
        // 循环数组，求和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        // 返回平均值
        return sum / arr.length;
    }

    /**
     * 在数组arr中查找num的位置
     * @param arr 提供查找的数组
     * @param num 要查找的数字
     * @return 该数组的下标，如果存在返回下标，不存在返回-1
     */
    public static int search(int [] arr, int num) {
        // 循环数组，并比较数组的每一个元素是否等于num
        for (int i = 0; i < arr.length; i++) {
            if(num == arr[i]) {
                return i;
            }
        }
        // 如果等于，直接返回下标
        return -1;
    }
}

public class Demo9 {
    public static void main(String[] args) {
        // 求一个数组的最大值和最小值
        int [] arr = {-23,-45,-65,-60,-79};
//        int max = arr[0];
//        int min = arr[0];
//        for (int i = 1; i < arr.length; i++) {
//            if(arr[i] > max) {
//                max = arr[i];
//            }
//            if(arr[i] < min) {
//                min = arr[i];
//            }
//        }
        System.out.println("最大值为：" + max(arr));
        System.out.println("最小值为：" + min(arr));
    }

    /**
     * 求数组元素的最大值
     * @param arr 指定数组
     * @return 返回最大值
     */
    public static int max(int [] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * 求数组元素的最小值
     * @param arr 指定数组
     * @return 返回最小值
     */
    public static int min(int [] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }
}

public class Demo10 {
    public static void main(String[] args) {
        // 一个班级有5个学生，使用数组记录学生成绩，求最高分和平均分
        int [] arr = new int[5];
        // 录入学生成绩
        // 创建一个输入设备
        Scanner input = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请录入第"+(i+1)+"个学生的成绩：");
            arr[i] = input.nextInt();
        }
        int max = 0; // 最高分
        double sum = 0; // 总分
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i]; // 计入总分
            if(arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("最高分为：" + max);
        System.out.println("平均分为：" + sum / arr.length);
    }
}

数组的参数和返回值

8.1 使用数组作为参数

注意：数组是引用数据类型，所以数组在作为参数传递时是引用传递，而不是值传递。

public static void main(String[] args) {
        int [] arr = {23,45,65,60,79};
        double v = avg(arr);
        System.out.println(v);
    }

    /**
     * 求数组元素的平均值
     * @param arr 传入的数组
     * @return 平均值
     */
    public static double avg(int [] arr) {
        // 定义一个和值
        double sum = 0;
        // 循环数组，求和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        // 返回平均值
        return sum / arr.length;
    }
}

概念：

值传递和引用传递：

在参数传递时，将参数中的值传递到其他的变量中，其他的变量修改该值后，不影响原来的变量。

int a = 5;

int b = a;

b++;

此时b的值为6，但是a的值还是5

引用传递是指在参数传递时，将参数中的引用（地址）传递到其他的变量中，其他的变量修改该引用的值后，会影响原来的变量引用的值。

int [] arr1 = {1,2,3,4,5};

int [] arr2 = arr1;

arr2[0] = 10;

此时arr1[0]的值也是10

public class Demo11 {
    public static void main(String[] args) {
        // 值传递
        int n = 5;
        m1(n);
        System.out.println(n); // 输出5

        // 数组是引用传递
        int [] arr = {1,2,3};
        m2(arr);
        System.out.println(arr[0]); // 输出2
    }

    // 值传递
    public static void m1(int n) {
        n++;
    }

    // 引用传递
    public static void m2(int [] arr) {
        arr[0]++;
    }
}

使用数组作为返回值

• 如果将数组作为参数传入，在方法中对数组元素进行了改变，外部的引用变量能够直接访问
• 如果将数组作为参数传入，在方法中对该数组变量进行重新分配空间并赋值，那么外部的引用不能访问方法内部重新分配的空间地址，此时需要将该数组作为返回值返回，外部接收该返回值，才能操作该数组

public class Demo12 {
    public static void main(String[] args) {
        // 数组作为返回值
        int [] arr = {1,2,3};
        arr = m1(arr);
        System.out.println(arr[0]);
    }

    // 如果将数组作为参数传入，在方法中对数组元素进行了改变，外部的引用变量能够直接访问
    // 如果将数组作为参数传入，在方法中对该数组变量进行重新分配空间并赋值，那么外部的引用不能访问方法内部重新分配的空间地址
    // 此时需要将该数组作为返回值返回，外部接收该返回值，才能操作该数组
    public static int [] m1(int [] arr) {
        arr = new int[] {7,8,9};
        return arr;
    }
}

代码的调试

• 在需要调试的地方设置断点（在行号前双击左键）。
• 使用Debug进入调式模式。
• 使用F6（Step Over）单步执行到下一行。
• 使用F5（Step Into）进入到方法中调试。
• 使用F8（Resume）直接跳到下一个断点处。
• 恢复窗口点右上角的Java按钮。

可变参数

是指在方法中定义一个参数，类型为相应的类型后面加上3个点，相当于数组的使用。

优点：

• 调用该方法时，可变参数可以不传值
• 也可以传多个值，用逗号隔开
• 还可以直接传数组
• 当方法中使用foreach时，调用时不传值，不会出现空指针异常

缺点：

• 只能作为方法的参数，不能直接定义变量
• 只能作为方法参数列表中的最后一个参数
• 在一个方法的参数列表中，只能有一个可变参数

public class Demo1 {
    // 可变参数
    public static void main(String[] args) {
        int [] arr = {1,2,3,4};
//        m2(1,2,3,4);

//        m1();
        m2();

    }

    public static void m1(int [] arr) {
//        for (int i = 0; i < arr.length; i++) {
//            System.out.println(arr[i]);
//        }
        for (int i : arr) {
            System.out.println(i);
        }
    }

    public static void m2(int... arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

数组的扩容

自定义复制

public class Demo2 {
    // 数组的扩容
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        int n = 6;
        // 将数字6添加到arr中
        arr = m1(arr, n);
        // 打印输入数组的内容
        System.out.println(Arrays.toString(arr));
    }

    public static int[] m1(int [] arr, int n) {
        int [] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];
        }
        newArr[arr.length] = n;
        return newArr;
    }
}

public class Demo3 {
    // 两个数组合并
    public static void main(String[] args) {
        int [] arr1 = {1,2,3,4,5};
        int [] arr2 = {6,7,8,9,10};
        // 调用合并数组的方法
        arr1 = m1(arr1, arr2);
        System.out.println(Arrays.toString(arr1));
    }

    public static int[] m1(int [] arr1, int [] arr2) {
        int [] newArr = new int[arr1.length + arr2.length];
        // 合并操作
        for (int i = 0; i < arr1.length; i++) {
            newArr[i] = arr1[i];
        }
        for (int i = 0; i < arr2.length; i++) {
            newArr[arr1.length + i] = arr2[i];
        }
        return newArr;
    }
}

使用系统提供的复制方法:

System.arraycopy：复制源数组中的内容到新数组中，需要提供两个数组

Arrays.copyOf：将数组进行复制到一个新数组中，会返回新数组

public class Demo4 {
    // 系统提供的数组复制功能
    public static void main(String[] args) {
        int [] arr1 = {1,2,3,4,5};
        int [] arr2 = {6,7,8,9,10};
        int [] newArr = new int[arr1.length + arr2.length];
        // 使用System.arraycopy
        System.arraycopy(arr1, 0, newArr, 0, arr1.length);
        System.arraycopy(arr2, 0, newArr, arr1.length, arr2.length);
        // 输出结果
        System.out.println(Arrays.toString(newArr));
    }
}

public class Demo5 {
    // 系统提供的数组复制功能
    public static void main(String[] args) {
        int [] arr1 = {1,2,3,4,5};
        int [] arr2 = {6,7,8,9,10};
        // 使用Arrays.copyOf()
        int [] newArr = Arrays.copyOf(arr1, 10);
        System.arraycopy(arr2, 0, newArr, arr1.length, arr2.length);
        // 输出结果
        System.out.println(Arrays.toString(newArr));
    }
}

数组排序

将数组中的元素按照指定的规则进行排列。

冒泡排序

每一轮循环，能够将最大值或最小值移动到最后。意味着需要循环length-1轮。（外层循环）

每一次循环都会将当前下标i元素与后面的i+1元素进行比较，意味着需要比较length-1次，由于每一轮会排序一个到最后，所以每一轮会少一次比较，最终比较的次数为length-1-轮数(从0开始)

public class Demo6 {
    // 冒泡排序
    public static void main(String[] args) {
        int [] arr = {88, 35, 3, 67, 22, 49, 96, 80, 75, 5};
//        int [] arr = {1, 2, 3, 4, 5};
        // 35 3 67 22 49 88 80 75 5 96 
        // 3 35 22 49 67 80 75 5 88 96 
        // 10个数字，只需要循环9次即可
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序
     * @param arr
     */
    public static void sort(int [] arr) {
        for (int j = 0; j < arr.length - 1; j++) {
            boolean b = false; // 设置一个标识
            // 第0次循环时，需要比较9(arr.length - j - 1)次
            // 第1次循环时，需要比较8(arr.length - j - 1)次
            // 第2次循环时，需要比较7(arr.length - j - 1)次
            for (int i = 0; i < arr.length - j - 1; i++) {
                if(arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                    b = true; // 如果有交换，意味着排序没有结束
                }
            }
            // 如果当次循环没有任何交换动作，意味着数组已经排序完毕
            if(b == false) {
                break;
            }
        }
    }
}

选择排序

public class Demo7 {
    // 选择排序
    public static void main(String[] args) {
        int [] arr = {88, 35, 3, 67, 22, 49, 96, 80, 75, 5};
        // 3, 35, 88, 67, 22, 49, 96, 80, 75, 5 
        // 3, 5, 88, 67, 22, 49, 96, 80, 75, 35 
        // 3, 5, 22, 67, 88, 49, 96, 80, 75, 35 
        // i = 2
        // index = 4
        // min = 22
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 选择排序
     * @param arr
     */
    public static void sort(int [] arr) {
        // 需要循环的轮次，每一轮会选出一个最小的值到最前面，意味着需要轮次为length-1
        for (int i = 0; i < arr.length - 1; i++) {
            int index = i; // 记住最前面没有排序的一个元素的位置
//            int min = arr[i]; // 记住的对应的
            // 循环后面所有的元素与index下标的元素进行比较
            for (int j = i + 1; j < arr.length; j++) {
                // 如果小，则记住位置和值
//                if(arr[j] < min) {
                if(arr[j] < arr[index]) {
//                    min = arr[j]; // 记住值
                    index = j; // 记住位置
                }
            }
            // 如果当次的位置已经改变，则交换最小值和当次的初始位置
            if(index != i) {
                int temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
        }
    }
}

插入排序

public class Demo8 {
    // 插入排序
    public static void main(String[] args) {
        int [] arr = {88, 35, 3, 67, 22, 49, 96, 80, 75, 5};
//        int [] arr = {3, 35, 67, 88, 22, 49, 96, 80, 75, 5};
        // int a = 35;
        // 35, 88, 3, 67, 22, 49, 96, 80, 75, 5
        // 3, 35, 88, 67, 22, 49, 96, 80, 75, 5
        // 3, 35, 67, 88, 22, 49, 96, 80, 75, 5
        // 3, 22, 35, 67, 88, 49, 96, 80, 75, 5
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 插入排序
     * @param arr
     */
    public static void sort(int [] arr) {
        // 循环的轮次，一共length-1次
        for (int i = 0; i < arr.length - 1; i++) {
            int a = arr[i+1]; // 记住下标为轮次+1的元素值，从下标为1的元素开始进行插入排序
            int index = i + 1; // 记住下标
            // 循环当前要处理的元素前面的元素，找到需要插入的位置
            for (int j = i; j >= 0; j--) {
                // 如果当前元素比需要处理的元素大，就向后挪动一个位置，
                if(a < arr[j]) {
                    arr[j+1] = arr[j]; // 向后挪动一个位置
                    index = j; // 记住空出的位置
                }
            }
            arr[index] = a; // 循环完毕后，将需要处理的元素插入到最终空出的位置
        }
    }
}

系统自带的排序

public class Demo9 {
    // 系统自带的排序
    public static void main(String[] args) {
        int [] arr = {88, 35, 3, 67, 22, 49, 96, 80, 75, 5};
        // 排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

二维数组

public class Demo10 {
    // 二维数组
    public static void main(String[] args) {
        int [][] arr = 
            {
                    {1,2},
                    {4,5,6},
                    {7,8,9,10}
            };
        // 理解为行和列
        // arr[1][2]表示第2行第3列，即6
        // arr[1]表示还是一个数组，代表第2行的数组
        System.out.println(Arrays.toString(arr[1]));

        int [][]arr1; // 定义
        arr1 = new int[5][]; // 定义一个行数固定但列数不固定
//        arr1[0][0] = 5; // 此行会报错，因为列没有固定
        // 需要先给列分配空间
        arr1[0] = new int[5]; // 给第1行分配空间
        arr1[0][0] = 10;
        System.out.println(arr1[0][0]);

        int [][] arr2 = new int[5][5]; // 定义一个5行5列的数组
        arr2[1][2] = 1; // 行和列都固定了，可以赋值使用
    }
}

案例：杨辉三角

public class Demo11 {
    // 杨辉三角
    public static void main(String[] args) {
        // 定义一个5行的杨辉三角
        int row = 5;
        // 定义一个行数固定，但是列数不固定的二维数组
        int [][] arr = new int [row][];
        // 给杨辉三角赋值
        for (int i = 0; i < arr.length; i++) {
            // 给每一行分配空间，第0行应该是1个元素，第n行就是n+1个元素
            arr[i] = new int[i+1];
            for (int j = 0; j < arr[i].length; j++) {
                // 每一行首元素和尾元素为1
                if(j == 0 || j == arr[i].length - 1) {
                    arr[i][j] = 1;
                // 其他元素是上一行的同列元素与前一个元素之和    
                }else {
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
        }
        // 打印杨辉三角
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}
/*
        1
       1 1 
      1 2 1
     1 3 3 1
    1 4 6 4 1
   1 5 10 10 5 1

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1    
 */

数组的各种方法（jsp）

有关增的方法

push

注意点1：它是将新增的元素添加到数组的尾部
注意点2：它会改变原数组
注意点3：并且返回的值为新数组的长度
举例：

 var arr=[1,2,3]
 var newarr = arr.push(4)
 console.log(arr);  //[1,2,3,4]
 console.log(newarr);//4

unshift

注意点1：它是将新增的元素添加到数组的头部
注意点2：它会改变原数组
注意点3：并且返回的值为新数组的长度

var arr=[1,2,3]
var newarr = arr.unshift(5)
console.log(arr);//[5,1,2,3]
console.log(newarr);//4

splice

重量级的人物来了，它不仅可以添加元素，删除，还可以替换，我们先来说它的添加用法

注意点1：可以添加元素至任意位置
注意点2：它会改变原数组
注意点3：参数1为你要添加的位置start的index（会添加到这个的前面），参数2为0，参数3为你要添加的元素（是添加元素时各个参数代表的意义哦！！）

var arr=[1,2,3]
var newarr = arr.splice(0,0,1)
console.log(arr);//[1,1,2,3]
console.log(newarr);//[]

concat

这个方法常常用了拼接数组

注意点1：这个方法不会改变原数组

var arr=[1,2,3,2,9]
var newarr = arr.concat(1,2)
console.log(arr);//[1,2,3,2,9]
console.log(newarr);//[1,2,3,2,9,1,2]

var arr2=[1,0]
var newarr2 = arr.concat(arr2)
console.log(newarr2);//[1,2,3,2,9,1,0]

有关删的方法

pop

注意点1：删除尾部的元素
注意点2：改变原数组
注意点3：返回的是删除的那个元素

var arr=[1,2,3]
var newarr = arr.pop()
console.log(arr);//[1,2]
console.log(newarr);//3

shift

注意点1：删除的是头部元素
注意点2：改变原数组
注意点3：返回的是被删除的那个元素

var arr=[1,2,3]
var newarr = arr.shift()
console.log(arr);//[2,3]
console.log(newarr);1

splice

老盆友又见了，这次来看下删除的用法

注意点1：删除任意位置的元素
注意点2：改变元素组
注意点3：返回的是删除元素数组（你没看错是数组！！）
注意点4：参数1：为从哪开始删start的index，参数2：删除几个元素

 var arr=[1,2,3]
var newarr = arr.splice(0,1)
console.log(arr);//[2,3]
console.log(newarr);[1]

slice

这个更像是截取，暂且归到这一类吧

注意点1：参数1为start的index，参数2为end的index(前包后不包哦)
注意点2：他不会改变原数组，并且将截取的元素新数组返回

var arr=[1,2,3,2,9]
var newarr = arr.slice(1,2)
console.log(arr);//[1,2,3,2,9]
console.log(newarr);//[2]

改的方法

splice

注意点1：改任意位置的元素
注意点2：改变原数组
注意点3：返回的新数组为替换下来的元素
注意点4：参数1：如上，参数2：删除几个，参数3：要填上去的元素

var arr=[1,2,3]
var newarr = arr.splice(0,1,4)
console.log(arr);//[4,2,3]
console.log(newarr);//[1]

查的操作

indexOf

注意点1：传入的为你要查找的元素，找到返回该元素在数组中的索引，没找到返回-1

var arr=[1,2,3]
var newarr = arr.indexOf(1)
console.log(newarr);// 0

includes

注意点1：传入你要查找的元素，返回true/false

var arr=[1,2,3]
var newarr = arr.includes(1)
console.log(newarr);//true

find

注意点：传入的是一个函数，返回第一个匹配的元素

var arr=[1,2,3,2,9]
var newarr = arr.find((item,index)=>{
    return item>2
})
console.log(newarr);//3

排序方法

sort

注意点：将原数组排序

var arr=[1,2,3,2,9]
arr.sort()
console.log(arr);//[1,2,2,3,9]

也可以自定义

var arr=[1,2,3,2,9]
//e1表示前一个元素，e2表示后一个元素
arr.sort((e1,e2)=>{
    return e1-e2
})
console.log(arr);//[1,2,2,3,9]

reverse

注意点：将原数组倒序

var arr=[1,2,3,2,9]
arr.reverse()
console.log(arr);

转换方法

join

注意点：将数组转化为字符串，不改变原数组

var arr=[1,2,3,2,9]
var newarr= arr.join(',')
console.log(newarr);//1,2,3,2,9
console.log(arr);//[1,2,3,2,9]

迭代方法

some

注意点：将数组每一项传入函数中，如果有一个符合添加就返回true

var arr=[1,2,3,2,9]
var newarr= arr.some((item,index)=>{
    return item>2
})
console.log(newarr);//true
复制代码

every

注意点：将数组每一项传入一个函数，如果每一项都符合条件才返回true

var arr=[1,2,3,2,9]
var newarr= arr.every((item,index)=>{
    return item>2
})
console.log(newarr);//false
复制代码

forEach

注意点1：forEach(function(){},obj)方法仅仅是一种快速迭代数组的方式，首先会遍历数组的每一个元素传入到函数中
注意点2：该方法不需要返回值
注意地3：参数二为this指向

var arr=[1,2,3,2,9]
var newarr= arr.forEach(element => {
    console.log(element);
})
console.log(newarr);//undefined
复制代码

map

注意点1:提供的是一种映射函数,将数组的每一项传入到函数
注意点2：元素会经过函数中的指令进行各种变换，生成新的元素，并且将新的元素返回
注定点3：最终会将返回的所有元素形成一个新的数组，该数组就是map()最终返回的值

var arr=[1,2,3,2,9]
var newarr= arr.map(element => {
    return element*2
})
console.log(newarr);//[2, 4, 6, 4, 18]
复制代码

reduce

arr.reduce(callback, initialValue)
callback（一个在数组中每一项上调用的函数，接受四个函数分别为：
previousValue（上一次调用回调函数时的返回值，或者初始值）
currentValue（当前正在处理的数组元素）
currentIndex（当前正在处理的数组元素下标）
array（调用reduce()方法的数组）
initialValue（可选的初始值。作为第一次调用回调函数时传给previousValue的值）

reduce应用：1.做累加2.数组扁平化3.属性对object分类4.数组去重等等