数组的定义：
概念：数组就是同一种类型数据的集合。其实数组就是一个容器。
好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
Java中数组的两种表现形式。
1）、元素类型[] 变量名 = new 元素类型[元素的个数]；
2）、元素类型[] 变量名 = {元素1，元素2...}；
元素类型[] 变量名 = new 元素类型[]{元素1，元素2...}；
代码示例：
public classArray2Demo
{
public static void main(String[] args)
{
//int [] arr = new int[3];//一维数组
//int [][] arr = new int[3][4];//定义了名称为arr的二维数组。
//而二维数组中有3个一维数组，每一个一维数组中有4个元素。
int[][] arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
System.out.println(arr.length);//打印二维数组的长度结果为 3
System.out.println(arr[0].length);//打印二维数组中第一个一维数组的长度。
int[][] arr1 ={{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum = 0;
for(int x = 0; x < arr1.length;x++)
{
for(int y = 0; y <arr1[x].length; y++)
{
sum = sum + arr1[x][y];
}
}
System.out.println("sum="+sum);
}
// int[]x; int x[]; 一维数组的几种定义方式
// int[][]y; int y[][]; int[] y[];二维数组的几种定义方式
int[] x, y[];//这样定义等于 int[] x, int[] y[];但实际开发中不允许这样定义。
}
数组的内存结构：
Java的5片内存。
1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
栈：用于存储局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；
只要数据运算完成所在的区域结束，该数据就会被释放。
堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
l 数组和对象，通过new建立的实例都存放在堆内存中。
l 每一个实体都有内存地址值
l 实体中的变量都有默认初始化值
l 实体不在被使用，会在不确定的时间内被垃圾回收器回收
数组操作常见问题：
数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)：arr引用没有指向实体，却在操作实体中的元素时。
代码示例：
public classArrayDemo2
{
public static void main(String[] args)
{
int[] b = new int[3];
System.out.println(b[2]);//ArrayIndexOutOfBoundsException数组角标越界异常！
//操作数组时，访问到了数组中不存在的角标。
b = null;
System.out.println(b[1]);//NullPointerException空指针异常！
//当引用没有任何指向值为null的情况，该引用还在用于操作实体。
}
}
常见的数组操作：（获取最大值和最小值）
代码示例：
public classArrayTest
{
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
int max = getMax(arr);
System.out.println("max="+max);
int min = getMin(arr);
System.out.println("min="+min);
int max_2 = getMax_2(arr);
System.out.println("max_2="+max_2);
double max_3 = getMax(arr);
System.out.println("doublemax_3="+max_3);
}
/* 获取数组中的最大值：
* 思路：
* 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(max < arr[x])
max = arr[x];
}
return max;
}
//定义功能，获取最小值
public static int getMin(int[] arr)
{
int min = arr[0];
for(int x = 1; x < arr.length;x++)
{
if(min > arr[x])
min = arr[x];
}
return min;
}
/* 获取最值的另外一种方式。可不可以将初始化值定为0呢？
* 可以，这种方式，其实是在初始化为数组中的任意一个角标。
**/
//定义功能，获取数组中的最大值
public static int getMax_2(int[] arr)
{
int max = 0;
for(int x = 1; x < arr.length;x++)
{
if(arr[max] < arr[x])
max = x;
}
return arr[max];
}
//获取double类型数组中的最大值。因为功能一致，所以定义相同的函数名。以重载形式存在。
public static double getMax(double[] arr)
{
int max = 0;
for(int x = 1; x < arr.length;x++)
{
if(arr[x] > arr[max])
max = x;
}
return arr[max];
}
}
排序（选择排序，冒泡排序）:
代码示例：
public classArrayTest2
{
/* 选择排序：
* 内循环结束一次，最值出现在头角标位置上。
*
* 冒泡排序：相邻的两个元素进行比较，如果符合条件就换位。
* 第一圈：最值出现在了最后位。
**/
//定义选择排序法
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);
/*
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
*/
}
}
}
}
//定义一个功能，用于打印数组中的元素。元素间用逗号隔开。
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 void bubbleSort(int[]arr)
{
for(int x = 0; x <arr.length-1; x++)//for(int x = arr.length-1; x > 0 ; x--)
{ //for(int y = 0; y< x; y++)
for(int y = 0; y <arr.length-x-1; y++)// -x：让每一次比较的元素减少。-1：避免角标越界。
{
if(arr[y] >arr[y+1])
{
swap(arr, y,y+1);
/*
int temp =arr[y];
arr[y] =arr[y+1];
arr[y+1] =temp;
*/
}
}
}
}
/* 发现无论什么排序，都需要对满足条件的元素进行位置的置换。
* 所以可以把这部分相同的代码提取出来，单独封装成一个函数。
* */
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);
Arrays.sort(arr);//java中已经定义好的排序方式，开发中对数组排序，要使用该句代码。
//选择排序
//selectSort(arr);
//冒泡排序
//bubbleSort(arr);
//排序后
printArray(arr);
}
}
折半查找(二分查找)：
代码示例：
/* 折半查找可以提高效率，但必须要保证该数组是有序的数组。(该数组里面的元素是有序的)
**/
public static int halfSearch(int[] arr,int key)
{
int min, max, mid;
min = 0;
max = arr.length-1;
mid = (min+max)/2;
while(arr[mid] != key)
{
if(key > arr[mid])
min = mid + 1;
else if(key < arr[mid])
max = mid - 1;
if(min > max)
return -1;
mid = (min+max)/2;
}
return mid;
}
//折半的第二种方式：
public static int halfSearch_2(int[] arr,int key)
{
int min = 0, max = arr.length-1, mid;
while(min <= max)
{
mid = (min+max) >> 1;
if(key > arr[mid])
min = mid +1;
elseif(key < arr[mid])
max = mid -1;
else
return mid;
}
return -1;
}
扫一扫
3812
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
