Java复习知识点六：Java中的数组、二维数组、杨辉三角、冒泡排序

GQ学编程

已于 2022-05-10 20:28:31 修改

阅读量232

点赞数

分类专栏： Java基础知识详解文章标签： java 排序算法算法

于 2022-05-09 20:00:57 首次发布

本文链接：https://blog.csdn.net/weixin_52797128/article/details/124673817

版权

Java基础知识详解专栏收录该内容

30 篇文章 2 订阅

订阅专栏

Java复习知识点六：

数组、排序、和查找

数组
– 数组赋值
– 数组扩容
排序
查找
– 冒泡排序
查找
二维数组
– 杨辉三角

1、数组

数组可以存放多个同一类型的数据。数组属于引用数据类型。

1.1使用方式：

动态初始化

使用方式1:
数据类型[] 数组名 = new 数据类型[大小]
    
int[] arr = new int[3];
//也可
int arr[] = new int[3];

使用方式2:
先声明数组
int[] arr;	或者	int arr[];
再创建数组
arr = new int[10];

静态初始化

语法：

数据类型 数组名[] = {元素值1，元素值2，}
			int arr[] = {1,2,3,4,5};

1.2 数组使用细节：

数组是多个相同类型数据的组合，也可以包含能够自动类型转换的类型
数组中的元素可以是，基本数据类型，也可以是引用数据类型，但是不能混用
数组创建后，如果没有赋值，会有默认值

数据类型默认值
byte、short、int、long 0
float、double 0.0
char \u0000 （\u代表是Unicode字符）
boolean false
String null
数组的下标是从0开始的
数组属于引用数据类型

数据类型	默认值
byte、short、int、long	0
float、double	0.0
char	\u0000 （\u代表是Unicode字符）
boolean	false
String	null

数组练习：

求出最大值{4,-1,9,10,23}，并得到对应的下标

//数组练习，求出最大值{4,-1,9,10,23}，并得到对应的下标

		int[] arr = {4,-1,9,10,23};
		int max = arr[0];
		int maxIndex = 0;

		for (int i = 1; i < arr.length; i++){
			if (max < arr[i]) {
				max = arr[i];
				maxIndex = i;
			}
		}
		System.out.println("最大值为：" + max + "  对应索引为：" + maxIndex);

1.3 数组赋值机制

基本数据类型赋值，这个值就是具体的值，而且互不影响
数组在默认情况下是引用传递，赋的值是地址

1.4 数组扩容练习

实现对数组的扩容，可添加元素

import java.util.Scanner;

public class ArrayExpansion {

	public static void main (String[] args){

		//对数组扩容，可以添加元素

		int[] arr = {1,2,3};
		int[] arrNew;
		Scanner myScanner = new Scanner(System.in);

		while(true){
			
			System.out.println("===========================");
			System.out.println("您是否要添加元素？是 y ,否 n,");

			char c = myScanner.next().charAt(0);

			if (c == 'y') {
				//添加
				System.out.println("请输入添加的元素");
				int num = myScanner.nextInt();
				//创建新数组
				arrNew = new int[arr.length + 1];
				//循环赋值
				for (int i = 0; i < arr.length ; i++) {
					arrNew[i] = arr[i];
				}
				//将添加的元素赋值给新数组
				arrNew[arrNew.length - 1] = num;

				arr = arrNew;

			}else if(c == 'n'){
				//不添加元素
				//遍历数组
				for (int i = 0; i < arr.length ; i++ ) {
					System.out.print(arr[i] + "\t");
				}
				//退出循环
				break;
			}else{
				System.out.println("您输入有误");
			}
		}
	}
}

1.5 数组缩减练习

对数组缩减，每次缩减最后那个元素
当只剩下最后一个元素不再缩减

import java.util.Scanner;

public class ArrayReduce {

