为了账号安全,请及时绑定邮箱和手机立即绑定

数组,选择排序,冒泡排序

标签:
Java

数组的定义(概念)以及两种格式

定义:可以存放同一种数据类型的多个数据(元素)的一个容器
既可以存基本数据类型(8种:byte,short,int,long,float,double,boolean,char)
也可以存引用数据类型(类,接口,数组)

格式:
格式1:数据类型[] 数组名(变量名)
格式2:数据类型 数组名[](变量名[])

如何给数组初始化:
Java中的数组必须先初始化,然后才能使用。
所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值。
数组的初始化方式
动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。
静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。
数组的索引值,是0开始计数
数组内存分配
一个数组变量的内存分配示意图
图片描述
两个数组的内存分配
图片描述
三个数组的内存分配
图片描述
总结:

new出来的东西,永远是在堆上存储的
多次new出来的东西,永远都不一样(元素值一样,不能代表是同一个数组)

多个数组变量,可以同时指向同一块内存空间
数组的静态初始化问题:
格式:
数据类型[] 数组名(变量名)= new 数据类型[] {元素1,元素2...};

举例:
int[] array1 = new int[]{1,2,3}
简写格式:
int[] array1 = {1,2,3}

赋值:赋值时候不能够使用静态初始化的简写形式

int[] array3;
//array3 = {1,2,3};
array3 = new int[]{1,2,3};

数组操作时会发生的异常

数组索引越界:ArrayIndexOutOfBoundException 访问了不存在的·索引元素
空指针异常:NullPointerException 访问了在堆中不存在的元素内容
选择排序:(直接排序)数组第一个元素与其他元素 两两比大小:
小了啥也不做,
大了 就元素交换位置
重复上面的步骤,可以完成所有数组元素的排序

public static void main(String[] args) {

            int[] array1 = {5,7,13,2,9,11};

            //排序前,遍历数组元素
            printArray(array1);
            for(int j=0;j<array1.length-1;j++){//j=0,j=1
                  for(int i=j;i<array1.length-1;i++){//i=0,1,2,3,4,5
                        if(array1[j]>array1[i+1]){
                              int temp = array1[j];
                              array1[j] = array1[i+1];
                              array1[i+1] = temp;
                        }
                  }
            }
/*          //排序,做了5次比较
            for(int i=0;i<array1.length-1;i++){
                  if(array1[0]>array1[i+1]){
                        int temp = array1[0];
                        array1[0] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,做了4次比较
            for(int i=1;i<array1.length-1;i++){
                  if(array1[1]>array1[i+1]){
                        int temp = array1[1];
                        array1[1] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,做了3次比较
            for(int i=2;i<array1.length-1;i++){
                  if(array1[2]>array1[i+1]){
                        int temp = array1[2];
                        array1[2] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,做了2次比较
            for(int i=3;i<array1.length-1;i++){
                  if(array1[3]>array1[i+1]){
                        int temp = array1[3];
                        array1[3] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,做了1次比较
            for(int i=4;i<array1.length-1;i++){
                  if(array1[4]>array1[i+1]){
                        int temp = array1[4];
                        array1[4] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            */
            //排序后,遍历数组元素
            printArray(array1);
      }
      /**
       * 循环遍历数组元素
       * @param array1
       */
      public static void printArray(int[] array1){
            System.out.print("[");
            for(int i=0;i<array1.length;i++){
                  if(i == array1.length-1){
                        System.out.println(array1[i]+"]");
                  }else{
                        System.out.print(array1[i]+",");
                  }
            }
      }

图片描述
冒泡排序:
数组的相邻两元素进行比较:
如果前面的元素小于后面的元素,不变
如果前面的元素大于后面的元素,交换
...
重复上面的步骤,可以实现数组的排序

public static void main(String[] args) {
            //原始数组
//          int[] array1 = {5,7,13,2,9,11};
            int[] array1 = {5,7,13,2,39,21,19,21};

            System.out.println("原始数组内容:");
            printArray(array1);

            for(int j=0;j<array1.length;j++){
                  for(int i=0;i<array1.length-1-j;i++){
                        if(array1[i] > array1[i+1]){
                              int temp = array1[i];
                              array1[i] = array1[i+1];
                              array1[i+1] = temp;
                        }
                  }
            }

/*          //排序,冒泡排序,比了5次
            for(int i=0;i<array1.length-1-0;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,冒泡排序,比了4次
            for(int i=0;i<array1.length-1-1;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,冒泡排序,比了3次
            for(int i=0;i<array1.length-1-2;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,冒泡排序,比了2次
            for(int i=0;i<array1.length-1-3;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
            //排序,冒泡排序,比了1次
            for(int i=0;i<array1.length-1-4;i++){
                  if(array1[i] > array1[i+1]){
                        int temp = array1[i];
                        array1[i] = array1[i+1];
                        array1[i+1] = temp;
                  }
            }
*/                      
            System.out.println("排序后数组内容:");
            printArray(array1);
      }

      /**
       * 循环遍历数组元素
       * @param array1
       */
      public static void printArray(int[] array1){
            System.out.print("[");
            for(int i=0;i<array1.length;i++){
                  if(i == array1.length-1){
                        System.out.println(array1[i]+"]");
                  }else{
                        System.out.print(array1[i]+",");
                  }
            }
      }

图片描述
Arrays 工具类的使用,jdk中折半查找的代码实现

在jdk中有个决定俗称的惯例: 类名+s,表示是一个工具类。
制作工具类的时候,喜欢(建议)将成员 设置为static

Arrays.sort(array);

对指定的 xx 型数组按数字升序进行排序。

binarySearch(array, value);

使用二分搜索法来搜索指定的 xx 型数组的范围,以获得指定的值。
图片描述
二维数组的定义与使用

// 定义一个二维数组,3个一维数组,每一个一维数组中有两个元素
int[][] array1 = new int[3][2];
// 取 二维数组源 地址值
System.out.println(array1);
// 取二维数组中的第一个元素
System.out.println(array1[0]);

二维数组的第二种格式 数据类型[][] 变量名 = new 数据类型[m][];
m:二维数组中有几个一维数组(元素)

// 定义一个整型的二维数组,二维数组当中有三个一维数组(元素)
int[][] array2 = new int[3][];
// 给二维数组的元素赋值
array2[0] = new int[3];
// 如果想获取一个内存地址值,目前只能是new 数据类型接口[];
// 如何获取二维数组中的每一个一维数组元素的内容:数据类型[m][n]
// array2[2][2]:获取二维数组中第三个元素的一维数组中的第三个元素。

二维数组的第三种格式
数据类型[][] 变量名 = new 数据类型[][]{{元素1...},{元素1...},{元素1...}};

简化格式:

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

// 定义一个二维数组,并且初始化
int[][] array3 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
点击查看更多内容
2人点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
软件工程师
手记
粉丝
51
获赞与收藏
617

关注作者,订阅最新文章

阅读免费教程

感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消