2021-03-07

学习笔记

一、数组概念

1. 数组是相同类型数据的有序集合；
2. 数组描述的是相同类型的若干个元素按照一定的先后次序排列组合而成；
3. 每一个数据称作一个数组元素每个元素可以通过一个下标来访问他们；（通过下标来访问，从0开始）

二、数组声明创建

1. 首先声明数组变量，才能在程序中使用数组，语法：

   dataType[] num;//首选方法
   dataType num[];//效果一样，但Java中不是首选方法
   

2. Java语言使用new操作符来创建数组，语法：

dataType[] num = new dataType[分配的大小]

public static void main(String[] args) {
    int[] num; //声明一个数组
    num = new int[10];//创建一个里面可以存放10个数字的数组
    num[0]=1;
    num[1]=2;
    num[2]=3;
    num[3]=4;
    num[4]=5;
    num[5]=6;
    num[6]=7;
    num[7]=8;
    num[8]=9;
    num[9]=10;
    //计算所有元素的和
    int sum=0;
    //获取数组长度 num.length
    for (int i = 0; i < num.length; i++) {
       sum = sum + num[i];
    }
    System.out.println(sum);
}

三、内存分析

1. 

声明一个数组，往栈里压入array，创建数组是在堆里面开辟了一个空间，然后赋值；

错误：数组不存在，超出去，下标越界9156456

2. 三种初始化：

   静态初始化和动态初始化

   public static void main(String[] args) {
       //静态初始化 创建+赋值
       int[] a = {1,5,65,2,8,};
       //动态初始化 包含默认初始化
       int[] num = new int[10];
       //后面要手动赋值
       num[1] = 10;
   }
   

默认初始化：数组是引用类型，他的元素相当于类的实例变量，因此数组一般分配空间，其中的每个元素也被按照实例变量同样方式被隐式初始化。（例如：num[1]未赋值，默认就是0）

四、下标越界及小结

数组的四个基本特点：

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

数组边界：

下标的合法区间[0，length-1]，越界就会报错；

Array Index Out Of Bounds Exception:数组小标越界异常；

数组使用：

public static void main(String[] args) {
    int[] array = {1,2,3,4,5,6,7,8,9};
    for (int i = 0; i < array.length ; i++) {
        System.out.println(array[i]);
    }
    //计算和
    int sum = 0;
    for (int i = 0; i < array.length; i++) {
        sum = sum + array[i];
    }
    System.out.println("sum="+sum);
    //找最大元素
    int max=array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i]>max){
            max = array[i];
        }
    }
    System.out.println("max="+max);
}

public static void main(String[] args) {
    int[] array = {1,2,3,4,5,6,7,8,9};
    //增强型for循环
    //for (int i : array) {
      //  System.out.println(i);
   //}
   // printArray(array);
    int[] reverse = reverse(array);//返回一个新数组
    printArray(reverse);
}
//打印数组
public static void printArray (int[] array){
    for (int i = 0; i <array.length ; i++) {
        System.out.print(array[i]+" ");
    }
}
//反转数组
public static int[] reverse (int[] array){
    int[] result = new int[array.length];
    for (int i = 0,j=result.length-1; i < array.length; i++,j--) {
        result[j] = array[i];
    }
    return result;
}

五、二维数组。

在一维数组里在嵌套一层

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

六、Arrays工具类

Arrays是针对数组的工具类，可以进行排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。

1、将数组转化为字符串 —— toString 方法

返回一个包含数组元素的字符串，这些数组元素被放置在[ ]内，用逗号分隔。

int[] a = {2, 3, 5, 7, 11, 13};
    
// [2, 3, 5, 7, 11, 13]
System.out.println(Arrays.toString(a));

2、数组拷贝 —— copyOf 方法

🔺 java允许将一个数组变量拷贝（赋值操作）给另一个数组变量，此时两个变量引用同一个数组。

public class Hello {

public static void main(String[] args) {
 
    int[] a = {2, 3, 5, 7, 11, 13};
    int[] b = a;
    a[1] = -1;
 
    System.out.println(Arrays.toString(a));  //[2, -1, 5, 7, 11, 13]
    System.out.println(Arrays.toString(b));  //[2, -1, 5, 7, 11, 13]
}

}
🔺 如果希望将一个是数组的内容拷贝到一个新的数组中去，且不引用同一个数组，就要使用Arrays.copyOf方法。

