JAVA学习笔记08——数组

JAVA学习笔记08——数组

数组是相同类型的有序集合

每一个数据称作一个数组元素，可通过下标来访问

数组的声明创建

先声明数组变量

        int[] nums1;
        int nums2[];

数组类型[] 数组名

数组类型 数组名[]

声明数组

int [] array = null;

创建数组

array = new int[10]

数组初始化

• 静态初始化

int [] a={1, 2, 3}

Man[] mans = {new Man (1,1),new Man(2,2)};

• 动态初始化

int[] a = new int[2];

a[0]=1;

a[1]=2;

数组的四个基本特点

长度确定，一旦创建大小不可以改变

元素是相同类型

元素可以是任何类型

数组对象本身在堆中

数组边界，下标的合法区间[0,length-1]

ArrayIndexOutOfBoundsException：数组下标越界异常

int[] a = new int[2]数组的初始化

数组的使用

• For-Each循环

打印数组

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

反转数组

    // 反转数组
    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;
    }

多维数组

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

Arrays类

需要import包导入

        //Arrays类
        int[] aaa = {1, 2, 3, 4, 567, 3234, 1123};
        System.out.println(aaa);
        System.out.println(Arrays.toString(aaa));

冒泡排序

两层循环

1、比较数组中两个相邻的元素，如果第一个数比第二个大，就交换位置

2、每一次比较，都会产生出一个最大，或者最小的数字

3、下一轮则，可以少一次排序

4、依次循环直到结束

输出数组

Arrays.toString(sort)

冒泡排序从大到小

import java.util.Arrays;

public class j08maopao {
    public static void main(String[] args) {
        int[] a={1,4,5,2,9,3,7};
        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++) {
            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;
                }
            }
        }
        return array;
    }
}

稀疏数组

是一种数据结构

当一个数组中大部分都是0或者大部分都是同一数值时候

记录数组一个又几行几列，把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

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