(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/获取每一个数据,然后赋值进数组

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





评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值