数组（二）

数组2

1. 数组的排序（冒泡排序，扩展选择排序）

1. 冒泡排序，
   1.   总轮数 = 数组的长度-1；
   2.  每轮中具体的排序 

  第1轮    4次

  第2 轮   3次

   第3轮   2次

  第4轮    1次

每一轮中比较的次数=数组的长度-轮数

public static void main(String[] args) {
        int[] hs= {172,156,132,177,190};
        
        //排序轮次的控制，排序轮次=数组的长度-1，所以从int i=1开始
        for(int i=1; i<hs.length; i++) {
            //每一轮的处理
            for(int j=0; j<hs.length-i;j++) {
            //每一轮比较的次数=数组的长度-排序轮次
            //因为开始是第0位和第1位开始比较，所以是从int j=0开始
                if(hs[j]>hs[j+1]) {//前面的比后面的大，换位置
                    //先对将要被覆盖的数据进行缓存
                    int temp=hs[j];
                    //覆盖
                    hs[j]=hs[j+1];
                    hs[j+1]=temp;
                }
            }
        }
        //展示排序后的数组
        for(int k:hs) {
            System.out.print(k+" ");
        }
    }

 

//升序排序 //排序的轮次的控制                    for(int i=1;i<5;i++) {                             //每一轮中的处理                             for(int j=0;j<5-i;j++) {                                      if(hs[j]>hs[j+1]) {//前面的比后面的大，则要换位置                                               //先对将要被覆盖的数据进行缓存                                                int temp=hs[j];                                                hs[j]=hs[j+1];//覆盖                                                hs[j+1]=temp;                                      }                             }                    }

2)利用java中Arrays这个工具进行升序排序

Arrays.sort(被排序的数组名);

3)利用Arrays进行降序排序

通过 Arrays中sort方式进行排完序，之后进行降序，交换前与后的位置

  

int[] hs= {172,156,132,177,190,50};                             //进行升序排序,语法： Arrays.sort(被排序的数组名);                             Arrays.sort(hs);                             //最后的一个元素的下标                             int last=hs.length-1;                             //                             for(int i=0;i<hs.length/2;i++) {                                           int temp=hs[i];                                           hs[i]=hs[last-i];                                           hs[last-i]=temp;                             }                                           //展示排序后的数组                             for(int h:hs) {                                           System.out.print(h+" ");                             }

 

4）选择排序

int[] hs= {172,156,132,177,190,50};            //选择排序            for(int i=0;i<hs.length-1;i++) {                  //先对最小下标进行缓存区域申请，默认值为 i                  int min=i;                  //和该下标之后的数据继续对比,每轮中具体操作，最终获取到那个最小元素的下标                  for(int j=i+1;j<hs.length;j++) {                       //对比元素数据的大小                       if(hs[j]<hs[min]) {                             min=j;//缓存小值下标                       }                  }                  //对下标上的数据进行交换                  if(min!=i) {                       int temp=hs[min];                                             hs[min]=hs[i];                                             hs[i]=temp;                  }                }            //展示排序后的数组            for(int h:hs) {                  System.out.print(h+" ");            }

 

1. 数组中查询，二分法查询

传统的查询

int[] hs= {172,156,132,177,190,50};         //选择排序         Arrays.sort(hs);         //展示排序后的数组         for(int h:hs) {             System.out.print(h+" ");         }         //查询所在的位置，         int  h=177;         for(int i=0;i<hs.length;i++) {             if(hs[i]==h) {                 System.out.println("找到了"+i);                 break;             }         }

 

要求：对有顺序（升序）的数组，可以进行查询

//查询所在的位置，     int  h=177;         //二分法查询         int startIndex=0;         int endIndex=hs.length-1;                 int midIndex=-1;                 int findIndex=-1;//数据找到是的下标值                         while(startIndex!=endIndex) {             midIndex=(startIndex+endIndex)/2;//分 两部分，进行缩小查询范围             //比较，查询的数据和中间的下标进行比较             if(h<hs[midIndex]) {                 endIndex=midIndex-1;             }else if(h>hs[midIndex]) {                 startIndex=midIndex+1;             }else {                 findIndex=midIndex;                 break;             }         }         if(findIndex==-1) {             System.out.println("没有找到"+h+"所在位置");         }else {             System.out.println("找到了，"+h+"所在位置："+findIndex);         }

1. 引用数据类型的初步认识

创建一个引用数据类型时，会在内存中开辟两个区域，分别是堆和栈；

其中堆放置时真实数据，栈中放置的是堆的地址；

例如

int[] zhangHao= {170,60};

 

System.out.println("变量zhangHao的地址信息："+zhangHao);

控制台上呈现出如下：

变量zhangHao的地址信息：[I@15db9742

[：数组

I:代表是int 或者Integer

15db9742:地址

 

1. 数组的扩容

String[] lnames=new String[3];            //赋值            lnames[0]="张浩";            lnames[1]="李明";            lnames[2]="张国荣";            lnames[3]="梅兰芳";

 

如果出现： java.lang.ArrayIndexOutOfBoundsException代表数组越界；如果进行想放置数据到数组容器中，就必须进行扩容

 

1. 数组的复制和扩容
2. 多维数组，二维数组（认识，会放数据和取数据）à面向对象

        数组中且套数组，次数就是多维为数组

 

int[] t1={12,34,56};

int[] t2={56,67,89};

 

二维数组

     申明 语法：

      数据类型[] []  数组名称；  int[]  [];

     给二维数组分配空间语法

                    数组名=new 数据类型[行的个数] [];

//声明数组            int[] []  test;            //分配空间            test=new int[6] [];   //开辟了10个可以放置int类型数组的空间相当于{ null,null,null,null,null,null}                       //赋值操作            test[0] = new int[]{1,2,3};//{ {1,2,3},null,null,null,null,null}            test[1] = new int[]{12,23,34};//{ {1,2,3},{12,23,34},null,null,null,null}            test[2] = new int[] {12,33,55,77,88,88,90};//{ {1,2,3},{12,23,34},{12,33,55,77,88,88,90},null,null,null}                       test[3]=new int[2];//给第3行位置开辟两个空间   { {1,2,3},{12,23,34},{12,33,55,77,88,88,90},{0,0},null,null}            test[3][0]=77;//{ {1,2,3},{12,23,34},{12,33,55,77,88,88,90},{77,0},null,null}            test[4]=new int[] {69,74};   //{ {1,2,3},{12,23,34},{12,33,55,77,88,88,90},{77,0},{69,74},null}            test[5]=new int[] {65,73}; //{ {1,2,3},{12,23,34},{12,33,55,77,88,88,90},{77,0},{69,74},{65,73}}                       //取值            /**             * {             *    {1,2,3},             *    {12,23,34},             *    {12,33,55,77,88,88,90},             *    {77,0},             *    {69,74},             *    {65,73}             * }             */            //获取第0行上的0列的值            //System.out.println(test[0][0]);            //变量二维数组中的所有数据            for(int i=0;i<test.length;i++) {//控制行，i是行                  for(int j=0;j<test[i].length;j++) {//行中 的每个元素,j是列                       System.out.print(test[i][j]+" ");                  }                  System.out.println();            }            System.out.println();

 

异常  java.lang.NullPointerException：空指向异常，null.xxxx()