Java数组初始化, 冒泡排序, 查找

淡淡的烟草味﹌ 2024-04-01 12:39 93阅读 0赞

#### 文章目录 ####

*   *  数组快速入门
     *  数组的使用
     *   *   *  使用方式1 动态初始化
             *  使用方式2 动态初始化
             *  使用方式3 静态初始化
             *  数组使用注意事项和细节
     *  数组赋值机制
     *   *   *  数组翻转
             *  数组扩容
     *  排序的介绍
     *   *   *  冒泡排序法
             *  数组的查找
     *  二维数组的使用
     *   *   *  使用方式1:动态初始化
             *  使用方式2:动态初始化
             *  使用方式3:静态初始化
             *  案例1 计算二维数组的和
             *  案例2 打印10行杨辉三角
             *  二维数组使用细节和注意事项
             *  二维数组课堂练习
     *  本章作业

### 数组快速入门 ###

为什么需要数组?

一个养鸡场有6只鸡，它们的体重分别是3kg, 5kg, 1kg, 3.4kg, 2kg, 50kg。请问这六只鸡的总体重是多少?平均体重是多少?请你编一个程序。

数组可以存放多个同一类型的数据。数组也是一种数据类型， 是引用类型。即:数组就是一组数据

public class Test {
        
        public static void main(String[] args) {
        
            double[] hens = {
        3, 5, 1, 3.4, 2, 50};
            // 可以通过hens[下标]来访问数组的数据
            double totalWeight = 0;
            int len = hens.length;
            for (int i = 0; i < len; i++) {
        
                totalWeight += hens[i];
            }
            System.out.println("平均体重=" + (totalWeight / len));
        }
    }

### 数组的使用 ###

##### 使用方式1 动态初始化 #####

数据类型数组名=new数据类型\[大小\]

int a\[\]=new int\[5\]; //创建了一个数组，名字a,存放5个int

数组的引用(使用/访问/获取数组元素)

数组名下标/索引\]比如:你要使用a数组的第3个数a\[2\]

##### 使用方式2 动态初始化 #####

先声明数组  
语法:数据类型数组名\[\];也可以数据类型\[\]数组名;  
int a\[\];或者int\[\] a;

再创建数组  
语法:数组名=new数据类型\[大小\];  
a= new int\[10\];

##### 使用方式3 静态初始化 #####

初始化数组  
语法:数据类型数组名\[\]= \{元素值,元素值…\}  
`int a[]= {2,5,6,7,8,89,90,34, 56}`,如果知道数组有多少元素，具体值  
上面的用法相当于:

int a[]=new int[9];
    a[0]= 2;a[1]=5;a[2]=6; a[3]=7;a[4]=8;a[5]= 89;a[6]=90;a[7]= 34;a[8]=56;

##### 数组使用注意事项和细节 #####

ArrayDetail.java  
1.数组是多个相同类型数据的组合，实现对这些数据的统一管理  
2.数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。  
3.数组创建后如果没有赋值有默认值int 0, short 0, byte 0, long 0, float 0.0,double 0.0, char \\u0000, boolean false, String null  
4.使用数组的步骤1.声明数组并开辟空间2给数组各个元素赋值3使用数组  
5.数组的下标是从0开始的。  
6.数组下标必须在指定范围内使用，否则报下标越界异常，比如`int[] arr= new int[5];` 则有效下标为0-4  
7.数组属引用类型，数组型数据是对象(object)

请求出一个数组int\[\]的最大值\{4,-1,9, 10,23\}, 并得到对应的下标。

public class Test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        4, -1, 9, 10, 23};
            int max = arr[0];// 假定第一个元素就是最大值
            int maxIndex = 0;
            for (int i = 1; i < arr.length; i++) {
        // 从下标1开始遍历arr
                if (max < arr[i]) {
        // 如果max < 当前元素
                    max = arr[i]; // 把max设置成当前元素
                    maxIndex = i;
                }
            }
            // 当我们遍历这个数组arr后, max就是真正的最大值，maxIndex最大值下标
            System.out.println("max=" + max + "\tmaxIndex=" + maxIndex);
        }
    }

### 数组赋值机制 ###

1 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。

int n1=2;
    int n2=1;

2 数组在默认情况下是**引用传递**，赋的值是地址。 看一个案例，并分析数组赋值的内存图(重点)。

int[] arr1 = {
        1,2,3};
    int[] arr2 = arr1;

public class Test {
        
