java数组

数组

数组：是指相同类型数据的有序集合
数组的声明：

int[] numbers  = new int[10];

获取数组长度：
arrays.length

java内存分析

• 堆：存放new的对象和数组
• 栈：存放基本变量类型
• 方法区

数组的三种初始化

• 静态初始化：int[] a ={1,2,3,4,5}
• 动态初始化（包括默认初始化）： int[]b = new int[10];
• 默认初始化：默认值

数组的基本特点

• 创建后长度固定
• 元素为相同类型
• 元素可以是任何数据类型，包括引用类型
• 数组变量属于引用类型，数组可以看成对象，数组的元素可以看成对象的成员变量

数组在堆中·

数组的使用

• For each循环

for (int i : arr) {
            System.out.println(i);
        }

可以遍历数组的值，但是无法获取下标

• 数组作为方法入参

反转数组

package method;

public class Arrays {

    //反转数组
    public static int[] reverse(int[] arrays) {
       int[] resault = new int[arrays.length];
        for(int i=0,j=resault.length-1;i<arrays.length;i++,j--) {
            resault[j]=arrays[i];
        }
        return resault;
    }
    public static void main(String[] args) {
        int[] arrays= {2,2,3,4,5};
        int[] a= reverse(arrays);
        for (int k:a) {
            System.out.println(k);
        }
        }
    }

多维数组

• 二维数组
  int a[][] = new int[2][5]

Arrays类

都是由static修饰，直接可以用类名调用

• Arrays.toString 打印数组
• Arrays.sort 数组排序

冒泡排序

比较相邻两个数的大小，左边大于右边，则交换，小于则不变，从右到左依次遍历
下一轮少一次排序

package Arrays;
import java.util.Arrays;
public class bubbleSort {
    //冒泡排序
    public static int[] bubblesort(int[] a){
        //外层循环判断走了多少次
        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]){
                  int b =a[j+1];
                  a[j+1]=a[j];
                  a[j]=b;
              }
        }
        }
        return a;
    }
    public static void main(String[] args) {
        int[] a = {1,3,4,2,5};
        System.out.println(Arrays.toString(bubblesort(a)));
}
}

稀疏数组

数组中大部分元素是0或者同一个数值时，可以用稀疏数组保存数组

处理方式：

• 查看数组有几行几列，有多少不同的值
• 把具有不同数值的行列记录在一个小数组中，从而缩小规模

package Arrays;

public class xishuArrays {
    //稀疏数组
    public static void main(String[] args) {
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        //普通数组
        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("............. ");
        //稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length; j++) {
                if (a[i][j] != 0) {
                    sum = sum + 1;
                }
            }
        }
        System.out.println(sum);
        //创建稀疏数组
        int[][] b = new int[sum + 1][3];
        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;
        //遍历二维数组
        int c = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0) {
                    c++;
                    b[c][0] = i;
                    b[c][1] = j;
                    b[c][2] = a[i][j];
                }

            }
        }
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i][0] + "\t" +
                    b[i][1] + "\t" +
                    b[i][2] + "\t");
        }
    }
}