java数组

本文主要是介绍java数组，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

数组定义：

package com.mao.array;

public class ArrayDemo01 {
    //变量的类型 变量的名字 =变量的值
    public static void main(String[] args) {

        int[] nums;//1.定义（首选）

        nums=new int[10];//2.创建一个数组

        //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[0]);

        //获取数组的和
        int sum=0;
        for (int i = 0; i <nums.length; i++) {
            sum+=nums[i];
        }

        System.out.println(sum);
    }
}

内存分析：

数组的三种初始化状态：

package com.mao.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化,创建+赋值
        int[] a={1,2,3,4,5,6};

        //引用类型
        Man[] mans={new Man(),new Man()};

        System.out.println(a[0]);

        //动态初始化:包含默认初始化
        int[] b=new int[10];
        b[0]=10;
        System.out.println(b[0]);
        System.out.println(b[1]);//未被初始化 默认位0 这就是默认初始化
    }
}

数组的使用：

package com.mao.array;

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]);
        }

        System.out.println("===============================");

        //计算所有元素的和
        int sum=0;
        for (int i = 0; i <arrays.length ; i++) {
            sum+=arrays[i];
        }
        System.out.println("和为："+sum);

        System.out.println("===============================");

        //查找最大元素
        int max=arrays[0];
        for (int i = 1; i <arrays.length ; i++) {
            if(arrays[i]>max){
                max=arrays[i];
            }

        }
        System.out.println("最大值为:"+max);
    }
}

进阶的数组使用： 

package com.mao.array;

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

//        for (int array : arrays) {
//            System.out.println(array);
//        }

       // printArray(arrays);

        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i <arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }

    }

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

}

多维数组：

package com.mao.array;

public class ArrayDemo05 {
    public static void main(String[] args) {

        //二维数组 [4][2]  四行两列
    /*
    1，2
    2，3
    3，4
    4，5
     */
        int[][] arrays={{1,2},{2,3},{3,4},{4,5}};

        for (int i = 0; i <arrays.length ; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.println(arrays[i][j]);
            }
        }

//        System.out.println(arrays[0][0]);
    }



}

Arrays类：

package com.mao.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {

        int[] a={1,2,3,455,8588,66,};//[I@14ae5a5
        //打印数组元素Arrays.toString
        System.out.println(a);

        System.out.println(Arrays.toString(a));

        //数组进行排序  升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //数组填充
        //Arrays.fill(a,0);
        Arrays.fill(a,2,4,0);//2到4之间包含2不包含4，进行填充0
        System.out.println(Arrays.toString(a));

    }
}

冒泡算法：

package com.mao.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {

        int[] a={1,568,55,44,6666,123};

        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;
                 }
             }
             if(flag==false)
             {
                 break;
             }


         }
         return array;

     }
}

稀疏数组：

package com.mao.array;

public class ArrayDemo08 {
    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();
        }

        //转换为稀疏数组 来保存
        //获取有效值的个数
        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);

        //2.创建一个稀疏数组的数组

         int[][] array2=new int[sum+1][3];

         array2[0][0]=11;
         array2[0][1]=11;
         array2[0][2]=sum;


         //遍历二维数组，将非0的值存放在稀疏数组中

        int count=0;
        for (int i = 0; i <array1.length; i++) {
            for (int j = 0; j < array1[1].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-1 ; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
            }

        //还原
        System.out.println("还原");

        //1.读取稀疏数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        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();
        }

    }
}

这篇关于java数组的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！