7.java中的数组

一、数组介绍

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

二、数组的使用

·使用方式1-动态初始化

√数组的定义

👇👇👇

使用方式1-动态初始化

数据类型 数组名[] =new 数据类型[大小] //也可以是数据类型[] 数组名=new 数据类型[大小]

int a[] = new int[5];

说明：这是定义数组的一种方法。

a

a[0] a[1] a[2] a[3]

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

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

数组的下标从0开始

package chap7;
import java.util.*;
public class Arrary02 {

	public static void main(String[] args) {
		double[] score =new double[5];
        Scanner in = new Scanner(System.in);
        for(int i =0;i<score.length;i++) {
        	System.out.println("请输入第"+(i+1)+"个元素的值");
        score[i] = in.nextDouble();
        }
        for(int i = 0;i<score.length;i++) {
        	System.out.println(score[i]);
        }
	}

}

使用方式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;....

数组使用注意事项和细节

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)

数组赋值机制

package chap7;

public class ArraryAssign {

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

}

数组的拷贝

package chap7;

public class ArraryVCopy {

	public static void main(String[] args) {
		// 将int [] arr1 = {10,20,30};拷贝到 arr2数组,
		//要求数据空间是独立的
		int[] arr1= {10,20,30};
		//创建一个新的数组arr2,开辟新的数据空间
		//大小 arr1.length;
		int[] arr2 = new int[arr1.length];
		//遍历arr1,按每个元素拷贝到对应的位置
		for(int i=0 ;i<arr1.length;i++) {
			arr2[i]=arr1[i];
		}

	}

}

数组的翻转

package chap7;

public class ArraryReverse {

	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55,66};
		int temp=0;
		int len = arr.length;
		for (int i =0;i<=len/2;i++) {
			temp = arr[len-1-i];
			arr[len-1-i]=arr[i];
			arr[i]=temp;
		}
		for(int i = 0;i<arr.length;i++) {
		System.out.print(arr[i]+"\t");}
 
	}

}

package chap7;

public class ArraryReverse02 {

	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];
		}
		arr=arr2;
		for (int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+"\t");
		}

	}

}

数组扩容

package chap7;
import java.util.*;
public class ArraryAdd02 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int[] arr= {1,2,3};
		do{int[] arrNew=new int[arr.length+1];
		for(int i =0;i<arr.length;i++) {
			
			arrNew[i]=arr[i];
		}
		System.out.println("请添加你要输入的元素:");
		int addNum=in.nextInt();
		arrNew[arrNew.length-1] =addNum ;
		arr =arrNew;
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+"\t");
		}
		System.out.println("是否继续添加？y/n");
		char key=in.next().charAt(0);
		if(key=='n') {
			break;
		}
		}while(true); 

	}

}

练习：求出最大值

package chap7;

public class ArraryExercise02 {

	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+"maxIndex"+maxIndex); 
	}

}

排序的介绍

排序是将一群数据，依指定的顺序进行排列的过程。

排序的分类：

1.内部排序：

指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）;

2.外部排序法：

数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）.

冒泡排序法

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

总结冒泡排序特点

1.我们一共有n个元素

2.一共进行了n-1轮排序。可以看成是外层循环

3.每一轮排序可以确定一个数的位置，比如第1轮排序确定最大数，第2轮排序，确定第2大的数位置，以此类推

4.当进行比较时，如果前面的数大于后面的数，就交换

5.每轮比较在减少n-1>n-2>n-3>...>n-(n-1)

package chap7;

public class BubbleSort {

	public static void main(String[] args) {
		int[] arr= {24,69,80,57,13};
		int temp = 0;//用于辅助交换的变量
		for(int i=0;i<arr.length-1;i++) {
		for(int j = 0;j<arr.length-1-i;j++) {
			if(arr[j] >arr[j + 1]) {
				temp = arr[j];
			    arr[j]=arr[j+1];
			    arr[j+1]=temp;
			} 
		}
		System.out.println("\n第"+(i+1)+"轮");
		for(int j = 0;j<arr.length;j++) {
			System.out.print(arr[j]+"\t");
		}
      }
	}
}

查询

package chap7;
import java.util.*;
public class SeqSearch {

