标签：java int day07 System arrays 数组 println out

d 07 Java数组(p 51-p 59)

1.什么是数组？

数组就是一组数的集合。

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成。
其中，每一个数据称之为一个数组元素，每个数组元素都可以通过对应的下标进行访问。

多个相同类型的数据使用多个相同类型的变量来记录是十分麻烦的，优先使用数组进行记录，再依靠下标取出。

2.数组的声明和创建

首先必须声明数组变量，才能在程序中使用数组。

dataType[] arrayRefVar;  //首选的方法，是Java中的首选定义方式
dataType arrayRefVar[];	 //效果相同，但不是首选的方法,C和C++是这样定义的

Java使用new操作符来新建数组
Java中定义一个东西的通式为：变量类型变量名字 = 变量值;

//Java中定义一个东西的通式为：变量类型 变量名字 = 变量值;
dataType[] arrayRefVar = new dataType[arraySize];
//数组的元素是通过索引进行访问的，数组索引从0开始；使用 数组名.length获取数组长度

public class Demo01 {
    public static void main(String[] args) {
        int[] nums;     //1.声明数组，尚未赋值(没有分配内存空间)
        nums = new int[3];  //2.创建数组的大小(分配空间),不写的话那我存多少呢？
        //声明和创建一起写 int[] nums = new int[3];
        //否则记录这10个数字，需要使用10个变量，此时使用一个变量就可以保存10个
        //此时分配了一个内存空间叫做nums，再在这基础上开辟多个空间...
        // 用于存储多个相同类型的数据
        //3.给数组中的元素赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        System.out.println(nums[2]);//不赋值的话，输出默认值
        //计算所有数字之和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum+=nums[i];
        }
        System.out.println("数组中元素总和为："+sum);
    }
}

数组的四个基本特点：
1. 数组的长度是确定的，一旦被创建，则其大小不可以改变。
2. 数组中的元素类型必须相同，不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属于引用类型，数组也可以视为对象，数组中的元素相当于该对象的成员变量。数组本身就是对象，Java中对象是存在于堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

3.三种初始化及内存分析

1) Java内存分析

① 堆

存放new的对象和数组(数组本身也是一种对象)
可以被所有的线程共享，不会存放别的对象引用

② 栈

存放基本变量类型(包含该基本变量类型的具体数值)
引用对象的变量(会存放该引用在堆里的具体地址)

③ 方法区

可以被所有的线程共享
包含了所有的class和static变量

声明数组时，数组是不存在的；数组都是通过new操作符创建出来的，存放在堆中；真正赋具体的值是存放在栈中的。

2) 三种初始化状态

静态初始化：创建+初始化

int[] a = {1,2,3};
Man[] men = {new Man(1,1),new Man(2,2)};//给内存空间一个名字

动态初始化：包含默认初始化

int[] a = new int[2];//创建后空间中均为默认值，可以随时初始化
a[0] = 1;
a[1] = 2;

数组的默认初始化

数组是引用类型(除了8大基本类型外，都是引用类型)，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

4.下标越界及小结

5.数组的使用

普通for循环：取出值或者下标进行操作

数组通常和for循环结合在一起使用，尤其是搭配增强for循环(for-each)使用。下面是普通for循环：

public class Demo02 {
    public static void main(String[] args) {
        int[] arrays = {-1,-2,-3,5,7,8,94,35,666};
        //输出数组中的所有元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println("数组中第"+(i+1)+"个元素为："+arrays[i]);
        }
        System.out.println("========================");
        //输出所有数组中元素之和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];
        }
        System.out.println("数组中所有元素之和为："+sum);
        System.out.println("========================");
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(arrays[i]>max){
                max = arrays[i];
            }else{
                max = arrays[0];
            }
        }
        System.out.println("数组中的最大值为："+ max);
    }
}

for循环中找值，循环体外进行输出，因为结果输出一次即可，不要进入循环体中，否则会多次输出。

For-Each循环：打印一些结果

int[] arrays = {1,2,3,4,5}	//使用arrays.for自动生成，省去了数组的下标
for(int array : arrays){	//arrays是数组,array是数组中的元素
    System.out.println(array);//适合打印输出，不便单独操作其中的元素
}

数组作方法参数：对数组进行操作处理

public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"\t");
        }
    }

数组作返回值：修改数组形成一个新的数组，返回新的数组

//数组作为返回值——反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转的具体操作
        for (int i = 0,j=arrays.length-1; i < arrays.length;i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }

6.二维数组

多维数组可以看作是数组的数组（即嵌套），比如二维数组就是一个特殊的一维数组，其中每一个元素都是一个一维数组。

//二维数组
int a[][] = new int[2][5];//2行5列的数组
int[][] arrays = {{1,2},{3,4},{5,6}}//int[]时每个位置上是元素，现在是数组{},3行2列[3][2]

一维数组可以看作是线，二维是直角坐标系，三维是空间坐标系，去确定一个点时所需的维度在不断提升。但是数组和真实世界的维度还是有区别的，因为数组自身是可以量化处理，而真实世界的上升维度是有限的，在人的认知范围内。

public class twoDarray {
    public static void main(String[] args) {
        /*
        * [4][2]
        * 1,2 array[0]
        * 3,4 array[1]
        * 5,6 array[2]
        * 7,8 array[3]
        * */
        int[][] array = {{1,2},{3,4},{5,6},{7,8}};
//        System.out.println(array[0]);//此时返回的是一个数组对象 [I@1540e19d
        printArray(array[0]);//数组之中嵌套数组
        System.out.println();
        //因为array[0]是一个数组对象，所以使用printArray方法是可以取出该数组中的所有元素的
        System.out.println("二维数组中的某个元素为："+array[0][1]);//使用二维数组角标也可以取出元素
        System.out.println(array.length);//最外层数组的维度4
        System.out.println(array[0].length);//嵌套在内层的数组的维度2       
    }
    //打印数组元素,将数组封装成方法的参数
    public static void printArray(int[] arrays){
        System.out.print("数组对象中的每个元素为：");
        for (int i = 0; i < arrays.length; i++) {
            System.out.print("数组中的第" + (i+1) + "个元素为" + arrays[i] + "\t");
        }
    }
}

