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 <intArray.length; 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<arr.length; 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<end; start++,end--) {
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<arr[mid]) {
max= mid - 1;
}
if(min>max){
return-1;
}
mid =(max+min)/2;
}
return mid;
}