	public static void main(String[] args) {
		String[] name= {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
		Scanner in = new Scanner(System.in);
		System.out.println("请输入名字");
		String findname=in.next();
		int index=-1;
		for(int i =0;i<name.length;i++) {
			if(findname.equals(name[i])) {
				System.out.println("值为"+findname);
				System.out.println("索引为"+i);
				index=i;
				break;
			}
		}
		if(index==-1) {
			System.out.println("没有此值");
		}
	}

}

二维数组

package chap7;

public class TwoDimensionalArray01 {

	public static void main(String[] args) {
		//关于二维数组的关键概念
		//(1)二维数组的元素个数=arr.length
		//(2)二维数组的每个元素是一维数组，所以如果需要得到每一个数组的值
		//   还需要再次遍历
		//(3)如果我们要访问第(i+1)个一维数组的第j+1个值 arr[i][j];
		//   举例 访问 3, => 它是第3个一维数组的第4个值 arr[2][3]
		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}};
        //1.从定义形式上看 int[][]
		//2.可以这样理解，原来的一维数组的每个元素是一维数组，就构成二维数组
		//遍历二维数组的每个元素
		for(int i = 0;i<arr.length;i++) {
			//1.arr[i] 表示 二维数组的第i+1个元素 比如arr[0]:二维数组的第一个元素
			//2.arr[i].length 得到 对应的 每一个一维数组的长度
			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]

内存布局

使用方式2：动态初始化

1)先声明：类型 数组名[][];

2)在定义（开辟空间）数组名 = new 类型[大小][大小]

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

package chap7;

public class TwoDimensionalArrary02 {

	public static void main(String[] args) {
		int arr[][];
		arr=new int[2][3];
		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)看一个需求：动态创建下面二维数组，并输出

package chap7;

public class ArraryDimensionalArrary03 {

	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();
		}

	}

}

使用方式4：静态初始化

·定义 类型 数组名[][]={{值1,,值2...},{值1,值2...},{值1,值2...}}

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

比如：

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

解读

1.定义了一个二维数组 arr

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

3.第一个一维数组有3个元素，第二个一维数组有3个元素，第三个一维数组有1个元素。

杨辉三角

package chap7;

public class YangHui {

	public static void main(String[] args) {
		int[][] yangHui = new int[10][];
		for (int i = 0; i < yangHui.length; i++) {
			// 遍历yanghui的每一个元素

			// 给每个一维数组（行）开空间
			yangHui[i] = new int[i + 1];
			for (int j = 0; j < yangHui[i].length; j++) {
				// 每一行的第一个元素和最后一个元素都是1
				if (j == 0 || j == yangHui[i].length - 1) {
					yangHui[i][j] = 1;
				} else {
					// 中间元素
					yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];
				}
			}
		}
		for(int i =0;i<yangHui.length;i++) {
			for(int j=0;j<yangHui[i].length;j++) {
				System.out.print(yangHui[i][j]+" ");
			}
			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;//错误 x[0][0]是错误

e)y[0][0] = x[0];//正确int -->int

f)x=y;//错误 int[][] --> int[]

PS:补充形式

String strs[]=new String[]{"a","b","c"};

作业

package chap7;
import java.util.*;
public class Homework04 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		/*
		 * 思路
		 * 本质数组扩容+定位
		 * 1.我们先确定 添加数应该插入到哪个索引
		 * 2.然后扩容
		 */
		//先定义原数组
		int[] arr= {10,12,45,90};
		int insertNum = 23;
		int index = -1; //index就是要插入的位置
		//遍历 arr数组，如果发现insertNum <=arr[i],说明 i 就是要插入的位置
		//使用index保留 index =i;
		//如果遍历完后，没有发现insertNum<=arr[i],说明index =arr.length
		//即：添加到arr的最后
		for(int i =0;i<arr.length;i++) {
			if(insertNum <= arr[i]) {
				index = i;
				break;//找到位置后，就退出
			}
		}
		//判断index的值
		if(index == -1) {
			index =arr.length;
		}
		int[] arrNew =new int[arr.length+1];
		for(int i =0,j=0;i<arr.length;i++) {
			if(i!=index) {
				arrNew[i]=arr[j];
				j++;
			}else {
				arrNew[i]=insertNum;
			}
		}
        
	}

}