Java基础学习之数组-------来自一个小菜鸟

1.1数组的简介

1.简介：

可以用来存放一堆数据类型相同的数据的一种数据结构，一般通过数组的下标来进行对数组中数据的改动。每一个数组都是对象。

2.特点：

->数组的长度是固定的，一旦规定了长度之后，数组的长度就不能改变了

 ->数组的长度就代表该数组可以存多少个数据

->数组中的每一个数据就是元素

1.2数组的实现

1.实现

方式1：

一般，当定义的数组知道里面的元素时可以直接定义,一个使用new或者可以不使用new

    使用new：

            数据类型[]   变量名 = new 数据类型[]{元素1，元素2，元素3，........}

例如：一个int类型数组的实现: int[]  arr = new int[]{1,2,3,4,5,6,7,8,9}

不使用new：

             数据类型[]   arr =  {元素1，......元素n};

例如：

           int   arr   =   {1,2,3,4,5,6,7,8};

方式2：

一般数组的元素不确定时可以这样定义：

             数据类型[]    变量名   =   new   数据类型[长度];

例如：定义一个长度为5int数组

             int[]    arr  = new    int[5];

注意：规定数组长度时，虽然没有给数组中的元素赋值，但是会有默认值

1.3数组元素的访问

1.数组实现之后，如果我们想要访问数组中的元素，我们就可以通过下标对数组进行访问了。

2.补充：

下标：元素存储在数组中的索引，用来记录元素在数组中的位置

数组长度：就是数组元素的总个数。在java中可以用：数组变量名.length表示数组的长度

数组小标都是从0开始的

例如：

int[] nums = new int[5];
nums[0] = 10;
nums[1] = 20;
nums[2] = 30;
nums[3] = 40;
nums[4] = 50;
System.out.println(nums[0]);

3.常见异常：

->越界异常：使用的数组下标超出了表示数组下标的最大值

->空指针异常:当引用为null的情况下，进行空间访问。

1.4数组的常见操作用

1.遍历数组:

可以依次获取数组中每一个元素

方式一：

用for循环遍历，遍历下标

for (int i = 0; i < array.length; i++) {
   // 通过下标获取元素
   int element = array[i];
   System.out.println(element);
}

方式二：

增强for循环：foreach循环

int[] array = new int[] { 1, 2, 3, 4, 5 };
// 增强for循环，逻辑是将数组array中的元素依次给ele进行赋值。
for (int ele : array) {
   System.out.println(ele);
}

2.元素排序：

本文章介绍三种排序方式

方式一:选择排序

原理：选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

例如：

// 遍历下标，从第0位开始，到倒数第二位结束
for (int i = 0; i < array.length - 1; i++) {
   // 依次跟后面的每一位元素进行比较
   for (int j = i + 1; j < array.length; j++) {
      // 比较两个元素
      if (array[i] > array[j]) {
         int temp = array[i];
         array[i] = array[j];
         array[j] = temp;
      }
   }
}

方式二：插入排序

原理：

对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增 1 的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

例如：

int[] nums = {4,6,1,3,2,7};
        // 分别拿nums[1] 到 nums[length-1]
        for (int i = 1; i < nums.length; i++) {
             for (int j = 0; j < i; j++) {
                    if(nums[i]<nums[j]){
                        int temp = nums[i];
                        //向后移动，然后插入。
                        move(nums,j,i);
                        nums[j] = temp;
                        break;
                    }
             }
        }
 

方式三：冒泡排序

冒泡排序是最简单和最通用的排序方法，其基本思想是：在待排序的一组数中，将相邻的两个数进行比较，若前面的数比后面的数大就交换两数，否则不交换；如此下去，直至最终完成排序 。由此可得，在排序过程中，大的数据往下沉，小的数据往上浮，就像气泡一样，于是将这种排序算法形象地称为冒泡排序 。

 int[]  nums = {6,2,4,7,1,5};
        //外层循环控制着轮数，轮数是leng-1轮
        for (int i = 0; i < nums.length-1; i++) {
            //内层是控制着每轮如何比较. 每次都要从左边开始比较，因此j从0开始
            for (int j = 0; j < nums.length-1-i ; j++) {
                // 如果前面的大于后面的，就做交换操作
                if (nums[j] > nums[j+1]) {
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
3.元素查找

从一个数组中查询是否有我们想要的元素，可以使用一下方式

方式一：顺序查找

遍历数组，用数组里的元素依次比较，直到找到要查询的元素，如果相同就返回这个下标

方式二：二分查找（该方法前提是，数组必须是排好序的）

例如一下代码实现二分查找法：

int[] nums = {1,4,6,7,9,10};
        int index = binarySearch(nums,7);
        System.out.println(index);
    }
    /**
     * 写一个使用二分查找算法，从int类型的数组arr中找元素element的方法
     * 找到，返回其坐标，没找到，返回-1
     */
    public static int binarySearch(int[] arr, int element) {
        int min = 0, max = arr.length - 1;
        //  min<=max时，表示还没有找到该元素， min=max时，是最后一次查找
        while (min <= max) {
            // 找到中间的元素下标
            int mid = (min + max) / 2;
            if (arr[mid] == element) {
                //如果mid位置上的元素就是我们要找的，就返回下标
                return mid;
            }else if (arr[mid] < element) { // 表示要找的元素，在中间值的右侧
                min = mid + 1;  //将min设置为中间下标+1.  然后重新循环
            }else {  //表示要找的元素，在中间值的左侧
                max = mid - 1;  //将max设置为中间下标-1.  然后重新循环
            }
        }
        //循环结束都没有遇到return,说明没有找到，就返回-1
        return -1;

1.5数组工具类的应用

在Java中，Arrays是一个提供了各种数组操作的工具类。它包含了许多静态方法，用于对数组进行排序、搜索、复制、填充等操作。Arrays类可以用于处理基本类型数组和对象类型数组。

1. toString()：将数组转换为字符串形式。
2. binarySearch()：在已排序的数组中查找指定元素的索引。
3. fill()：将数组的所有元素都设置为指定值。
4. sort(数组)：对数组进行排序。
5. copyOf()：将一个数组的部分或全部元素复制到一个新数组中。