java数组整理笔记

数组介绍

1. 数组就是相同类型的数据的有序组合，包含多个数组元素，每个元素都能通过下标获取，下标为0-数组长度（arrays.length）；
2. 数组的元素可以是8种类型中的任意一种，或是引用类型，但是同一个数组中的所有元素类型都必须相同，不可a0是int型，a1是char型；
3. 动态初始化：int\[\] a =new a10;未赋值的数组元素默认为0；
4. 静态初始化：int\[\] a={1,2,3,4,5,6};
5. 数组元素通过下标引用，如a0;

二维数组

1. 数组定义声明：int \[\]\[\] arraysTwo ={{1,2},{1,5},{3,5},{4,55},{3,444}};
2. 如何取值，通过下标如arraysTwo00;
3. 代码示例：

package ArraysTest;

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

工具类Arrays

1. 打印元素；Arrays.toString(a)；
2. 排序：Arrays.sort(a)；
3. 填充：Arrays.fill(a,2, 4, 0)；

package ArraysTest;
import  java.util.Arrays;

public class ArraysDemo05 {
    static void main(String[] args) {
        int[] a={1,3,5,6,8,2,22,11,2};
        //打印数组元素
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);//排序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2, 4, 0);//填充，下标2-4之间的填充0,即a[2] a[3]填充0；
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

1. 两层循环，第一层排序轮数，第二层比较前一个数和后一个数的大小，大的排前，小的排后，按照从大到小的排序；java代码如下：

package ArraysTest;
import java.util.Arrays;

public class ArraysDemo06 {
    static void main(String[] args) {
        int[] a={50,3,5,6,8,255,22,11,2};
        int[]aa=sortTest(a);
        System.out.println(Arrays.toString(aa));
    }
    public static  int[] sortTest(int[] a){
        int temp ;
        //比较的轮数。
        for (int i=0;i<a.length-1;i++){
            //比较，后面的比前面大则交换，那么就是相当按照从大到小排序；
            for (int j=0;j<a.length-1-i;j++){
                if (a[j+1]>a[j]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }
}

稀疏数组

1. 同一个数组中大部分元素都是0（或是其他的同一个值时），可以用稀疏数组表示，节省资源；
2. 如原数组如下：

package ArraysTest;
import java.util.Arrays;

public class ArraysDemo07 {
    static void main(String[] args) {
         int[][] arrays1 =new int[11][11];
        arrays1[2][2] =1;
        arrays1[0][3] =2;
        for (int i = 0; i< arrays1.length; i++){
            for (int j = 0; j< arrays1[i].length; j++){
                System.out.print(arrays1[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

3. 转换稀疏数组如下：

package ArraysTest;

public class ArraysDemo07 {
    static void main(String[] args) {
        int[][] arrays1 = new int[11][11];
        arrays1[2][2] = 1;
        arrays1[0][3] = 2;
        System.out.println("原数组如下：");
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                System.out.print(arrays1[i][j] + "\t");
            }
            System.out.println();
        }
        //转换为稀疏数组，先获取有效值个数
        int count1 = 0;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if (arrays1[i][j] != 0) {
                    count1++;
                }
            }
        }
        System.out.println("数组arrays有效值个数" + count1);
        //创建稀疏数组,赋值第一行的值
        int[][] arrays2 = new int[count1 + 1][3];
        arrays2[0][0] = 11;
        arrays2[0][1] = 11;
        arrays2[0][2] = count1;
        //遍历原数组，将非零的值，存在稀疏数组中
        int count2 = 0;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if (arrays1[i][j] != 0) {
                    count2++;
                    arrays2[count2][0] = i;
                    arrays2[count2][1] = j;
                    arrays2[count2][2] = arrays1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组如下：");
        for (int i= 0; i < arrays2.length; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arrays2[i][j] + "\t");
            }
            System.out.println();
        }
    }
}