java数组操作简介

java   数组操作

一、概念

数组就是用来存储同一种数据类型,定长的容器 。

类型：引用数据类型。

好处：在数组中可以存储多种类型的数据，数组中也可以存放数组。数组会给存入的数据从0开始编号，建立数组索引，方便对这些数据进行操作。

一维数组语法格式：

1. 动态初始化

数据元素类型 []  数组名 = new 数组元素类型 [数组元素个数]；//int [] x = new int[3]

2. 静态初始化

数组元素类型 [] 数组名 = new 数组元素类型[]{元素1,元素2....}; //int [] x = new int[]{20,30,40}

数组元素类型 [] 数组名 = {元素1,元素2....};//int[] x = {20,30,40}

二维数组语法格式：

1. 动态初始化
  数据类型 数组名[][] = new 数据类型[m][n];
            数据类型 [][] 数组名 = new 数据类型[m][n];
数据类型[] 数组名[] = new 数据类型[m][n];

2. 静态初始化
数据类型 [][] 数组名 = {{元素1，元素2}，{元素1，元素2}，{元素1，元素2}...};

静态初始化和动态初始化的区别：

当确定了元素内容,不确定数组长度， 就用静态初始化.
当确定了数组长度,不确定元素内容,用动态初始化.

二、数组的遍历

一维数组遍历的两种方式：

1. 普通for循环

	for(int i=0;i<x.length;i++)//x.length数组的长度
	{ //i不只是循环条件 还是数组的脚标 从0开始
	 //设定x为数组
	     System.out.print(x[i]+" ");//i代表索引值，可以通过x[i]对数组中的数据进行操作
	}

2. 增强for循环

	for(int i: x)  //i为x数组中的元素不代表脚标
	{
      	     System.out.println(x+",")；//只能进行打印操作，无法修改具体数组中的值
	}

二维数组的遍历方式

	for(int i = 0;i<x.length;i++)//x.length为数组的行数
	{
		for(int j = 0;j<x[i].length;j++)//x[i].length当前行的列数
		{
			System.out.println(x[i]);
		}
	}

三、数组的排序

        //选择排序（从小到大）
	public static int[] xuanze(int [] num)
	{
		int temp = 0;
		for(int i = 0;i<num.length;i++)
		{
			for(int j = i+1;j<num.length;j++)
			{
				if(num[i]>num[j])
				{
					 temp = num[i];
					num[i] = num[j];
					num[j] = temp;
				}
			}
		}
		return num;
	}

       //冒泡排序（从小到大）
	public static int[] maopao(int[] num)
	{
		int temp = 0;
		for(int i = 0;i<num.length;i++)
		{
			for(int j = 0;j<num.length-i-1;j++)//-1防止越界
			{									
				if(num[j]>num[j+1])
				{
					temp = num[j];
					num[j] = num[j+1];
					num[j+1] = temp;
				}
			}
		}
		return num;
	}
       //快排调用
        public static void quickSort(int[] num)
	{
		kuaipai(num,0,num.length-1);
	}
	//快速排序（从小到大）
	public static void kuaipai(int[] num,int head,int tail)
	{
		int i = head;
		int j = tail;
		int p = num[(i+j)/2];
		while(j>=i)
		{
			while(num[i]<p)
			{
				i++;
			}
			while(num[j]>p)
			{
				j--;
			}
			if(i<=j)
			{
				int temp = num[i];
				num[i] = num[j];
				num[j] = temp;
				i++;
				j--;
			}
			if(head<j)
			{
				kuaipai(num,head,j);
			}
			if(i<tail)
			{
				kuaipai(num,i,tail);
			}
		}
	}

四、数组的查找（二分法）

1.  非递归

class Demo_findIndex
{
	public static void main(String[] args) 
	{
		//二分法 需要先排序

		int[] arr = {3,7,5,8,1,6};
		print(arr);
		System.out.print("\r\n-------------\r\n");
		sort(arr);
		print(arr);
		System.out.print("\r\n-------------\r\n");
		int index = findIndex(arr,9);
		System.out.println(index);
	}
	public static void sort(int[] arr){
		for(int i=0;i<arr.length;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;			
				 }
			}
		}
	}
	/*
		二分查表法
			1.返回值类型 int
			2.方法名	findIndex()
			3.参数列表 int[] arr,int value
	*/
	public static int findIndex(int[] arr,int value){
		int start = 0;
		int end = arr.length-1;
		int key = (start+end)/2; 
		while(arr[key] != value){
			if(value<arr[key]){
				end = key-1;
			}else if(value>arr[key]){
				start = key+1;
			}
			if(start>end){
				return -1;
			}
			key = (start+end)/2;
		}
		return key;
		
	}
	public static void print(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+",");
		}
	}
}

2. 递归调用

	//二分查找
	public static int erfen(int[] num,int L,int R,int key)//初始传入值  数组名   0   数组长度  查找数据
	{
		if(L<=R)
		{
			int mid = (L+R)/2;
			if(num[mid] == key)
			{
				return mid;
			}
			else if(num[mid]>key)
			{
				return erfen(num,L,mid,key);
			}else{
				return erfen(num,mid,R,key);
			}
		}
		else
		   return -1;
	}

五、Arrays工具类的常用方法

常用方法:
1.将数组内容转化成字符串的形式输出
Arrays.toString(数组数据类型[] arr);
2.数组排序
Arrays.sort(数组数据类型[] arr);
3.二分法
Arrays.binarySearch(int[] arr,int value);
4.复制指定的数组
Arrays.copyOf(int[] arr,int newlength);//复制给定长度数据[0,newlength）
Arrays.copyOfRange(int[] arr,int from,int to);//复制范围内数据[from,to）
5.判断两个数组是否相等
boolean Arrays.equals(int[] arr1,int[] arr2);

注：该类主要用于一维数组，需要导包  java.util.Arrays