黑马程序员——java中数组的定义与应用

       定义一维数组有两种格式：
       格式1：元素类型 [ ]数组名 = new 元素类型 [元素个数] ;
       如： int [] arr = new int [3]; 也可以写成： int arr[] = new int[3];
       格式2：元素类型 []数组名 = new 元素类型 [ ]{元素1,元素2,…};
       如： int [] arr = new int []{1,2,3,4,5};
       数组的定义有两个步骤：声明和分配内存。数组声明实际上实在栈内存中保存了此数组的名称，接下来在堆内存中分配数组所需的内存，而new关键字就是在堆内存中开辟空间供数组使用。对数组的访问采用“数组名称[下标]”的方式，如：arr[0]、arr[1]、arr[2]。而arr[3]在程序运行时会发生数组角标越界异常。

        


       提示：
       栈内存：用于存储局部变量，变量所属的作用域一旦结束，该变量就自动释放。
       堆内存：1、数组和对象，通过new建立的实例都存放在堆内存中。
                      2、每一个实体都有内存地址值。
                      3、实体中的变量都有默认初始化值。
                      4、实体不在被使用，会在不确定的时间内被垃圾回收器回收。

三、二维数组

       定义二维数组的格式如下：
       格式1： int[][] arr= new int[3][2];
       格式2： int[][] arr= new int[3][];
       格式3：int[][] arr = {{30,82,21},{20,11,12},{91,20,13}};
       二维数组在内存中的分配情况示例：

        


        提示：

//对数组进行定义和输出

class ArrayDemo
{
public static void main(String[] args)
{
int[] arr = new int[]{2,3,5,7,1};

//获取数组的长度

System.out.println("length:"+arr.length);

//对数组中的每一个元素进行遍历输出

for(int x=0; x<arr.length ; x++)
{
System.out.println("arr["+x+"] = "+arr[x]+";");
}
}
}

//数组工具：包含数组排序、查找、反转、获取最大值、转换字符串输出

class ArrayTools
{
public static void main(String[] args)
{
//定义数组
int[] arr = new int[]{40,23,87,56,90};

//打印原始数组
System.out.print("原始数组为：");
printArray(arr);

//调用获取数组最大值函数并输出最大值
int max = getMax(arr);
System.out.println("该数组中最大元素为："+max);

//int index = getIdex(arr,40);

//调用二分法函数查找元素位置
int index = halfSearch(arr,87);
System.out.println("index="+index);

//selectSort(arr);

//调用冒泡法函数对数组进行排序
bubbleSort(arr);
System.out.print("排序后的数组为：");
printArray(arr);

//调用函数对数组进行反转
reverseArray(arr);
System.out.print("反转后的数组为：");
printArray(arr);

//调用函数将数组转成字符串输出
String str = arrayToString(arr);
System.out.println("str="+str);

}
//数组遍历输出函数
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]+", ");
else
System.out.println(arr[x]+"]");
}
}
//获取数组最大值函数
public static int getMax(int arr[])
{
int maxIndex = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[maxIndex])
maxIndex = x;
}
return arr[maxIndex];
}

//数组选择排序函数
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])
{
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-1-x;y++)
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}

//数组查找元素函数
public static int getIndex(int[] arr,int key)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==key)
return x;
}
return -1;
}

//数组二分查找法
public static int halfSearch(int[] arr,int key)
{
int max,min,mid;
min = 0;
max = arr.length-1;

while (min<max)
{
mid =(min+max)/2;

if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;

}

return -1;//表示在数组中没有该元素的位置

}

//数组元素反转函数
public static void reverseArray(int[] arr)
{
for(int start=0,end=arr.length-1;start<end;start++,end--)
swap(arr,start,end);
}

//数组转字符串输出函数
public static String arrayToString(int[] arr)
{
String str = "[";

for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
str = str + arr[x] + ", ";
else
str = str + arr[x] + "]";
}
return str;
}

//两个变量的值互换
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

}