(06)Java学习笔记——数组

数组：

同一种类型数据的集合，就是一个数据的容器。

多个变量的数据类型要一致。

数组可以存储基本数据类型，也可以存储引用数据类型。

数组初始化：（就是为数组开辟空间，并为每个数组元素赋值）

java中的数组必须先初始化才能使用。

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值

数组的初始化方式：

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

数组的格式1（动态初始化）：（需要一个容器，但是不明确容器中的具体数据）

元素类型[ ]   数组名 =  new   元素类型[元素个数或数组长度];     // 用关键字new来建立数组

示例：int [ ] array = new int [ 5 ];      //  数组一建立，必须明确数组长度！

数组的格式2（静态初始化）：（需要一个容器，存储已知的具体数据）

元素类型 [ ]   数组名 = new 元素类型 [ ] {元素1，元素2，元素3，……}

示例：

int [ ] array = new int [ ] {2,4,5,7};   //常规初始化方式

int [ ] array = {2,4,5,7};    //静态初始化方式

**//动给数组中的数据进行角标编号（从0开始），方便操作这些元素。

范例：

class ArrayDemo 
{
	public static void main(String[] args) 
	{
		int [] array=new int[]{5,8,13,64,9};  //定义了一个数组，并在数组中给了元素。
		System.out.println(array[1]);    //打印数组中1角标对应的元素。
	}
}

————————————————————————————————————————

栈内存：存储的都是局部变量。变量所属的作用一旦结束，该变量就自动释放。

堆内存：储存的是数组和对象（其实数组就是对象）凡是new就建立在堆中。

                每个new出来的东西都有首地址值。

                堆内存中的每个变量都有默认初始化值，根据类型的不同而不同。

局部变量：在方法定义中 或者 方法声明上的变量都称为局部变量。

————————————————————————————————————————————

练习01：

定义一个数组，输出该数组的名称和数组元素值
给数组元素赋值，再次输出该数组的名称和数组元素值。

/*
定义一个数组，输出该数组的名称和数组元素值
给数组元素赋值，再次输出该数组的名称和数组元素值。
*/

class  ArrayTest_01
{
	public static void main(String[] args) 
	{
		int [] array = new int[3];
		
		System.out.println(array);

		System.out.println(array[0]);
		System.out.println(array[1]);
		System.out.println(array[2]);

		System.out.println("----------------------");

		array[0] = 30;
		array[1] = 60;
		array[2] = 90;

		System.out.println(array[0]);
		System.out.println(array[1]);
		System.out.println(array[2]);

	}
}

练习02：

定义一个数组，给数组元素赋值，输出数组名称和元素

定义第二个数组，给数组元素赋值，输出数组名称和元素

定义第三个数组，把第一个数组的地址值赋值给它（注意类型一致），通过第三个数组的名称去吧元素重新赋值，再一次输出第一个数组名称和元素。

栈内存的两个引用指向同一个堆空间

class ArrayTest_02 
{
	public static void main(String[] args) 
	{
		int [] array1 = new int [3];

		array1[0] = 33;
		array1[1] = 55;
		array1[2] = 88;

		System.out.println(array1);
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);

		System.out.println("--------------------------");

		int [] array2 = new int [4];

		array2[0] = 13;
		array2[1] = 21;
		array2[2] = 89;
		array2[3] = 19;

		System.out.println(array2);
		System.out.println(array2[0]);
		System.out.println(array2[1]);
		System.out.println(array2[2]);
		System.out.println(array2[3]);

		System.out.println("---------------------------");

		int [] array3 = array1;	//将array1数组的地址给了array3，array3依据地址指向堆内存中的array1内存空间

		array3[0] = 6;
//		array3[1] = 8;
		array3[2] = 5;

		System.out.println(array1);
		System.out.println(array1[0]);	//因为array1的地址给了array3,array3的重新赋值改变了array1中的元素。
		System.out.println(array1[1]);
		System.out.println(array1[2]);
	
	}
}

————————————————————————————————————————————————

数组常见的操作：

对数组的操作动作就是“存”和“取”。实际上就是对角标的操作。