	public static void main (String[] args){

		//对数组缩减，每次缩减最后那个元素
		//当只剩下最后一个元素不再缩减

		int[] arr = {1,2,3,4,5};
		int[] arrNew;
		Scanner myScanner = new Scanner(System.in);

		while(true){
			System.out.println("===========================");
			System.out.println("您是否要缩减该数组？是 y ,否 n,");

			char c = myScanner.next().charAt(0);
			if (arr.length == 1){
				System.out.println("该数组缩减不可再被缩减");
				//遍历打印
				for (int i = 0; i < arr.length ; i++ ) {
					System.out.print(arr[i] + "\t");
				}
				//退出循环

				break;
			}

			if (c == 'y') {
				//进行缩减
				arrNew = new int[arr.length - 1];
				//循环赋值
				for (int i = 0; i < arrNew.length; i++) {
					arrNew[i] = arr[i];
				}
				arr = arrNew;

			}else if (c == 'n'){
				//遍历打印
				for (int i = 0; i < arr.length ; i++ ) {
					System.out.print(arr[i] + "\t");
				}
				//退出循环

				break;
			}

		}
	}
}

2、排序

1、冒泡排序

public class BubbleSorting {

	public static void main (String[] args){

		//冒泡排序
		int[] arr = {94,64,10,47,13};
		int len = arr.length;
		int temp;

		for (int i = 0;i < len - 1; i++) { 
		//排序次数  5个元素，要进行4轮排序
			for (int j = 0; j < len - 1 - i; j++) { 
			//每轮排序比较的次数
			//每轮比较在减少

				if (arr[j] > arr[j+1]) {
					//交换顺序
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}

		for (int i = 0; i < len ; i++) {
			System.out.print(arr[i]+"\t");			
		}

	}
}

3、查找

顺序查找
二分查找

4、二维数组

4.1 初始化：

静态初始化：
int[][] arr = {{0,0,0},{0,2,0,0,2},{0,0}};

动态初始化：
int[][] arr = new int[3][4];
//可以不指定其中一维数组的大小 如：
    int[][] arr = new int[3][];  
    注意：
        这样初始化时，要先创建一维数组，再往二维数组里赋值
//补充：
 	也可这样初始化：
        int[] arr = new int[]{0,0,0,0,};
		//中括号中不可写数字

快速入门：

 int[][] arr = {
                 {0,1,0,3,4},
                 {0,1,0,3,4},
                 {0,1,0,3,4},
                 {0,1,0,3,4}
 				};
//输出二维数组
for(int i = 0; i < arr.length; i++){
    //arr.length代表有几个一维数组
    for(int j = 0; i < arr[i].length; i++){
    	//arr[i].length代表每个对应的一维数组的长度
        System.out.print(arr[i][j]);
	}
    System.out.println();//换行
}

4.2 二维数组使用细节

一维数组的声明方式有：
```
int[] arr 或者 int arr[]
```

二维数组的声明方式有：

int[][] arr 或者 int arr[][] 或者 int[] arr[]

二维数组实际上是由多个一维数组组成，各个一维数组的长度可以相同，也可以不同
可通过 arr[i].length 得到一维数组的大小

4.3 杨辉三角

 public class YangHui {

	public static void main (String[] args){

		//使用二维数组打印 杨辉三角 10行
		/*
			1
			1 1
			1 2 1
			1 3 3  1
			1 4 6  4  1
			1 5 10 10 5 1

			规律：
				1、第一行有一个元素，第n行有n个元素
				2、每一行的第一个元素和最后一个元素都是1
				3、从第三行开始，对于非第一个和最后一个元素的值：
					满足：
						arr[i][j] = arr[i-1][j] + arr[i-1][j-1];

		*/

		int[][] arr = new int[10][];
		//遍历二维数组中的每个元素(每行)
		for (int i = 0; i < arr.length; i++) {
			
			//给每个一维数组(行)开辟空间
			arr[i] = new int[i+1];
			//给每行赋值
			for (int j = 0; j < arr[i].length; j++) {
				if (j == 0 || j == arr[i].length - 1) {
					//如果是每行的第一个元素和最后一个元素
					arr[i][j] = 1;
				}else if (i > 1) {
					arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
				}
				
			}
		}

		//打印二维数组
		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();
		}
	}
}