java数组、冒泡排序，稀疏数组

于 2019-12-16 19:07:01 发布
阅读量210 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sw_eet/article/details/103568173
本文详细介绍了数组的概念、创建、声明、使用及排序方法，包括数组的内存分析、多维数组的使用、Array类的功能介绍以及冒泡排序算法的实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数组

数组的定义

  • 数组是相同类型数据的有序集合
  • 数组描述相同数据的若干数据，按一定的先后顺序排列而成
  • 每一个数据称数组元素，用数组的下标访问它们
  • 数组的下标从0开始

数组的创建、声明

  • 数组长度是确定的，一旦被创建大小就不可以改变,如果越界会报ArrayIndexOutofBounds错误
  • 其类型必须相同，不能出现混合类型
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  • 数字变量属于引用类型，数组也可看成对象，数组中的每个元素，相当于该对象的成员变量，数组本身就是对象，java的对象是在堆中的，数组对象是在堆中的
  • 数组元素通过索引访问，从0开始
  • 获取数组长度，aray.length
 public static void main(String[] args) {

        int[] nums;                //声明一个数组
        nums=new int[10];          //创建一个数组
        
        int[] nums2=new int[10];     //一步完成
        
        nums[0]=0;
        nums[1]=1;
        nums[2]=2;
        nums[3]=3;
        nums[4]=4;
        nums[5]=5;
        nums[6]=6;
        nums[7]=7;
        nums[8]=8;
        nums[9]=9;
        
     for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
        
    }

内存分析

堆

  • 存放new的数组和对象
  • 可以被所有线程共享，不会存放别的对象引用

栈

  • 存放基本变量类型（会包含这个基本类型的具体数据）
  • 引用对象的变量（会存放这个引用在堆里的具体地址）

方法区

  • 可以被所有线程共享
  • 包含了所有的class和staic变量
 public static void main(String[] args) {

        //静态初始化
        int[] nums={1,2,3,4,5,6};
        for (int i = 0; i < 6; i++) {
            System.out.println(nums[i]);
        }

        System.out.println("===============================");
        //动态初始化
        //初始未赋值，默认为0
        int[] nums2=new int[6];
        nums2[0]=1;
        nums2[1]=2;
        for (int i = 0; i < 6; i++) {
            System.out.println(nums2[i]);
        }

    }

数组的使用

  • 普通for循环

     public static void main(String[] args) {

        int[] arrays={1,2,3,4,5};

        //打印全部数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("===========================");
        //计算所有元素总和
        int sum=0;
        for (int j = 0; j < arrays.length; j++) {
            sum=sum+arrays[j];
        }
        System.out.println("总和为："+sum);
        System.out.println("===========================");
        //查找最大元素
        int max=arrays[0];
        for (int k = 1; k <arrays.length ; k++) {
            if(max<arrays[k]){
                max=arrays[k];
            }
        }
        System.out.println("最大数为："+max);
    }

  • 增强for循环

     public static void main(String[] args) {
        int[] arrays={1,2,3,4,5,6};

        //jdk1.5以后才有，无下标
        for (int i : arrays) {
            System.out.println(i);
        }
    }

  • 数组作为方法传入参数

  • 数组作为返回值

 public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5, 6};

        printarrays(arrays);
        reverse(arrays);
        printarrays(arrays);
        }

    //打印数组元素
    // 作为传入参数
    public static void printarrays(int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i]+"  ");
        }
        System.out.println();
    }
    //反转数组
    //作为返回值
    public static int[] reverse(int[] arrays){

        int a=0;
        for (int i = 0; i <(arrays.length)/2 ; i++) {
            a=arrays[i];
            arrays[i]=arrays[arrays.length-1-i];
            arrays[arrays.length-1-i]=a;
        }

        return arrays;
    }

多维数组

  • 多维数组可以看成数组的数组，例如二维数组就是一个特殊的一维数组，其中每一个元素就是一个一维数组

二维数组

 public static void main(String[] args) {

        int[][] arrays={{1,2},{2,3},{3,4},{4,5},{5,6}};

        //使用for循环打印
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                System.out.print(arrays[i][j]+" ");
            }
        }
    }

Array类

  • 数组工具类，java.util.Arrays
  • 由于数组对象本神并没有什么方法供我们调用，但API中提供了一个工具类Arrays，供我们使用从而可以对数据对象进行一些基本操作
  • 具体包含的请看JDK帮助文档
  • Arrays类中的方法，都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而”不用“使用对象来调用（注意是”不用“不是”不能“）

