黑马程序员--数组

-------Android培训、Java培训、期待与您交流！ ----------

数组基本概念：

数组是用来存储一组相同数据类型数据的数据结构。
数组也是一种引用类型。
数组的元素可以是简单类型的数据，也可以是引用类型的数据。
数组有一个对应的索引，可以通过索引访问数组中的每个元素
数组被创建好之后，它的大小是不能改变的，但是数组中的各个元素是可以被改变的

一维数组定义

数组的声明方式有两种：
type[] arr_name;
type arr_name[];
在数组定义中，不能指定数组的长度，而需要在数组的创建阶段来指定
几个例子：
int[] array;  // 声明了一个int的数组
float b[];
String c[];
Date []  d;
Student stus [];

数组的创建

在声明数组时不能指定数组的大小，也没有给数组分配存储数据的内存空间
通过new操作符来创建数组对象，指定数组的大小，给数组元素的存储分配空间
   例如： int [] a ;
                a = new int[100];

数组的初始化

在创建成功一个数组之后,它将完成如下三个动作:
    1.  创建一个数组对象
    2.  在内存中给数组分配存储空间
    3.  给数组的元素初始化一个相应的数据类型的默认值.
    例如:
      int[] intArray = new int[10];;
      System.out.println("第一个元素默认初始化值是："+intArray[0]);

在创建完数组后，可以对数组进行初始化，也就是给数组的各个元素进行赋值。
可以采用两种方式为数组进行初始化：
静态初始化

在数组定义的同时，对数组进行初始化
    例如:
     int a[] = {1,3,5,7,9,11};
     String s [] = {“a”,”b”,”c”};
     代码参见:案例5-3 数组的静态初始化
     注意:
     1. 数组的大小有大扩号里的元素的个数决定
     2. 数组在声明不能指定大小
利用这种方式进行数组的初始化，其实完成了三步动作：
数组声明
数组创建
数组初始化

动态初始化

所谓数组的动态初始化，就是将数组的定义和数组的初始化分开来进行
例子：
      int a [] = new int[3];
      a[0] = 1;
      a[1] = 10;
      a[2] = 100;
      或者:
  int[] a;
  a = new int[10];
  for (int i = 0;i<10;i++) {
     a[i] = 2*i+1;
  } 

数组元素的引用

通过数组名和数组索引来引用一个数组中的元素，数组的索引从0开始到数组长度减1，如arr[0]表示数组arr中的第1个元素，数组的第二个元素为arr[1]等。
可以使用数组的一个属性length来获得数组的长度。
元素的索引必须小于数组的长度,否则会产生数组越界异常

一维数组的应用举例

利用一维数组来进行冒泡排序：
对几个无序的数字进行排序，最常用的方法是所谓的冒泡排序法。这种方法每次比较两个相邻的数，将较小的放到前面，较大的放到后面，这样就可以将这些数中的最大的找出来访到最后，然后比较剩下的数，再在这些数中找出最大的来，直到所有的数字按照从小到大的顺序排列
可以用一个一维数组来存放这些需要进行排序的数字，然后对这个一维数组进行排序
例子：

 