public class Hello {

public static void main(String[] args) {
 
    int[] a = {2, 3, 5, 7, 11, 13};
    int[] b = Arrays.copyOf(a, a.length);
    a[1] = -1;
 
    System.out.println(Arrays.toString(a));  //[2, -1, 5, 7, 11, 13]
    System.out.println(Arrays.toString(b));  //[2, 3, 5, 7, 11, 13]
}

}
此法也经常可以用来增加数组长度！

static type copyOf （type[ ] a, int length）

传入参数：待拷贝数组 a，拷贝长度 length。

length < a.length 只拷贝长度范围内的元素
length = a.length 完整拷贝
length > a.length 完整拷贝后再增长数组
–也有局部复制的方法 –

3、数组排序 —— sort 方法

采用优化的快排。

static void Arrays.sort（type[ ] a）

public class Hello {

public static void main(String[] args) {
 
    int[] a = {3, -1, 16, 7, 1, 3};
    Arrays.sort(a);  //排序
 
    System.out.println(Arrays.toString(a));  // [-1, 1, 3, 3, 7, 16]
}

}

4、集体赋值 —— fill 方法

static void fill（type[ ] a, type v）

将数组的所有元素值设置为v

public class Hello {

public static void main(String[] args) {
 
    int[] a = {3, -1, 16, 7, 1, 3};
    Arrays.fill(a, 0);

    System.out.println(Arrays.toString(a));  //[0, 0, 0, 0, 0, 0]
}

}

–也有局部赋值的方法 –

5、查找 —— binarySearch 方法

二分法查找。

需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
（如果数组中有多个相同的元素，查找结果是不确定的）

static int binarySearc（type[ ] a, type v）

查找成功：返回相应的下标值
查找失败：返回一个负数
–也有局部查找的方法 –
原文链接：https://blog.csdn.net/weixin_43787043/article/details/104157944

public static void main(String[] args) {
    int[] a={1,82,93,64,5};
    //System.out.println(a);//[I@16b98e56
   // System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5]
                                           //直接用工具
    Arrays.sort(a);//对数组进行排序
    System.out.println(Arrays.toString(a));
    printArrays(a);
}
//自己写的方法
public static void printArrays(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]+", ");
        }

    }
}

七、冒泡排序

public static void main(String[] args) {
    int[] a={1,2,9,3,5,8,6};
    int[] sort = sort(a);//调用完自己写的排序方法以后，返回一个排序后数组
    System.out.println(Arrays.toString(sort));
}
//冒泡排序 时间复杂度n的平方
public static int[] sort(int[] arry){
    int temp = 0;//临时变量
    //判断外层一共循环多少次
    for (int i = 0; i < arry.length-1; i++) {
        boolean flag = false;//通过flag标识位减少没有意义的比较
        //内层循环 判断第一个数如果比第二个数大 交换位置
        for (int j = 0; j < arry.length-1; j++) {
            if (arry[j+1]>arry[j]){//从大到小 反之改成小于符号
                temp = arry[j];
                arry[j] =arry[j+1];
                arry[j+1] = temp;
                flag = true;
            }
            if (flag == false){
                break;
            }
        }
    }
    return arry;
}

八、稀疏矩阵

public static void main(String[] args) {
    //1.创建一个二维数组
    int[][] array1 = new int[11][11];
    array1[1][2] = 1;
    array1[2][3] = 3;
    //输出原始数组
    System.out.println("输出数组");
    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++;
            }
        }

    }
    System.out.println("有效值个数："+sum);

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

    //遍历二维数组，将非0值存放在稀疏矩阵中
    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");
    }
    //还原稀疏矩阵
    //读取稀疏数组
    int[][] array3 = new int[array2[0][0]][array2[0][1]];
    //给其中的元素还原它的值
    for (int i = 1; i < array2.length; i++) {
        array3[array2[i][0]][array2[i][1]] = array2[i][2];
    }
    //打印
    System.out.println("还原数组");
    for (int[] ints : array3) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();

    }

}