1/数组的遍历

**数组长度的固定语句： 数组名.length 例如：array.length

class ArrayTest01   
{  
    public static void main(String[] args)   
    {  
        int[] array=new int[]{23,4,12,55,29};//定义一个数组，及初始化数组的元素
        for (int x=0;x<array.length ;x++ )// 用数组的长度语句控制循环次数。array.length
  
        {  
            System.out.println("array["+x+"]="+array[x]+";");//用循环语句遍历数组中的0开始的全部角标，并把相对应的值打印出来 

        }  
        System.out.println("length:"+array.length); //统计数组并打印出数组的长度值。
    }  
} 

遍历数组的方法：

两个明确：

1 / 返回值类型 ：void

2/ 参数列表：int [ ] array 

数组的一个属性，数组长度 ：数组名 . length

class ArrayTest_03 
{
	public static void main(String[] args) 
	{
		int [] array = new int[] { 3,6,88,33,12,5,66,47,29};	//声明一个数组，并静态初始化赋值
		
		printArray(array);	//调用打印数组的方法
			
	}

	public static void printArray(int[] array)	//创建一个遍历打印数组的方法
	{
		for (int x=0;x<array.length ;x++ )
		{
			System.out.println(array[x]);
		}
	}
}

2/数组取最值
思路：

1/1需要进行比较，并定义变量来记录每次比较厚较大的值。

2/对数组中的值遍历取出和变量中的值进行比较，取出较大值。

class ArrayTest02 
{
	public static void main(String[] args) 
	{
		int [] array=new int[]{34,55,22,7,98,12,67};  //定义一个数组并初始化了元素
		int getmax=max(array);     //调用名为max的方法，将最大值赋给getmax
		System.out.print(getmax);   //打印数组中的最大值
	}

	public static int max(int[] array)   //定义了一个方法，用来遍历比较数组中的元素，取出最大值
	{
		int max=0;
			
		for (int x=0;x<array.length ;x++ )
		{
			if (array[x]>max)
			{
				max=array[x];
			}
		}
		return max;	
	}
	
}

3/ 数组元素逆序

/*
数组的逆序

分析：
把数组角标0的元素和array.length-1的数据交换
把数组交表1的元素和array.length-2的数据交换
。。。。。
只要做到array.length/2的位置


*/

class  ArrayTest_05
{
	public static void main(String[] args) 
	{
		int [] array = new int[] {2,3,4,5,6,7,8,9,10,11,12};

		printArray(array);	//调用打印方法，打印逆序前的数组

		System.out.println();

		reverce(array); //调用逆序方法

		printArray(array);	//调用打印方法，打印逆序后的数组

//		System.out.println("["+array+"]");


	}

	public static void reverce(int[] array)	//定义一个位置交换的方法
	{
		for (int x=0;x<=array.length/2 ;x++ )
		{
			int temp = array[x];
			array[x] = array[array.length-1-x];
			array[array.length-1-x] = temp;
		}
	}

	public static void printArray(int[] array)	//定义一个遍历打印数组的方法
	{
		for (int x=0;x<array.length ;x++ )
		{
			System.out.print(array[x]+",");
		}

		return ;
	}

}

4 / 数组查表法

根据键盘录入索引，查找对应星期

/*
数组查表法
根据键盘输入索引，查找对应星期
*/

import java.util.Scanner;

class  ArrayTest_06
{
	public static void main(String[] args) 
	{
		String [] weekArray = new String[] {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

		Scanner sc = new Scanner(System.in);

		System.out.println("输入数据");
		int x = sc.nextInt();

		System.out.println("查找的是: "+weekArray[x]);	//依据输入数值，查找数组中对应角标的元素并输出
		
	}
}

5 / 查找数组元素对应角标

/*
查找数组元素对应的角标
*/

class  ArrayTest_07
{
	public static void main(String[] args) 
	{
		int [] array = new int[] {4,65,23,77,1,5,88,13};

		int index = getIndex(array,77);

		System.out.println(index);

	}

