java中的数组

1.声明数组:

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  //  works but not preferred way.

注：风格 dataType[] arrayRefVar 是首选的。风格 dataType arrayRefVar[] 来自于C/C++语言，并采用了在Java中容纳C/C++编程。

例子：

下面的代码片段是这种语法的例子：

double[] myList;         // preferred way.
or
double myList[];         //  works but not preferred way.

2.创建数组:

可以通过使用new运算符使用以下语法创建一个数组：

arrayRefVar = new dataType[arraySize];

上面的语句做了两件事：

• 它创建一个数组使用 new dataType[arraySize];

• 它分配新创建的数组变量 arrayRefVar 的引用。

声明数组变量，建立一个数组，并分配阵列的参考变量可以在一个语句中被组合，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

另外，可以创建数组，如下所示：

dataType[] arrayRefVar = {value0, value1, ..., valuek};

数组元素通过索引访问。数组的下标是从0开始的，也就是说，它们从0开始到 arrayRefVar.length-1.

例子：

下面的语句声明一个数组变量 myList，创建 double 类型10个元素的数组，并把它的引用到 myList ：

double[] myList = new double[10];

以下图片代表数组 myList。在这里，myList 有10个 double 值，索引是从0到9。

处理数组：

当处理数组元素，经常使用的是loop循环或foreach循环，因为所有的对数组中的元素是相同类型和数组的大小是已知的。

例子：

下面是一个演示如何创建，初始化和处理数组的完整例子：

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

这将产生以下结果:

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

foreach循环：

JDK 1.5 引入了一个新的 for循环被称为foreach循环或增强的for循环，它无需使用一个索引变量来遍历数组的顺序完成。

例子：

下面的代码显示遍历数组myList 中的所有元素：

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

这将产生以下结果:

1.9
2.9
3.4
3.5

将数组传递给方法：

正如传递基本类型值的方法，也可以将数组传递给方法。例如，下面的方法显示在一个int数组中的元素：

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

可以通过传递数组调用它。例如，下面的语句调用方法PrintArray 显示3，1，2，6，4，2：

printArray(new int[]{3, 1, 2, 6, 4, 2});

返回一个数组的一个方法：

方法也可以返回一个数组。例如，下面所示的方法返回一个数组，它是另一个数组的反转：

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;
}

Arrays 类:

java.util.Arrays中的类包含各种静态方法用于排序和搜索数组，数组的比较和填充数组元素。这些方法被重载的所有基本类型。

