4[1].1Java数组

4.1 Java数组一、 一维数组1.基本概念：（1）数组：数组是有序数据的集合2）数组元素：数组名和下标来唯一地确定数组中的元素数组元素的下标从0开始）（3）数组长度：数组对象所包含的元素个数2．一维数组的声明在Java中，一维数组的定义形式为：数组元素类型 数组名[ ]；或 数组元素类型 [ ] 数组名；例如 char [] c;Char c[];也可以在一条语句中声明多个数组变量：（一般不提倡使用）Char [] a,b,c;Char a[],b[],c[];但 char a[],b,c;中a是数组变量，而b和c不是3. Java中数组对象的创建（两种形式）（1）使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素的个数]；例如：public class TestNew  {   public static void main(String args[]) {           int [] s ;           int i ;           s = new int[5] ;           for(i = 0 ; i < 5 ; i++) {               s[i] = i ;           }           for(i = 4 ; i >= 0 ; i--) {               System.out.println(" " + s[i]) ;           }       }   } （2）数组的初始化语句创建数组对象数组元素的数据类型[] 变量名={数组元素1，数组元素2，…,数组元素n};或：数组元素的数据类型 变量名[] ={数组元素1，数组元素2，…,数组元素n};例如：char [] c={‘a’，‘b’，‘c’，‘d’，‘e’}初始化：1）静态初始化：在定义数组的同时就为数组元素分配空间并赋值； 2）动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；3）默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化。

数组元素的数据类型是引用型（即类、接口或数组类型）时，数组名[下标]的值是引用在没有给它赋值前，其默认的值为null因此还需要通过new运算符及赋值语句给它们分别赋值例如：String s[]=new String[3];S[0]=new String(“abc”);S[1]=new String(“def”);S[2]=new String(“gh”);上面的四条语句还可以简化成一个数组的初始化语句：String s[]={new String(“abc”), new String(“def”), new String(“gh”)};//变量s是一个数组对象的引用，执行初始化以后，该数组的三个元素分别指向三个不同的字符串对象程序举例：public class TestD{public static void main(String args[]) { int a[] ; a = new int[3] ; a[0] = 0 ; a[1] = 1 ; a[2] = 2 ; for(int i=0;i<3;i++) System.out.print(" "+a[i]); System.out.println(); Date days[] ; days = new Date[3] ; days[0] = new Date(2008,4,5) ; days[1] = new Date(2008,2,31) ; days[2] = new Date(2008,4,4) ; for(int i=0;i<3;i++) { System.out.print(days[i].year); System.out.print("."+days[i].month); System.out.print("."+days[i].day); System.out.println(); }}}class Date{ int year,month,day ; Date(int year ,int month ,int day) { this.year = year ; this.month = month ; this.day = day ; }}程序输出：0 1 22008.4.52008.2.312008.4.4静态初始化举例：public class TestS     {        public static void main(String args[]) {              int a[] = {0,1,2} ;              Time times [] = {new Time(19,42,42),new Time(1,23,54),new Time(5,3,2)} ;          }     }      class Time     {          int hour,min,sec ;          Time(int hour ,int min ,int sec) {              this.hour = hour ;              this.min = min ;              this.sec = sec ;          }     }    4．一维数组元素的引用• 只有完成了对所有数组元素的创建和初始化工作之后，才可以在程序中引用数组元素、修改其属性和调用其方法。

• Java中数组元素的引用是通过数组下标来实现的，其引用方式为：• 数组名[数组下标]• 其中数组下标可以为整型常数或表达式，下标从0开始，到数组元素个数值减1为止每个数组都有一个属性length来指明它的长度，即数组元素的个数例：//一维数组定义与输出class  shuzu{ public static void main(String[] args)  {  int stu[]=new int[]{1,2,3};   //方法一  //int stu[]={1,2,3};                 方法二  //int []stu=new int[]{1,2,3};  方法三  //int[] stu={1,2,3};                方法四  for(int i=0;ia[i+1]){ hold=a[i]; a[i]=a[i+1]; a[i+1]=hold; } printArray(a); } } //打印数组的方法 public static void printArray(int b[]){ for(int i=0;i

排序算法即解决以下问题的算法： 输入：n个数的序列 输出：原序列的一个重排；使得a1*<=a2*<=a3*<=...<=an*1.选择排序每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完 基本思想　　n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果： 　　①初始状态：无序区为R[1..n]，有序区为空 　　②第1趟排序 　　在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区 　　…… 　　③第i趟排序 　　第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区 这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

