数组的创建与使用、冒牌排序、稀疏数组

听风说你！

已于 2022-02-27 10:50:29 修改

阅读量265

点赞数 1

文章标签：数据结构算法排序算法

于 2022-02-27 10:41:31 首次发布

本文链接：https://blog.csdn.net/m0_47801930/article/details/123160898

版权

本文详细介绍了Java中的数组，包括数组的定义、声明、创建、初始化、使用方法，如静态初始化、动态初始化和默认初始化。同时展示了多维数组、Arrays工具类的使用，如排序、填充和比较数组。此外，还涵盖了冒泡排序算法和稀疏数组的概念及转换。内容全面，适合Java初学者参考学习。

摘要由CSDN通过智能技术生成

数组

1.数组概述

数组是相同类型的数据的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们
数组的四个基本特点：

1.其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型,不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

2.数组声明创建

声明数组的语法:

int[] num; 或者 int num[];

创建数组、分配空间：

num=new int[10]; 或者直接在声明的时候创建并分配空间： int[] num = new int[10];

声明后数组还没有存在，创建后数组才真实存在
数组的三种初始化

1.静态初始化

//静态初始化:   创建+赋值
        int[] nums = {1,2,3,4,5};

2.动态初始化

//动态初始化：创建+分配空间
int[] nums2 = new int[10];
        nums2[0]=10;

3.默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组已经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

public class Demo01 {
    public static void main(String[] args) {
         int j=1;
        int x = 0;
        //数组定义
        int[] num ;//定义方法①  首选
        //int nums[];  定义方法②
        num = new int[10];  //创建一个数组  分配空间
        for (int i = 0; i < 10; i++) {  //给数组赋值
            num[i]=j;
            j++;
            }

        for (int i = 0; i < 10; i++) {  //循环遍历输出
            System.out.println("num["+i+"]="+num[i]);
        }

        for (int i = 0; i < num.length; i++) { //计算数组的总和
            x+=num[i];
        }
        System.out.println("总和为："+x);
    }
}

3.数组使用

    public class Demo02 {
        public static void main(String[] args) {
            int[] nums = {1,2,6,4,5};
            int sum = 0;
            int max = nums[0];
            //打印数组的全部内容
            for (int i = 0; i < nums.length; i++) {
                System.out.println(nums[i]);
            }
            //计算数组元素的总和
            for (int i = 0; i <nums.length; i++) {
                sum+=nums[i];
            }
            System.out.println("数组元素总和为："+sum);
            //查找最大元素
            for (int i = 1; i <nums.length; i++) {
                if(max<nums[i]){
                    max=nums[i];
                }
            }
            System.out.println("最大元素是："+max);
    
        }
    }

For-Each循环

 public class Demo02 {
          public static void main(String[] args) {
              int[] nums = {1,2,6,4,5};
              //没有下标
              for (int num : nums
                   ) {
                  System.out.println(num);
              }
          }   
      }

数组作方法入参

public class Demo02 {
        public static void main(String[] args) {
            int[] nums = {1,2,6,4,5};
            printArray(nums);
        }
        //打印数组元素
        public static void printArray(int[] nums){
            for (int i = 0; i <nums.length ; i++) {
                System.out.print(nums[i]+" ");
            }
        }
    }

数组作返回值

public class Demo02 {
        public static void main(String[] args) {
            int[] nums = {1,2,6,4,5};
            int[] result = reverse(nums);
            //打印result数组的元素
            for (int resul:result
                 ) {
                System.out.println(resul);
            }
        }
        //反转数组
        public static int[] reverse(int[] nums){
            int[] result = new int[nums.length];
            //反转操作
            for (int i = 0,j=result.length-1; i < nums.length; i++,j--) {
                     result[j] = nums[i];
            }
            return result;
        }
    }

4.多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组语法：

int a[][] = new int[2][5];

 //二维数组输出方式一：
    public class Demo03 {
        public static void main(String[] args) {
            int[][] nums = {{1, 2}, {2, 3}, {4, 3}};
            System.out.println(nums[2][1]);//选择性输出二维数组元素
            for (int i = 0; i <nums.length ; i++) {    //循环遍历输出数组元素
                for (int j = 0; j <nums[i].length ; j++) {
                    System.out.println(nums[i][j]);
                }
            }
        }
    }

//二维数组输出方式二：

 public class Demo05 {
        public static void main(String[] args) {
             //创建一个二维数组 11*11
            int[][] nums = new int[11][11];
            nums[1][2] = 1;
            nums[2][3] = 2;
            //输出数组元素
            for (int[] num:nums
                 ) {
                for (int nu:num
                     ) {
                    System.out.print(nu+"\t");
                }
                System.out.println();
            }
        }
    }

输出结果：

0 0 0 0 0 0 0 0 0 0 0

0 0 1 0 0 0 0 0 0 0 0

