数组

1. 数组的概念

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组变量属于引用类型，数组也是对象。

2. 一维数组

1. 创建数组

1.静态初始化
在静态初始化中，可以直接指定数组的元素值，并在创建数组时进行初始化。语法格式如下：

dataType[] arrayName = {value1, value2, value3, ...};

示例：

int[] numbers = {1, 2, 3, 4, 5}; // 创建并初始化一个包含5个整型元素的数组

2.动态初始化
在动态初始化中，需要先创建数组对象，然后通过索引逐个赋值。语法格式如下：

dataType[] arrayName = new dataType[length];

示例：

int[] numbers = new int[5]; // 创建一个包含5个整型元素的数组
numbers[0] = 1; // 给第一个元素赋值
numbers[1] = 2; // 给第二个元素赋值
// ...

3.默认初始化
在默认初始化中，数组的元素会根据其数据类型进行默认初始化。例如，整型数组的元素默认值为0，浮点型数组的元素默认值为0.0，布尔型数组的元素默认值为false，引用类型数组的元素默认值为null。示例：

int[] numbers = new int[5]; // 创建一个包含5个整型元素的数组，默认值为0使用 Arrays 类的 fill() 方法

4.Arrays 类中的 fill() 方法可以用指定的值填充数组的所有元素。语法格式如下：

Arrays.fill(arrayName, value);

示例：

<u>int[] numbers = new int[5];</u>
Arrays.fill(numbers, 0); // 将数组的所有元素设置为0

这些是在 Java 中创建和初始化数组的常用方法。根据需求和场景的不同，选择合适的方法来创建和初始化数组。

2. 遍历数组

在 Java 中，有多种方式可以遍历数组，对数组中的每个元素进行操作。以下是几种常用的数组遍历方法：

for 循环
使用普通的 for 循环可以遍历数组，通过索引逐个访问数组元素。示例：

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
int element = numbers[i];
// 对每个元素进行操作
System.out.println(element);
}

增强 for 循环（foreach 循环）
增强 for 循环提供了一种简化的语法，可以直接遍历数组中的元素，无需使用索引。示例：

int[] numbers = {1, 2, 3, 4, 5};
for (int element : numbers) {
// 对每个元素进行操作
System.out.println(element);
}

使用 Arrays 类的 toString() 方法
使用 Arrays 类的 toString() 方法可以将整个数组转换为字符串表示，方便打印或输出。示例：

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(numbers));

3.数组的算法

1.冒泡算法

冒泡排序算法简介
冒泡排序是一种基于比较的排序算法，它通过重复地交换相邻的元素来将最大（或最小）的元素逐渐“冒泡”到数组的一端。在每一轮比较中，相邻的两个元素进行比较，如果它们的顺序不正确，就交换它们的位置。通过多次迭代，最大（或最小）的元素会逐渐“冒泡”到正确的位置上，直到整个数组排序完成。
冒泡排序的实现步骤
冒泡排序的实现步骤如下：

遍历数组，从第一个元素开始，依次比较相邻的两个元素。
如果相邻的两个元素顺序不正确，交换它们的位置。
继续进行下一轮的比较，直到完成所有的比较和交换。
重复执行上述步骤，直到整个数组排序完成。
3. 冒泡排序的Java代码实现
下面是使用Java语言实现冒泡排序的示例代码：

public class bubbling {
    public static void main(String[] args) {
        int[] arr = {15,56,89,99,48,75};
        System.out.println("冒泡排序前："+Arrays.toString(arr));
        for (int i = 0; i < arr.length-1; i++) {//控制轮数 轮数 = 数组长度-1
            for (int j = 0; j < arr.length-1-i; j++) {//控制循环次数
                //定义一个变量，存放临时存放数据
                int current = arr[j];//当前值
                int next = arr[j+1];//下一个值的大小
                int tem = 0;// 定义一个临时变量
                //比较临时数据和下一个值的大小
                if (current>next){
                    tem = current;
                    arr[j] = next;
                    arr[j+1] = tem;
                }
            }
        }
        System.out.println("冒泡排序后："+Arrays.toString(arr));
    }
}

冒泡排序的时间复杂度
冒泡排序的时间复杂度为O(n^2)，其中n是数组的长度。在最坏的情况下，需要进行n*(n-1)/2次比较和交换操作。尽管冒泡排序的时间复杂度较高，但由于其简单直观的实现和基本的原理，它在一些小规模的排序任务中仍然具有一定的应用价值。

上述代码有些复杂，这是优化后的代码：

public class bubbling {
    public static void main(String[] args) {
        int[] arr = {15,56,89,99,48,75};
        System.out.println("冒泡排序前："+Arrays.toString(arr));
        for (int i = 0; i < arr.length-1; i++) {//控制轮数 轮数 = 数组长度-1
            for (int j = 0; j < arr.length-1-i; j++) {//控制循环次数
                if (arr[j]>arr[j+1]){
                    int tem = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tem;
                }
            }
        }
        System.out.println("冒泡排序后："+Arrays.toString(arr));
    }
}

当然，关于冒泡排序Java语言中Arrays类中的sort方法可以直接实现冒泡排序：

public class bubbling {
    public static void main(String[] args) {
        //冒泡排序
        //定义一个整数数组
        int[] arr = {15,56,89,99,48,75};
        System.out.println("冒泡排序前："+Arrays.toString(arr));

    //利用Arrays类中的Array.sort()方法实现冒泡排序;
    Arrays.sort(arr);
    System.out.println("冒泡排序后："+Arrays.toString(arr));
}

}

冒泡排序是一种简单而强大的排序算法，通过不断比较和交换相邻元素的位置，可以将一个无序数组按照升序（或降序）进行排序。本文介绍了冒泡排序算法的原理、Java代码实现和时间复杂度分析。通过学习和实践冒泡排序算法，读者可以加深对排序算法的理解，并能够在实际开发中灵活应用

2.选择排序

1.原理

从0索引处开始，依次与后边的元素进行比较，小的放前面，这样子一趟下来就得到了最小值，然后从1索引处开始，得到第二个较小值，依次循环下去

2.图示

代码实现

public static int[] selectSequence(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
//                比较，若外层循环的数大于内层循环的数，则交换位置（将最小的数交换到最前面）
                if (arr[i] > arr[j]) {
                    int mid = arr[i];
                    arr[i] = arr[j];
                    arr[j] = mid;
                }
            }
        }
        return arr;
    }

后续补充

4. 多维数组

多维数组：相当于数组的嵌套
语法
int [][] arrs = new int [4][5]; 相当于创建了一个4行5列的数组;
int [][] arrs2 = new int [4][];相当于创建了一个4行的数组，没有声明每个数组的长度（长度可以不相同）
代码如下：
//创建4行5列的数组
int[][] arrs = new int[4][5];
//赋值
for (int i = 0 ,num=10; i < arrs.length ; i++){
for (int j = 0 ; j < arrs[i].length; j++){
arrs[i][j]=num;
num++;
}
}
//遍历
for (int i = 0 ; i < arrs.length ; i++){
for (int j = 0; j < arrs[i].length ; j++){
System.out.print(arrs[i][j]+" ");
}
System.out.println();

    }
    /*
     输出结果为下
            10 11 12 13 14
            15 16 17 18 19
            20 21 22 23 24
            25 26 27 28 29
     */

标签：arr,int,元素,冒泡排序,Arrays,数组
From： https://www.cnblogs.com/zpjd/p/18329882

数组

数组