	public static int getIndex(int[] array,int value)	//定义一个方法遍历数组并与查询值进行比较。
	{
		for (int x =0;x<array.length ;x++ )
		{
			if (array[x]==value)
			{
				return x;
			}
		}
		return -1;
	}
}

4/ 数组的排序

A / 数组的冒泡排序

范例：

package cn.itcsat_01;

/*
 * 数组的的冒泡排序
 */
public class ArrayDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 24, 69, 80, 57, 13 };
		System.out.println("排序前：");
		printArray(arr);
		
		System.out.println("冒泡排序后：");
		bublleSort(arr);

/*		// 第一次比较
		for (int x = 0; x < arr.length-1-0; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第一次比较：");	//结果：[24, 69, 57, 13, 80]
		printArray(arr);
		
		// 第二次比较
		//arr.length-1  是为了防止越界
		//arr.length -1 -1 是为了减少比较的次数
		for (int x = 0; x < arr.length-1-1; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第二次比较：");	//结果：[24, 57, 13, 69, 80]
		printArray(arr);
		
		// 第三次比较
		for (int x = 0; x < arr.length-1-2; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第三次比较：");	//结果：[24, 13, 57, 69, 80]
		printArray(arr);
		
		// 第四次比较
		for (int x = 0; x < arr.length-1-3; x++) {
			if (arr[x] > arr[x + 1]) {
				int temp = arr[x];
				arr[x] = arr[x + 1];
				arr[x + 1] = temp;
			}
		}
		System.out.println("第四次比较：");	//结果：[13, 24, 57, 69, 80]
		printArray(arr);
		
		System.out.println("-----------------------------------");*/
/*		
		//上面的代码可以用循环改进
		for(int y=0;y<arr.length-1;y++){
			for (int x = 0; x < arr.length-1-y; x++) {
				if (arr[x] > arr[x + 1]) {
					int temp = arr[x];
					arr[x] = arr[x + 1];
					arr[x + 1] = temp;
				}
			}
		}
		System.out.println("冒泡排序结果：");
		printArray(arr);
	*/
	}

	// 遍历功能
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				System.out.print(arr[x]);
			} else {
				System.out.print(arr[x] + ", ");
			}
		}
		System.out.println("]");
	}
	
	//定义一个数组冒泡排序的方法：
	public static void bublleSort(int[] arr){
		for(int y=0;y<arr.length-1;y++){
			for (int x = 0; x < arr.length-1-y; x++) {
				if (arr[x] > arr[x + 1]) {
					int temp = arr[x];
					arr[x] = arr[x + 1];
					arr[x + 1] = temp;
				}
			}
		}
		printArray(arr);
	}
}

B / 数组的选择排序

思想：

分别用数组内的元素进行遍历。

用第三个临时变量来换位，将小的元素移动到前面。

范例：

package cn.itcsat_02;

/*
 * 数组的选择排序
 */
public class ArrayDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 24, 69, 80, 57, 13 };
		System.out.println("排序前：");
		printArray(arr);
		
		System.out.println("选择排序后：");
		selectSort(arr);

