java学习笔记day05 数组

1、一维数组的两种初始化方式

在定义一维数组时，只是声明了一个数组类型的变量，并没有为数组分配实际的内存空间，这需要通过初始化操作来实现。

初始化数组有动态创建和静态创建两种方式。

（1）静态初始化

在定义数组的同时对数组元素进行初始化，例如：

         int[]intArray={4,2,3,1};

（2）动态初始化

使用运算符new为数组分配空间，其格式如下：

type[] arrayName = new type[arraySize];

B、对象类型(需要复习)

Date dataArray[] = new Date[3];

因为 Date 是一个类，所有对象变量的默认值是null，因此所有数组元素的值都是null。

 

如果需要为数组元素赋值，就需要显示的赋值。例如：

dataArray[0]=new Date();       //初始化

dataArray[1]=new Date();       //初始化

dataArray[2]=new Date();       //初始化

2、数组理解

（1）数组是一个对象

（2）同一数组中元素具有相同类型

c、子类对象赋值给父类对象可以自动造型（学习面向对象之后再理解）

在Java中，父类变量可以引用它的不同子类的实例，例如，Person有子类Man、Woman：

         public class Manextends Person {

         }

         public class Womanextends Person {

         }

那么，可以使用Person定义的变量引用下面各种具体的对象：

         Person p1 = newPerson();

         Person p2 = new Man();

         Person p3 = newWoman();

 

可以使用Person类型定义一个数组，其中可以存储Person类本身和它的所有子类。

         Person[] array = newPerson[3];

         array[0] = newPerson();

         array[1] = new Man();

         array[3] = newWoman();

（3）同一数组中存放的数据元素是有序的

（4）一旦创建数组，数组的大小是不可改变的

（5）一维数据的遍历

public class ArrayTest {

   public static voidmain(String args[]) {

                   int i;

                   int a[] =new int[5];

                   for(i=0;i<5; i++) {     从前向后循环，本循环结束后：[0,1,2,3,4]

                      a[i]=i;

                   }

                   //使用for循环的新语法

                   for(int j : a) {              只支持从前向后的顺序在数组中取值。输出：0 1 2 3 4

                            System.out.println(j);

                   }

         }

} 

（6）二维数据的遍历

int[][] intArray = new int[2][]; 

         intArray[0] = new int[3];

         intArray[1] = new int[2]

 

现在遍历如下：

         for(int i = 0; i

                   for(int j =0; j <intArray[i].length; j++) {

                            System.out.print(intArray[i][j]+ ' ');

                   }

                   System.out.println();

         }

         

for(int[] array : intArray) {

                   for(intvalue : array) {

                            System.out.print(value+ ' ');

                   }

                   System.out.println();

         }

三、数组算法和常用工具类/方法

1、常用工具类/方法

（1）数组拷贝

System.arraycopy(src, srcPos, dest, destPos, length)

         将源数组（src）中的数据拷贝到目标数组（dest）中。

         srcPos表示从源数组的那个下标开始拷贝

         destPost表示拷贝数据从目标数组的那个下标开始写

         length表示拷贝的数据个数

 

将 a 中的 38, 65, 65拷贝到 b 中，最终 b 的数据元素是 38, 65, 65, 0, 0, 0

         int[] a = { 49, 38, 65, 65, 65, 65, 65, 97, 76, 13, 27 };

         int[] b = new int[6];

         System.arraycopy(a, 1, b, 0, 3); // 数组拷贝

（2）数组排序

Arrays.sort是JDK提供的排序方法，它默认是使用升序排列。

Collections.reverseOrder()支持实现Comparator的降序，不支持基本类型的降序。

String类是实现了Comparator接口的，因此可以使用Collections.reverseOrder()排降序。

 

整数数组排序，只支持升序，不支持降序

         int[] a = { 49, 38,65, 65, 65, 65, 65, 97, 76, 13, 27 };

         Arrays.sort(a); // 默认排升序

        

字符串等支持Comparator接口的类，则既支持升序，也支持降序

         String[] items = {"z", "f", "a", "C", "f","c", "b" };

         Arrays.sort(items); //升序

         Arrays.sort(items,Collections.reverseOrder()); // 降序

（3）取出数组中最大值

定义一个获取最大值的功能。

 

思路：

1、定义一个变量，记录住数组的比较大的元素。

2、遍历整个数组，让数组的每一个元素都和该变量进行对比即可。

3、当变量遇到比它大的元素，则让该变量记录该元素的值，当循环结束时，最大值产生了

public static int getMax(int[] arr) {

         //定义变量记录较大的值，初始化为数组中的任意一个元素。

         int max = arr[0];

 

         for(int x=1;x

                   if(arr[x]>max){

                            max= arr[x];

                   }

         }

         return max;

}

（4）数组翻转

反转其实就是头下标和尾下标的元素进行位置的置换，然后在让头下标自增。尾下标自减。

当头下标<尾下标时，可以进行置换的动作。

 

public static void reverseArray(int[] arr) {

         for(intstart=0,end=arr.length-1; start

                   swap(arr,start,end);

         }

         }

         //对数组的元素进行位置的置换。

         public static voidswap(int[] arr,int a,int b) {

         int temp = arr[a];

         arr[a] = arr[b];

         arr[b] = temp;

}

（5）二分查找实现

public static int halfSeach(int[] arr,int key) {

         int min,mid,max;

         min = 0;

         max = arr.length-1;

         mid = (max+min)/2;

 

         while(arr[mid]!=key) {

                   if(key>arr[mid]){

                            min= mid + 1;

                   } elseif(key

                            max= mid - 1;

                   }

                  

                   if(min>max){

                            return-1;

                   }

 

                   mid =(max+min)/2;

         }

         return mid;

}