动力节点——数组（十九）

一，数组的概述

1，定义

数组就是存储相同数据类型的多个元素的容器。

2，特点

A，数组是一个容器，装东西数据使用。

B，数组中的数据必须是相同的数据类型。

C，数组中在定义时可存储数据的个数一旦固定，则不能再被改变。

3，数组的定义：

数组元素类型[]    数组名称    或者    数组元素类型    数组名称[]

4，数组的初始化

数组一共有两种初始化方式：

第一种：

静态初始化：程序指定数组元素值，由程序自己计算数组中数组元素个数。

全语法形式：数组元素类型[]    数组名称=new    数组元素类型[]{手动指定数组元素值}；

简写形式：数组元素类型[]    数组名称={手动指定数组元素值}；

第二种：

动态初始化：程序员执行数组中元素个数，由程序自己为数组中每个元素赋默认值。

语法形式：数组元素类型[]    数组名称=new  数组元素类型[手动指定数组元素个数]；

二，数组的使用方式

1，数组索引

数组中的每一个元素都有一个下标，这个下边从数组的左边开始右边结束。

下边值从0开始，一直到数组的个数-1。

2，可以使用数组索引来获取指定的数组元素值。

语法：数组名称[待获取元素的索引值]

public  class ArrayDemo1{

        public  static  void  main(String[]  args){

                //定义一个整型数组

                int[]  xx={10,20,14,8};

                //如何获取数组中某个位置的元素值？

                //数组索引  0   1   2    3

                //使用数组索引输出

                System.out.println(xx[2]);

                //使用数组索引把数组中的14改成24

                xx[2]=24;

                System.out.println(xx[2]);

        }

}

三，数组长度

1，定义

数组长度就是指数组中存储的元素个数。

语法：        数组名称 . length

2，依次对数组每一个元素进行相关处理，叫对数组进行遍历。

for(int  x=0;x<数组名称 . length;x++){

       System.out.println(数组名称[x]); 

}

四，对象做数组元素的内存图解

数组元素的类型不仅仅是基本数据类型还可以是引用数据类型。

1，数组元素是基本数据类型

在堆内存的数组空间中存储的是值。

2，数组元素是引用数据类型

在堆内存的数组空间中存储的是地址值

class  Student{

        private  int  age;

        public  Student(){

        }

        public  Student(int  age){

                this.age=age;

        }

        public  void  setAge(int  age){

                this.age=age;

        }

        public  int  getAge(){

                return  age;

        }

}

public  classArrayDemo2{

        public  static  void  main(String[]  args){

                //创建一个数组元素是基本数据类型的数组

                int[]  x1={10,20,30};

                

                //创建一个数组元素是引用数据类型的数组

                //创建不同年龄的学生对象

                Student  s1=new  Student(20);

                Student  s2=new  Student(21);

                Student  s3=new  Student(22);

                //把三个学生对象放入数组

                int[]  x2={s1,s2,s2};

        }

}

五，基本、引用类型数组做方法参数

数组做方法参数，因为数组是引用类型，所以数组做方法参数。如果在方法内对数组的元素有

改动，往往会影响到原有的数组元素值。

class  Teacher{

        private  int  age=10;

        public  Teacher(){}

        public  void  setAge(int  age){

                this.age=age;

        }

        public  int  getAge(){

                return  age;

        }

}

public  class  ArrayDemo3{

        public  static  void  main(String[]  args){

                //定义一个整型数组

                int[]  xx={10,20,30};

                System.out.println("1  xx[0]="+xx[0]);

                chengeValue(xx);

                System.out.println("2   xx[0]="+xx[0]);

                

                Teacher  t1=new  Teacher(20);

                Teacher  t2=new  Teacher(30);

                Teacher  t3=new  Teacher(40);

                Teacher[]  yy={t1,t2,t3};

                System.out.println("1   yy[0].age="+yy[0].getAge);

                chengeValue(yy);

                System.out.println("2  yy[0].age="+yy[0].getAge);

                

        }

        public  static  void  chengeValue(int[]  xx){

                xx[0]=40;

        }

        public  static  void  chengeValeu(Teacher[]  yy){

                yy[0].setAge(60);

        }

}

六，数组的常见异常

1，java . lang . ArrayIndexOutOfBoundsException

使用了超出范围的数组索引来获取数组元素。

2，java . lang . NullPointerException

如果一个对象的引用并没有指向任何堆内存空间，同时调用了这个引用的

属性或者方法。那么会报出空指针异常。

