黑马程序员-JAVASE入门（组成部分3。数组）

最新推荐文章于 2023-05-12 19:04:47 发布

a78926635

最新推荐文章于 2023-05-12 19:04:47 发布

阅读量674

点赞数

分类专栏：学习总结

本文链接：https://blog.csdn.net/a78926635/article/details/8931948

版权

学习总结专栏收录该内容

29 篇文章 0 订阅

订阅专栏

8：数组

1：数组概念:

数组其实就是同一种类型数据的集合.其实数组就是一个容器

它的好处是可以从0开始编号,方便操作这些元素.

2：数组的组成：

格式1：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

示例：int[] arr = new int[5];//创建数组实体的关键字

格式2：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};（不会在内存开辟空间）

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

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

3：数组在内存中分别情况图：

如：String [] arr = new String [5];

int[] arr = new int[5];//arr是引用类型变量,指向堆内存中的一个实体;

arr[0] = 15;//给零角标位置赋值

arr = null;//没有任何实体指向

栈内存特点:存储局部变量,在方法执行完会随方法弹栈.会自动释放空间

堆内存特点:存储的是数组和对象,凡是用new建立的实体都存在于堆中

1,每一个实体都有内存地址值

2,每一个实体都有默认初始化值

int--->0; double--->0.0; boolean--->false; char----->'\u0000';

3,当实体不被使用时将被视为垃圾,java有一个垃圾回收机制,对垃圾进行回收,对堆内存进行释放.

4：为什么使用数组：

当我们定义一个变量时可以使用一个变量名表示，但是如果出现很多的变量我们分别起变量名代替表示存储就比较麻烦了，

为了解决这样的问题我们采用数组的形式来进行存储，使用下标表示每个变量。

数组只有一个名称，即标识符

数组中每一个元素都能通过下标来访问

数组角标：从0开始

数组长度：变量名.length，数组的长度是固定的，因为它的底层是public和final修饰

数组最大角标值：length-1 数组长度固定，避免角标越界

数组动态初始化：int[] arr = new int[5];

数组静态初始化：int[] arr = {1,2,3,4};

数组定义的注意事项：

1，数组定义时，必须明确元素的类型。

2，数组定义时，必须明确元素的个数。

u什么时候使用数组?

当要操作的同种数据类型的变量较多时,需要将这些数据进行存储,这时就需要用的容器,而数组就是容器中的一种.

5：数组常见的错误：

1，int[] arr = new int[];//没有注明数组大小

2，int[] arr = new int[5];

System.out.println(arr[5]);//数组下标越界

ArrayIndexOutOfBoundsException//访问到了数组中不存在的角标。但是编译可以通过。因为，new运行的时候，只是在运行的时候才建立数组，编译时只进行语法检查，编译只能检查出语法错误。new只有在运行的时候才在堆内存开辟一块内存空间，并分配0，1，2,3,4,这5个角标,换个角度说编译的时候就这个数组已经把堆内存的空间占用,如果不运行会造成空间的浪费

3，int[] arr;

arr = {1,2,3,4};//创建数组并赋值的方式，必须在一条语句中完成。

4，int[] arr = null;//arr不指向任何实体

System.out.println(arr[0]);

NullPointerException//空指针异常

数组使用练习题：

简易代码显示：

数组格式：
会在内存开辟空间
 int [] arr = new arr[5];//下面五个数组就是
 int [] arr1 =new arr[]{20,5,42,1,5};//arr[]不要定义个数，避免不符合
 arr[0]=10; 
 arr[1]=2; 
 arr[2]=8; 
 arr[3]=19; 
 arr[4]=11; 
 不会在内存开辟空间
 int [] arr2 ={45,5,44,1,15,6};

数组小练习1

给数组用逗号隔开打印在控制台上

class  Demo
{
	public static void main(String[] args) 
	{
		int [] arr= {12,15,11,5,4,8};
		printArray(arr);//打印数组
	}
		//定义功能，打印数组中的元素，用逗号隔开
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		//数组中有一个属性获取数组的元素个数。length
		for (int x=0;x<arr.length ;x++ )
		{
			if (x<arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.print(arr[x]+"]");			
		}
	}
}

数组小练习2

