Java的数组、Arrays类和冒泡排序初体验

一、定义数组

//1.声明一个数组
int[] nums;//首选
int nums[];//备选
//2.创建一个长度为10数组
nums = new int[10];
//合并：声明和创建一个长度为10的数组
int[] nums = new int[10];

//创建一个数组{1,2,3,4,5}
int[] nums = {1,2,3,4,5};

二、内存分析

• Java内存：栈、堆、方法区

1. 声明数组

int[] nums;

栈：存放基本类型的变量或引用对象的变量，如nums。

2. 创建数组

nums = new int[3];

堆：开辟变量空间，如3个子空间的数组空间nums[3]。

3. 数组赋值

nums[0] = 1;
nums[1] = 2;
nums[2] = 3;

子空间：对应的索引赋予对应的值，如nums[1]为2。

未赋值则为默认值。

• 超出数组空间：报错–>数组下标越界

java.lang.ArrayIndexOutOfBoundsException

三、数组使用

public class Demo{
    public static void main(String[] args){
        //创建一个数组{1,2,3,4,5}
        int[] arrays = {1,2,3,4,5};
        //调用reverse()方法，传入arrays数组，返回结果reverse数组
        int[] reverse = reverse(arrays);
        System.out.println("arrays reverse: ");
        //遍历reverse数组，将每一个值赋值给i
        for(int i : reverse){
            //打印i
            System.out.print(i + " ");
        }
    }
    //数组倒转方法
    //传入参数为数组，返回值为数组
    public static int[] reverse(int[] arrays){
        //创建一个数组result，长度为arrays数组的长度
        int[] result = new int[arrays.length];
        //遍历，次数为数组长度
        for(int i = 0,j = result.length - 1;i < arrays.length;i++,j--){
            //将arrays数组的正序值，赋值给result数组的倒序位置
            result[j] = arrays[i];
        }
        //返回结果result数组
        return result;
    }
}

• 数组创建：int[] arrays = {1,2,3,4,5};
• 创建指定长度的数组：int[] result = new int[arrays.length];
• 传入参数为数组，返回值为数组：public static int[] reverse(int[] arrays){}
• 将数组对应索引的值取出，赋值给另一个数组的索引位置：result[j] = arrays[i];
• 数组遍历：for(int i : reverse){}

四、Arrays 类

toString()方法：将数组转为String类

import java.util.Arrays;
public class Demo{
    public static void main(String[] args){
        int[] a = {1,2,333,41,57,6,723,81};
        System.out.println(Arrays.toString(a));
    }
} //~ [1, 2, 333, 41, 57, 6, 723, 81]

sort()方法：将数组排序

import java.util.Arrays;
public class Demo{
    public static void main(String[] args){
        int[] a = {1,2,333,41,57,6,723,81};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
} //~ [1, 2, 6, 41, 57, 81, 333, 723]

五、冒泡排序

import java.util.Arrays;
public class Demo{
    public static void main(String[] args){
        int[] a = {1,6,4,2,55,16,9,66,45};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    //排序方法
    //冒泡排序：重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
    /**
    比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
    针对所有的元素重复以上的步骤，除了最后一个。
    持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
    */
    public static int[] sort(int[] array){
        int temp = 0;
        for(int i = 0; i < array.length-1; i++){
            for(int j = 0; j < array.length-1-i; j++){
                if(array[j+1] > array[j]){ // 相邻元素两两对比
                    temp = array[j]; // 元素交换
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}