Java SE 数组学习整理

最新推荐文章于 2023-06-27 10:13:16 发布

南理利拉德0.0

最新推荐文章于 2023-06-27 10:13:16 发布

阅读量43

点赞数

本文链接：https://blog.csdn.net/qq_40784315/article/details/116400100

版权

数组的声明与创建

package array;

public class Demo02 {
    public static void main(String[] args) {
        
        //静态初始化：创建+幅值
        int[] a = {1,2,3,4,5};
        System.out.println(a[0]);


        //动态初始化：包含默认初始化
        int[] nums = new int[10];
        nums[0]=10;


        System.out.println(nums[0]);
        System.out.println(nums[1]);

    }
}

for循环数组使用

遍历语句

for (int i = 0; i < array.length; i++) {

package array;
    //  for循环数组使用
public class Demo03 {
    public static void main(String[] args) {

        int array[] = {1,2,3,4,5};

        //打印全部
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");

        }
        System.out.println();
        System.out.println("==============");
        //求和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];

        }
        System.out.println(sum);

        System.out.println("==============");
        //最大的数
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i]>max){
                max = array[i];
            }

        }
        System.out.println(max);
    }
}

forEach循环数组使用（增强for循环）

一维数组 arrays.for

package array;
    //Each循环数组使用 增强for循环
public class Demo04 {
    public static void main(String[] args) {

        int arrays[] = {1,2,3,4,5};
        //arrays.for
        for (int array : arrays) {
            System.out.print(array+" ");

        }
        //无法对数组里面具体的数进行操作

    }
}

二维数组
arrays.for / ints.for

package array;
    
public class Demo09 {
    public static void main(String[] args) {
        //原始数组
        int[][] arrays1 = new int[11][11];

        arrays1[1][2] = 1;
        arrays1[2][3] = 2;

        //输出原始数组
        for (int[] ints : arrays1) {//arrays.for
            for (int anInt : ints) {//ints.for
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

数组作方法入参数组作返回值

package array;
    //数组作方法入参
    //数组作返回值
public class Demo05 {
        public static void main(String[] args) {
            int arrays[] = {1,2,3,4,5};

            int[] reverse = reverse(arrays);
            printArrays(reverse);
            System.out.println();
            printArrays(arrays);


        }

        //打印
        public static void printArrays(int[] arrays){
            for (int i = 0; i < arrays.length; i++) {
                System.out.print(arrays[i]+" ");
            }
        }
        //反转数组
        public static int[] reverse(int[] arrays){
            //创造一个长度相同的新数组来作为反转数组
            int[] a = new int[arrays.length];

            for (int i = 0; i < arrays.length; i++){
                int j = arrays.length - i - 1;
                a[j] = arrays[i];

            }
            return a;
        }
}

结果：

5 4 3 2 1 
1 2 3 4 5 
Process finished with exit code 0

数组作返回值时，原始数组在方法中没有发生改变,只是调用应用了这个数组的长度。

二维数组

package array;

public class Demo06 {
    public static void main(String[] args) {
        int[][] arrays = {{1,2},{3,4},{5,6},{7,8}};
        /*
        arrays[0]   1,2
        arrays[1]   3,4
        arrays[2]   5,6
        arrays[3]   7,8
         */
		//输出二维数组
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j]+" ");

            }
        }

    }
}

Arrays类

package array;

import java.util.Arrays;

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

        int[] a = {1,3,4,5,67,89,0,7,4,35};
        //打印数组元素Arrays.toString
        //System.out.println(Arrays.toString(a));
        //printArrays(a);

        //排序Arrays.sort
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));


        //填充
        Arrays.fill(a,1,4,0);
        System.out.println(Arrays.toString(a));

    }



    //也可以自己写toString方法
    public static void printArrays(int[] a){
        for (int i = 0; i < a.length; i++) {
            if(i==0){
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }

        }
    }
//    if(i==0){
//        System.out.print("["+a[i]+", ");
//    }else if(i==a.length-1){
//        System.out.print(a[i]+"]");
//    }else {
//        System.out.print(a[i]+", ");
//    }




}

