三、数组

一、数组

1. 概念：数组就是可以保存同一种数据类型的多个对象。

2. 本质：在内存中开辟的一组指定数量的连续的小格子。

3. 数组的创建：

动态创建：长度指定，内容动态。

int[] nums = new int[5];
		·int-->该数组保存的是int类型的数据；
		·[]-->数组的标志；
		·nums-->给数组起的名字，随便起，但是符合命名规则即可；
		·new int[5]-->开辟五个连续小格子的空间。

静态创建：创建的同时指定了内容，然后根据内容的个数算出长度。

int[] num1 = new int[]{10,20,30,40,80,42,65};

int[] nums = new int[5];
nums[0] = 50;
nums[1] = 75;
for (int n:nums) {
System.out.println(n);
}
System.out.println("=============================================");
for (int i = 0; i <nums.length ; i++) {
System.out.println(nums[i]);
}

4. Arrays常用方法：
   Arrays.sort()：对数组的排序（从小到大）。
   Arrays.toString()：返回指定数组的内容的字符串表示形式。

5. 数组排序：

1.最大值最小值：
public static void main(String[] args) {
int[] nums = {20,14,52,36,74,58,96,85};
int max = nums[0];//假设数组的第一位是最大值
int min = nums[0];//假设数组的第一位是最小值
for (int i = 1; i < nums.length; i++) {
if(max<nums[i]){//max应该放的是最大值，但是我发现了比我更大的，那么立马换
值；
max = nums[i];
}
if(min>nums[i]){
min = nums[i];
}
}
System.out.println(max);
System.out.println(min);
}

2.冒泡排序：将数组中的相邻两个元素进行比较，将比较大（较小）的数通过两两比较移动到数组末尾（开始），执行一遍内层循环，确定一个最大（最小）的数，外层循环从数组末尾（开始）遍历到开始（末尾）。
public class BubbleSort {
    //从大到小
    public static void main(String[] args) {
        int[] arr = {5, 3, 15, 56, 33, 28, 10};
        for (int i = 1; i < arr.length; i++) {//外层循环控制比较的轮数
            for (int j = 0; j <arr.length-i; j++) {//内存循环控制的是每轮比较的次数
                if (arr[j] < arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

3.选择排序法：将要排序的数组分成两部分，一部分是从大到小已经排好序的，一部分是无序的，从无序的部分取出最小的放到已经排序的最后面。
public class ChooseSort {
    public static void main(String[] args) {
        int[] arr = {5,3,15,56,33,28,10};
        for (int i = 0; i < arr.length; i++) {
            int m = i;
            for (int j = i+1; j <arr.length ; j++) {
                if(arr[j]<arr[m]){
                    m=j;
                }
            }
            if(m!=i){
                int temp = arr[i];
                arr[i] = arr[m];
                arr[m] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

4.数组反转：把正着的数组倒着过来，不涉及排序；
//第一种方法：本质：数组本身没有变，只不过是下标从尾部到头部这样倒着输出；
int[] nums = {20,14,52,36,74,58,96,85};
//反转
for (int i = nums.length-1; i >=0; i--) {
System.out.print(nums[i]+"\t");//85 96 58 74 36 52 14 20
}
System.out.println("===============================================");
System.out.println(nums);//输出的是数组的内存地址
System.out.println(Arrays.toString(nums));//[20,14,52,36,74,58,96,85]
//通过类名点出来的方法或者属性都是静态方法或者静态属性；


//第二种方法：本质：数组本身已经发生改变；奇数会产生min == max；
//偶数个数的话直接min >max,如果发生以上两种情况立即停止交换；
int[] nums = {20,14,52,36,74,58,96,85};
//反转
for (int min = 0,max=nums.length-1; min<max;min++,max--) {
int temp = nums[min];
nums[min] = nums[max];
nums[max] = temp;
}
System.out.println(Arrays.toString(nums));

5.数组排序：
int[] nums = {20,14,52,36,74,58,96,85};
Arrays.sort(nums);//直接改变了数组元素的位置，默认是从小到大
System.out.println(Arrays.toString(nums));

6.数组部分排序：
int[] nums = {20,14,52,36,74,58,96,85};
Arrays.sort(nums,3,6);//从数组下标为3的地方开始排序，到数组下标为6的地方但不包括6
System.out.println(Arrays.toString(nums));

6. 数组的删除：

   数组的添加就是把元素一个一个往后移动；
   数组的删除就是把元素一个一个的往前移动；
   添加和删除的效率比较低，所以但凡涉及到添加和删除的操作，我们不使用数组，
   使用arraycopy方法。

public static void arraycopy(Object src, int srcPos, Object dest, int destPos,
int length)

代码解释:
Object src : 原数组
int srcPos : 从原数据的起始位置开始
Object dest : 目标数组
int destPos : 目标数组的开始起始位置
int length : 要copy的数组的长度

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] nums = {20,14,52,36,74,58,96,85};
System.out.println("请输入您要删除的数字：");
int num = sc.nextInt();
int len = nums.length;
for (int i = 0; i < nums.length; i++) {
if(nums[i] == num){
//如果找到，当前i就是你要找的下标，我们可以根据下标直接移动
System.arraycopy(nums,i+1,nums,i,len-i-1);
break;
}
}
System.out.println("========================================");
//把nums赋值到一个新的数组里
int[] a = Arrays.copyOf(nums,nums.length-1);
System.out.println(Arrays.toString(a));
}

7. 数组问题：
   1、数组越界异常：ArrayIndexOutOfBoundsException
   2、空指针异常：NullPointerException
   3、传值问题：

int[] nums = {20,14,52,36,74,58,96,85};
nums[0] = 20;
int[] nums2 = nums;//nums保存的地址，所以给nums2是数组的内存地址；
System.out.println(nums2[3]);
nums2[0] = 15;
System.out.println(Arrays.toString(nums));