Java教程

Java数组(二)

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

Java数组(二)

Arrays类

  1. Arrays类是一个数组工具类

  2. Arrays类的方法都是static修饰的静态方法,所以在使用时可以之间使用类名进行调用

  3. 常用方法:

    • 给数组赋值(填充、覆盖):fill
    • 对数组排序(升序):sort
    • 比较数组是否相等:equals
    • 查找数组元素(用的是二分查找法):binarySearch
  4. 导入包:

    import java.util.Arrays;
    
  5. //输出数组
    import java.lang.reflect.Array;
    import java.util.Arrays;
    public class ArrayDemo08 {
        public static void main(String[] args) {
            int[] a = {1,2,4,5,6,3};
            System.out.println(Arrays.toString(a));//调用Arrays的toString方法输出数组a
        }
    }
    //输出:
    [1, 2, 4, 5, 6, 3]
    
    //通过Arrays的sort方法对数组从小到大(升序)进行排序
    import java.util.Arrays;
    public class ArrayDemo09 {
        public static void main(String[] args) {
            int[] a = {5,3,7,1,8,2};
            Arrays.sort(a);//排序
            System.out.println(Arrays.toString(a));//输出数组
        }
    }
    //输出:
    [1, 2, 3, 5, 7, 8]
    
    //对数组进行覆盖(填充)
    import java.util.Arrays;
    public class ArrayDemo10 {
        public static void main(String[] args) {
            int[] a={1,2,3,4,5,6};
            System.out.println("填充前:");
            System.out.println(Arrays.toString(a));
            Arrays.fill(a,0);//全部填充成0
            System.out.println("全部填充成0后:");
            System.out.println(Arrays.toString(a));
            Arrays.fill(a,2,4,3);//将第二个和第四个元素填充成3
            System.out.println("再将下标为2到下标为4的元素填充成3后:");
            System.out.println(Arrays.toString(a));
        }
    }
    //输出:
    填充前:
    [1, 2, 3, 4, 5, 6]
    全部填充成0后:
    [0, 0, 0, 0, 0, 0]
    再将下标为2到下标为4的元素填充成3后:
    [0, 0, 3, 3, 0, 0]
    
    

冒泡排序

  1. //在一段数组中自底向上两两排序,每次都将小的数排到最前头
    //通过元素的两两比较,判断是否符合要求,如过不符合就交换位置来达到排序的目的
    
    • 比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
    • 每一次比较,都会产生出一个最大,或者最小的数字
    • 下一轮则可以少一次排序
    • 依次循环,直到结束
  2. 时间复杂度:O(n^2)

//例子:
/*
在一个数组5,3,7,2,9,1,3中,从左向右,要求最终结果是从大到小排列
第一遍:
-第一次:5>3,5在左3在右,不用交换
-第二次:3<7,由于要求从大到小排列,所以3和7交换位置5,7,3,2,9,1,3
-第三次:3>2,不用交换
-第四次:2<9,交换:5,7,3,9,2,1,3
-第五次:2>1,不用交换
-第六次:1<3,交换:5,7,3,9,2,3,1
第一遍结果:5,7,3,9,2,3,1
最小值1排到了最右边,(类似将冒泡一样一步一步到最右面)
第二遍再将5,7,3,9,2,3依照上面方法进行排序
经过一遍一遍冒泡得到最终结果:9,7,5,3,3,2,1
*/
  1. //实例:从大到小排列
    import java.util.Arrays;
    public class BArrayDemo01 {
        public static void main(String[] args) {
            int[] array = {1,6,2,4,9,4,8};
            array=Bubble(array);
            System.out.println(Arrays.toString(array));//输出排好序的
        }
        public static int[] Bubble(int[] array){
            int a=0;
            for (int i=array.length-1;i>=0;i--){
                for (int j=0;j<i;j++){
                    if (array[j]<array[j+1]){
                        a=array[j];
                        array[j]=array[j+1];
                        array[j+1]=a;
                    }
                }
            }
            return array;
        }
    }
    //输出:
    [9, 8, 6, 4, 4, 2, 1]
    