结果：

[0, 1, 3, 4, 4, 5, 7, 35, 67, 89]
[0, 0, 0, 0, 4, 5, 7, 35, 67, 89]

Process finished with exit code 0

冒泡排序

package array;

import java.util.Arrays;

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

        int[] a = {8, 3, 4, 6, 7, 4, 56, 76, 345, 89, 0};

        //sort(a);
        int[] sort = sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(sort));
    }

    //冒泡排序
    public static int[] sort(int[] arrays){
        //临时变量 用于排序交换
        int temp = 0;

        //外循环 进行多少次排序
        for (int i = 0; i < arrays.length - 1; i++) {
            //内循环 从小往大排 大的在后面
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j+1]<arrays[j]){
                    temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;

                }
            }

        }
        return arrays;
    }


}

结果：

[0, 3, 4, 4, 6, 7, 8, 56, 76, 89, 345]
[0, 3, 4, 4, 6, 7, 8, 56, 76, 89, 345]

Process finished with exit code 0

sort方法对数组a进行了改变，所以数组a和返回数组sort都进行了排序。和数组入方法入参一节产生对比，体会其中差异。

稀疏数组

思路：

建立原始数组，填入有效值；
输出原始数组；
建立稀疏矩阵数组；（我们需要知道该数组有几行几列所以需要知道原始数组中有多少个有效值，这样该矩阵的行数就为有效值+1，故引入sum来获取有效值的个数）
创建之后遍历原始数组，将非零的元素存放在稀疏矩阵中；（count）
输出稀疏矩阵；
通过稀疏矩阵来得到原始矩阵，并输出；

package array;
    //稀疏数组：记录有效的坐标
public class Demo09 {
    public static void main(String[] args) {
        //原始数组
        int[][] arrays1 = new int[11][11];

        arrays1[1][2] = 1;
        arrays1[2][3] = 2;

        //输出原始数组
        for (int[] ints : arrays1) {//arrays.for
            for (int anInt : ints) {//ints.for
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=========================================");
        //转换为稀疏数组

        //1.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if (arrays1[i][j]!=0) {
                    sum++;
                }
            }

        }
        System.out.println("有效值的个数:"+sum);


        //2.创建一个稀疏数组
        int[][] arrays2 = new int[sum+1][3];
        arrays2[0][0] = 11;
        arrays2[0][1] = 11;
        arrays2[0][2] = sum;

        //遍历二维数组，将非零的值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j <arrays1[i].length; j++) {
                if (arrays1[i][j]!=0){
                    count++;
                    arrays2[count][0] = i;
                    arrays2[count][1] = j;
                    arrays2[count][2] = arrays1[i][j];
                }

            }
        }
        System.out.println("稀疏数组为：");
        //输出稀疏数组
        for (int i = 0; i < arrays2.length; i++) {
            System.out.println(arrays2[i][0]+"\t"
                    +arrays2[i][1]+"\t"
                    +arrays2[i][2]+"\t");
        }


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

        //还原
        int[][] arrays3 = new int[arrays2[0][0]][arrays2[0][1]];
        arrays3[arrays2[1][0]][arrays2[1][1]] = arrays2[1][2];
        arrays3[arrays2[2][0]][arrays2[2][1]] = arrays2[2][2];

        //输出还原后的数组
        for (int[] ints : arrays1) {//arrays.for
            for (int anInt : ints) {//ints.for
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

结果：

0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
=========================================
有效值的个数:2
稀疏数组为：
11	11	2	
1	2	1	
2	3	2	
=========================================
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

Process finished with exit code 0

南理利拉德0.0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java SE 数组学习整理

数组的声明与创建package array;public class Demo02 { public static void main(String[] args) { //静态初始化：创建+幅值 int[] a = {1,2,3,4,5}; System.out.println(a[0]); //动态初始化：包含默认初始化 int[] nums = new int[10];
复制链接

扫一扫