黑马程序员 Java基础<五> 数组

最新推荐文章于 2022-07-22 18:49:36 发布

吃番茄不吃番茄皮

最新推荐文章于 2022-07-22 18:49:36 发布

阅读量835

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/kubZhaiNan/article/details/32716697

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

---------- android培训、java培训、期待与您交流！ ----------

一、数组

数组是引用数据类型中的一种。

什么是数组

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

好处:可以自动给数组中的元素从0开始编号,方便操作这些元素

数组格式

/**
 *  格式一
 *           数据元素类型[]  变量名 = new 元素类型[元素个数或数组长度];
 *                   
 */
public class Temp{ 
	public static void main(String[]args)  
	{  
		//定义一个int类型的数组分配,分配3个存储空间
		int[] arr = new int[3];
		arr[0] = 1; //给0角标元素赋值
		System.out.println(arr[2]);//由于没有赋值所以打印的是int默认值0
      		
	}  
}

/**
 *  格式二
 *           数据元素类型[]  变量名 = new 元素类型[]{元素1,元素2,元素3……} ;
 *             
 */
public class Temp{ 
	public static void main(String[]args)  
	{  
		int[] arr = new int[]{2,1,3,5,4};
		//直接赋值
		int[] arr1= {2,1,3,5,4};
		System.out.println(arr[2]);//打印角标为2的数,也就是数组第3个元素 3
      		
	}  
}

一维数组初始化

当创建一个数组时，arr在栈中new int[3]在堆中，并且它们每个数组元素的初始值＝0，并生成一个十六进制的地址值

0x0011传给栈中的arr，当栈中arr拿到地址值时，再去访问堆中的数组元素

如果将arr = null; 那么栈中的地址值和数组元素将会被视为垃圾，但是它不会立即进行清除，Java虚拟机它会不定时的启动一个垃圾回收机制，

将数组实体在堆内存中清除。

栈内存特点

存储的都是局部变量。

而且变量所属的作用域一旦结束,该变量就自动释放

堆内存特点

堆内存中的实体都有首内存地址值

堆内存中的变量都有默认初始化值

对于没有任何引用变量指向的实体,会视为垃圾,会被jvm所回收。(数组和对象,只要是new创建的,都在堆内存中)

数组操作常见问题

1、数组角标.数组角标越界异常(ArrayIndexOutOfBoundsException):操作数组时，访问到了数组中不存在的角标。

2、空指针异常(NullPointerException)：当引用没有任何指向值为null的情况，该引用还在用于操作实体。

public class Temp{ 
	public static void main(String[]args)  
	{  
		int[] arr = new int [3];
		System.out.println(arr[3]);//发生异常角标越界
		arr = null;
		System.out.println(arr[0]);//空指针异常
      		
	}  
}

二维数组

二维数组和一维数组操作类似下面简单演示一下

/**
 * 格式 一
 *  int[][] arr = new int[3][2];
 *   定义了名称为arr的二维数组
 *   二维数组中有3个一维数组
 *   每一个一维数组中有2个元素
 *   一位数组的名称分别为arr[0],arr[1],arr[2];
 *   给第一个一位数组角标为1的角标赋值 arr[0][1] = 55;
 * 
 * 格式 二
 *   int[][] arr = new int[2][];
 *   二维数组中有2个一位数组
 *   每个一维数组都是默认初始化值null
 *   可以兑这三个一位数组分别进行初始化
 *    arr[0] = new int[3];
 *    arr[1] = new int[1];
 *  
 * 格式 三 
 *     int[][] arr = {{3,1,2},{12,22},{5,6,4}};
 *    显示初始化数组中每个元素都有具体的值
 */
public class Temp{ 
	public static void main(String[]args)  
	{   
		//定义一个2行3列的数组 6个元素 
		int[][] arr = new int[2][3];
		int x = 0;
		//给二维数组动态赋值
		for (int i=0; i<2; i++){
			for (int j=0; j<3; j++){
				arr[i][j] = x;
				x++;
			}
		}
		//输出二维数组
		for (int i=0; i<arr.length; i++){
			for (int j=0; j<arr[i].length; j++){
				System.out.print(arr[i][j]+"，");
			}
		}
   	}  
}

