java不规则数组杨辉,JavaLearningmanual

Java数组

一、数组的概念

1.1 数组的概念

概念： 一组连续的存储空间，存储多个相同数据类型的值

特点：

1、类型相同

2、长度固定

1.2 数组的创建

二、数组的声明和赋值

声明赋值方式

具体声明赋值方法

先声明、再分配空间

数据类型[] 数组名; 数组名 = new 数据类型[长度];

声明并分配空间

数据类型[] 数组名 = new 数据类型[长度];

声明并赋值(繁)

数据类型[] 数组名 = new 数据类型[] {value1, value2, ...};

声明并赋值(简)

数据类型[] 数组名 = {value1, value2, ...};

三、数组的下标(索引)

数组中的每个数据格被称为“数组元素”。

对每个元素进行复制或取值的操作被称为“元素的访问”。

访问元素时，需要使用“下标”(从0开始，依次+1，自动生成)。

访问的语法：数组名[下标]; //例如 存：a[0] = 10; 取：a[0];

四、数组的异常错误

数组的使用：创建数组，依次赋值，依次取值

有效下标范围：0~(数组长度-1)

注意：如果访问无效的下标，会导致数组下标越界，终端异常会出现Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException：6(数字说明是你访问的这个下标是无效的下标)

五、数组的遍历

5.1 数组的遍历方式

遍历： 从头到尾，逐一对数组的每个元素进行访问

//遍历方式

public class Test {

public static void main(String[] args) {

int[] a = new int[2];

a[0] = 1;

1[1] = 2;

for (int i = 0; i < a.length; i++) {//数组名.length可动态获得数组长度

System.out.println(a[i]);//使用循环变量“i”充当下标，逐一访问数组中的每个元素

}

}

}

5.2 关于数组的默认值

在没有为数组元素赋值的情况下，依旧可以正确访问

数据类型

该类型的数组默认值

整数

0

小数

0.0

字符

\u000

布尔

false

其他

null

六、数组的应用

6.1 数组的扩容

创建数组时，必须显示指定长度，并在创建之后哦不可以更改长度

扩容的思路：

1、创建大于原数组长度的新数组

2、将原数组中的元素依次赋值到新数组中

6.2 数组的复制方式

循环将原数组中所有元素逐一赋值给新数组

System.arraycopy(原数组, 原数组起始, 新数组, 新数组长度, 长度);

java.util.Arrays.copyOf(原数组, 新长度); //返回带有原值的新数组

6.2.1 地址的替换

数组作为引用类型之一，其变量中存储的是数组的地址

完成元素赋值后，需将新数组地址，赋值给原变量进行替换

6.2.2 组成类型的参数

注意：方法调用时，将nums中的地址赋值给oneArray，此时二者只想同一个数组

6.2.3 数组类型的返回值

创建新数组，长度为原数组的2倍，新数组中保持原有数据，返回新数组

注意：创建新数组，长度为原数组的2倍，新数组中保留原有数据，返回新数组

6.3 可变长参数

概念： 可接收多个同类型实参，个数不限，使用方式与数组相同

语法： 数组类型...形参名 //必须定义在形参列表的最后，且只能有一个

七、数组的排序

7.1 简单的数组排序分类

冒泡排序法：相邻的两个数值比较大小，互换位置

选择排序法：固定值与其他值依次比较大小，互换位置

JDK排序法：java.tuil.Arrays.sort(数组名); //JDK提供(默认升序)

7.2 冒泡排序法

冒泡排序(Bubble Sort)，是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列)，就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

//冒泡排序法

public class ArrayBubbleSort {

public static void main(String[] args) {

//定义一个数组

int[] array = new int[] {34, 65, 26, 12, 9, 14};

for (int i = 0; i < array.length - 1; i++) {//外层循环控制的次数

for (int j = 0; j < array.length - 1 - i; j++) {//内层循环控制元素互换次数

//判断相邻两个元素的大小，如果前者比后者大，则执行换位

if (array[j] > array[j + 1]) {

int temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

}

}

}

for (int i = 0; i < array.length; i++) {//遍历数组元素

System.out.print(array[i] + " ");

}

}

}

7.3 选择排序法

选择排序法是一种不稳定的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

//选择排序法

