数组

数组：数组是存储同一种数据类型数据的集合容器。

数组的定义格式：

数据类型[]  变量名  =  new  数据类型[长度];

数组的好处：对分配到数组对象中每一个数据都分配一个编号(索引值、角标、下标),索引值的范围是从0开始，最大是：长度-1。

局部变量：如果一个变量是在一个方法(函数)的内部声明的，那么该变量就是一个局部变量。

成员变量：成员变量就是定义在方法之外，类之内的.

数组中最常见的问题：

1.NullPointerException 空指针异常原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

2.ArrayIndexOutOfBoundsException索引值越界。原因：访问了不存在的索引值。

数组的初始化方式：

动态初始化:

数据类型[] 变量名 = new 数据类型[长度];

静态初始化：

数据类型[] 变量名 = {元素1，元素2.....};

如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果数据一开始还不太明确，这时候就建议使用动态初始化。

class Demo7 {

public static void main(String[] args) {

//动态初始化

//int[] arr = new int[10];

//静态初始化

int[] arr = {10,20,30,40,50};

for(int index = 0 ; index

System.out.print(arr[index]+",");

}

/*

int[] arr = new int[50];

Scanner scanner = new Scanner(System.in);

for(int i = 0 ; i< arr.length ; i++){

arr[i] = scanner.nextInt();

}

*/

}

}

class Demo8 {

public static void main(String[] args)

{

int[] arr = {-12,-14,-5,-26,-4};

int max = getMax(arr);

System.out.println("最大值："+ max);

}

public static int getMax(int[] arr) {

int max = arr[0]; //用于记录最大值

for(int i = 1 ; i < arr.length ; i++){

if(arr[i]>max){ //如果发现有元素比max大，那么max变量就记录该元素。

max = arr[i];

}

}

return max;

}

}

选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。

class Demo9 {

public static void main(String[] args) {

int[] arr = {12,5,17,8,9}; //对于5元素的数组，只需要找出4个最大值就可以排序了。

selectSort(arr);

}

public static void selectSort(int[] arr) {

//把最大值放在首位置。

for(int j = 0; j

for(int i = j+1 ; i

if(arr[i]>arr[j]){

//交换位置

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

//遍历数组，查看效果

System.out.print("目前的元素：");

for (int i = 0 ; i

System.out.print(arr[i]+",");

}

}

}

冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。

class Demo10 {

public static void main(String[] args) {

int[] arr = {12,8,17,5,9}; // 最大的索引值: 4 容量：5

bubbleSort(arr);

}

public static void bubbleSort(int[] arr){

// 把最大值放在最后一个位置

for(int j = 0 ; j

for(int i = 0 ; i

//相邻的元素比较

if(arr[i]>arr[i+1]){

int temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] = temp;

}

}

}

//遍历数组，查看效果

System.out.print("目前的元素：");

for (int i = 0 ; i

System.out.print(arr[i]+",");

}

}

}

折半查找法(二分法): 使用前提必需是有序的数组。

class Demo12 {

public static void main(String[] args) {

int[] arr = {12,16,19,23,54};

//int index = searchEle(arr,23);

int index = halfSearch(arr,116);

System.out.println("元素所在的索引值是："+ index);

}

public static int halfSearch(int[] arr, int target){

//定义三个变量分别记录最大、最小、中间的查找范围索引值

int max = arr.length-1;

int min = 0;

int mid = (max+min)/2;

while(true){

if(target>arr[mid]){

min = mid+1;

}else if(target

max = mid -1;

}else{

//找到了元素

return mid;

}

//没有找到的情况

if (max

return -1;

}

//重新计算中间索引值

mid = (min+max)/2;

}

}

public static int searchEle(int[] arr, int target) {

for(int i = 0 ; i

if(arr[i]==target){

return i;

}

}

return -1;

}

}

二维数组： 二维数组就是数组中的数组。

二维数组的定义格式：

数据类型[][] 变量名 = new 数据类型[长度1][长度2];

二维数组 的初始化方式：

动态初始化:

数据类型[][] 变量名 = new 数据类型[长度1][长度2];

静态初始化：

数据类型[][] 变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}

class Demo16 {

public static void main(String[] args) {

int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};

//遍历二维数组

for(int i = 0; i

for(int j = 0 ; j

System.out.print(arr[i][j]+",");

}

//换行

System.out.println();

}

}

}

数组的特点：

1.数组只能存储同一种数据类型的数据。

2.数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；

3.数组一旦初始化，长度固定。

4.数组中的元素与元素之间的内存地址是连续的。