获取数组中的最大值。（最小值思路同理）
	思路：
	1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
	通过一个变量进行临储。
	2，让数组中的每一个元素都和这个变量中的值进行比较。
	如果大于了变量中的值，就用该该变量记录较大值。
	3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

	步骤：
	1，定义变量。初始化为数组中任意一个元素即可。
	2，通过循环语句对数组进行遍历。
	3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
	
	需要定义一个功能来完成。以便提高复用性。
	1，明确结果，数组中的最大元素 int。、
	2，未知内容：一个数组。int[]

//给定一个数组{10,5,44,15,16,20,1}
//获取数组中的最大值和最小值
class  Demo
{
	public static void main(String[] args) 
	{
		int [] arr ={10,5,44,15,16,20,1};//创建给定数组
		//获取最大值
		int max = arrayTest(arr);
		System.out.println(max);
		//获取最小值
		int min = arrayTest_1(arr);
		System.out.println(min);

	}
	public static int arrayTest(int[] arr)//创建方法获取最大值
	{
		int num=0;//定义第三方变量方法，初始化临时变量为0，其实就是初始化为任一个数组中的角标
		for (int x=0;x<arr.length ;x++ )
		{
			if (arr[x]>arr[num])
			{
					num=x;
			}
		}
		return arr[num];
	}
	public static int arrayTest_1(int [] arr)//获取数组中最小值
	{
		int min=arr[0];
		for (int y=0;y<arr.length ;y++ )
		{
			if (min>arr[y])
			{
				min=arr[y];
			}
		}
		return min;
	}
}

6：数组的其他应用

选择排序和冒泡排序

Arrays.sort(arr);这时数组具备的排序方法。直接调用即可。

import java.util.*;
/*
对给定数组进行排序。
{5,1,6,4,2,8,9}


*/
class ArrayTest2 
{

	/*
	选择排序。
	内循环结束一次，最值出现头角标位置上。
	*/
	public static void selectSort(int[] arr)
	{
		for (int x=0; x<arr.length-1 ; x++)
		{
			for(int y=x+1; y<arr.length; y++)
			{
				if(arr[x]>arr[y])//小到大进行排序
				{
					swap(arr,x,y);
				}
			}
		}
	}
	/*
	冒泡排序
	*/

	public static void bubbleSort(int[] arr)
	{
		for(int x=0; x<arr.length-1; x++)
		{									
			for(int y=0; y<arr.length-x-1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。
			{
				if(arr[y]<arr[y+1])//大到小排序
				{
					swap(arr,y,y+1);
				}
			}
		}
	}

	/*
	发现无论什么排序。都需要对满足条件的元素进行位置置换。
	所以可以把这部分相同的代码提取出来，单独封装成一个函数。
	*/
	public static void swap(int[] arr,int a,int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	public static void main(String[] args)
	{
		int[] arr = {5,1,6,4,2,8,9};
		//排序前；
		printArray(arr);

		//排序
		selectSort(arr);

		//排序后：
		printArray(arr);
		bubbleSort(arr);

		//Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
		//排序后：
		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.println(arr[x]+"]");

		}		
	}
}

折半查找（二分查找）给任意一个数找到在数组中与其对应的角标值//只对有序的数组有效

/*
练习：有一个有序的数组，想要将一个元素插入到该数组中，
还要保证该数组是有序的。如何获取该元素在数组中的位置。
*/
import java.util.*;
class Demo
{
	public static void main(String[]args)
	{
		int [] arr ={7,9,10,14,15,20};
		int Index=getIndex(arr,10);
		System.out.println(Index);
	}
	public static int getIndex(int[]arr,int key)//折半查找获取
	{
		int min=0,max=arr.length-1,mid=(min+max)/2;
		while(min<=max)
		{
			
			if (key>arr[mid])
				min=mid+1;
			else if (key<arr[mid])
				max=mid-1;
			else
				return mid;//如果数组中有这个数了，直接返回该数所在位置，也就是插入位置
			mid=(min+max)/2;
		}
		return min;//获取插入角标
	}
}

十进制转二进制，八进制，十六进制

需要导入import java.lang.*;
Arrays.toBinaryStirng(arr);

Arrays.toOctalString(arr);

Arrays.toHexString(arr);