Java笔记之数组(五)

学习内容

  • 一、数组的基本概念
    • 1.什么是数组
    • 2.数组的使用
    • 3.数组使用的注意事项
    • 4.数组的基本操作
      • 1.数组的赋值和复制
      • 2.数组的反转
      • 3.数组的扩容
  • 二、数组的排序
  • 三、数组的查找
  • 四、二维数组
    • 1.基本介绍
    • 2.二维数组的使用
    • 3.数组练习
      • 1.杨辉三角
      • 2.数组的添加与排序

一、数组的基本概念

1.什么是数组

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

2.数组的使用

1.方法一(动态初始化)

  • 数组的定义
    语法格式:
    数据类型 数组名[] = new 数据类型[大小];
    数据类型[] 数组名 = new 数据类型[大小];
    以上两种定义方式等价;
    例:int test[] = new int[5]; //创建一个名字为test,长度为5,int类型的数组
  • 数组的引用
    格式:
    数组名[下标];
    例:test[2]; //使用数组第三个数
    注意:数组下标是从0开始的

2.方法二(动态初始化)

  • 先声明数组,再创建数组
    语法格式:
    第一步:数据类型 数组名[];或者 数据类型[] 数组名;
    第二部:数组名=new 数据类型[大小];
    例:int test[];
      test = new int[5];

3.方法三(静态初始化)

  • 语法格式
    数组类型 数组名[] = {元素值1,元素值2 ···};
    例:int test[] = {1,2,3,4,5};
//声明数组
int test[] = new int[5];

Scanner myScanner =  new Scanner(System.in);
for (int i = 0 ;i<test.length ; i++ ) {
	System.out.println("请输入下标为"+i+"的元素");
	//对每个数组进行赋值
	test[i] = myScanner.nextInt();
}

//声明+赋值 与上面代码等价
int test1[] = {1,2,3,4,5};

//遍历数组
for (int i = 0 ;i<test.length ; i++ ) {
	System.out.println("第"+i+"元素的值为"+test[i]);
}

3.数组使用的注意事项

  1. 数组是多个相同类型数据的组合,如果有不同类型,则会进行类型自动转换(符合类型转换的规则,否则会报错)。
  2. 数组的下标是从 0 开始的。
  3. 数组属引用类型,数组型数据是对象(object)。
  4. 数组创建后,如果没有赋值,则会有默认值 如:int默认的默认值为0。
  5. 数组中的元素可以是任何数据类型,包括基本类型和引用类型,但是不能混用。
  6. 数组下标必须在指定范围内使用,否则会报下标越界异常的错误。
//注意事项1
int a[] = {1,2,3,4,2.0};	//错误,double不能转int
double a1[] = {1.0,2.0,3.0,4.0,2};	//正确,int可以转int

//注意事项2
int b[] = {1,2,3,4,5};
System.out.println(b[0]);	//值为1

//注意事项3
//数组不是基本数据类型,它是一个对象

//注意事项4
int c[] = new int[5];
for (int i = 0 ;i<c.length ; i++ ) {
	System.out.println(c[i]);	//值为 0 0 0 0 0
}

//注意事项5 
//跟1表达的意思差不多

//注意事项6
int d[] = {1,2,3,4,5};		//下标0-4
System.out.println(d[5]);	//错误,下标为5,越界了

4.数组的基本操作

1.数组的赋值和复制

注意:数组在默认情况下是引用传递,赋的值是地址。

int a1[] = {1,2,3};
//把a1赋值给a2,传递的是一个地址,修改a2中的数据会,a1中的数据也会受到影响
int a2[] = a1;

a2[0] = 10;	//修改a2数组中第0个元素的值,对数组a1有影响

//遍历数组a1
for (int i = 0; i<a1.length ; i++) {
	System.out.println(a1[i]);	//10 2 3
}

System.out.println("------------");
//创建一个新的数组 b2,开辟新的数据空间
int b1[] = {1,2,3};
int b2[] = new int[3];

//把数组b1的值赋值给b2
for (int i = 0; i<b1.length ; i++) {
	b2[i] = b1[i];
}

b2[0] = 10;	//修改b2数组中第0个元素的值,对数组b1不会有影响

//遍历数组b1
for (int i = 0; i<b1.length ; i++) {
	System.out.println(b1[i]);	//1 2 3
}

2.数组的反转

把数组的内容进行反转 如:int arr1= {1,2,3} => int arr1 = {3,2,1}
说明:通过定义一个中间变量,进行替换

int arr1[] = {1,2,3};
int len = arr1.length;
int temp = 0;
for (int i = 0; i<len/2 ; i++) {
	temp = arr1[len-1-i];
	arr1[len-1-i] = arr1[i];
	arr1[i] = temp;
}

for (int i = 0; i<len ; i++) {
	System.out.println(arr1[i]);	//3 2 1
}

3.数组的扩容

要求:

  1. 创建一个静态数组 如:int arr = {1,2,3};
  2. 在arr后面增加一个元素 如:添加一个4,使arr = {1,2,3,4};
  3. 判断是否继续添加元素,输入Y继续添加,否则退出添加。
import java.util.Scanner;