        public static void main(String[] args) {
        
            // 基本数据类型赋值 赋值方式为值拷贝
            // n2的变化, 不会影响到n1的值
            int n1 = 10;
            int n2 = n1;
            n2 = 80;
            System.out.println("n1=" + n1);
            System.out.println("n2=" + n2);
    
            // 数组默认情况下是引用传递, 赋的值是地址, 赋值方式为引用传递
            // 是一个地址, arr2的变化会影响到arr1
            int[] arr1 = {
        1, 2, 3};
            int[] arr2 = arr1;
            arr2[0] = 7;
            System.out.println("arr1[0] = " + arr1[0]);
        }
    }

![image-20221029195222982][]

那怎么完成数组的**值拷贝**呢?

public class Test {
        
        public static void main(String[] args) {
        
            int[] arr1 = {
        10, 20, 30};
            // 创建一个新的数组arr2
            // 大小为arr1
            int[] arr2 = new int[arr1.length];
            // 遍历arr1,把每个元素拷贝到arr2对应的位置
            for (int i = 0; i < arr1.length; i++) {
        
                arr2[i] = arr1[i];
            }
            //现在就是值拷贝了
        }
    }

##### 数组翻转 #####

public class Test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        11, 22, 33, 44, 55, 66};
            int[] arr2 = new int[arr.length];
            for (int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
        
                arr2[j] = arr[i];
            }
            // 当for循环结束后,arr2就是一个逆序后的数组
            // 让arr指向arr2数据空间
            arr = arr2;
        }
    }

##### 数组扩容 #####

public class Test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        1, 2, 3};
            int[] arrNew = new int[arr.length + 1];
            // 遍历arr数组，依次将arr的元素拷贝到arrNew数组
            for (int i = 0; i < arr.length; i++) {
        
                arrNew[i] = arr[i];
                // 把4赋给arrNew最后一个元素
                arrNew[arrNew.length - 1] = 4;
                // 让arr指向arrNew, 原先arr被销毁
                arr = arrNew;
            }
        }
    }

### 排序的介绍 ###

排序是将多个数据，依指定的顺序进行排列的过程。  
排序的分类:  
1.内部排序: 指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法);  
2.外部排序法: 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。

##### 冒泡排序法 #####

冒泡排序(Bubble Sorting)的基本思想是:通过对待排序席列从后向前(从下标较大的元素开始) ,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

下面我们举一个具体的案例来说明冒泡法。我们将五个无序:  \{ 24 , 69 , 80 , 57 , 13 \} \\\{24,69,80,57,13\\\} \{ 24,69,80,57,13\}使用冒泡排序法将其排成一个**从小到大**的有序数列。

![image-20221029205917214][]

![image-20221029205933490][]

public class Test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        24, 69, 80, 57, 13};
            for (int i = 0; i < arr.length; i++) {
        
                for (int j = 0; j < arr.length - i - 1; j++) {
        
                    if (arr[j] > arr[j + 1]) {
        
                        // 交换顺序
                        arr[j] = arr[j] ^ arr[j + 1];
                        arr[j + 1] = arr[j] ^ arr[j + 1];
                        arr[j] = arr[j] ^ arr[j + 1];
                    }
                }
            }
            // 循环结束,咱们来瞅瞅
            for (int k = 0; k < arr.length; k++) {
        
                System.out.print(arr[k] + "\t");
            }
        }
    }

##### 数组的查找 #####

介绍:

在java中，我们常用的查找有两种:  
1.顺序查找SeqSearch.java  
2.二分查找\[二分法，我们放在算法讲解\]

案例演示:

1.有一个数列:\[白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王\] 猜数游戏:从键盘中任意输入一个名称，判断数列中是否包含此名称\[顺序查找\]要求: 如果找到了，就提示找到，并给出下标值。