public  class  ArrayDmeo4{

        int[]  xx={10,20,30};

        //System.out.println(xx[3]);//使用了超出异常范围的数组索引

        

        xx=null;

        System.out.println(xx . length);//空指针

}   

七，main方法参数

1，main方法的参数是一个字符串数组。

2，这个数组永远不会为nill。

3，默认在args数组中是没有任何元素的。

4，args数组的使用方法

因为main方法是被jvm自动调用的，所以args的内容被jvm自动装入的。

默认的执行class文件的命令是：    java   ArrayDemo5  

开始在执行时为args的数组指定数组内容：     java   ArrayDemo5  aaa  bbb

以上语法中的aaa和bbb就是在运行ArrayDemo5类时，想在main方法中直接接收

的参数aaa和bbb会被jvm自动放到args数组中。

注意：可以把以下程序使用命令行测试结果

public  class  ArrayDemo5{

        public  static  void  main(String[]  args){

                //测试args数组是否为null

                //以下代码输出0是代表args数组在main方法中直接接收，它不是null。

                //数组的长度是0，说明默认其中是没有元素的

                System.out.println(args.length);//0

                //假设在main方法中接收args参数，开始遍历args数组

                for(int  x=0;x<args.length;x++){

                        System.out.println(args[x]);

                }

        }

}

八，数组的复制

1，目的

解决数组长度不可变问题。

数组长度一旦固定就不能改变，需要再另外创建一个数组其长度超过已有数组，

再把已有数组的元素都复制到新数组中去。

2，System.arraycopy(Object  src,  int  srcPos ,  Object  dest,  int  destPos,  int  length)

Object  src：被复制数组的引用，复制源。

int  srcPos：从复制源数组的哪个索引值开始选取元素。

Object   dest：复制的目的源。

int  destPos：从目的源数组的哪个索引开始复制（复制是会覆盖掉目的源数组的元素值的）。  

int  length：复制几个元素。

class  ArrayDemo6{

        public  static  void  main(String[]  args){

                int[]  x1={10,20,30};

                //第一种方法

                //定义一个数组，其长度要超过已有数组x1长度

                int[]  x2=new  int[x1 . length+5];

                //数组的复制

                //x1      10    20     30

                //x2       10   20     30    0    0    0     0    0

                //使用for循环完成

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

                        x2[i]=x1[i];//把x1和x2相同位置的赋值给x2

                }

                //输出x2的数组元素值测试

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

                        System.out.println(x2[i]);

                }

                //第二种方法

                int[]  x2={11,22,33};

                System . arraycopy(x1,1,x2,1,2);

                //输出x2的元素值进行测试

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

                        System.out.println(x2[i]);

                }

        }

}

九，冒泡排序算法编码

public  class  ArrayDemo7{

        public  static  void  main(String[]  args){

                int[]  xx={21,45,13,96,55,58};

                for(int  j=0;j<xx.length-1;j++){

                        for(int  i=0;i<xx.length-1-j;i++){

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

                                        int  temp=xx[i];

                                        xx[i]=xx[i+1];

                                        xx[i+1]=temp;

                                }

                        }

                }

        printArray(xx);

        }

        //每次排序完测试输出

        public  static  void  printArray(int[]  xx){

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

                        System.out.println(xx[i]);

                }

        }

}

十，选择排序算法编码

public  class  ArrayDemo8{

        public  static  void  main(String[]  args){

                for(int  j=0;j<xx.length-1;j++){

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

                                if(xx[ j ]>xx[ j ]){

                                        int  temp=xx[ j ];

                                        xx[ j ]=xx[ i ];

                                        xx[ i ]=temp;

                                }

                        }

                }

        printArray(xx);

        }

        public  static  void  printArray(int[]  xx){

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

                        System.out.println(xx[ i ]);

                }

        }

}

十一，数组二分查找算法编码

public  calss  ArrayDemo9{

        public  static  void  main(String[]  args){

                int[]  xx={11,22,33,44,55,66};

                int  index=halfSearch(xx,44);

                System.out.println("index="+index);

        }

        public  static  void  halfSearch(int[]  xx,int  arr){

                int  min=0;

                int  max=xx.length-1;

                int  mid=(min+max)/2;

                while(xx[mid]!=arr){

                        //说明元素值不在数组中

                        if(min>max){

                                return  -1；

                        }

                        //说明arr值在mid值左边

                        if(xx[mid]>arr){

                                max=mid-1;

                                mid=(min+max)/2;

                        }else{

                        //说明arr值在mid左边

                                min=mid+1;

                                mid=(min+max)/2;

                        }

                }

                return  mid; 

        }

}