/*		// 第一次排序
		int x = 0;
		for (int y = 1; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第一次排序后：");
		printArray(arr);
		
		// 第二次排序
		//经过第一次排序后，0角标元素不再参与比较
		x = 0+1;
		for (int y = 1+1; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第二次排序后：");
		printArray(arr);
		
		// 第三次排序
		//经过第二次排序后，1角标元素不再参与比较
		x = 0+2;
		for (int y = 1+2; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第三次排序后：");
		printArray(arr);
		
		// 第四次排序
		//经过第三次排序后，2角标元素不再参与比较
		x = 0+3;
		for (int y = 1+3; y < arr.length; y++) {
			if (arr[y] < arr[x]) {
				int temp = arr[x];
				arr[x] = arr[y];
				arr[y] = temp;
			}
		}
		System.out.println("第四次排序后：");
		printArray(arr);
		
		System.out.println("----------------------------");
		
		
		//上面的过程可以简化成下列代码：
		for (int z=0;z<arr.length-1;z++){
			x = 0+z;
			for (int y = 1+z; y < arr.length; y++) {
				if (arr[y] < arr[x]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
		System.out.println("选择排序后：");
		printArray(arr);
*/
	}

	// 遍历数组的功能
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				System.out.print(arr[x]);
			} else {
				System.out.print(arr[x] + ", ");
			}
		}
		System.out.println("]");
	}
	
	//定义一个选择排序的方法
	public static void selectSort(int[] arr){
		for (int z=0;z<arr.length-1;z++){
			int x = 0+z;
			for (int y = 1+z; y < arr.length; y++) {
				if (arr[y] < arr[x]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
		printArray(arr);
	}
}

练习01：把字符串中的字符进行排序

举例：“dacgebf"

结果：”abcdefg"

package cn.itcast_03;
/*
 * 把字符串中的字符进行排序
 * 思路：
 * A/ 把字符串转换成字符数组
 * B/ 通过对字符数组的排序后，得出符合顺序的字符数组
 * C/ 将符合顺序的字符数组转成字符串
 */
public class ArrayTest_01 {
	public static void main(String[] args) {
		//定义一个字符串
		String s = "dacgebf";
		
		//把字符串转换成字符数组
		char[] chs =s.toCharArray();
		printArray(chs);
		bulleSort(chs);
		printArray(chs);	//打印输出排序后的字符数组
		
		//将排序后的字符数组转成字符串
		String s1 = String.valueOf(chs);
		
		System.out.println(s1);
	
	}
	
	//定义一个遍历数组并打印数组的功能
	public static void printArray(char[] chs){
		System.out.print("[");
		for(int x=0;x<chs.length;x++){
			if(x==chs.length-1){
				System.out.print(chs[x]);
			}
			else{
				System.out.print(chs[x]+", ");
			}
		}
		System.out.println("]");
	}
	
	//定义一个数组排序的功能
	public static void bulleSort(char[] chs){
		for(int x=0;x<chs.length-1;x++){
			for(int y=0;y<chs.length-1-x;y++){
				if(chs[y]>chs[y+1]){
					char temp=chs[y];
					chs[y]=chs[y+1];
					chs[y+1]=temp;
				}
			}
		}
	}
}

5/数组查找 （查找数组中某个元素对应的角标）

思路：用遍历方式查找。

范例：

class ArrayTest05 
{
	public static void main(String[] args) 
	{
		int[] array=new int[] {45,33,7,89,32,14,55};
		int index=getIndex(array,14);  //给出需要寻找的元素
		System.out.print("index="+index);  //打印出所寻找元素的对应角标
	}

	public static int getIndex(int[] array,int element)  //定义一个方法，用于寻找某元素的角标
	{
		for (int x=0;x<array.length ;x++ )
		{
			if (array[x]==element)
			{
				return x;
			}
		}
		return -1;
	}
}

6/数组的二分查找（折半查找）

前提：数组元素是有序的

范例：

package cn.itcast_04;

/*
 * 数组的折半查找
 * 思路：
 * A/定义最大索引，最小索引
 * B/ 计算中间索引
 * C/ 拿中间索引的值和要查找的值进行比较
 * 相等：就返回当前的中间索引
 * 不相等：小：左边找
 * 		大：右边找
 * D/ 重新计算出中间索引
 * 大：左边找   max = mid-1;
 * 小：右边找   min = mid+1;
 * E/ 回到B
 * 
 */
public class ArrayDemo {
	public static void main(String[] args) {

		// 定义一个数组
		int[] arr = { 11, 22, 33, 44, 55, 66, 77 };

		// 调用方法
		int index = getIndex(arr, 33);
		System.out.println(index);
	}

	// 写方法实现：
	/*
	 * 两个明确： 1.返回值类型 2。参数列表 int[] arr, int value
	 */
	public static int getIndex(int[] arr,int value){
		//定义最大索引，最小索引
		int max = arr.length-1;
		int min = 0;
		
		//计算中间索引
		int mid = (max+min)/2;

		//拿中间索引的值和要查找的值进行比较
		while (arr[mid]!=value){
			if(arr[mid]>value){
				max = mid-1;
			}
			else if(arr[mid]<value){
				min = mid+1;
			}
			
			//加入判断
			if(min>max){
				return -1;
			}
			mid =(max+min)/2;
		}
		return mid;
	}
}

7/进制转换

8/查表法

————————————————————————————————————

二维数组（数组中的数组）

格式1：（动态初始化）

数据类型 [ ] [ ]  数组名 = new 数据类型 [m ] [n ]

m表示这个二维数组有多少个一维数组

n表示每个一维数组的元素个数

int[ ] [ ] array=new int [3] [2];

1/定义了一个名为array的二维数组

2/二维数组中有3个一位数组

3/每个一维数组中有2个元素

		int [][] array=new int[3][2];  //定义一个二维数组。该数组中有3个一维数组，每个一维数组中有2个元素。

		System.out.println(array);	//直接打印二维数组
		System.out.println(array[0]);	//直接打印二维数组中的角标0的一维数组。
		System.out.println(array[0][0]);	//直接打印二维数组中的角标0的一维数组中的角标为0的元素。

二维数组的内存图解

		int[][] array=new int[3][2];

		System.out.println(array.length);	//打印二维数组的长度，其实就是一维数组的个数
		System.out.println(array[1].length);	//打印二维数组中角标为1的一维数组的长度。

格式2:（动态初始化）

数据类型 [ ] [ ]  数组名 = new  数据类型 [ m ] [ ] 

m表示这个二维数组有多少个一维数组

没有给出一维数组的元素个数，可以动态给出。

int [ ] [ ]  array = new int [ 3 ] [ ]

array[0]=new int [2 ];

array[1]=new int [1];

array[2]=new int [3];

格式3：

数据类型[ ] [ ]  数组名 = { {元素1，元素2，....}，{元素1，元素2，元素3，...}，{元素1，元素2，....}}

int[ ] [ ] array={{3,1,7},{4,6.2.9},{4,3,7}};

练习01：二维数组的遍历

用forfor循环嵌套方法遍历二维数组，

外循环控制的是二维数组的长度（一维数组的个数）

内循环控制的是一维数组的长度

/*
二维数组的遍历
分析：
用forfor循环的思想
*/

class ArrayTest02_01 
{
	public static void main(String[] args) 
	{
		int [] [] array ={{2,6,11,54},{55,3,71,33,87},{23,17}};
		
		ergodic(array);	//调用遍历方法
	}

	public static void ergodic(int [][] array)	//定义一个用forfor循环遍历二维数组的方法
	{
		for (int x=0;x<array.length ;x++ )
		{
			for (int y=0;y<array[x].length ;y++ )
			{
				System.out.print(array[x][y]+", ");
			}
			System.out.println();
		}
	}
}

练习02：公司年销售额求和

/*
公司年销售额求和
第一季度：22，66，44
第二季度：77，33，88
第三季度：25，45，65
第四季度：11，66，99

分析：
定义二维数组int [季度数] [每季度销售额]
定义一个统计方法
forfor循环嵌套遍历数组
将遍历出来的元素统计输出
 
*/

class  ArrayTest02_02
{
	public static void main(String[] args) 
	{
		int [][] array = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

		int result = arraySum(array);

		System.out.println("年销售额是"+result);
		
	}

	public static int arraySum(int [][] array)
	{
		int sum = 0;
		for (int x=0;x<array.length ;x++ )
		{
			for (int y=0;y<array[x].length ;y++ )
			{
				sum = sum+array[x][y];
			}
		}

		return sum;
	}
}

练习03：打印杨辉三角形

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

分析：

任何一行的第一列和最后一列都是1

从第三行开始，每一个数据都是它上一行的前一列和它上一行的本列之和。最后一列除外。

练习04：数据转换成数组进行操作

如何把数据转换成数组？：

a/定义一个数据：

int number = 123456;

b/定义一个数组，将数组长度定义8（不超过8位的数据）

c/获取每一个数据，然后赋值进数组

参考《流程控制——水仙花数》模运算的方法取出每一位数字。