数组

数组概述

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

数组声明创建

• 首先声明数组变量，才能在程序中使用数组，下面是声明语法

 int [] b;  //定义数组 首选
 int a[];   //定义数组，效果相同，但不首选
       

• Java语言使用new 操作符来创建数组，语法

   int[] c=new int[3];

• 数组的元素通过索引访问的，数组索引从0开始
• 获取数组长度：

arrays.lenth

• 三种初始化

  • 静态初始化

       int[]  a={1,2,34,5,6};//静态初始化
       Demo2[]  man={new Demo2(),new Demo2()};
  

  • 动态初始化

   int[]  b=new int[3];//动态初始化,含默认初始化
          ///赋值
          b[0]=1;
          b[1]=2;
          b[2]=3;
  

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

• 数组的四个基本特点

  1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
  2. 其元素必须是相同类型，不允许出现混合类型
  3. 数组的元素可以是任何数据类型，包括基本类型和引用类型。
  4. 数组变量属于引用类型，数组也可以看成是对象。数组中的每个元素相当于该对象的成员变量。数组本身就是对象，JAVA中对象是在堆中的(new出来的都在堆中的)，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的
  5. 数组下标越界：下标的合法区间[0,length-1]如果越界报错ArrayIndexOutOfBoundsException

        int[]  b=new int[3];//动态初始化,含默认初始化
          ///赋值
          b[0]=1;
          b[1]=2;
          b[2]=3;
        System.out.println(b[3]);//输出报错java.lang.ArrayIndexOutOfBoundsException: 3
  

数组使用

• for-each循环
• 数组作方法入参
• 数组做返回值

 public static void main(String[] args) {
        int[] a={1,23,4,5,6};
        for (int v:a
             ) {
               System.out.print(v+"\t");
              }
               System.out.println();
              System.out.println("-----------排序升序----------------------");
              int[] m=arrayPrin(a);
              for(int l:m){
                  System.out.print(l+"\t");
               }
              System.out.println();
              System.out.println("-----------数组反转----------------------");
              int[]  p=testArray(a);
              for (int i=0;i<p.length;i++)
              {
                 System.out.print(p[i]+"\t");
              }
    }
    //排序
    public static int[] arrayPrin(int [] v){

        int tmp=0;
        for (int a=0;a<v.length;a++)
        {
         for (int b=a+1;b<v.length;b++)
            if(v[a]>v[b]){
                tmp=v[a];
                v[a]=v[b];
                v[b]=tmp;
            }
        }
        return  v;
    }
    //反转数组
    public  static int[] testArray(int[] a){
        int[] q=new int[a.length];
        for (int i=0,j=q.length-1;i<q.length &&j>=0;i++,j--)
        {
            q[i]=a[j];
        }
        return q;
    }
}
/*
* 
*  1    23  4   5   6   
*  -----------排序升序----------------------
*  1    4   5   6   23  
*  -----------数组反转----------------------
*  23   6   5   4   1   
* 
* */

多维数组

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

二维数组：

int[][] a={{1,5},{23,4},{4,22}};
    for (int i=0;i<a.length;i++)
    {
        for (int j=0;j<a[i].length;j++)
        {
            System.out.print(a[i][j]+"\t");
        }
    }

Arrays类

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

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

• 查看JDKB帮助文档

• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类调用，而不用使用对象来调用

• 具有以下常用功能

  • 给数组赋值：通过fill方法
  • 给数组排序：通过sort方法 按升序
  • 比较数组.通过equals方法比较数组中元素值是否相等。
  • 查证数组元素：通过binarySearch方法能对排序号的数组进行二分查找操作。

  实例1：

     public static void main(String[] args) {
          int [] a={ 1,3,5,22,34,11,32};
          System.out.println("比较--------------");
          int [] b={ 1,3,5,22,34,11,32};
          System.out.println(Arrays.equals(a,b));
          System.out.println("查找3--------------");
          System.out.println(Arrays.binarySearch(a,3));//返回下标
          Arrays.sort(a);
          System.out.println("排序--------------");
          System.out.println(Arrays.toString(a));//默认升序排
       /*
          比较--------------
          true
          查找3--------------
          1
          排序--------------
         [1, 3, 5, 11, 22, 32, 34]
       */
  
      }
  

