数组

数组

  1. 数组概述

  2. 数组声明创建

  3. 数组使用

  4. 多维数组

  5. Arrays类

  6. 稀疏数组

什么是数组

数组是相同数据类型的有序集合

数组描述的是相同的数据类型的若干数据,按照一定的先后次序排列组合而成

其中,每一个数据称作一个数组元素,每一个数组元素可以通过一个下标来访问它们。

数组声明创建

首先必须声明数组才可以在程序中使用,语法:

package array;

public class ArrayDemo01 {
   //变量的类型 变量的名字 =变量的值
   //数组类型
   public static void main(String[] args){
       int[] nums;//1.定义
       nums=new int[10];//这里面可以存放10个int 类型的数字
       //3.给数组元素赋值
       nums[0]=1;
       nums[1]=2;
       nums[2]=3;
       nums[3]=4;
       nums[4]=5;
       nums[5]=6;
       nums[6]=7;
       nums[7]=8;
       nums[8]=9;
       nums[9]=10;
       System.out.println(nums);
       //计算所有元素的和
       int sum=0;
       for (int i=0;i<nums.length;i++){
           sum=sum+nums[i];
      }
       System.out.println(sum);
  }
}
package array;

public class ArrayDemo02 {
  public static void main(String[] args) {
      //静态初始化
      int[]a={1,2,3,4,5,6,7,8};
      System.out.println(a[0]);
      //动态初始化
      int[]b=new int[10];
      b[0]=10;
      System.out.println(b[0]);
      System.out.println(b[2]);
  }
}

四个基本特点

  1. 长度是确定的,一旦被创建,他的大小就是不可变的

  2. 元素的类型必须是相同的类型,不允许出现混合类型

  3. 数组元素可以是任何数据类型,包括基本类型和引用类型

  4. 数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量

  5. 数组本身就是对象,java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

下标的合法区间[0,array.length-1]

否则会出现ArrayIndexOutOfBoundsException异常

数组使用

For-Each循环

 

数组作方法入参

 

数组作返回值
package array;

import java.util.Arrays;

public class ArrayDemo03 {
   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]);

      }
       //不再使用下标
       for (int array:arrays){
           System.out.println(array);
      }
       //反转数组
       int[]array=reverse(arrays);
       //打印全部的数组元素
       for (int i=0;i<array.length;i++){
           System.out.println(array[i]);

      }

  }
   public static int[] reverse(int[] arrays){
       int[] result=new int[arrays.length];
       for (int i=0,j=result.length-1;i<arrays.length;i++,j--){
           result[j]=arrays[i];
      }
       return result;
  }
}

 

多维数组

package array;

public class ArrayDemo04 {
   public static void main(String[] args) {
       //[4][2]
       /*
       1,2 array[0]
       2,3 array[1]
       3,4 array[2]
        */
       int[][] array={{1,2},{2,3},{3,4},{4,5}};
       System.out.println(array[0][0]);
       System.out.println(array[0][1]);
       System.out.println(array[2][0]);
       System.out.println(array[2][1]);
  }
}

Arrays类

数组的工具类java.util.Arrays

由于数组对象本身没有什么方法可以供我们调用,但是API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作

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

具有以下常用的功能:

给数组赋值:通过fill方法

对数组排序:通过sort方法

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

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

package array;
import java.util.Arrays;

public class ArrrayDemo05 {
   public static void main(String[] args) {
      int[]a={1,2,3,4,9090,11313,1424,343509};
       /*System.out.println(a);
       //打印数组元素Arrays.toString
       System.out.println(Arrays.toString(a));*/
       Arrays.sort(a);//排序
       printArray(a);
       Arrays.fill(a,2,4,0);//填充
       printArray(a);
  }
   public static void printArray(int[]a){
       for (int i=0;i<a.length;i++){
           if (i==0){
               System.out.print("[");
          }
           if (i==a.length-1){
               System.out.print(a[i]+"]");
          }else {
               System.out.print(a[i] + ",");
          }
      }
  }
}

冒泡排序

一共有八大排序

原理:两层循环,外层冒泡轮数,里层依次比较

时间复杂度O(n2)

package array;

import java.util.Arrays;