稀疏数组

  1. 什么情况下用:

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

  2. 稀疏数组如何存储:

    记录有效坐标

  3. 稀疏矩阵的处理方法:

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

    //二维数组
    [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] 
    

    将上面二维数组转为稀疏数组为:

    行(row) 列(col) 值(value)
    [0] 6(共6行) 7(共7列) 8(有8个有效值)
    [1] 0 3 22
    [2] 0 6 15
    [3] 1 1 11
    [4] 1 5 17
    [5] 2 3 -6
    [6] 3 5 39
    [7] 4 0 91
    [8] 5 2 28

    其中下标为0存储的是二维数组有多少行和多少列,有效值有几个

    只用记录9个值就行

    原数组:

    import java.util.Arrays;
    public class ArrayDemo11 {
        public static void main(String[] args) {
            int[][] array = new int[6][7];
            array[0][3]=22;
            array[0][6]=15;
            array[1][1]=11;
            array[1][5]=17;
            array[2][3]=-6;
            array[3][5]=39;
            array[4][0]=91;
            array[5][2]=28;
            for (int[] ints : array) {
                System.out.print(Arrays.toString(ints)+" ");
                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] 
    
    

    稀疏矩阵:

    import java.util.Arrays;
    public class ArrayDemo11 {
        public static void main(String[] args) {
            int[][] array = new int[6][7];
            array[0][3]=22;
            array[0][6]=15;
            array[1][1]=11;
            array[1][5]=17;
            array[2][3]=-6;
            array[3][5]=39;
            array[4][0]=91;
            array[5][2]=28;
            for (int[] ints : array) {
                System.out.print(Arrays.toString(ints)+" ");
                System.out.println("");
            }
            System.out.println("====================");
            //转换为稀疏数组
            System.out.println("将上述矩阵转为稀疏数组:");
            //获取有效值个数
            int sum=0;//sum记录有效值个数
            for(int i=0;i<6;i++){
                for(int j=0;j<7;j++){
                    if(array[i][j]!=0){
                        sum++;
                    }
                }
            }
            System.out.println("有效值个数为:"+sum);
            //创建稀疏数组
            int[][] array2=new int[sum+1][3];
            int count=0;
            array2[0][0]=array.length;//存入二维数组有多少行
            array2[0][1]=array[0].length;//存入二维数组有多少列
            array2[0][2]=sum;//存入二维数组有多少有效值
            for(int i=0;i<array.length;i++){
                for(int j=0;j<array[i].length;j++){
                    if(array[i][j]!=0){
                        count++;
                        array2[count][0]=i;//行
                        array2[count][1]=j;//列
                        array2[count][2]=array[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]+" ");
                }
                System.out.println("");
            }
            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] 
    ====================
    将上述矩阵转为稀疏数组:
    有效值个数为:8
    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 
    ====================
    

    稀疏矩阵还原:

    import java.util.Arrays;
    public class ArrayDemo11 {
        public static void main(String[] args) {
            int[][] array = new int[6][7];
            array[0][3]=22;
            array[0][6]=15;
            array[1][1]=11;
            array[1][5]=17;
            array[2][3]=-6;
            array[3][5]=39;
            array[4][0]=91;
            array[5][2]=28;
            for (int[] ints : array) {
                System.out.print(Arrays.toString(ints)+" ");
                System.out.println("");
            }
            System.out.println("====================");
            //转换为稀疏数组
            System.out.println("将上述矩阵转为稀疏数组:");
            //获取有效值个数
            int sum=0;//sum记录有效值个数
            for(int i=0;i<6;i++){
                for(int j=0;j<7;j++){
                    if(array[i][j]!=0){
                        sum++;
                    }
                }
            }
            System.out.println("有效值个数为:"+sum);
            //创建稀疏数组
            int[][] array2=new int[sum+1][3];
            int count=0;
            array2[0][0]=array.length;//存入二维数组有多少行
            array2[0][1]=array[0].length;//存入二维数组有多少列
            array2[0][2]=sum;//存入二维数组有多少有效值
            for(int i=0;i<array.length;i++){
                for(int j=0;j<array[i].length;j++){
                    if(array[i][j]!=0){
                        count++;
                        array2[count][0]=i;//行
                        array2[count][1]=j;//列
                        array2[count][2]=array[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]+" ");
                }
                System.out.println("");
            }
            System.out.println("====================");
            //将稀疏数组还原为二维数组
            int[][] array3 = new int[array2[0][0]][array2[0][1]];
            for (int i=1;i<=array2[0][2];i++){
                array3[array2[i][0]][array2[i][1]]=array2[i][2];
            }
            System.out.println("恢复成二维数组为:");
            for (int[] ints : array3) {
                System.out.print(Arrays.toString(ints)+" ");
                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] 
    ====================
    将上述矩阵转为稀疏数组:
    有效值个数为:8
    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] 
    
    
这篇关于Java数组(二)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!