import java.util.Scanner;
    
    public class Test {
        
        public static void main(String[] args) {
        
            // 有一个数列:[白眉鹰王,金毛狮王,紫衫龙王,青翼蝠王] 
            // 猜数游戏:从键盘中任意输入一个名称，判断数列中是否包含此名称[顺序查找]要求: 如果找到了，就提示找到，并给出下标值。
            String[] kings = {
        "白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
            Scanner sc = new Scanner(System.in);
            int index = -1;
            String inputK = sc.next();
            for (int i = 0; i < kings.length; i++) {
        
                if (inputK.equals(kings[i])) {
        
                    index = i;
                    break;
                }
            }
            if (index >= 0) {
        
                System.out.println("找到了, index = " + index);
            } else {
        
                System.out.println("妹油找到! ");
            }
        }
    }

2.请对一个有序数组进行二分查找\{1,8, 10, 89, 1000, 1234\}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示"没有这个数"。

### 二维数组的使用 ###

请用二维数组输出如下图形

0 0 0 0 0 0
    0 0 1 0 0 0
    0 2 0 3 0 0
    0 0 0 0 0 0

public class Test {
        
        public static void main(String[] args) {
        
            int[][] arr = {
        
                    {
        0, 0, 0, 0, 0, 0},
                    {
        0, 0, 1, 0, 0, 0},
                    {
        0, 2, 0, 3, 0, 0},
                    {
        0, 0, 0, 0, 0, 0}
            };
            // 输出二维图形
            for (int i = 0; i < arr.length; i++) {
        
                for (int j = 0; j < arr[i].length; j++) {
        
                    System.out.print(arr[i][j] + "\t");
                }
                System.out.println();
            }
        }
    }

##### 使用方式1:动态初始化 #####

1)语法:

类型[][]数组名=new 类型[大小][大小]

2)比如:

int a[][]=new int[2][3]

3)使用演示

public class Test {
        
        public static void main(String[] args) {
        
            int arr[][] = new int[2][3];
            // 遍历arr数组
            for (int i = 0; i < arr.length; i++) {
        
                for (int j = 0; j < arr[i].length; j++) {
        
                    System.out.print(arr[i][j] + " ");
                }
                System.out.println();// 换行
            }
        }
    }

4)二维数组在内存的存在形式

![image-20221030155202899][]

##### 使用方式2:动态初始化 #####

1)先声明:

类型 数组名[][];

2)再定义(开辟空间)

数组名 = new 类型[大小][大小];

3)赋值(有默认值，比如int 类型的就是0)

4)使用演示  
使用方式3:动态初始化列数不确定

1)看一个需求: 动态创建下面二维数组， 并输出。

![image-20221030160808636][]

2)完成该案例

public class Test {
        
        public static void main(String[] args) {
        
            int[][] arr = new int[3][]; // 创建二维数组，但是只是确定维数组的个数
            for (int i = 0; i < arr.length; i++) {
          // 遍历arr每个一维数组
                // 给每个一维数组开空间new
                // 如果没有给一维数组new, 那么arr[i]就是null
                arr[i] = new int[i + 1];
                // 遍历一维数组，并给一维数组的每个元素赋值
                for (int j = 0; j < arr[i].length; j++) {
        
                    arr[i][j] = i + 1;// 赋值
                }
            }
            // 遍历arr输出
            for (int i = 0; i < arr.length; i++) {
        
                // 输出arr的每个一维数组
                for (int j = 0; j < arr[i].length; j++) {
        
                    System.out.print(arr[i][j] + " ");
                }
                System.out.println();// 换行
            }
        }
    }

3)画出执行分析示意图

##### 使用方式3:静态初始化 #####

1 定义

类型 数组名[][] = {
        {
        值1,值2..}.{
        值1,值2..}.{
        值1,值2..}};

2 使用即可\[固定方式访问\]

比如:

