java基础一数组

一、数组的概述

1.数组的理解，数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，
并通过编号的方式对这些数据进行统一管理

2.数组相关概念

>数组名
>元素
>角标、下标、索引
>数组的长度:元素的个数

3.数组的特点:
(1)数组是有序排列的
(2)数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
(3)创建数组对象会在内存中开辟一整块连续的空间
(4)数组的长度一旦确定，就不能修改。

4.数组的分类:
(1)按照维数:一维数组、二维数组、…
(2)按照数组元素的类型:基本数据类型元素的数组、引用数据类型元素的数组

5.一维数组的使用:
(1)一维数组的声明和初始化
(2)如何调用数组的指定位置的元素
(3)如何获取数组的长度
(4)如何遍历数组
(5)数组元素的默认初始化值:

>数组元素是整型:0
>数组元素是浮点型:0.0
>数组元素是char型: 0或'\u0000',而非'0'(ascii码中，如'a'对应97),ascii码中'\u0000'对应的是null;
>数组元素是浮点型:false
>数组元素是引用数据类型:null

(6)数组的内存解析:略

举例:

//************************************************************************
      //(1)一维数组的声明和初始化
       //声明
       int num;
       //初始化
       num =10;
       //声明+初始化
       int id=1001;


       //声明
       int[] ids;
       //1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
       //引用对象类型，索引要new
       ids =new int[]{1001,1002,1003};
       //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
       String[] names=new String[5];

       //错误的写法:
       //int[] arr=new int[];
       //int[] arr=new int[3]{1,2,3};

       //也是正确的写法:
       int[] arr4={1,2,3,4};//类型推断

       //总结:数组一旦初始化完成，其长度就确定了。

//************************************************************************
      //(2)如何调用数组的指定位置的元素:通过角标的方式调用
       //数组的角标(或索引)从0开始的，到数组的长度-1结束
       names[0]="阿1";
       names[1]="阿2";
       names[2]="阿3";
       names[3]="阿3";
       names[4]="阿4";
       //names[5]="阿5"; 数组下表越界

//************************************************************************
      //(3)如何获取数组的长度
       //属性:length
       System.out.println(names.length);

//************************************************************************
      //(4)如何遍历数组
       /*System.out.println(names[0]);
       System.out.println(names[1]);
       System.out.println(names[2]);
       System.out.println(names[3]);
       System.out.println(names[4]);*/

       for (int i = 0; i <names.length ; i++) {
           System.out.println(names[i]);
       }
//************************************************************************
      //(5)数组元素的默认初始化值:
       int[] arr=new int[4];
       for (int i = 0; i <arr.length ; i++) {
           System.out.println(arr[i]);
       }
       char[] arr1=new char[4];
       for (int i = 0; i <arr1.length ; i++) {
           System.out.println("----"+arr1[i]+"*****");
       }
       if (arr1[0]==0){
           System.out.println("你好!");
       }
       System.out.println("********************");

       boolean[] arr2=new boolean[5];
       System.out.println(arr2[0]);



//       int[]x,y[];//int[]x,int[]y[]
//       x[0]=y; //no
//       y[0]=x;//yes
//       y[0][0]=x;//no
//       x[0][0]=y;//no
//       y[0][0]=x[0];
//       x=y;//no

二维数组

1.理解:
对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
其实,从数组底层的运行机制来看，其实没有多维数组
2.二维数组的使用:
(1)二维数组的声明和初始化
(2)如何调用数组的指定位置的元素
(3)如何获取数组的长度
(4)如何遍历数组
(5)数组元素的默认初始化值:
针对初始化方式一:比如：int[][] arr6=new int[4][3];

  外层元素的初始化值为:地址值
  内层元素的初始化值为:与一维数组初始化情况相同

数组元素是整型:0
数组元素是浮点型:0.0
数组元素是char型: 0或’\u0000’,而非’0’(ascii码中，如’a’对应97),ascii码中’\u0000’对应的是null;
数组元素是浮点型:false
数组元素是引用数据类型:null

针对初始化方式二:比如：int[][] arr6=new int[4][];

 外层元素的初始化值为:null
 内层元素的初始化值为:不能调用，否则报错

(6)数组的内存解析

二维数组的使用:
规定:二维数组分为外层数组元素,内层数组的元素
int[][] arr=new int[4][3];
外层元素：arr[0],arr[1]等
外层元素：arr[0][0],arr[1][2]等

举例:

//(1)二维数组的声明和初始化
//静态初始化
int[][] arr1=new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2=new String[3][2];
//动态初始化2
String[][] arr3=new String[3][];

//错误初始化
//String[][] arr4=new String[][4];

//正确
int[] arr4[]=new int[][]{{1,2,3},{4,5},{6,7,8}};
int[] arr5[]={{1,2,3},{4,5},{6,7,8}};


//(2)如何调用数组的指定位置的元素
System.out.println(arr1[0][1]);
//2
System.out.println(arr2[1][1]);
//null
//System.out.println(arr3[1][0]);
//报错


//(3)如何获取数组的长度
System.out.println(arr4.length);
//3
System.out.println(arr4[0].length);
//3
System.out.println(arr4[1].length);
//2

//(4)如何遍历数组
for (int i = 0; i <arr4.length ; i++) {
    for (int j = 0; j <arr4[i].length ; j++) {
        System.out.print(arr4[i][j]+" ");
    }
    System.out.println();
}

//(5)数组元素的默认初始化值:
int[][] arr6=new int[4][3];
System.out.println(arr6[0]);
System.out.println(arr6[1]);
//地址值:[I@1540e19d
System.out.println(arr6[0][0]);
//0
System.out.println(arr6);
//[[I@677327b6