二维数组初始化

二维数组中的小问题

public class Temp{ 
	public static void main(String[]args)  
	{   
	   int[][] arr = new int[3][2];
	   //打印数组长度
	   System.out.println(arr.length);//二维数组长度
	   System.out.println(arr[0].length);//二维数组中一维数组的长度
	   
	  //打印数组地址,地址用哈希值表示的 @左边是实体的类型.右边是实体哈希值
	   System.out.println(arr);//直接打印二维数组地址
	   System.out.println(arr[0]);//二维数组中一维数组的地址
	   System.out.println(arr[0][0]);//二维数组中的角标为0的一维数组中角标为0的数
	    
	    //没有指定二维数组大小
	    int[][] arr1 = new int[3][];
	    System.out.println(arr1[0]);//没有二维数组中一维数组的地址 打印null
	    System.out.println(arr1[0][0]);//NullPointerException
   
	}  
}

二、数组常用操作

获取最值

/*
获取数组中的最大值。
思路：
1，需要进行比较。并定义变量记录住每次比较后较大的值。
2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
	如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值。 
3，遍历结果，该变量记录就是最大值。

定义一个功能来是实现。
明确一，结果。
		是数组中的元素。int .
明确二，未知内容。
		数组.
*/
public class Temp{ 
	//方法1 初始化值
	public static int getMax(int[] arr){
		//定义变量记录较大的值。
		int maxElement = arr[0];//初始化为数组中的任意一个元素。
		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]>maxElement)
				maxElement = arr[x];
		}
		return maxElement;
	}
	//方法2 初始化角标
	public static int getMax2(int[] arr){
		//初始化为数组中任意一个角标。
		int maxIndex = 0;
		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]>arr[maxIndex])
				maxIndex = x;
		}
		return arr[maxIndex];
	}
	public static void main(String[]args)  
	{   
		 int[] arr ={6,1,2,34,5,97,5}; 
		 System.out.println(getMax2(arr));
		
   	} 
	
}

排序(冒泡排序、选择排序)

public class Temp{ 
	
	//冒泡排序。
	
	public static void bubbleSort(int[] arr)
	{
		//控制比较的趟数，循环一次，表示比较了一趟  
		for(int x=0; x<arr.length-1; x++)
		{ //-1:避免角标越界，-x为了让外循环增加一次,内循环参数与比较的元素个数递减
		 //上面每循环一次，此循环就少比较一次  
			for(int y=0; y<arr.length-1-x; y++)
			{
				if(arr[y]>arr[y+1])	
				{
					swap(arr,y,y+1);
					/*
					int temp  = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
					*/
				}
			}	
		}
	}

	//选择排序
	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);
					/*
					int temp  = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
					*/
				}
			}
		}
	}
	//交换两数
	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 ={6,1,2,34,5,97,5}; 
 		
   	} 

}

查找(二分法)

class Temp
{
	public static void main(String[] args) 
	{
		int[] arr ={1,2,5,6,7,8,9};//折半查找前提必须要是有序数组 
		 System.out.println(halfSearch(arr,6));
		
	}
	//一般查找
	public static int getIndex(int[] arr,int key)
	{
		for(int x=0; x<arr.length; x++)
		{
			if(arr[x]==key)
				return x;
		}
		return -1;
	}
	//折半查找
	public static int halfSearch(int[] arr,int key)
	{
		int max,min,mid;
		min = 0;
		max = arr.length-1;
		mid = (max+min)/2;
		
		while(arr[mid]!=key)
		{
			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid - 1;

			if(max<min)
				return -1;

			mid = (max+min)/2;
		}
		return mid;

	}
}

查表法

/**
 * 通过输入数字判断是对应的星期几 
 * 通过查表法完成
 */

class Temp
{
	public static void main(String[] args) 
	{
		String week = getWeek(2);
		System.out.println(week);
	}
	
	public static String getWeek(int num)
	{

		if(num>7 || num<1)
		{
			return "错误的星期";
		}
		//通过数组创建星期表，因为它们有对应的关系
		String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};

		return weeks[num];
	}

}