十二，数组Array类讲解

Array数组工具类

1，Arrays.binarySearch：实现了数组的二分查找

2，Arrays.toString：直接把数组元素值按照顺序以字符串的方式输出。

3，Arays.sort：把数组元素排列

public  class  ArrayDemo10{

        public  static  void  main(String[]  args){

                //测试Arrays.binarySearch

                int[]  xx={11,22,33,44,55,66};

                System.out.println(Arrays.binarySearch(xx,44));

                //测试Arrays.toString

                int[]  yy={21,45,13,96,55,58};

                System.out.println(Arrays.toString(yy));

                //测试Arrays.sort

                int[]  tt={21,45,13,96,55,58};

                Arrays.sort(tt);

                System.out.println(Arrays.toString(tt));

        }

}

十三，二维数组的定义及初始化

1，定义

二维数组就是一个数组元素是一维数组的一维数组。

就是一维数组的每一个元素都是一维数组。

2，定义和初始化

静态：

数组元素类型[][]    数组名称={{2,4,8},{10,12,25},{20,25}};

动态：

数组元素类型[][]    数组名称=new  数组元素类型[2][3]；

3，获取二维数组的某个数组元素值

public  class  ArrayDemo11{

        public  static  void  main(String[]  args){

                //定义一个整型二维数组

                int[][]   xx={{12,15,18,2},     {8,6,4},     {21,58}};

    //外层一维数组索引         0                   1               2

    //内存一维数组索引  0   1   2  3        0  1  2       0   1  

                //使用获取数组元素值的语法输出8

                System.out.println(xx[1][0]) ;

        }

}

十四，二维数组遍历

public  class  ArrayDemo12{

        public  static  void  main(String[]  args){

                //遍历以下二维数组，输出每一个数组元素值。

                int[][]  xx={{2,4,8},{10,12,25},{20,25}};

                //先对外层数组进行循环

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

                        //再对每一个内层的一维数组进行循环

                        for(int  j=0;j<xx[i].length;j++){

                                //输出每一个数组元素值

                                System.out.println(xx[ i ][ j ]);

                        }

                }

        }

}

​

一，数组的概述

1，定义

数组就是存储相同数据类型的多个元素的容器。

2，特点

A，数组是一个容器，装东西数据使用。

B，数组中的数据必须是相同的数据类型。

C，数组中在定义时可存储数据的个数一旦固定，则不能再被改变。

3，数组的定义：

数组元素类型[]    数组名称    或者    数组元素类型    数组名称[]

4，数组的初始化

数组一共有两种初始化方式：

第一种：

静态初始化：程序指定数组元素值，由程序自己计算数组中数组元素个数。

全语法形式：数组元素类型[]    数组名称=new    数组元素类型[]{手动指定数组元素值}；

简写形式：数组元素类型[]    数组名称={手动指定数组元素值}；

第二种：

动态初始化：程序员执行数组中元素个数，由程序自己为数组中每个元素赋默认值。

语法形式：数组元素类型[]    数组名称=new  数组元素类型[手动指定数组元素个数]；

二，数组的使用方式

1，数组索引

数组中的每一个元素都有一个下标，这个下边从数组的左边开始右边结束。

下边值从0开始，一直到数组的个数-1。

2，可以使用数组索引来获取指定的数组元素值。

语法：数组名称[待获取元素的索引值]

public  class ArrayDemo1{

        public  static  void  main(String[]  args){

                //定义一个整型数组

                int[]  xx={10,20,14,8};

                //如何获取数组中某个位置的元素值？

                //数组索引  0   1   2    3

                //使用数组索引输出

                System.out.println(xx[2]);

                //使用数组索引把数组中的14改成24

                xx[2]=24;

                System.out.println(xx[2]);

        }

}

三，数组长度

1，定义

数组长度就是指数组中存储的元素个数。

语法：        数组名称 . length

2，依次对数组每一个元素进行相关处理，叫对数组进行遍历。

for(int  x=0;x<数组名称 . length;x++){

       System.out.println(数组名称[x]); 

}

四，对象做数组元素的内存图解

数组元素的类型不仅仅是基本数据类型还可以是引用数据类型。

1，数组元素是基本数据类型

在堆内存的数组空间中存储的是值。

2，数组元素是引用数据类型

在堆内存的数组空间中存储的是地址值

class  Student{

