黑马程序员——Java数组相关知识

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

数组是多个具有相同数据类型对象的集合，当要操作多个相同类型的元素时，数组就有了用武之地。数组中的元素是通过下标来引用的，通过一些循环语句可以方便地操作数组元素，并对其实施统一的管理。

一、数组的初始化

Java数组必须经过初始化后才可以使用，可以通过下面两种方式初始化数组：

静态初始化，就是由程序员显式指定数组中每个元素的初始值，由系统来计算数组的长度
动态初始化，就是程序员只指定数组长度，由系统为数组元素分配初始值，这些初始值是各种形式的零

Java的数组变量是引用类型的变量，它并不是数组对象本身。事实上，数组变量是不需要初始化的，真正要初始化的是数组变量所引用的数组对象。基本类型数组的初始化比较简单，其初始化时，由系统直接在堆中为数组分配内存，然后将数组元素的值存入对应的内存中；由于引用型数组的数组元素还是引用类型的，所以数组元素中存储的还是引用值。

虽然可以定义多维数组，但是Java中没有真正的多维数组，有的只是数组的数组，也就是说数组的元素类型仍然是数组，通过这种方式可以定义n维数组。

二、与数组操作的相关函数

1 System.arraycopy():

原型 public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length )

功能从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组指定的位置结束。

扫描二维码关注公众号，回复： 3436360 查看本文章

2 Arrays.sort():

对某种指定类型的数组按升序排序。

三、自定义操作数组的工具类和工具函数

1 求数组的最大值和最小值

class ArrayTest 
{
     public static int getMax(int[] arr)
	{
		int max = arr[0];

		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]>max)
				max = arr[x];
		}
		return max;
	}

public static int getMin(int[] arr)
	{
		int min = 0;
		for(int x=1; x<arr.length; x++)
		{
			if(arr[x]<arr[min])
				min = x;
		}
		return arr[min];
	}
}

2 数组元素反转

import java.util.*;


public class Revease
{
	public static void revease(DataWrap[] dw)
	{
		int arrayLength = dw.length;
		for(int i=0,j=arrayLength-1;i<arrayLength/2;i++,j--)
		{
			Sort.swap(dw,i,j);
		}
		System.out.println("反转后的数据：\n"+Arrays.toString(dw));

	}
	public static void main(String[] args)
	{
		DataWrap[] dw = new DataWrap[6];
		dw[0] = new DataWrap(21,"");
		dw[1] = new DataWrap(30,"");
		dw[2] = new DataWrap(49,"");
		dw[3] = new DataWrap(30,"*");
		dw[4] = new DataWrap(16,"");
		dw[5] = new DataWrap(9,"");

		System.out.println("反转前的数据：\n"+Arrays.toString(dw));
		revease(dw);


	}
}

运行结果：

反转前的数据：
[21, 30, 49, 30*, 16, 9]
反转后的数据：
[9, 16, 30*, 49, 30, 21]

3 选择排序和冒泡排序的实现

import java.util.*;
class DataWrap
{
	private int data;
	private String s;

	public DataWrap(int data,String s)
	{
		this.data = data;
		this.s = s;
	}
	
	public int compareTo(DataWrap dw)
	{
		return this.data > dw.data?1:(this.data==dw.data?0:-1);
	}

	public String toString()
	{
		return data+s;
	}

}

public class Sort
{
	public static void selectSort(DataWrap[] dw)
	{
		System.out.println("开始排序");
		for(int i=0;i<dw.length-1;i++)
		{
			int minIndex = i;
			for(int j=i+1;j<dw.length;j++)
			{
				if(dw[i].compareTo(dw[j])>0)
					minIndex = j;
				if(minIndex!=i)
				{
					//DataWrap temp = dw[i];
					//dw[i] = dw[j];
					//dw[j] = temp;
					swap(dw,minIndex,i);
				}
				
		    }
			System.out.println("第"+(i+1)+"趟："+Arrays.toString(dw));
	
		}
		System.out.print("最终结果："+Arrays.toString(dw));
	}

	public static void bubbleSort(DataWrap[] dw)
	{
		int arrayLength = dw.length; 
		for(int i =0;i<arrayLength-1;i++)
		{
			boolean flag = false;
			for(int j=0;j<arrayLength-i-1;j++)
			{
				if(dw[j].compareTo(dw[j+1])>0)
				{
					swap(dw,j,j+1);
					flag = true;
				}

			}
			System.out.println("第"+(i+1)+"趟："+Arrays.toString(dw));
			if(!flag)
			{
				break;
			}
		}
		System.out.println("最终结果："+Arrays.toString(dw));
	}

	public static void swap(DataWrap[] arr,int i,int j)
	{
		DataWrap temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	public static void main(String[] args)
	{
		DataWrap[] dw = new DataWrap[6];
		dw[0] = new DataWrap(21,"");
		dw[1] = new DataWrap(30,"");
		dw[2] = new DataWrap(49,"");
		dw[3] = new DataWrap(30,"*");
		dw[4] = new DataWrap(16,"");
		dw[5] = new DataWrap(9,"");

		System.out.println("排序前的数据：\n"+Arrays.toString(dw));
		//selectSort(dw);
		 bubbleSort(dw);

	}


}

运行结果：

排序前的数据：
[21, 30, 49, 30*, 16, 9]
第1趟：[21, 30, 30*, 16, 9, 49]
第2趟：[21, 30, 16, 9, 30*, 49]
第3趟：[21, 16, 9, 30, 30*, 49]
第4趟：[16, 9, 21, 30, 30*, 49]
第5趟：[9, 16, 21, 30, 30*, 49]
最终结果：[9, 16, 21, 30, 30*, 49]