public class ArrayChooseSort {

public static void main(String[] args) {

int[] array = new int[] {23, 12, 56, 22, 99, 6};//定义一个数组

for (int i = 0; i < array.length - 1; i++) {//外层循环控制第一个元素

for (int j = i + 1; j < array.length; j++) {//内层循环控制第二个元素

//判断每次循环的第一个元素比第二个元素的值大就互换

if (array[i] > array[j]) {

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

}

}

for (int i = 0; i < array.length; i++) {

System.out.print(array[i] + " ");

}

}

}

7.4 JDK中的排序

JDK排序是JDK中自带的一个保存在API中的方法。我们可以调用该方法实现排序

import java.util.Arrays;

//JDK排序

//注意：默认JDK排序只能升序，升序后可以通过元素的倒置来实现降序

public class ArrayJDKSort {

public static void main(String[] args) {

int[] array = new int[] {23, 65, 23, 12, 34, 2, 1};

Arrays.sort(array);//JDK排序方法

print(array);

}

//遍历打印数组元素

public static void print(int[] array) {

for (int i = 0; i < array.length; i++) {

System.out.print(array[i] + " ");

}

}

}

八、关于二维数组

8.1 二维数组的概念

概念： 一维数组中的一维数组；数组总的元素还是数组

8.2 二维数组的赋值

8.3 二维数组的内存分配

8.4 二维数组的访问

8.5 二维数组的创建语法

声明赋值方式

具体声明赋值方法

先声明、再分配空间

数据类型[][] 数组名; 数组名 = new 数据类型[高维长度][低维长度];

声明并分配空间

数据类型[][] 数组名 = new 数据类型[高维长度][低维长度];

声明并赋值(繁)

数据类型[][] 数组名 = new 数据类型[高维长度] //不规则数组，自行new低维数组

声明并赋值(简)

数据类型[] 数组名 = {{v1,v2,v3},{v4,v5},{v6}}; //显示初始化

8.6 杨辉三角

8.6.1 什么是杨辉三角

杨辉三角，是二项式系数在三角形中的一种几何排列，中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。

简单来说，每个数等于它上方两数之和，并且每行数字左右对称，由1开始逐渐变大。

8.6.2 基础数组版实现“杨辉三角”

import java.util.Scanner;

public class ArrayYangHui {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.print("请输入要打印“杨辉三角”的行数：");

int rows = sc.nextInt();

// 定义数组，定义n行n列的数组

int[][] nums = new int[rows][rows];

// 每一行的第一列和最后一列都是1

for (int i = 0; i < nums.length; i++) {

nums[i][0] = 1;

nums[i][i] = 1;

}

// 从第三行开始上面数之和等于下面数的值，i控制行

for (int i = 2; i < rows; i++) {

// 从第二列开始，j控制列

for (int j = 1; j < rows; j++) {

// 每个数等于它上方两数之和(上一行的上一列+上一行的同一列)

nums[i][j] = nums[i - 1][j - 1] + nums[i - 1][j];

}

}

// 打印输出杨辉三角

for (int i = 0; i < rows; i++) {

// 并非每行中的每一列都打印，所以j的截止条件不是j

for (int j = 0; j <= i; j++) {

System.out.print(nums[i][j] + " ");

}

System.out.println();

}

}

}

8.6.3 高级数组版“杨辉三角”

import java.util.Scanner;

public class ArrayYangHui1 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.print("请输入杨辉三角型的行数：");

int n = sc.nextInt();

int[][] nums = new int[n][];

for (int i = 0; i < n; i++) {//行数 i=0 第一行 i=1 2 第二行 i=2 第3行

//创建内层数组(二维数组中每一个值都是一维数组)

nums[i] = new int[i + 1];//元素个数，根据行数增加元素的个数 nums[0]=new int [1]; nums[1]=new int [2];

//遍历赋值

for (int j = 0; j < nums[i].length; j++) {//列

if (j == 0 || j == i) {//j == 0是左边全为1，j == i是右边全为1

nums[i][j] = 1;

} else {

nums[i][j] = nums[i - 1][j - 1] + nums[i - 1][j];

}

}

}

//遍历：增强for循环，不懂得可以去百度，很简单的

for (int[] num : nums) {

for (int a : num) {

System.out.print(a + " ");

}

System.out.println();

}

}

}

8.6.4 算法实现“杨辉三角”

import java.util.Scanner;

public class TestYangHui {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.print("请输入行数：");

int rows = sc.nextInt();

//控制行数

for (int i = 1; i <= rows; i++) {

//控制空格列数

for (int j = 1; j <= rows - i; j++) {

System.out.print(" ");

}

//控制数字列数

int cols = 1;

for (int k = 1; k <= i; k++) {

System.out.print(cols + " ");

cols = cols * (i - k) / k;//涉及算法

}

System.out.println();

}

}

}