        private  int  age;

        public  Student(){

        }

        public  Student(int  age){

                this.age=age;

        }

        public  void  setAge(int  age){

                this.age=age;

        }

        public  int  getAge(){

                return  age;

        }

}

public  classArrayDemo2{

        public  static  void  main(String[]  args){

                //创建一个数组元素是基本数据类型的数组

                int[]  x1={10,20,30};

                

                //创建一个数组元素是引用数据类型的数组

                //创建不同年龄的学生对象

                Student  s1=new  Student(20);

                Student  s2=new  Student(21);

                Student  s3=new  Student(22);

                //把三个学生对象放入数组

                int[]  x2={s1,s2,s2};

        }

}

五，基本、引用类型数组做方法参数

数组做方法参数，因为数组是引用类型，所以数组做方法参数。如果在方法内对数组的元素有

改动，往往会影响到原有的数组元素值。

class  Teacher{

        private  int  age=10;

        public  Teacher(){}

        public  void  setAge(int  age){

                this.age=age;

        }

        public  int  getAge(){

                return  age;

        }

}

public  class  ArrayDemo3{

        public  static  void  main(String[]  args){

                //定义一个整型数组

                int[]  xx={10,20,30};

                System.out.println("1  xx[0]="+xx[0]);

                chengeValue(xx);

                System.out.println("2   xx[0]="+xx[0]);

                

                Teacher  t1=new  Teacher(20);

                Teacher  t2=new  Teacher(30);

                Teacher  t3=new  Teacher(40);

                Teacher[]  yy={t1,t2,t3};

                System.out.println("1   yy[0].age="+yy[0].getAge);

                chengeValue(yy);

                System.out.println("2  yy[0].age="+yy[0].getAge);

                

        }

        public  static  void  chengeValue(int[]  xx){

                xx[0]=40;

        }

        public  static  void  chengeValeu(Teacher[]  yy){

                yy[0].setAge(60);

        }

}

六，数组的常见异常

1，java . lang . ArrayIndexOutOfBoundsException

使用了超出范围的数组索引来获取数组元素。

2，java . lang . NullPointerException

如果一个对象的引用并没有指向任何堆内存空间，同时调用了这个引用的

属性或者方法。那么会报出空指针异常。

public  class  ArrayDmeo4{

        int[]  xx={10,20,30};

        //System.out.println(xx[3]);//使用了超出异常范围的数组索引

        

        xx=null;

        System.out.println(xx . length);//空指针

}   

七，main方法参数

1，main方法的参数是一个字符串数组。

2，这个数组永远不会为nill。

3，默认在args数组中是没有任何元素的。

4，args数组的使用方法

因为main方法是被jvm自动调用的，所以args的内容被jvm自动装入的。

默认的执行class文件的命令是：    java   ArrayDemo5  

开始在执行时为args的数组指定数组内容：     java   ArrayDemo5  aaa  bbb

以上语法中的aaa和bbb就是在运行ArrayDemo5类时，想在main方法中直接接收

的参数aaa和bbb会被jvm自动放到args数组中。

注意：可以把以下程序使用命令行测试结果

public  class  ArrayDemo5{

        public  static  void  main(String[]  args){

                //测试args数组是否为null

                //以下代码输出0是代表args数组在main方法中直接接收，它不是null。

                //数组的长度是0，说明默认其中是没有元素的

                System.out.println(args.length);//0

                //假设在main方法中接收args参数，开始遍历args数组

                for(int  x=0;x<args.length;x++){

                        System.out.println(args[x]);

                }

        }

}

八，数组的复制

1，目的

解决数组长度不可变问题。

数组长度一旦固定就不能改变，需要再另外创建一个数组其长度超过已有数组，

再把已有数组的元素都复制到新数组中去。

2，System.arraycopy(Object  src,  int  srcPos ,  Object  dest,  int  destPos,  int  length)

Object  src：被复制数组的引用，复制源。

int  srcPos：从复制源数组的哪个索引值开始选取元素。

Object   dest：复制的目的源。

int  destPos：从目的源数组的哪个索引开始复制（复制是会覆盖掉目的源数组的元素值的）。  

int  length：复制几个元素。

class  ArrayDemo6{

        public  static  void  main(String[]  args){

                int[]  x1={10,20,30};

                //第一种方法

                //定义一个数组，其长度要超过已有数组x1长度

                int[]  x2=new  int[x1 . length+5];

                //数组的复制

                //x1      10    20     30

                //x2       10   20     30    0    0    0     0    0

                //使用for循环完成

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

                        x2[i]=x1[i];//把x1和x2相同位置的赋值给x2

                }