0 0 0 2 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0

5.Arrays类

◆数组的工具类java.util.Arrays

◆由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一-些基本的操作。查看JDK帮助文档

◆Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用"而不是"不能")

◆具有以下常用功能:

   ◆给数组赋值:通过fill方法。 

   ◆对数组排序:通过sort方法,按升序。 

   ◆比较数组:通过equals方法比较数组中元素值是否相等。  

   ◆查找数组元素: 通过binarySearch方法能对排序好的数组进行二分查找法操作。

使用Arrays工具类输出数组元素：

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        int[] a = {11,43,454,76,35,79};
        //打印数组
        System.out.println(a);   //输出一个对象的hashCode  [I@7c30a502
        System.out.println(Arrays.toString(a));  //使用Arrays.toString来打印数组元素  [11, 43, 454, 76, 35, 79]
        Arrays.sort(a); //使数组进行排序 升序
        System.out.println(Arrays.toString(a));//输出排序后的数组元素  [11, 35, 43, 76, 79, 454]
        Arrays.fill(a,0);//数组填充
        System.out.println(Arrays.toString(a));//输出填充后的数组元素   [0, 0, 0, 0, 0, 0]
        Arrays.fill(a,2,4,333);
        System.out.println(Arrays.toString(a));//输出填充后的数组元素     [0, 0, 333, 333, 0, 0]
    }
}


6.冒泡排序

   import java.util.Arrays;
   
   public class Demo04 {
       public static void main(String[] args) {
           int[] a = {1,5,2,9,4,6};
           int[] sort = sort(a);
           System.out.println(Arrays.toString(sort));
   
       }
       //冒泡排序
       //1.比较数组中，两个相邻的元素，如果第一个比第二个大，我们就交换它们的位置
       //2.每一次比较，都会产生一个最大，或者是最小的数字
       //3.下一轮则可以少一次排序
       //4.依次循环，知道结束
       public  static int[] sort(int[] nums){
           int temp = 0;  //临时变量
           //外层循环 判断数字要走多少次
           for (int i = 0; i <nums.length-1 ; i++) {
               
               boolean flag = false;//通过flag表示来减少没有意义的比较
               
               //内层循环，比较判断两个数，如果第一个数，比第二个数大，则交换位置
               for (int j = 0; j <nums.length-1-i; j++) {
                   if(nums[j+1]<nums[j]){
                       temp = nums[j];
                       nums[j] = nums[j+1];
                       nums[j+1] =temp;
                       flag = true；
                   }
               }
               if(flag==false){
                   break；
               }
           }
           return nums;
       }
   }

7.稀疏数组

处理方式：

记录数组一共有几行几列，有多少个不同的值
把具有不同值得元素和行列及值记录在一个小规模的数组中，从而宋晓程序的规模

构建稀疏数组以及稀疏数组的还原：

public class Demo05 {
    public static void main(String[] args) {
         //创建一个二维数组 11*11
        int[][] nums = new int[11][11];
        nums[1][2] = 1;
        nums[2][3] = 2;
        //输出数组元素
        for (int[] num:nums
             ) {
            for (int nu:num
                 ) {
                System.out.print(nu+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(nums[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //创建一个稀疏数组的数组
        int[][] nums2 = new int[sum+1][3];
        nums2[0][0] = 11;
        nums2[0][1] = 11;
        nums2[0][2] = sum;
        //遍历二维数组，将非0的值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i <nums.length ; i++) {
            for (int j = 0; j <nums[i].length ; j++) {
                if (nums[i][j]!=0){
                    count++;
                    nums2[count][0] = i;
                    nums2[count][1] = j;
                    nums2[count][2] = nums[i][j];
                }
            }

        }
        //输出稀疏数组
        System.out.println("稀疏数组：");
        for (int i = 0; i <nums2.length ; i++) {
            System.out.println(nums2[i][0]+"\t"+
                     nums2[i][1]+"\t"+
                     nums2[i][2]+"\t");
        }
        System.out.println("================================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] nums3 = new int[nums2[0][0]][nums2[0][1]];

        //2.给其中的元素还原他们的值
        for (int i = 1; i <nums2.length ; i++) {
            nums3[nums2[i][0]][nums2[i][1]] = nums2[i][2];
        }

        //3.打印
        System.out.println("输出还原的数组：");
        for (int[] num:nums3
        ) {
            for (int nu:num
            ) {
                System.out.print(nu+"\t");
            }
            System.out.println();
        }

    }
}

听风说你！

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组的创建与使用、冒牌排序、稀疏数组

数组1.数组概述数组是相同类型的数据的有序集合数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们数组的四个基本特点：1.其长度是确定的，数组 一旦被创建，它的大小就是不可以改变的。其元素必须是相同类型,不允许出现混合类型。数组中的元素可以是任何数据类型，包括基本类型和引用类型。数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象
复制链接

扫一扫