package heima;
public class bubbleSort{
 static String sortArray(int before[])//用来遍历数组 {  String result="";  for(int i=0;i<before.length;i++)  {   result+=before[i]+" ";  //元素逐个读取  }  return result; }  static int[] bubbleSort(int before[])//冒泡方法  {  int t;  for (int i=0;i<before.length;i++)  {   for(int j=0;j<before.length-i-1;j++)   {    if (before[j]>before[j+1])//冒泡就是两个相邻元素比较    {     t=before[j];//换位置     before[j]=before[j+1];     before[j+1]=t;    }   }     } return before; }  public static void main(String args[]) {  int a[]={12,43,23,56,8,22,65,87};  System.out.println("排序之前:"+sortArray(a));  a=bubbleSort(a);  System.out.println("排序之后:"+sortArray(a)); }}

 

数组拷贝

可以将一个数组变量拷贝给另一个数组变量，这个时候，这两个数组变量均指向相同的数组。通过任何一个变量对数组进行操作,都会影响数组的内容

public class ArrayCopy1 {
public static void main(String[] args) {
        int [] array1 =  
                     {2,3,4,57,8,9};
        int [] array2 = array1;       
        for(int i = 0;i<array2.length;i++) {
        array2[i] = array2[i]*10;
        }      
        for(int i : array1) {
        System.out.println(i);
        }       
        for(int i : array2) {
        System.out.println(i);
        }      
}
}

多维数组（con.）

在知道数组元素的情况下，可以直接初始化数组，不必调用new来创建数组，这和一维数组的静态初始化类似
int[][] a = {{1,2},{10,2},{20,1}};  //[2][3]

除了静态初始化外，多维数组也可以通过数组声明和初始化分开的动态初始化方法来对数组进行初始化
 int a[][] = new int[4][5];
 int b[][] = new int[3][]
 b[0] = new int[4];
 b[1] = new int[3];
 b[2] = new int[5];

 

练习：

/*给定一个数组{5,1,6,4,2,8,9}。1，获取数组中的最大值，以及最小值。*/class ArrayTest {/*获取数组中的最大值。思路：1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。通过一个变量进行临储。2，让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该该变量记录较大值。3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。步骤：1，定义变量。初始化为数组中任意一个元素即可。2，通过循环语句对数组进行遍历。3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；需要定义一个功能来完成。以便提高复用性。1，明确结果，数组中的最大元素 int。、2，未知内容：一个数组。int[]*/public static int getMax(int[] arr){int max = arr[0];for(int x=1; x<arr.length; x++){if(arr[x]>max)max = arr[x];}return max;}/*获取最大值的另一种方式。可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。*/public static int getMax_2(int[] arr){int max = 0;for(int x=1; x<arr.length; x++){if(arr[x]>arr[max])max = x;}return arr[max];}/*获取最小值。*/public static int getMin(int[] arr){int min = 0;for(int x=1; x<arr.length; x++){if(arr[x]<arr[min])min = x;}return arr[min];}//获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。/*public static double getMax(double[] arr){}*/public static void main(String[] args){int[] arr ={5,1,6,4,2,8,9};int max = getMax_2(arr);int min = getMin(arr);System.out.println("max="+max);System.out.println("min="+min);//boolean[] ar = new boolean[3];//System.out.println(ar[1]);}}

冒泡排序：

import java.util.*;/*对给定数组进行排序。{5,1,6,4,2,8,9}*/class ArrayTest2 {/*选择排序。内循环结束一次，最值出现头角标位置上。*/public static void selectSort(int[] arr){for (int x=0; x<arr.length-1 ; x++){for(int y=x+1; y<arr.length; y++){if(arr[x]>arr[y]){/*int temp = arr[x];arr[x] = arr[y];arr[y]= temp;*/swap(arr,x,y);}}}}/*冒泡排序*/public static void bubbleSort(int[] arr){for(int x=0; x<arr.length-1; x++){for(int y=0; y<arr.length-x-1; y++)//-x:让每一次比较的元素减少，-1：避免角标越界。{if(arr[y]<arr[y+1]){/*int temp = arr[y];arr[y] = arr[y+1];arr[y+1] = temp;*/swap(arr,y,y+1);}}}}/*发现无论什么排序。都需要对满足条件的元素进行位置置换。所以可以把这部分相同的代码提取出来，单独封装成一个函数。*/public static void swap(int[] arr,int a,int b){int temp = arr[a];arr[a] = arr[b];arr[b] = temp;}public static void main(String[] args){int[] arr = {5,1,6,4,2,8,9};//排序前；printArray(arr);//排序//selectSort(arr);//bubbleSort(arr);//Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。//排序后：printArray(arr);}public static void printArray(int[] arr){System.out.print("[");for(int x=0; x<arr.length; x++){if(x!=arr.length-1)System.out.print(arr[x]+", ");elseSystem.out.println(arr[x]+"]");}}}