double[][] arr7=new double[4][];
System.out.println(arr7[1]);
//null
System.out.println(arr7[1][0]);
//报错，空指针

算法的考查1：求数值型数组中元素的最大值、最小值、平均数、总和等
定义:一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后
求出所有元素的最大值，最小值，和值，平均值，并输出
要求:所有随机数都是两位数

int[] arr =new int[100];

for (int i = 0; i <arr.length ; i++) {
    arr[i]=(int)(Math.random()*(99-10+1)+10);
}

//最大值
//int max=0;全是负数0不行
int max=arr[0];
for (int i = 0; i <arr.length ; i++) {
    if (max<arr[i]){
        max=arr[i];
    }
    System.out.print(arr[i]+"、");
}
System.out.println("最大值:  "+max);


//最小值
int min=arr[0];
for (int i = 0; i <arr.length ; i++) {
    if (min>arr[i]){
        min=arr[i];
    }
    System.out.print(arr[i]+"、");
}


//总和
int sum=0;
for (int i = 0; i <arr.length ; i++) {
    sum+=arr[i];
}


//平均数
int avg=sum/arr.length;


//数组的赋值
//array1=array2(赋的是地址值，两个用的是同一个地址，不能称作数组的复制)
//array1、array是什么关系? array1和array2的地址值相同，都指向了堆空间的唯一的一个数组实体

int[] array1,array2;
array1 =new int[]{2,3,4,5};

//复制array1数组给array2
array2=new int[array1.length];
for (int i = 0; i <array2.length ; i++) {
    array2[i]=array1[i];
}

算法的考查2:数组的复制、反转、查找(线性查找、二分查找)

String[] arr=new String[]{"JJ","DD","MM","BB"};

//数组的复制(区别于数组变量的赋值:arr1=arr)
 String[] arr1=new String[arr.length];
 for (int i = 0; i <arr1.length ; i++) {
     arr1[i]=arr[i];
 }

 //数组的反转
 //方法一:
 for (int i = 0; i <arr.length/2 ; i++) {
     String temp=arr[i];
     arr[i]=arr[arr.length-i-1];
     arr[arr.length-i-1]=temp;
 }
 //方法二:
 for (int i = 0,j=arr.length; i <j ; i++,j--) {
     String temp=arr[i];
     arr[i]=arr[j];
     arr[j]=temp;
 }

 //查找(或搜索)
 //线性查找:
 String dest ="BB";
 boolean isFlag=true;
 for (int i = 0; i <arr.length ; i++) {
     if (dest.equals(arr[i])){
         System.out.println("找到了"+i);
         isFlag=false;
         break;
     }
 }
 if (isFlag){
     System.out.println("很遗憾,没找到");
 }


 //二分法查找:(熟悉)
 //前提:所要查找的数组必须有序。
 int[] arr2=new int[]{-98,-34,3,45,67};
 int dest1=-34;
 //初始的首索引
 int head=0;
 //初始的末索引
 int end=arr2.length-1;
 boolean isFlag1=true;
 while (head<=end){
     int middle=(head+end)/2;
     if (dest1==arr2[middle]){
         System.out.println("找到了"+middle);
         isFlag1=false;
         break;
     }else if (arr2[middle]>dest1){
         end=middle-1;
     }else {//arr2[middle]<dest1
         head=middle+1;
     }
 }
 if (isFlag1){
     System.out.println("很遗憾，没有找到的拉!");
 }
 

************************冒泡排序*****************************
int[] arr=new int[]{43,32,76,-98,0,64};
//冒泡排序
for (int i = 0; i <arr.length-1 ; i++) {
    for (int j = 0; j <arr.length-1-i ; j++) {
        if (arr[j]>arr[j+1]){
            int temp =arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }
}
for (int i = 0; i <arr.length ; i++) {
    System.out.print(arr[i]+" ");
}

三、数组工具类的使用

java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法

//1.boolean equals(int[] a,int[] b):判断两个数组是否相等
int[] arr1=new int[]{1,2,3,4};
int[] arr2=new int[]{1,2,3,4};
boolean equals = Arrays.equals(arr1, arr2);


//2.String toString(int[] a):输出数组的信息
System.out.println(Arrays.toString(arr1));


//3.void fill(int[] a,int val):将指定值填充到数组之中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));

//4.void sort(int[] a):对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));

//5.int binarySearch(int[] a,int key)
int[] arr3=new int[]{-98,-34,3,45,67};
int i = Arrays.binarySearch(arr3, 911);
System.out.println(i);

四、数组中常见的异常

数组中常见的异常:

• 1.数组角标越界的异常:ArrayIndexOutBoundException
• 2.空指针异常:NullPointerException

 //1.数组角标越界的异常:ArrayIndexOutBoundException
        int[] arr=new int[]{1,2,3,4,5};
//        for (int i = 0; i <=arr.length ; i++) {
//            System.out.println(arr[i]);
//        }

//        System.out.println(arr[-2]);


        //2.空指针异常:NullPointerException
        //情况一:
        int[] arr1=new int[]{1,2,3};
        arr1=null;//把原来有的(栈)地址值赋值成null,所有空指针
        System.out.println(arr1[0]);


//        //情况二:
        int[][] arr2=new int[4][];
        System.out.println(arr2[0][0]);

        //情况三:
        String[] arr3=new String[]{"AA","BB","CC"};
        arr3[0]=null;
        System.out.println(arr3[0].toString());