黑马程序员 java学习笔记——数组

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！
----------------------

数组的定义

概念：同一种类型数据的集合，其实数组就是一个容器。

优点：可以自动给数组中的元素从0开始编号，方便操作这些元素。
定义数组有两种格式：

1、元素类型[] 数组名=new 元素类型[元素个数或数组长度]；

示例：int[] arr=new int[5];

2、元素类型[] 数组名=new 元素类型[]{元素，元素，元素，……}

示例：int[] arr=new int[]{1,9,4,6};

int[] arr={1,9,4,6}

public class Test1 {
public static void main(String[] args){
//x是数组类型
//x[0]是int型
int[] x=new int[5];  //在堆内存中创建一个长度为5的数组
for(int i=0;i<5;i++){
System.out.print(x[i]);
}
}
}
//output:00000
//由输出结果可知，数组中的元素在未赋值时有默认值,为0
//char类型的数组，元素的默认值为'\u0000',unicode表中的空格

数组的内存分配及特点

java程序在运行时，需要在内存中的分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一篇区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

定义在方法中的变量，定义在方法参数上的变量，定义在for循环中的变量，都是局部变量。

堆内存：数组和对象，通过new建立的实例都存放在堆内存中。

每一个实体都有内存地址值

实体中的变量都有默认初始化值

实体不在被使用，会在_不确定_的时间内被垃圾回收器回收。

内存中除了堆内存和栈内存外，还有方法区，本地方法区和寄存器。

public class Test1 {
public static void main(String[] args){
int[] arr=new int[4]; //将堆内存中的数组指向栈内存中的数组变量x。
int[] arr1=arr;  //将内存地址x传递给y
arr[0]=5;
arr1[0]=9;
arr=null; //将数组变量x清除，也就是说它不在指向堆内存中的数组
System.out.println(arr1[0]);
}
}
//output:9

上面程序的内存图如下

数组中的常见异常

1、ArrayIndexOutOfBoundsException：数组角标越界异常

如int[] arr=new int[3];

System.out.println(arr[3]);

由于这段代码不存在语法错误，并未创建数组，编译期间不会报错，但当运行时，就会报错ArrayIndexOutOfBoundsException,因为它访问到了数组中不存在的角标。

2、NullPointerException:空指针异常

如int[] arr=new int[3];

arr=null;

System.out.println(arr[3]);

当引用没有任何指向值，为null的情况，该引用还在用于操作实体，就会产生NullPointerException。

数组的常见操作

遍历

public class Test1 {
public static void main(String[] args){
//数组的操作
//获取数组中的元素，通常会用到遍历
int[] x=new int[]{68,81,35,64,22};
for(int i=0;i<x.length;i++){  //x.length为数组x的长度
System.out.println(x[i]);
}
}
}
//output:
//68
//81
//35
//64
//22

获取最值

/*
* //给定数组{68,81,35,64,22,39}，获取最大值与最小值
* 思路：
1、获取最值需要进行比较。每一次比较都会有一个较大值，因为该值不确定，通过一个变量进行临时存储。
2、让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该变量记录较大值
3、当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值

步骤：
1、定义变量，初始化为数组中任意一个元素即可
2、通过循环语句对数组进行遍历
3、在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量

需要定义一个功能来完成，以便提高复用性
1、明确返回值，数组中的最大元素int型
2、未知内容：一个数组，int[]

最小值与最大值的思路与步骤相似。
* */
public class Test1 {
public static void main(String[] args){
int[] x=new int[]{68,81,35,64,22,39};
System.out.println("max="+getMax(x));
System.out.println("min="+getMin(x));
}
/*
* 获取最大值
* @param arr 接收一个int型数组
* @return 返回数组中的最大值
* */
public static int getMax(int[] arr){
int max=arr[0];
for(int i=1;i<arr.length;i++){
if(arr[i]>max)
max=arr[i];
}
return max;
}
/*
* 获取最小值
* @param arr 接收一个int型的数组
* @return 返回数组中的最大值
* */
public static int getMin(int[] arr){

//将min定义为数组的角标，而不是元素。
int min=0;
for(int i=1;i<arr.length;i++){
if(arr[i]<arr[min])
min=i;
}
return arr[min];
}
}
//output:
//max=81
//min=22

排序：选择排序和冒泡排序

import java.util.Arrays;
public class Test1 {
public static void main(String[] args){
int[] x=new int[]{68,81,35,64,22,39};
System.out.println(Arrays.toString(x));
selectSort(x);
System.out.println(Arrays.toString(x));
bubbleSort(x);
System.out.println(Arrays.toString(x));
}

//选择排序
//第一圈时，最值出现在第一位
public static void selectSort(int[] arr){   //x指向堆中对象，操作对象，此处不用返回值。
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
swap(arr,i,j);
}
}
}
}

