Java数组

1、数组概述

2、数组声明创建

package 数组;

public class Demo {
    public static void main(String[] args) {
        int[] nums;//声明一个数组
        nums = new int[5];//创建一个数组

        //int [] num = new int[5];

        //给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;

        //计算所有数组的和
        int sum = 0;

        //获取数组的长度
        for(int i = 0; i < nums.length;i++){
            sum = sum+nums[i];
        }
        System.out.println("总数和为："+sum);
    }
}

3、数组使用

package 数组;

public class Demo {
    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 int [] reverse(int[] arrays) {
        int[] result = new int[arrays.length];
        //反转操作
        for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
    //  打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

4、多维数组

package 数组;

public class Demo1 {
    public static void main(String[] args) {
        /*
        1,2
        2,3
        3,4
        4,5
        */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array);
        System.out.println(array[0][1]);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

5、arrays分类

6、稀疏数组

package 数组;

public class Demo4 {
    public static void main(String[] args) {
        //创建一个二维数组10*10
        int[][] array1 = new int[10][10];
        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();
        }
        System.out.println("======================");

        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数"+sum);

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

        //遍历二维数组，将非零的值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].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; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }
    }
}

冒泡排序

package 数组;

import java.util.Arrays;

public class Demo3 {
    public static void main(String[] args) {
        int[]a={1,13,34,512,132,512,3235};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //通过flag标识位减少没有意义的比较
            boolean flag = false;
            //内层循环，比价判断两个数，如果第一个数比第二个数大，责交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if(array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+i];
                    array[j+i] = temp;
                    flag = true;
                }
            }
            if(flag == false){
                break;
            }
        }
        return array;
    }
}