SN	方法和描述
1	public static int binarySearch(Object[] a, Object key) 搜索对象的指定数组（字节，整数，双精度等）使用二进制搜索算法来指定值。该数组必须在进行此调用之前对分类。这将返回索引搜索关键字，如果它被包含在列表 (-(insertion point + 1).
2	public static boolean equals(long[] a, long[] a2) 如果多头的两个指定数组彼此相等返回true。两个数组认为是相等判定方法：如果两个数组包含相同的元素数目，并在两个数组元素的所有相应对相等。如果两个数组相等，返回true。同样的方法可以用于所有其它的原始数据类型 (Byte, short, Int, etc.)
3	public static void fill(int[] a, int val) 将指定的int值到指定的int型数组中的每个元素。同样的方法可以用于所有其它的原始数据类型(Byte, short, Int etc.)
4	public static void sort(Object[] a) 排序对象指定的数组升序排列，根据其元素的自然顺序。同样的方法可以用于所有其它的原始数据类型( Byte, short, Int, etc.)

数组中常见的问题

面试题

1.数组中的最值

/*
*
* 求数组中的最值
*/
public class ArrayDemo2
{
	public static void main(String[] args)
	{
		int[] x = {1,9,8,5,6,3};
		int max = getMax(x);
		System.out.println(max);
	}
	
	
	public static int getMax(int[] arr)
	{
		//定义变量记录较大的值
		int max =arr[0];
		for(int x=0; x<arr.length; x++)
		{
			if(arr[x]>max)
			{
				max=arr[x];
			}
		}
		
		return max;
	}
	
	//或者记录最值下标
	// public static int getMax(int[] arr)
	// {
		
		// int maxindex = 0;
		// for(int x=1; x<arr.length; x++)
		// {
			// if(arr[x] > arr[maxindex])
			// {
				// maxindex = x;
			// }
				
		// }
		
		// return  arr[maxindex];
	// }	
	
}

2.排序

（1）import java.util.Arrays;

int[ ] a= {3, 8, 5 , 6};

Arrys.sort(a); //3 5 6 8

Arrys.sort(a,0,2) //3 5 8 6

（2）选择排序

//选择排序

public class SortDemo
{
	public static void main(String[] args)
	{
		int[] x={1,6,9,87,12};
		
		//输出排序前的数组
		System.out.print("排序前：");
		for(int i:x)
		{
			System.out.print(i + " ");
	
		}
		
		selectSort(x);  //进行排序
		
		//输出排序后的数组
		System.out.println();
		System.out.print("排序后：");
		for(int i:x)
		{
			System.out .print(i + " ");
		}
		
		
	}
	
	//功能：选择排序
	// public static void selectSort(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])
				// {
					// swap(arr,i,j);
				// }
				
			// }
			
		// }
	// }
	
	//高效点的选择排序
	public static void selectSort(int[] arr)
	{
		for(int i=0; i<arr.length-1; i++)
		{
			int flag = i;                 //记录最小值下标
			
			for(int j=i+1; j<arr.length;j++)
			{
				if(arr[i]>arr[j])
				{
					flag = j;
				}
			}
			
			if(i!=flag)
			{
				swap(arr, i,flag);
			}
			
			
		}
	}
	
	//功能：交换
	public static void swap(int[] arr, int x, int y)
	{
		int temp;
		temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
	

（3）冒泡排序

//冒泡排序

public class SortDemo2
{
	public static void main(String[] args)
	{
		int[] x={1, 5, 6, 9, 2, 7};
		System.out.print("排序前：");
		for(int i:x)
		{
			System.out.print(i + " ");
		}
		
		bubbleSortAdvanced2(x);
		
		System.out.println();
		System.out.print("排序后：");
		for(int i:x)
		{
			System.out.print(i + " ");
		}
		
	}
	
	
	// //普通的冒泡排序
	// public static void 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])
				// {
					// swap(arr, j ,j+1);
				// }
				
			// }
		// }
	// }	
	
	
	//改进的冒泡排序
	/*
	public static void  bubbleSort(int[] arr)
	{
		int flag=1;
		
		for(int i=0; i<arr.length-1; i++)
		{
			flag = 0;
			for(int j=0; j<arr.length-1-i; j++)
			{
					
				if(arr[j] > arr[j+1])
				{
					swap(arr, j, j+1);
					flag=1;
				}				
			}	
			if(flag==0)
			{
				break;
			}
				
		}
		
	}
	*/
	
	
	 /**
	 *同上
     * 改进的冒泡法
     * 改进之处在于：设一个标志位，如果某趟跑下来，没有发生交换，说明已经排好了；
     *
	 */
	 /*
	 public static void bubbleSortAdvanced(int[] a){  
        int k = a.length-1;  
        boolean flag = true;  
        while(flag)
		{  
            flag = false;  
            for(int i=0;i<k;i++)
			{  
                if(a[i]>a[i+1])
				{  
                    int tmp = a[i];  
                    a[i] = a[i+1];  
                    a[i+1] = tmp;  
                    //有交换则继续保持标志位；  
                    flag = true;  
                }  
            }  
            k--;  
        }  
    }  
     */
	 
	 /** 
     * 改进的冒泡法2<br> 
     * 改进之处在于吸收上面的思想(没有交换意味着已经有序)，如果局部的已经是有序的，则后续的比较就不需要再比较他们了。<br> 
     * 比如：3142 5678，假如刚刚做完了2和4交换之后，发现这趟比较后续再也没有发生交换，则后续的比较只需要比到4即可；<br> 
     * 该算法就是用一个标志位记录某趟最后发生比较的地点；<br> 
     */  
    public static void bubbleSortAdvanced2(int[] a){  
        int flag = a.length - 1;  
        int k;  
        while(flag>0)
		{  
            k = flag;  
            flag = 0;  
            for(int i=0; i<k; i++)
			{  
                if(a[i] > a[i+1])
				{  
                    int tmp = a[i];  
                    a[i] = a[i+1];  
                    a[i+1] = tmp;  
                    //有交换则记录该趟最后发生比较的地点；  
                    flag = i+1;  
                }  
            }  
        }  
    }  
	
	public static void swap(int[] arr, int x, int y)
	{
		int temp;
		temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

3.折半查找

public class SelectDemo
{
	public static void main(String[] agrs)
	{
		int[] a1 = {1, 56, 98, 2, 65, 48};
		int[] a2 = {1, 2, 48, 56, 65, 98};    //排好序的数组
		int ret1 = getIndex(a1, 65);
		int ret2 = binarySearch(a2, 65);
		int ret3 = binarySearch2(a2, 65);
		System.out.println("Index1=" + ret1);
		System.out.println("Index2=" + ret2);
		System.out.println("Intex3=" + ret3);
	}
	

	
	//普通查找	
	public static int getIndex(int[] a, int key)
	{
		for(int i=0; i<a.length; i++)
		{
			if(a[i]==key)
			{
				return i;
			}
		}
		
		return -1;
	}
	
	
	//折半查找（前提是排好顺序的数组）
	public static int binarySearch(int[] arr, int key)
	{
		int low,high,mid;
		low = 0;
		high = arr.length - 1;
		mid = (low + high)/2;
		
		while(arr[mid]!=key)
		{
			if(key>arr[mid])
			{
				low = mid + 1;
			}
			else if(key<arr[mid])
			{
				high = mid - 1;
			}
			
			if(high<low)
			{
				return -1;
			}
			
			mid = (high + low)/2;
			
		}
		return mid;
	}
	
	
	//改进的折半查找
	public static int binarySearch2(int[] arr, int key)
	{
		int low, high, mid;
		low = 0;
		high = arr.length - 1;
		while(low <= high)
		{
			mid = (low + high)>>1;
			if(key > arr[mid])
			{
				low = mid + 1;
			}
			else if(key < arr[mid])
			{
				high = mid -1;
			}
			else
			{
				return mid;
			}
		}
		
		return -1;
	}
	
	
}