稀疏数组

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

• 稀疏数组的处理方式是:

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

• 第一行是 行列以及值的个数；后续行则展示行列坐标以及对应的值。

public static void main(String[] args) {
    int [][] array1=new int[6][7];
        array1[0][3]=22;
        array1[0][6]=15;
        array1[1][1]=11;
        array1[1][5]=17;
        array1[2][3]=-6;
        array1[3][5]=39;
        array1[4][0]=91;
        array1[5][2]=28;
        for (int i=0;i<array1.length;i++){
            for(int j=0;j<array1[i].length;j++ )
            {
                System.out.print(array1[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("二维数组转稀疏数组---------------");
        int [][] array2;
        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+=1;
            }
          }
        }
        //创建稀疏数组
       array2=new int[count+1][3];
        //赋值
        array2[0][0]=6;
        array2[0][1]=7;
        array2[0][2]=count;
       int con=0;
        for (int i=0;i<array1.length;i++)
        {
            for(int j=0;j<array1[i].length;j++){
                if(array1[i][j]!=0)
                {
                    con++;
                    array2[con][0]=i;
                    array2[con][1]=j;
                    array2[con][2]=array1[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int i=0;i<array2.length;i++){
            for(int j=0;j<array2[i].length;j++ )
            {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("----------------稀疏数组还原二维数组");
        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];
        }
      //输出还原后的数组
        for (int i=0;i<array3.length;i++){
            for(int j=0;j<array3[i].length;j++ )
            {
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
    }

}
/*
0	0	0	22	0	0	15	
0	11	0	0	0	17	0	
0	0	0	-6	0	0	0	
0	0	0	0	0	39	0	
91	0	0	0	0	0	0	
0	0	28	0	0	0	0	
二维数组转稀疏数组---------------
6	7	8	
0	3	22	
0	6	15	
1	1	11	
1	5	17	
2	3	-6	
3	5	39	
4	0	91	
5	2	28	
----------------稀疏数组还原二维数组
0	0	0	22	0	0	15	
0	11	0	0	0	17	0	
0	0	0	-6	0	0	0	
0	0	0	0	0	39	0	
91	0	0	0	0	0	0	
0	0	28	0	0	0	0	
*/

数组拓展，冒泡排序

eg1:

/**
     * @author  xujb
     * 冒泡排序
     * */
    public static void main(String[] args) {
      int [] v={1,2,3,4,5,6,7,8,9};
     // sortTest(v);
        sorTest2(v); 冒泡排序
        System.out.print(Arrays.toString(v));
    }

    /**
     * 普通的自个写的排序,每次拿对应次数位置的数字和剩余的数字比较取最大的值放在对应位置。
     * */
    public static int[] sortTest(int [] b)
    {
        int tmp=0;
        for(int i=0;i<b.length;i++){
            for(int j=i+1;j<b.length;j++ )
            {
              if(b[i]<b[j])  {
                  tmp=b[i];
                  b[i]=b[j];
                  b[j]=tmp;
              }
            }
        }
        return  b;
    }
    /**
     * 冒泡排序，内层循环，从1开始每次筛选一个最小值
     * 冒泡排序：
     * 1.比较数组中，两个相邻的元素，如果第一个数比第二个数小，我们就交换他们的位置
     * 2.每一次比较都会产生一个最大或者最新的数字
     * 3下一轮可减少一次排序j<ar.length-1-i 体现在-i
     * 4.依次循环，直到结束
     *
     * */
    public  static  int[] sorTest2(int[] ar){
        int temp=0;
        for(int i=0;i<ar.length-1;i++){
            for(int j=0;j<ar.length-1-i;j++)
            {
                if (ar[j]<ar[j+1]) {
                    temp=ar[j];
                    ar[j]=ar[j+1];
                    ar[j+1]=temp;
                }
            }
        }
        return  ar;

    }
//输出：[9, 8, 7, 6, 5, 4, 3, 2, 1]