int[][] arr = {
        {
        1,1,1}, {
        8,8,9}, {
        100};

解读

1 定义了一个二维数组arr

2 arr有三个元素(每个元素都是一维数组)

3 第一个一维数组有3个元素, 第二个一维数组有3个元素, 第三个一维数组有1个元素

##### 案例1 计算二维数组的和 #####

public class Test {
        
        public static void main(String[] args) {
        
            // 遍历二维数组，并将各个值累计到sum
            int arr[][] = {
        {
        4, 6}, {
        1, 4, 5, 7}, {
        -2}};
            int sum = 0;
            for (int i = 0; i < arr.length; i++) {
        
                // 遍历每个一维数组
                for (int j = 0; j < arr[i].length; j++) {
        
                    sum += arr[i][j];
                }
            }
            System.out.println("sum = " + sum);
        }
    }

##### 案例2 打印10行杨辉三角 #####

\[提示\]  
1.第一行有1个元素，第n行有n个元素  
2.每一行的第一个元素和最后一个元素都是1  
3.从第三行开始，对于非第一个元素和最后一个元素的元素的值.

arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律

public class Test {
        
        public static void main(String[] args) {
        
            // 首先,杨辉三角有多少行
            int rows = 10;
            int[][] arr = new int[rows][];
            // 用于赋值的二重循环
            for (int i = 0; i < rows; i++) {
        
                // 给每个一维数组开空间
                arr[i] = new int[i + 1];
                for (int j = 0; j <= i; j++) {
        
                    if ((j == 0) || (j == i)) {
        
                        arr[i][j] = 1;
                    } else {
        
                        arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
                    }
                }
            }
            // 用于输出的二重循环
            for (int[] ints : arr) {
        
                for (int anInt : ints) {
        
                    System.out.print(anInt + "\t");
                }
                System.out.println();
            }
        }
    }

##### 二维数组使用细节和注意事项 #####

1.一维数组的声明方式有:

int[] x;
    int x[];

2.二维数组的声明方式有:

int[][] y;
    int[] y[];
    int y[][];

3.二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同， 也可以不相同。比如: map\[\]\[\] 是一个二维数组

map [][]= {
        {
        1,2},{
        3,4,5}}

由map\[0\]是一个含有两个元素的一维数组，map\[1\] 是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组。

##### 二维数组课堂练习 #####

声明:`int[] x,y[];`以下选项允许通过编译的是() :  
说明:  
x是int类型一维数组，y是int类型的二维数组

a) x[0] = y;//错误int[][] -> int
    b) y[0] = x; //正确int[] -> int[]
    c) y[0][0] = x; //错误int[]->int
    d) x[0][0] = y; //错误 
    e) y[0][0] = x[0]; //正确int->int
    f) x= y; //错误int[][]->int[]

### 本章作业 ###

1.下面数组定义正确的有 ()

A. String strs[] = {
        'a', 'b', 'c'};
    B. String[] strs = {
        "a","b","c"};
    C. String[] strs = new String{
        "a" "b" "c"};
    D. String strs[] = new String[]{
        "a","b","c"};
    E. String[] strs = new String[3]{
        "a", "b","c"};

> BD

2.写出结果

public class Test {
        
        public static void main(String[] args) {
        
            String foo = "blue";
            boolean[] bar = new boolean[2];
            if (bar[0]) {
        
                foo = "green";
            }
            System.out.println(foo);
        }
    }

> blue

3.以下Java代码的输出结果为( )

public class Test {
        
        public static void main(String[] args) {
        
            int num = 1;
            while (num < 10) {
        
                System.out.println(num);
                if (num > 5) {
        
                    break;
                }
                num += 2;
            }
        }
    }

> 1  
> 3  
> 5  
> 7

4.已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序，比如:  
\[10,12,45,90\],添加23后，数组为\[10,12,23,45,90\]

public class Test {
        
        public static void main(String[] args) {
        
            // 本质是数组扩容+定位
            int[] arr = {
        10, 12, 45, 90};
            int insertVal = 23;
            int[] newArr = new int[arr.length + 1];
            for (int i = 0; i < arr.length; i++) {
        
                newArr[i] = arr[i];
            }
            newArr[arr.length] = insertVal;
            for (int i = newArr.length - 1; i > 0; i--) {
        
                if (newArr[i - 1] > newArr[i]) {
        
                    newArr[i] = newArr[i] + newArr[i - 1];
                    newArr[i - 1] = newArr[i] - newArr[i - 1];
                    newArr[i] = newArr[i] - newArr[i - 1];
                }
            }
            // 输出一下newArr
            for (int item : newArr) {
        
                System.out.println(item + "\t");
            }
        }
    }

5.随机生成10个整数(1-100的范围)保存到数组，并倒序打印以及求平均值、求最大值和最大值的下标、并查找里面是否有8

6.试写出以下代码的打印结果

char[] arr1={
        'a','z','b','c'};
    char[] arr2=arr1;
    arr1[2]= '韩';
    for(int i=0;i<arr2.length; i++){
        
    	System.out.println(arr1[i]+ ","+ arr2[i]);
    }

因为数组是引用复制, `arr2[2]='韩'`

7.写出冒泡排序的代码

前面有

[image-20221029195222982]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/673b602b4acc4d359be7ceee836b6d17.png
[image-20221029205917214]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3b7eb9311ca04bada682e79168170148.png
[image-20221029205933490]: https://s3.bmp.ovh/imgs/2022/10/29/d2244367997627ff.png
[image-20221030155202899]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/328344d8b5fd446ba6ee7142826fb274.png
[image-20221030160808636]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/79d1cc7e5b4e43a79301ce85674531ca.png