例如：初始关键字 [49 38 65 97 76 13 27 49] 　　第一趟排序后 13 [38 65 97 76 49 27 49] 　　第二趟排序后 13 27 [65 97 76 49 38 49] 　　第三趟排序后 13 27 38 [97 76 49 65 49] 　　第四趟排序后 13 27 38 49 [76 97 65 49 ] 　　第五趟排序后 13 27 38 49 49 [97 65 76] 　　第六趟排序后 13 27 38 49 49 65 [97 76] 　　第七趟排序后 13 27 38 49 49 65 76 [97] 最后排序结果 13 27 38 49 49 65 76 97public class selectsort{ public static void main(String[] args){ int[] arr={2,345,111,1,34,5}; int temp=0; int min=0; for(int i=0;iarr[j]) min=j; } temp=arr[min]; arr[min]=arr[i]; arr[i]=temp; } System.out.println("排序后的数组为:"); for (int i=0;i

即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后至此第一趟结束，将最大的数放到了最后在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）如此下去，重复以上过程，直至最终完成排序 由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序用二重循环实现，外循环变量设为i，内循环变量设为j假如有10个数需要进行排序，则外循环重复9次，内循环依次重复9，8，...，1次每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i,j的值依次为1,2,...10-i程序：public class maopaosort { public static void main(String[] args){ int[] arr={2,345,111,1,34,5}; int temp=0; for(int i=0;iarr[j+1]) {temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } System.out.println("排序后的数组为:"); for (int k=0;k

是稳定的排序方法插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素在第一部分排序后，再把这个最后元素插入到此刻已是有序的第一部分里的位置基本思想:　　将n个元素的数列分为已有序和无序两个部分，如插入排序过程示例： 　　{{a1}，{a2，a3，a4，…，an}} 　　{{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}} 　　… 　　{{a1(n-1），a2(n-1) ，…},{an(n-1)}} 每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，找出插入位置，将该元素插入到有序数列的合适位置中具体算法描述如下： 　　⒈ 从第一个元素开始，该元素可以认为已经被排序 　　⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描 　　⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置 　　⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 　　⒌ 将新元素插入到下一位置中 ⒍ 重复步骤2public class InsertSort{ public static int[] a={5,8,11,6,77,33,13,99,24,37}; public static void main(String args[]) { int i; // 循环计数变量 int Index = a.length;// 数据索引变量 System.out.print("排序前: "); for (i = 0; i < Index ; i++) System.out.print(" " + a[i] + " "); System.out.println(""); InsertSort(a); // 选择排序 // 排序后结果 System.out.print("排序后: "); for (i = 0; i < Index ; i++) System.out.print(" " + a[i] + " "); System.out.println(""); } public static void InsertSort(int b[]) { int i, j, k; // 循环计数变量 int InsertNode; // 欲插入数据变量 for (i = 1; i < b.length; i++) // 依序插入数值 { InsertNode = a[i]; // 设定欲插入的数值 j = i - 1; // 欲插入数组的开始位置 // 找适当的插入位置 while (j >= 0 && InsertNode < a[j]) { a[j + 1] = a[j]; j--; } a[j + 1] = InsertNode; // 将数值插入 // 打印目前排序结果 System.out.print("排序中: "); for (k = 0; k < a.length; k++) System.out.print(" " + a[k] + " "); System.out.println(""); } }}4.快速排序基本思想：    设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：①分解：     在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。

  注意：    划分的关键是要求出基准记录所在的位置pivotpos划分的结果可以简单地表示为(注意pivot=R[pivotpos])：    　R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys              其中low≤pivotpos≤high②求解：   通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序③组合：   因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序对快速排序而言，"组合"步骤无须做什么，可看作是空操作快速排序算法QuickSortvoid QuickSort(SeqList R，int low，int high)   { //对R[low..high]快速排序     int pivotpos； //划分后的基准记录的位置     if(low=key) hight--; sortArray[low] = sortArray[hight]; while(low

例如：• int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};3．二维数组元素的引用• 与一维数组相同，二维数组元素可以通过指定数组元素下标的方式进行引用• 对二维数组中的每个元素，引用方式为：数组名[index1][index2]• 需要注意的是：在数组的每一维中，数组元素的编号均从0开始，到该维的数组元素个数减1结束//二维数组定义与输出class erwshzu{ public static void main(String args[]) {  //int [][] num=new int[][]{{1,2,3},{4,5,6}};     方法一  int [][] num={{1,2,3},{4,5,6}};                      //方法二  for (int i=0;i

2．创建数组对象的三种形式：（1）直接创建多维数组New 数组元素的数据类型 [第n维元素个数][第(n-1)维元素个数]…[第1维元素个数]; 例如 int matrix;Matrix=new int [2][2]；//数组matrix的元素是2，并且数组matrix的每一个元素都是包含2个元素的一维数组2）从高维开始逐维创建数组对象例如 int [] [] [] matrix3d ;Matrix3d=new int [3][][] ;Matrix3d[0]=new int [2][];Matrix3d[1]=new int [3][];Matrix3d[2]=new int [2][];Matrix3d[0][0]=new int [2];Matrix3d[0][1]=new int [3];Matrix3d[1][0]=new int [4];Matrix3d[1][1]=new int [5];Matrix3d[1][2]=new int [7];Matrix3d[2][0]=new int [2];Matrix3d[2][1]=new int [3];int matrix;Matrix=new int [2][2]；上面的等价创建：Matrix=new[2][] ;Matrix[0]=new[2] ;Matrix[1]=new[2] ;(3)采用数组初始化语句创建数组对象数组元素的数据类型 [] 变量名={数组元素1，数组元素2，...数组元素n} ;或 数组元素的数据类型变量名 []={数组元素1，数组元素2，...数组元素n} ;例如：Int [][] matrix={{1,2},{3,4}} ;String [][] matrixstring={{new String(“abcd”), new String(“efg”)}, {new String(“hi”), new String(“j”)}};3.多维数组的访问格式：数组名[第n维元素下标][ 第（n-1）维元素下标]…[第1维元素下标]；综合举例：“和为15的棋盘游戏“（”1-9“数字不重复地填入3*3的方格，使行、列、两对角线的和均为15，得出游戏的所有解）（p129）public class grid15{ int [][]array=new int[3][3]; int count = 1; public void showgrid() { int i,j; for(i=0;i{2,6,5,1,3} 如:  int[] arr = { 3, 1, 5, 6, 2 };  for (int start = 0, end = arr.length - 1; start < end; start++, end--) {   int temp = arr[start];   arr[start] = arr[end];   arr[end] = temp;  } 5.数据查找 一般查询都利用循环遍历来匹配,不过java提供好的一个进行二分法查找的功能。

java.util.Arrays.binarySearch(arr[],key),如果查找到了就返回下标值,否则就返回一个负数 如：  int[] arr = { 2, 4, 5, 7, 8, 19, 32, 45 };  int x = Arrays.binarySearch(arr, 5); // 开发时使用这个  System.out.println(x); //输出:2  6.数据插入 有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的如何获取该元素在数组中的位置7．二维数组实现矩阵乘法/** * 两 个 矩 阵 Am¡Á n、 Bn¡Á l相 乘 得 到 Cm¡Á l, * 每 个 元 素 Cij = aik*bkj (i=1..m,n=1..n) */public class MatrixMultiply {    public static void main(String args[]) {       int i, j, k;       int a[][] = new int[2][3];       int b[][] = { { 1, 5, 2, 8 }, { 5, 9, 10, -3 }, { 2, 7, -5, -18 } };       int c[][] = new int[2][4];              for (i = 0; i < 2; i++)//行           for (j = 0; j < 3; j++)//列              a[i][j] = (i + 1) * (j + 2);              for (i = 0; i < 2; i++) {//行           for (j = 0; j < 4; j++) {//列              c[i][j] = 0;              for (k = 0; k < 3; k++)                  c[i][j] += a[i][k] * b[k][j];           }       }              System.out.println("\n*** Matrix A ***");       for (i = 0; i < 2; i++) {           for (j = 0; j < 3; j++)              System.out.print(a[i][j] + " ");           System.out.println();       }       System.out.println("\n*** Matrix B ***");       for (i = 0; i < 3; i++) {           for (j = 0; j < 4; j++)               System.out.print(b[i][j] + " ");           System.out.println();       }       System.out.println("\n*** Matrix C ***");       for (i = 0; i < 2; i++) {           for (j = 0; j < 4; j++)              System.out.print(c[i][j] + " ");           System.out.println();       }    }}。