众所周知，坐标系有一维、二维、三维，Java中数组也不例外，像一维数组、二维数组，下面就数组来说下相关知识。
先通过简单的案例来熟悉数组：
（1）任务：实现二维数组的行列互换
（2）准备工作：二维数组的初始化、定义
（3）编程：
public class ArrayChange {
public static void main(String[] args) {
//创建二维数组并初始化
int arr[][] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
System.out.println("行列互换前：");
//输出互换前数组
printArr(arr);
//定义相同大小的二维数组
int _arr[][] = new int[arr.length][arr.length];
//互换行列数据
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
_arr[i][j] = arr[j][i];
}
}
System.out.println("行列互换前：");
//输出互换后数组
printArr(_arr);
}
public static void printArr(int[][] arr){
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}（4）运行：可在控制台打印出互换行列前后的数组内容
注意：互换行列数据的原理是把新数组与原数组的行列索引交换进行元素赋值；定义数组变量时，不能声明其长度，只能在使用new关键字创建数组时指定，如int[] arr = new int[9]；还支持静态数组初始化，如int[] arr={1,2,3}；遵守代码重用原则，如上数组的输出函数。
下面通过几种常见的排序算法来进一步熟悉数组的操作：
- 选择排序算法
（1）任务：选择排序算法
（2）准备工作：算法思想：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排序好的数列的最后，直到全部待排序的元素排完。
（3）编程：
import java.util.Random;
/*
* 选择排序算法
*/
public class SelectSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = new int[10];
Random random = new Random();
for(int i=0;i<arr.length;i++){
//生成100以内的随机数并赋值给数组
arr[i] = random.nextInt(100);
}
System.out.println("排序前数组：");
printArr(arr);
int index;
for(int i=1;i<arr.length;i++){
index = 0;
for(int j=1;j<=arr.length-i;j++){
if(arr[j] > arr[index])
index = j;
}
//交换
int temp = arr[arr.length-i];
arr[arr.length-i] = arr[index];
arr[index] = temp;
}
System.out.println("排序后数组：");
printArr(arr);
}
public static void printArr(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}（4）运行：输出排序前后的数组
- 冒泡排序算法
（1）任务：冒泡排序算法
（2）准备工作：算法思想：对比相邻的元素值，若满足条件就交换元素值，把较小的元素移到数组前面，把大的元素移到数组后面，像气泡一样从底部上升到顶部。
（3）编程：
import java.util.Random;
/*
* 冒泡排序算法
*/
public class BubbleSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = new int[10];
Random random = new Random();
for(int i=0;i<arr.length;i++){
//生成100以内的随机数并赋值给数组
arr[i] = random.nextInt(100);
}
System.out.println("排序前数组：");
printArr(arr);
for(int i=1;i<arr.length;i++){
for(int j=0;j<arr.length-i;j++){
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println("排序后数组：");
printArr(arr);
}
public static void printArr(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
（4）运行：输出排序前后的数组
- 快速排序算法
（1）快速排序算法
（2）准备工作：算法思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可递归进行。
（3）编程：
import java.util.Random;
/*
* 快速排序算法
*/
public class QuickSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = new int[10];
Random random = new Random();
for(int i=0;i<arr.length;i++){
//生成100以内的随机数并赋值给数组
arr[i] = random.nextInt(100);
}
System.out.println("排序前数组：");
printArr(arr);
QuickSort(arr,0,arr.length-1);
System.out.println("排序后数组：");
printArr(arr);
}
public static void QuickSort(int arr[],int lowIndex,int highIndex){
//记录最小索引
int low = lowIndex;
//记录最大索引
int high = highIndex;
//分界点元素
int mid;
if(highIndex > lowIndex){
//确定中间分界点元素值
mid = arr[(lowIndex+highIndex)/2];
while(low <= high){
//确定不大于分界点元素值的最小索引
while((low <highIndex) && (arr[low] < mid)){
++low;
}
//确定大于分界点元素值的最大索引
while((high > lowIndex) && (arr[high] > mid)){
--high;
}
//若最大索引和最小索引没有重叠，交换索引元素
if(low <= high){
swap(arr,low,high);
++low;
--high;
}
}
//递归排序
if(lowIndex < high){
QuickSort(arr,lowIndex,high);
}
if(highIndex > low){
QuickSort(arr,low,highIndex);
}
}
}
//交换方法
public static void swap(int arr[],int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArr(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
（4）运行：输出排序前后的数组
以上是几种常见的排序算法，各有优劣，下面说下Arrays类提供的sort()方法对数组的排序：
（1）任务：Arrays.sort()排序方法
（2）准备工作：Arrays类位于java.util包，它是数组的一个工具类，包含很多方法
（3）编程：
import java.util.Arrays;
import java.util.Random;
/*
* Arrays.sort()
*/
public class ArraysSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = new int[10];
Random random = new Random();
for(int i=0;i<arr.length;i++){
//生成100以内的随机数并赋值给数组
arr[i] = random.nextInt(100);
}
System.out.println("排序前数组：");
printArr(arr);
Arrays.sort(arr);
System.out.println("排序后数组：");
printArr(arr);
}
public static void printArr(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
（4）运行：输出排序前后的数组
注意：Arrays类提供了创建、操作、搜索、排序的方法，sort()方法有很多重载格式，可以接受任何数据类型的数组并执行不同类型的排序，默认升序排序，上面使用了int参数类型的重载实现。
最后，说下数组在函数可变参数中的使用：
（1）任务：可变参数
（2）准备工作：可变参数是java1.5之后的新特性，可以代表零到多个相同数据类型的变量，是为了解决因参数个数的变化而导致过多的方法重载问题
（3）编程：
public class ParaChange {
public static void main(String[] args) {
// TODO Auto-generated method stub
double sum = add(4,2.1,3.6,5.3);
System.out.println("数组求和为："+sum);
}
public static double add(int a,double...b){
double sum = a;
for(int i=0;i<b.length;i++){
sum += b[i];
}
return sum;
}
}（4）运行：输出数组求和的值
注意：可变参数只能用于形式参数（方法定义时），可以把可变参数当作数组来处理；一个方法在最多只能有一个可变参数，可变参数必须作为最后一个参数；调用带可变参数的方法时，数据类型必须与可变参数的类型对应。
好了，上面通过几个案例已经熟悉了数组的基本使用，这里不再详述了。
