Java基础—数组

Java的数组

一、数组概述

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

数组的特点：

• 一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。
• 有序性：数组中的元素是有序的，通过下标访问，下标从0开始。
• 不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。

二、数组声明创建

数组的创建方式:

• 数据类型[] 数组名称=new 数据类型[数组长度]；
• 数据类型[] 数组名称={数组元素}；

// 方式一：创建一个长度为5的数组并初始化（默认值为0）
int[] nums=new int[5];
//方式二：创建数组并初始化
int[] nums={1,2,3,4,5};

三、数组的使用

数组的使用通过数组下标进行操作，数组名[index]

//获取数组的第一个元素的内容
nums[0];
//修改数组的第二个元素为10
nums[1]=10;

四、多维数组

多维数组就数组里面套数组。

//二维数组的定义并初始化（2行3列）
int[][] nums=new int[2][3];
//方式二
int[][] nums={{1,23,2},{4,5,6}};

五、Arrays类

常用的Arrays类的方法

//该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。
Arrays.toString(array);
//比较两个数组是否相等；数组相等的条件不仅要求数组元素的个数必须相等，而且要求对应位置的元素也相等。
Arrays.equals(arrayA, arrayB);
/*数组填充：Arrays 类提供了一个 fill() 方法，可以在指定位置进行数值填充。fill() 方法虽然可以填充数组，但是它的功能有限制，只能使用同一个数值进行填充。*/
Arrays.fill(array,value);
/*查找数组是指从数组中查询指定位置的元素，或者查询某元素在指定数组中的位置。使用 Arrays 类的 binarySearch() 方法可以实现数组的查找，该方法可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。*/
Arrays.binarySearch(Object[] a,int fromIndex(可选),int toIndex(可选),Object key);
/*使用 Arrays.sort(数组名) 语法对数组进行排序，排序规则是从小到大，即升序*/
Arrays.sort(array);

六、数组常见的排序算法

1.冒泡排序

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

java中冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

例子：

//排序数组从小到大
public class Test{
     public static void main(String[] args) {
        int[] nums={23,45,12,9,7};
        for (int i = 0; i <nums.length-1 ; i++) {
            for (int j = 0; j <nums.length-1-i ; j++) {
                if(nums[j+1]<nums[j]){
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(nums));
    }
}

2.快速排序

快速排序的基本思想是：通过一趟排序，将要排序的数据分隔成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。

具体做法是：假设要对某个数组进行排序，首先需要任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它的前面，所有比它大的数都放到它的后面。这个过程称为一趟快速排序；递归调用此过程，即可实现数据的快速排序。

public class Test{
	public static void main(String[] args) {
        int[] nums={5,2,77,8,1,6,9,10,66};
        quickSort(nums,0,nums.length-1);
        System.out.println("快速："+Arrays.toString(nums));
        System.out.println("================================================");
    }
    public static void quickSort(int[] a,int low,int hight){
        if(low>hight) return;
        int left=low;
        int right=hight;
        //保存基准值
        int temp = a[low];
        while (left<right){
//            右边指针向左进行，直到找到一个比基准值小的值
            while (temp<=a[right]&&left<right){
                right--;
            }
//            左边指针向右进行，直到找到比基准值大的值
            while (temp>=a[left]&&left<right){
                left++;
            }
            //当左指针left找到比基准值大的值，右指针找到比基准值大的值时，交互位置
            if(left<right){
                int temp1=a[right];
                a[right]=a[left];
                a[left]=temp1;
            }
        }
        //此时就是left与right相遇，交换基准值
        a[low]=a[left];
        a[left]=temp;

        //左边的内容进行排序
        quickSort(a,low,left-1);
        //右边的内容进行排序
        quickSort(a,right+1,hight);
    }
}

3.选择排序

选择排序是指每一趟从待排序的数据元素中选出最大（或最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

public class Test{
	public static void main(String[] args) {
        int[] nums={5,2,77,8,1,6,9,10,66};
        xuanze(nums);
        System.out.println("选择："+Arrays.toString(nums));
        System.out.println("================================================");
    }
    //    选择排序
    public static void xuanze(int[] a){
//        遍历轮数
        for (int i = 0; i <a.length-1 ; i++) {
//            存储最小值的下标，假设i为最小值的下标
            int index=i;
//            从比较值的下一个坐标开始进行遍历
            for (int j = i+1; j <a.length-1 ; j++) {
                if(a[j]<a[index]){
                    index=j;
                }
            }
//            交换最小值
            int temp=a[index];
            a[index]=a[i];
            a[i]=temp;
        }
    }
}