常用功能

  • 给数组赋值，通过fill方法

  • 对数组排序，通过sort方法，按升序

  • 比较数组，通过equals方法，比较数组中元素是否相等

  • 查找数组元素，通过binarySearch方法，对排好序的数组进行二分查找法操作

    public class ArraysDemo06 {
    public static void main(String[] args) {
        int[] a={5,23,6,9,48,56,12,46,63,85,154,1};
        //打印数组元素
        System.out.println(Arrays.toString(a));
        printarrays(a);
        System.out.println("=================================================");
        //排序,升序
        Arrays.sort(a);
        printarrays(a);
        System.out.println("=================================================");
        //fill赋值
        Arrays.fill(a,0);//全赋值为0
        printarrays(a);
        Arrays.fill(a,2,5,6);//2-5之间赋值为0，不包括2、5
        printarrays(a);
    }

    //打印数组,,,,,开始造轮子
    public static void printarrays(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            if(i==0){
                System.out.print("["+arrays[0]+", ");
            }else if(i==arrays.length-1){
                System.out.println(arrays[i]+"]");
            }else {
                System.out.print(arrays[i]+", ");
            }
        }
    }
}

冒泡排序（8大排序之一）

  • 两层循环，外层冒泡轮数，内层依次比较
  • 两层循环嵌套，时间复杂度为O(n^2)
  • 冒泡排序，比价数组中两个相邻的元素，第一个大于第二个，则交换
  • 每一次比较都会产生一个最大或最小的数
  • 下一轮会少一次排序
  • 依次循环直到结束
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a={5,23,6,9,48,56,12,46,63,85,154,1};
        int[] b={5,23,6,9,48,56,12,46,63,85,154,1};
        sorts(a);
        System.out.println(Arrays.toString(a));
        System.out.println("===================================================");
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
    }

    //冒泡排序，比价数组中两个相邻的元素，第一个大于第二个，则交换
    //每一次比较都会产生一个最大或最小的数
    //下一轮会少依次排序
    public static void sorts(int[] arrays){
        //判断走多少次
        for (int i = 0; i <arrays.length ; i++) {
            //判断其是否有序，若第一次不进行任何赋值，则就是有序数组
            boolean flag=false;
            //从第一个与后面的一一对比
            for (int j = 0; j < arrays.length-i-1; j++) {
                if(arrays[j]>arrays[j+1]){
                    int a=arrays[j+1];
                    arrays[j+1]=arrays[j] ;
                    arrays[j]=a;
                    flag=true;
                }
                if(flag==false){
                    //若一趟不进行任何赋值，则就是有序数组
                    //直接结束排序
                    break;
                }
            }
        }

    }

}
//出现错误java.lang.ArrayIndexOutOfBoundsException
//问题是数组下标越界

稀释数组

  • 数组中有很多值是相同的，只有几个是修改的，我们只需存储修改值就好，可以节省空间
  • 稀疏数组的处理方式
    • 记录数组有几行几列
    • 把具有不同值元素的行和列，记录到小规模数组中，从而缩小程序规模（压缩）
    • 下表第一行表示数组为6行7列数组共8个值不为0，之后每行表示该行该列的值

稀疏数组

public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个11*11,0是无棋，1是白棋，2是黑棋
        int[][] arrays=new int[11][11];
        arrays[1][2]=1;
        arrays[2][3]=2;

        //输出原始数据
        System.out.println("输出原始数据");
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组存储
        //1.获取有效值得个数
        int num=0;
        for (int[] array : arrays) {
            for (int i : array) {
                if(i!=0){
                    num++;
                }
            }
        }
        System.out.println("================================================");
        System.out.println("有效值个数"+num);
        //创建稀疏数组
        int[][] array1=new int[num+1][3];
        //把数据记录到稀疏数组
        int count=1;
        array1[0][0]=arrays.length;
        array1[0][1]=arrays[0].length;
        array1[0][2]=num;
        //遍历数组，将不为0的存放在稀疏数组中
        for (int i = 0; i <arrays.length ; i++) {
            for (int j = 0; j <arrays[i].length ; j++) {
                if(arrays[i][j]!=0){
                    array1[count][0]=i;
                    array1[count][1]=j;
                    array1[count][2]=arrays[i][j];
                    count++;
                }
            }
        }
        //打印稀疏数组
        System.out.println("================================================");
        System.out.println("打印稀疏数组");
        for (int[] ints : array1) {
            for (int k : ints) {
                System.out.print(k+"\t");
            }
            System.out.println();
        }
        //还原稀疏数组
        System.out.println("================================================");
        System.out.println("还原稀疏数组");
        //创建数组
        int[][] array2=new int [array1[0][0]][array1[0][1]];
        //给数组还原值
        for (int i = 1; i <array1.length ; i++) {
            array2[array1[i][0]][array1[i][1]]=array1[i][2];
        }
        //打印还原结果
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

idea快捷键

5.for+enter，自动生成循环

arrays（数组名）.for+enter，自动生成增强for循环

i.for/fori+enter，自动生成循环结构

psvm+enter，自动生成mian函数

sout+enter，自动生成输出语句

sw_eet
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值