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