一次性取出多维数组中的所有元素，使用for循环

平常使用中，二维数组足矣，Java中不会使用多维数组进行操作，因为Java是面向对象编程，后续遇到的东西都会变成对象进行处理。这里多维数组了解即可，不必深究。

public class twoArray {
    public static void main(String[] args) {
        int[][] array = {{1,2},{3,4},{5,6},{7,8},{9,10}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+"\t");
            }
        }
    }
}

7. Arrays类讲解

数组的工具类 java.util.Arrays 由于数组对象本身并未提供什么方法可以调用，但API中提供了一个工具类Arrays，从而可以对数组对象进行一些基本操作。
Arrays类中的方法使用的修饰符均为static，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用(注意：是不用不是不能)，作为静态类可以 . 出来很多方法使用。
具有以下常用功能
- 给数组赋值：使用fill方法
- 对数组排序：使用sort方法，按升序
- 比较数组：使用equals方法比较数组中元素的值是否相等
- 查找数组元素：使用binarySearch方法能对排序好的数组进行二分查找操作

public class array {
    public static void main(String[] args) {
        int[] a = {1,23,12,2,34,1,555,9};
        System.out.println(a);
        //[I@1540e19d 数组的返回值的是一个对象object，本质是一个hashcode
        //打印数组元素，以字符串的形式打印出来
        System.out.println(Arrays.toString(a));//toString方法打印数组
        printArray(a);
        System.out.println();
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));//升序,常用排序方法有8种
    }
    //方法类也都开可以自己写
    public static void printArray(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]+", ");
            }
        }
    }
}

8.冒泡排序

冒泡的代码有两层循环：外层冒泡轮数，里层依次比较，循环嵌套的时间复杂度为O(n2)。

/*冒泡排序
1、比较数组中，两个相邻的元素，如果前一个数字比后一个数字大，则交换位置
2、每一次比较都会产生一个最大或者最小的数字
3、下一轮可以减少一次排序顺序，同时参与排序的元素也会减少一个
4、依次循环，直至结束。
**/
public class test {
    public static void main(String[] args) {
        int[] a = {1,2,3,55,4,3,2,666,76,9};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array) {
        int temp = 0;
        boolean flag = true; //减少不必要的比较
        //外层循环，判断走多少次循环
        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;
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
        return array;
    }
}

9.稀疏数组

稀疏数组属于一种数据结构，是一种压缩算法，用于压缩数组，便于保存，大大减少空间储存量。遍历后再进行取值和赋值的工作，稀疏数组——记录有效的坐标及其坐标值。

需求：编写五子棋游戏时，有存盘退出和续上盘的功能。因为该二维数组的很多值默认是0，因此记录了很多没有意义的数据；解决方法就是使用稀疏矩阵进行数据的记录。
当一个数组中大部分元素为0，或者为同一数值时，可以使用稀疏数组来保存该数组。
- 稀疏数组的处理方式：
  - 记录数组有几行几列，有多少个不同值
  - 记录的数据有：①几行几列 ②几处是非零值（有效的数字） ③非零值的坐标位置以及非零值的具体数值，从而缩小程序的规模。

//稀疏数组——记录有效的坐标及其坐标值
public class demo08 {
    public static void main(String[] args) {
        //1、创建一个二维数组 11*11  1：黑棋 2：白棋
        int[][] a1 = new int[11][11];
        a1[1][2] = 1;
        a1[2][3] = 2;
        //使用增强for循环，输出原始数组
        //System.out.println("输出原始的数组为：" + Arrays.toString(a1[1]));
        for (int[] ints : a1) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
        System.out.println("=====================");
        //转换为稀疏数组——遍历后再进行取值和赋值的工作
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(a1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数为："+sum);
        //2、创建一个代表稀疏数组的二维数组
        int[][] a2 = new int[sum+1][3];//列数固定为3列，行数为有效值个数加1
        a2[0][0] = 11;
        a2[0][1] = 11;
        a2[0][2] = sum;
        //遍历二维数组，将非零的值放入稀疏数组中
        int count = 0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                if(a1[i][j]!=0){
                    count++;
                    a2[count][0] = i;
                    a2[count][1] = j;
                    a2[count][2] = a1[i][j];
                    //将非零值的行列位置对应的原始坐标以及具体数值放在稀疏矩阵中
                }
            }
        }
        System.out.println("输出稀疏数组：");
        for (int i = 0; i < a2.length; i++) {
            System.out.println(a2[i][0]+"\t"
                                +a2[i][1]+"\t"
                                +a2[i][2]+"\t");
        }
        System.out.println("=====================");
        //还原
        System.out.println("稀疏数组还原为原始数组：");
        //1、读取系数数组
        int[][] a3 = new int[a2[0][0]][a2[0][1]];
        //2、给其中的元素还原回原来的值
        for (int i = 1; i < a2.length; i++) {//从1开始，第0行是头部信息，不需要读取
            a3[a2[i][0]][a2[i][1]]=a2[i][2];
        }
        System.out.println("输出还原的数组：");
        for (int[] ints : a3) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }
}

标签：java,int,day07,System,arrays,数组,println,out
From： https://www.cnblogs.com/olin25/p/16935455.html

day07_java_数组