                //输出x2的数组元素值测试

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

                        System.out.println(x2[i]);

                }

                //第二种方法

                int[]  x2={11,22,33};

                System . arraycopy(x1,1,x2,1,2);

                //输出x2的元素值进行测试

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

                        System.out.println(x2[i]);

                }

        }

}

九，冒泡排序算法编码

public  class  ArrayDemo7{

        public  static  void  main(String[]  args){

                int[]  xx={21,45,13,96,55,58};

                for(int  j=0;j<xx.length-1;j++){

                        for(int  i=0;i<xx.length-1-j;i++){

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

                                        int  temp=xx[i];

                                        xx[i]=xx[i+1];

                                        xx[i+1]=temp;

                                }

                        }

                }

        printArray(xx);

        }

        //每次排序完测试输出

        public  static  void  printArray(int[]  xx){

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

                        System.out.println(xx[i]);

                }

        }

}

十，选择排序算法编码

public  class  ArrayDemo8{

        public  static  void  main(String[]  args){

                for(int  j=0;j<xx.length-1;j++){

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

                                if(xx[ j ]>xx[ j ]){

                                        int  temp=xx[ j ];

                                        xx[ j ]=xx[ i ];

                                        xx[ i ]=temp;

                                }

                        }

                }

        printArray(xx);

        }

        public  static  void  printArray(int[]  xx){

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

                        System.out.println(xx[ i ]);

                }

        }

}

十一，数组二分查找算法编码

public  calss  ArrayDemo9{

        public  static  void  main(String[]  args){

                int[]  xx={11,22,33,44,55,66};

                int  index=halfSearch(xx,44);

                System.out.println("index="+index);

        }

        public  static  void  halfSearch(int[]  xx,int  arr){

                int  min=0;

                int  max=xx.length-1;

                int  mid=(min+max)/2;

                while(xx[mid]!=arr){

                        //说明元素值不在数组中

                        if(min>max){

                                return  -1；

                        }

                        //说明arr值在mid值左边

                        if(xx[mid]>arr){

                                max=mid-1;

                                mid=(min+max)/2;

                        }else{

                        //说明arr值在mid左边

                                min=mid+1;

                                mid=(min+max)/2;

                        }

                }

                return  mid; 

        }

}

十二，数组Array类讲解

Array数组工具类

1，Arrays.binarySearch：实现了数组的二分查找

2，Arrays.toString：直接把数组元素值按照顺序以字符串的方式输出。

3，Arays.sort：把数组元素排列

public  class  ArrayDemo10{

        public  static  void  main(String[]  args){

                //测试Arrays.binarySearch

                int[]  xx={11,22,33,44,55,66};

                System.out.println(Arrays.binarySearch(xx,44));

                //测试Arrays.toString

                int[]  yy={21,45,13,96,55,58};

                System.out.println(Arrays.toString(yy));

                //测试Arrays.sort

                int[]  tt={21,45,13,96,55,58};

                Arrays.sort(tt);

                System.out.println(Arrays.toString(tt));

        }

}

十三，二维数组的定义及初始化

1，定义

二维数组就是一个数组元素是一维数组的一维数组。

就是一维数组的每一个元素都是一维数组。

2，定义和初始化

静态：

数组元素类型[][]    数组名称={{2,4,8},{10,12,25},{20,25}};

动态：

数组元素类型[][]    数组名称=new  数组元素类型[2][3]；

3，获取二维数组的某个数组元素值

public  class  ArrayDemo11{

        public  static  void  main(String[]  args){

                //定义一个整型二维数组

                int[][]   xx={{12,15,18,2},     {8,6,4},     {21,58}};

    //外层一维数组索引         0                   1               2

    //内存一维数组索引  0   1   2  3        0  1  2       0   1  

                //使用获取数组元素值的语法输出8

                System.out.println(xx[1][0]) ;

        }

}

十四，二维数组遍历

public  class  ArrayDemo12{

        public  static  void  main(String[]  args){

                //遍历以下二维数组，输出每一个数组元素值。

                int[][]  xx={{2,4,8},{10,12,25},{20,25}};

                //先对外层数组进行循环

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

                        //再对每一个内层的一维数组进行循环

                        for(int  j=0;j<xx[i].length;j++){

                                //输出每一个数组元素值

                                System.out.println(xx[ i ][ j ]);

                        }

                }

        }

}

​