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. //在一段数组中自底向上两两排序，每次都将小的数排到最前头
//通过元素的两两比较，判断是否符合要求，如过不符合就交换位置来达到排序的目的
    • 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    • 每一次比较，都会产生出一个最大，或者最小的数字
    • 下一轮则可以少一次排序
    • 依次循环，直到结束

  3. 时间复杂度：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数组（二）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
栏目导航