java-数组Array的应用总结

1.什么是数组？

数组是指一组数据的集合，数组中的每个数据被称作元素。数组被分为一维数组和二维数组及多维数组。 其中最常用的是一维，其次是二维。

2.一维数组的定义

数组的定义可以有以下三种类型：

a.直接新建数组

int[] x = new int[100];

同一个数组中的所有元素类型是相同的，数组一旦分配了空间，空间就固定不能修改了。

上述图中语句等号“=”左边定义变量x，该数组变量为int类型，变量x会在栈中占用一块内存单元，等号“=”右边的语句是创建内存大小为100的数组空间，整个语句的合起来就是创建一个内存空间为100的数组，然后将数组的首地址赋值给数组变量x，100个数组内存中保存的初值都为0.

数组是通过索引（下标）一一对应取值的，数组的下标是从0开始计的，例如，上面100个空间，通过数组下标对应为x[0],x[1]......x[99],详情见下图内存状态图。

数组是常见的引用数据类型，声明在栈中，存储在堆中，通过应用对象把声明和具体的存储空间联系起来。

b.先声明，后分配空间

int[] x;           //声明变量
x = new int[100];  //创建数组对象

c.直接赋值确定数组长度

1.  int[] x=new int[]{1,2,3}; 
2.  int[] x={1,2,3};

3.数组的遍历

package com.m.demo02.view;

public class Example {

    public static void main(String[] args) {
        //创建数组对象并赋值
        int[] x = new int[10];
        
        System.out.println("赋值前，遍历数组");        
        //
        for(int i=0;i<x.length;i++){
            System.out.print(x[i]+"、");    
        }
        System.out.println();
        System.out.println("给数组赋值");        
        //给数组赋值
        for(int i=0;i<x.length;i++){
            x[i]=i+1;
        }
        //赋值后，遍历数组
        System.out.println("赋值后，遍历数组");        
        for(int i=0;i<x.length;i++){
            System.out.print(x[i]+"、");
        }        
    }    
}

4.数组的最值

计算数组的最大值和最小值

package com.m.demo02.view;

public class Example {

    public static void main(String[] args) {
        //创建直接赋值数组
        int[] x = {4,1,5,3,8,6,2,7};    
        
        int[] result =getvalue(x);
        System.out.println("最大值为:"+result[0]);
        System.out.println("最小值为:"+result[1]);    
    }
    
    /*
     * 获取最值
     */
    private static int[] getvalue(int[] x) {
        int max = x[0];
        int min = x[0];
        for(int i=1;i<x.length;i++){
            if(max<x[i]){
                max = x[i];
            }
            if(min>x[i]){
                min = x[i];
            }
        
        }
        int[] result={max,min};
        return result;
    }
}

5.数组的排序

　　经典冒泡排序

package com.m.demo02.view;
public class Example {

    public static void main(String[] args) {
        //创建直接赋值数组
        int[] x = {4,1,5,3,8,0,6,2,7};        
        System.out.println("排序前");        
        print(x);    
        System.out.println("排序后");
        sort(x);
        print(x);    
    }    
    /*
     * 打印数组
     */
    public static void print(int[] x){
        for(int i=0;i<x.length;i++){
            System.out.print(x[i]+"、");
        }    
        System.out.println();
    }
    /*
     * 经典冒泡排序
     * if(x[j]>x[j+1]) 把'>'改成'<'可以实现数组升序或者降序排列
     */
    public static int[] sort(int[] x){
        if(x==null||x.length<2){
            return x;
        }
        for(int i=0;i<x.length-1;i++){
            for(int j=0;j<x.length-i-1;j++){
                if(x[j]<x[j+1]){
                    int temp= x[j+1];
                    x[j+1]=x[j];
                    x[j]=temp;
                }else{
                    continue;
                }
            }
        }
        return x;
    }
}

6.数组的逆序

package com.m.demo02.view;

import java.util.Arrays;

public class Example {

    public static void main(String[] args) {
        //创建直接赋值数组
        int[] x = {4,1,5,3,8,6,2};    
        
        //数组逆序之前要先给数组排序
        Arrays.sort(x);
        //数组按照升序排列
        print(x);
        //逆序后的数组
        int[] ReOrdSort=ReverseOrder(x);
        //逆序后的数组降序排序
        print(ReOrdSort);


    }
    /*
     * 数组逆序
     */
     private static int[] ReverseOrder(int[] x) {
         int start = 0;
         int end = x.length-1;
         int mid = x.length/2;
         for(int i=0; i<mid;i++){
             if(start<=mid){
                 int temp =x[start];
                 x[start] = x[end];
                 x[end] = temp;
                 start++;
                 end--;
             }else{
                 return x;
             }
         }
         return x;
    }

    /*
     * 打印数组
     */
    public static void print(int[] x){
        for(int i=0;i<x.length;i++){
            System.out.print(x[i]+"、");
        }    
        System.out.println();
    }
}

7.二维数组的定义

方式一

//二维数组的定义
int[][] arr = new int[3][4];

二维数组相当于一个矩阵，上述定义的二维数组，相当于3行4列的矩阵，二维数组的索引也是从0开始，例如：arr[0][0]

方式二

//定义不定长二维数组
int[][] arr = new int[3][];

这种定义，只确定了行数，没有确定每行具体的元素个数，所以元素排列可长可短。

方式三

//直接通过所赋值来确定二维数组的行和列
int[][] arr = {{1,2},{1,2,3},{1,2,3,4}};

8.二维数组的遍历、求和和最值

package com.m.demo02.view;

public class Example {

    public static void main(String[] args) {
        //创建二维数组
        //也可以直接这样赋值 int[][] arr = {{4,1,5},{3,8,6},{2,0,9}};
        int arr[][] =new int[3][3];
        arr[0] = new int[]{4,1,5};
        arr[1] = new int[]{3,8,6};
        arr[2] = new int[]{2,0,9};
            
        //二维数组的遍历
        print(arr);
        
        //打印 计算二维数组的总和
        int sum = 0;
        print(arr,sum);
        
        // 打印最大值和最小值
        int max = 0;
        int min = 0;
        print(arr,max,min);
        
    }
    

    /*
     * 打印二维数组
     */
    public static void print(int[][] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
            System.out.print(arr[i][j]+"、");    
            }
        } 
        System.out.println();
    }
    /*
     * 计算二维数组的和
     */
    public static int print(int[][] arr,int sum){
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
            sum = sum+arr[i][j];    
            }
        } 
        System.out.println("二维数组总和为："+sum);
        return sum;
    }
   /*
    * 计算二维数组的最大值最小值 
    */
private static void print(int[][] arr, int max, int min) {
     for(int i=0;i<arr.length;i++){
         for(int j=0;j<arr[i].length;j++){
         if(max<arr[i][j]){
             int temp = arr[i][j];
             arr[i][j] = max;
             max = temp;
         }
         if(min>arr[i][j]){
             int temp = arr[i][j];
             arr[i][j] = min;
             min = temp;
         }
         }
     } 
     System.out.println("二维数组最大值："+max);
     System.out.println("二维数组最小值："+min);

    }
}