public class test{
	public static void main(String[] args) {
		Scanner myScanner = new Scanner(System.in);
		int arr[] = {1,2,3};

		do{	
			//把arr数组的元素依次赋值给newArr
			int newArr[] = new int[arr.length+1];
			for (int i=0; i<arr.length;i++ ) {
				newArr[i] = arr[i];
			}

			System.out.println("请输入要添加元素的值");
			int element =  myScanner.nextInt();
			newArr[newArr.length-1] = element;

			//把newArr指向的值1 2 3 4的地址赋值给arr,类似于链表元素的插入
			arr = newArr;

			System.out.println("添加元素后数组的值");
			for (int i=0; i<arr.length;i++ ) {
				System.out.print(arr[i]+"\t");
			}

			System.out.println("是否继续添加元素y/n?");

			char key = 	myScanner.next().charAt(0);
			if (key == 'n') {
				break;
			}
		}while(true);	

		System.out.println("元素添加完毕,已退出");
	}
}

二、数组的排序

排序:是将多个数据,依指定的顺序进行排列的过程。
冒泡排序:
通过对待排序序列从后向前(从下标较大的元素开始),依次比较相邻元素 的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。

import java.util.Scanner;

public class test{
	public static void main(String[] args) {
		/*
			i一共循环4次
			j一共循环4+3+2+1次
			第一次循环比较前五个元素
			第二次循环比较前四个元素
			第三次循环比较前三个元素
			第四次循环比较前二个元素
		 */
		int arr[] = {5,3,8,9,2};
		int temp = 0;
		for (int i=0; i<arr.length-1;i++ ) {
			for (int j = 0;j<arr.length-i-1;j++ ) {
				if (arr[j]>arr[j+1]) {
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}

		//排序后的数组
		for (int i=0; i<arr.length;i++ ) {
			System.out.print(arr[i]+"\t");
		}
	}
}

三、数组的查找

查找:查找数组中对于的元素
常用的查找有顺序查找和二分查找,这里演示一下顺序查找

//查找数组元素等于8的数组下标
int arr[] = {5,3,8,9,2};
int index = -1;
for (int i=0; i<arr.length-1;i++ ) {
	if (arr[i] == 8) {
		index = i;
		System.out.println("找到了!数组元素等于8下标为"+index);
		break;
	}
}

if (index == -1) {
	System.out.println("没找到!");
}

四、二维数组

1.基本介绍

二维数组本质上是以数组作为数组元素的数组,即“数组的数组”,类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵,行列数相等的矩阵称为方阵。

2.二维数组的使用

方法一(动态初始化)

  • 定义格式:
    类型[][] 数组名=new 类型[大小][大小];
    如:int a[][]=new int[2][3];
      说明:表示二维数组中有2个一维数组,每个一维数组中有3个元素。

方法二(动态初始化)

  • 定义格式
    先声明:类型 数组名[][];
    再定义(开辟空间): 数组名 = new 类型[大小][大小];
    如:int a[][];
      a = new int[2][3];
    如果没有赋值则有默认值,如int类型的默认值为0,上面一维数组中已经介绍过了,这里就不在举例了

方法三(动态初始化-列数不确定)

  • 说明:如第一个一维数组中有一个元素,第二个一维数组有两个元素,第三个一维数组有三个元素
  • 定义格式
    先声明:类型[][] 数组名=new 类型[大小][];
    再定义(给每个一维数组开辟空间):数组名[大小] = new 类型[大小];
//创建类型为int的二维数组,期中三个一维数组,但没有开辟数据空间
int[][] arr = new int[3][];
for(int i = 0; i < arr.length; i++) {
	//给每个一维数组开辟数据空间
	arr[i] = new int[i + 1];	

	//给每个一维数组赋值
	for(int j = 0; j < arr[i].length; j++) { 
		arr[i][j] = i + 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();
}

方法四(静态初始化)

  • 定义格式:
    类型 数组名[][] = {{值 1,值 2…},{值 1,值 2…},{值 1,值 2…}};
    如:int[][] arr = {{1,2,3}, {4,5,6}, {2}};
//遍历二维数组
int[][] arr = {{1,2,3}, {4,5,6}, {2}};
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();
}

3.数组练习

1.杨辉三角

要求:打印前五行:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

//打印五行杨辉三角
int arr[][] = new int[5][];
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) {
			//第一行和第二行的元素都是1
			arr[i][j] = 1;
		}else{
			//arr[i][j] = 上一行的第j个元素和上一行的第j-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();
}	

2.数组的添加与排序

要求:在一个升序数组{11,22,33,44,55}中插入一个数组元素25,使数组仍然是升序排列的,添加后的数组为:{11,22,25,33,44,55}。

/*
	1.找到插入的位置
	2.将数组赋值给一个新数组,在赋值的过程中插入新的数

 */

int arr[] = {11,22,33,44,55};
int newNum = 25;
int index = -1;
//找到插入的位置
for (int i=0 ; i<arr.length ; i++ ) {
	if (arr[i]>25) {
		index = i;
		break;
	}
}

//创建一个新数组,插入新增的数
int newArr[] = new int[arr.length+1];
for (int i=0,j=0; i<newArr.length ; i++ ) {
	if (i != index) {
		newArr[i] = arr[j];
		j++;
	}else{
		newArr[i] = newNum;
	}
}

//遍历数组验证
for (int i=0 ; i<newArr.length ; i++ ) {
	System.out.print(newArr[i]+" ");
}

你可能感兴趣的