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

文章目录

数组快速入门
数组的使用
- 使用方式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开始遍历arrif (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的变化会影响到arr1int[] arr1 = {1, 2, 3};int[] arr2 = arr1;arr2[0] = 7;System.out.println("arr1[0] = " + arr1[0]);}
}

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

public class Test {public static void main(String[] args) {int[] arr1 = {10, 20, 30};// 创建一个新的数组arr2// 大小为arr1int[] 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}使用冒泡排序法将其排成一个从小到大的有序数列。

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)二维数组在内存的存在形式

使用方式2:动态初始化

1)先声明:

类型 数组名[][];

2)再定义(开辟空间)

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

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

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

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

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]就是nullarr[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) {// 遍历二维数组，并将各个值累计到sumint 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];}}// 输出一下newArrfor (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.写出冒泡排序的代码

前面有