//冒泡排序
//第一圈时，最值出现在最后位
public static void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]<arr[j+1]){
swap(arr,j,j+1);
}
}
}
}
public static void swap(int[] arr,int a,int b){  //位置置换功能的抽取
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
}
//output:
//[68, 81, 35, 64, 22, 39]
//[22, 35, 39, 64, 68, 81]
//[81, 68, 64, 39, 35, 22]

折半查找

public class Test1 {
public static void main(String[] args){
int[] x=new int[]{68,81,35,64,22,39};
int index=getIndex(x,35);
System.out.println(index);

}
/*
*当数组按照顺序排列时，折半查找某一个数
* @param arr key 接收一个int型数组和一个int型数值
* @return 返回一个int型值
*/
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;
if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
/*
* 当数组按照顺序排列时，折半查找某一个数
* @param arr key 接收一个int型数组和一个int型数值
* @return 返回一个int型值
* */
public static int halfSearch_1(int[] arr,int key){
int min=0,max=arr.length-1,mid=(min+max)/2;
while(key!=arr[mid]){
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;
}
/*
* 获取key第一次出现在数组中的位置
* @param arr key 接收一个int型数组和一个int型值
* @return 返回值为int型值
* */
public static int getIndex(int[] arr,int key){
for(int i=0;i<arr.length;i++){
if(key==arr[i])
return i;
}
return -1;
}
}

折半查找的前提是数组是有序的。

进制转换：查表法

/*
* 用查表法将十进制转换成二进制、八进制、十六进制
* 经过抽取，从三个方法中抽取出trans方法，表就放在其中。其他三个方法只需要调用它既可
* */
public class Test1 {
public static void main(String[] args){
//toBin(6);
//toHex(-60);
toOct(18);
}
/*
* 将十进制转换成八进制
* @param num 接收int型数值
* */
public static void toOct(int num){
trans(num,7,3);
}
/*
* 将十进制转换成二进制
* @param num 接收int型数值
* */
public static void toBin(int num){
trans(num,1,1);
}
/*
* 将十进制转成十六进制
* @param num 接收int型数值
* */
public static void toHex(int num){
trans(num,15,4);
}
/*
* 从toBin、toOct、toHex中抽取出来的方法，查表法的凝结精华。
* @param num base offset 接收三个int型数值
* */
public static void trans(int num,int base,int offset){
char chs[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char arr[]=new char[32];
int pos=arr.length;
while(num!=0){
int temp=num&base;
arr[--pos]=chs[temp];
num=num>>>offset;
}
for(int i=pos;i<arr.length;i++){
System.out.print(arr[i]+"");
}
}
}

二维数组

定义二维数组的两种格式

格式1：int[][] arr=new int[3][2];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每一个一维数组中都有2个元素

一维数组的名称分别为arr[0]、arr[1]、arr[2]

给第一个一维数组1角标位赋值为78，写法是：arr[0][1]=78

格式2：int[][]=new int[3][];

二维数组中有3个一维数组

每一个一维数组都是默认初始化值null

可以对这三个一维数组分别进行初始化

arr[0]=new int[3];

arr[1]=new int[1];

arr[2]=new int[2];

public class Test1 {
public static void main(String[] args){
int[][] arr=new int[3][4];//定义了名称为arr的二维数组，二维数组中有3个一维数组
//每一个一维数组中有4个元素

System.out.println(arr);  //output:[[I@1db9742
System.out.println(arr[0]); //[I@106d69c
System.out.println(arr[0][1]); //0

int[][] arr1=new int[3][];
System.out.println(arr1); //[[I@52e922
System.out.println(arr1[0]); //null：：：：这个才是重点
//由于arr1[0]没有初始化，所以它是默认初始化。数组是引用数据类型，所以为null

arr1[0]=new int[3];
arr1[1]=new int[1];
arr1[2]=new int[2];
System.out.println(arr1[0]);//[I@25154f
System.out.println(arr1.length);//3     //打印的是二维数组的长度
System.out.println(arr1[0].length);//3	 //打印二维数组中第一个一维数组长度
}
}

二维数组的求和

public class Test1 {
public static void main(String[] args){
int[][] arr={{16,43,52,1},{24,10,32},{2,91,34,55,61,33}};
int sum=0;
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
sum=sum+arr[i][j];
}
}
System.out.println("sum="+sum);
}
}
//output:sum=454

二维数组的小练习：判断正误

小练习：

一维数组的定义方式：int[] x;int x[]

二维数组的定义方式：int[][] x;int x[][];int[] x[];

——————————————————————————

int[] x,y[];x是一维，y是二维

拆开来就是这样int[] x ;int[] y[]

——————————————————————————

a.x[0]=y//error

b.y[0]=x//yes

c.y[0][0]=x//error

d.x[0][0]=y//error

e.y[0][0]=x[0]//yes

f.x=y//error

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！
----------------------