黑马程序员-Java数组（一）

最新推荐文章于 2021-06-12 16:40:12 发布

被驯服的象

最新推荐文章于 2021-06-12 16:40:12 发布

阅读量520

点赞数

分类专栏： Java基础文章标签： java 数组

本文链接：https://blog.csdn.net/ddesyt/article/details/24599837

版权

Java基础专栏收录该内容

27 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

本文将介绍Java数组的声明、创建、初始化以及常见应用。

声明数组变量

语法：

dataType[] arrayName;   // 首选的方法
或
dataType arrayName[];   // 效果相同，但不是首选方法

注意： 建议使用dataType[] arrayName 的声明风格声明数组变量。 dataType arrayName[] 风格是来自 C/C++ 语言，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

实例：

int[] arr;   //首选方法
或
int arr[];   //效果相同，但不是首选方法

创建并初始化数组

arrayName =new type[]{element1,element2,element3.....};   //静态初始化，显示指定数组每个元素的初始值，由系统决定数组的长度
arrayName =new type[length];                              //动态初始化，只指定数组的长度，由系统为数组分配默认初始值

注意：

1、不能同时使用静态初始化和动态初始化

arrayName =new type[length]{element1,element2,element3.....};   //error

2、静态初始化的简化

arrayName ={element1,element2,element3.....};

实例：

int[] arr=new int[]{1,2,3};  //静态初始化
int[] arr2={1,2,3};          //简化的静态初始化
int[] arr3=new int[3];       //动态初始化

数组作为函数的参数

下面的例子是一个打印int数组中元素的方法

public static void printArray(int[] array)
 {
    for (int i = 0; i < array.length; i++) 
    {
        System.out.print(array[i] + " ");
    }
}

数组作为函数的返回值

下面的例子是一个反转数组的方法

public static int[] reverse(int[] list) 
{
  int[] result = new int[list.length];

  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) 
	{
		result[j] = list[i];
	}
  return result;
}

数组的操作

数组的操作就是引用数组的索引，数组的索引是从0开始的，到length-1为止。通常会用到遍历，下面简单用普通for语句和增强型for语句演示一下。

public class ArrayTest 
{
    public static void main(String[] args) 
    {    
        String[] strings = new String[]{"Hi", "xiaoming"};
        
        for(int i = 0; i < strings.length; i++)
            System.out.println(strings[i]);
        
        for(String string : strings) 
            System.out.println(string);
    }
}

注意：
1、空指针异常：当引用没有指向任何实体，值为null时，该引用还在用于操作。
2、数组角标越界异常：访问到了数组中不存在的角标。

数组的常见应用

1、排序

1）选择排序：内循环结束一次，最值出现在头角标位置上。

public static int[] selectSort1(int[] arr)
	{
		for (int i=0;i<arr.length-1 ;i++ )
		{
			for (int j=i+1;j<arr.length ;j++ )
			{
				if (arr[i]>arr[j])
				{
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
		return arr;
	}

选择排序的优化，每次比较后不直接交换。待确定最小值后再交换

public static int[] selectSort2(int[] arr)
	{
		int min=0;
		for (int i=0;i<arr.length-1 ;i++ )
		{
			for (int j=i+1;j<arr.length ;j++ )
			{
				if (arr[min]>arr[j])
					min=j;
			}
			int temp=arr[i];
			arr[i]=arr[min];
			arr[min]=temp;
			min=i+1;
		}	
		return arr;
	}

2）冒泡排序：内循环结束一次，最值出现在尾角标位置上。

public static int[] bubbleSort(int[] arr)
	{
		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])
				{
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		return arr;
	}

最快排序：希尔排序

Java已经提供的排序方法：Arrays.sort();

2、查找

1）遍历查找

获取目标值key第一次出现在数组中的位置。若返回值为-1，则代表该值key在数组中不存在。

public static int getIndex(int[] arr,int key)
{
    for(int x=0;x<arr.length;x++)
    {
        if(arr[x]==key)
            return x;
    }
    return -1;
}

2）折半查找

提高效率，但是必须保证该数组是有序的。

折半查找的两种形式：

public static int halfSearch1(int[] arr,int key)
	{
		int min=0;
		int max=arr.length-1;
		int mid=(min+max)/2;
		while (arr[mid]!=key)
		{
			if(arr[mid]>key)
				max=mid-1;
			else
				min=mid+1;
			if(min>max)
				return -1;
			mid=(min+max)/2;
		}
		return mid;
	}

public static int halfSearch2(int[] arr,int key)
	{
		int min=0;
		int max=arr.length-1;
		int mid;
		while (min<=max)
		{
			mid=(min+max)/2;
			if(arr[mid]==key)
				return mid;
			else if(arr[mid]>key)
				max=mid-1;
			else
				min=mid+1;
		}
		return -1;
	}

进一步的推广应用：

有一个有序的数组，想要将一个元素插入到该数组中。保证该数组是有序的。

public static int insertChar(int[] arr,int key)
	{
		int min=0;
		int max=arr.length-1;
		int mid;
		while (min<=max)
		{
			mid=(min+max)/2;
			if(arr[mid]==key)
				return mid;
			else if(arr[mid]>key)
				max=mid-1;
			else
				min=mid+1;
		}
		return -min;
	}

3、进制转换

查表实现进制转换

public static void systemConversion2(int num,int system)
	{
		int base,offset;
		char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
		char[] des=new char[32];
		int pos=des.length;
		if (system==2)
		{
			base=1;
			offset=1;
		}
		else if (system==8)
		{
			base=7;
			offset=3;
		}
		else
		{
			base=15;
			offset=4;
		}
		while (num!=0)
		{
			int temp=num&base;
			des[--pos]=chs[temp];
			num=num>>>offset;
		}
		for (int i=pos;i<des.length ;i++ )
		{
			System.out.print(des[i]+" ");
		}
		System.out.println();
	}

}

Arrays类

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

给数组赋值：通过fill方法。
对数组排序：通过sort方法,按升序。
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。