public class ArrayDemo06 {
   public static void main(String[] args) {
       int[]a={1,2,3,4213,12131,414,134342,435,10,7,9};
       int[] sort=sort(a);
       System.out.println(Arrays.toString(sort));
       //冒泡排序
       //1.比较数组中两个相邻的元素,如果第一个元素比第二个元素大,我们就交换他们的位置
       //2.每一次比较都会产生最大最小数字
       //3.下一轮则可以减少一次排序
       //4.依次循环
  }
   public static int[] sort(int[] array){
       //临时变量
       int temp=0;
       //外层循环.判断我们要走多少次
       for (int i=0;i<array.length-1;i++){
           //内层循环比较两个数,如果第一个数比第二个数大则交换位置
           for(int j=0;j<array.length-1-i;j++){
               if (array[j+1]>array[j]){
                   temp=array[j];
                   array[j]=array[j+1];
                   array[j+1]=temp;
              }
          }
      }
       return array;
  }
}

优化:

package array;

import java.util.Arrays;

public class ArrayDemo06 {
   public static void main(String[] args) {
       int[]a={1,2,3,4213,12131,414,134342,435,10,7,9};
       int[] sort=sort(a);
       System.out.println(Arrays.toString(sort));
       //冒泡排序
       //1.比较数组中两个相邻的元素,如果第一个元素比第二个元素大,我们就交换他们的位置
       //2.每一次比较都会产生最大最小数字
       //3.下一轮则可以减少一次排序
       //4.依次循环
  }
   public static int[] sort(int[] array){
       //临时变量
       int temp=0;
       //外层循环.判断我们要走多少次
       for (int i=0;i<array.length-1;i++){
           boolean flag=false;//通过flag标志位减少没有意义的比较
           //内层循环比较两个数,如果第一个数比第二个数大则交换位置
           for(int j=0;j<array.length-1-i;j++){
               if (array[j+1]>array[j]){
                   temp=array[j];
                   array[j]=array[j+1];
                   array[j+1]=temp;
                   flag=true;//不产生比较结果,flag就不变,直接跳过
              }
          }
           if (flag==false){
               break;
          }
      }
       return array;
  }
}

 

稀疏数组

当一个数组中大部分元素为0,或者为同一个值的数组时,可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是:

记录数组一共有几行几列,有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模数组中,从而缩小程序规模

package array;

public class ArrayDemo07 {
   public static void main(String[] args) {
       //1.创建一个二维数组11*11 0:没有棋子 1:黑棋 2:白棋
       int[][]array1=new int[11][11];
       array1[1][2]=1;
       array1[2][3]=2;
       //输出原始的数组
       System.out.println("输出原始的数组");
       for (int[] ints:array1){
           for (int anInt:ints){
               System.out.print(anInt+"\t");
          }
           System.out.println();
      }
//转换为稀疏数组保存
       //获取有效值的个数
       System.out.println("=============================");
       int sum=0;
       for (int i = 0; i < 11; i++) {
           for (int j = 0; j < 11; j++) {
               if (array1[i][j]!=0){
                   sum++;
              }

          }

      }
       System.out.println("有效值的个数:"+sum);
       //创建一个稀疏数组的数组
       int[][]array2=new int[sum+1][3];
       array2[0][0]=11;
       array2[0][1]=11;
       array2[0][2]=sum;
       //遍历二维数组,将非零的值,存放稀疏数组中
       int count=0;
       for (int i = 0; i < array1.length; i++) {
           for (int j = 0; j < array1[i].length; j++) {
               if (array1[i][j]!=0){
                   count++;
                   array2[count][0]=i;
                   array2[count][1]=j;
                   array2[count][2]=array1[i][j];
              }

          }

      }
       //输出稀疏数组
       System.out.println("稀疏数组");
       for (int i = 0; i < array2.length; i++) {
           System.out.println(array2[i][0]+"\t"
                   +array2[i][1]+"\t"
                   +array2[i][2]+"\t");

      }
       System.out.println("==============================");
       System.out.println("还原");
       //1.读取数组
       int[][] array3=new int[array2[0][0]][array2[0][1]];
       //给其中的元素还原值
       for (int i =1; i < array2.length; i++) {
           array3[array2[i][0]][array2[i][1]]=array2[i][2];

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

 

posted @ 2021-07-09 23:54  一颗苹果!!  阅读(132)  评论(0)    收藏  举报