JAVA数组学习笔记

A.数组定义：同类型数据的有序组合

B.数组特点：

a.长度是确定的，一旦创建无法改变
b.数组内的元素必须是相通类型的
c.数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当 于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

C.创建数组：

a.声明数组：1. 数组数据类型[] 数组名称;如 int[] a；（首选方法）
2.数组数据类型 数组名称[]; 如 int a[];
b.创建数组：java使用new来创建数组。如a = new int[5];
c.声明和创建数组可以同时完成，如 int[] a = new int[5];

D.java数组内存分析

java语言的内存分配

声明数组时没有实例对象，JVM不会创建空间，因此声明数组时不能指定数组的长度（个数）

构造数组时必须指定其长度

//2.创建一个数组
myList = new int[10];

//3.像数组中存值
myList[0] = 1;
myList[1] = 2;
myList[2] = 3;
myList[3] = 4;
myList[4] = 5;
myList[5] = 6;
myList[6] = 7;
myList[7] = 8;
myList[8] = 9;
myList[9] = 10;

E.数组的初始化

1.默认初始化

数组创建好后系统会给数组的各元素赋以默认值

整数型数组 0

浮点型数组 0.0

引用类型如String数组 null

char类型数组 \u0000（unicode字符，代表的空格）

boolean类型数组 false

2.静态初始化

int c[] = {23,43,56,78};//长度：4，索引范围：[0,3]
int[] d = new int[]{3,5,9,5,4,9,56};

3.动态初始化

int[] a = new int[9];
        for (int i = 0; i < a.length; i++) {
            a[i]=i+6;
        }

F.数组边界

数组的边界是从0到它的长度减一 int[] a = new int[5] 数组a的边界是从a[0]到a[4]共5个

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

public static void main(String[] args) {
    int[] a=new int[2];
    System.out.println(a[2]);
}
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at com.kuang.chapter3.Demo03.main(Demo03.java:6)

ArrayIndexOutOfBoundsException : 数组下标越界异常！

F.数组的使用

数组的元素类型和数组的大小都是确定的，所以处理数组元素时，我们通常使用基本循环或者For-Each循环。

​ 例：

public class TestArray{
    public static void main(String[] args){
        double[] myList = {1.5,2.6,10.9,7.98};
        
        //输出数组元素
        for(int i=0;i<myList.length;i++){
            System.out.print(myList[i]+"\t");
        }
        
        //计算所有数组元素的和
        double total = 0;
        for(int i=0;i<myList.length;i++){
            total = total + myList[i];
        }
        System.out.println("Total is" + total);
        
        //输出数组最大元素   
        double max = myList[0];
        for(int i=1;i<myList.length;i++){
            if(max<myList[i]){
                max = myList[i];
            }
        }
        System.out.println("Max is" + max);
    }
}

1.数组作为方法的参数

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

2.数组作为返回值

package LianXi;

import java.util.Arrays;

public class LianXi001 {
    public static void main(String[] args) {
        int[] a = {1,2,3,5,8};
        int[] x = reverse(a);
        System.out.println(Arrays.toString(x));
        /*Arrays.toString(x)  Arrays.toString是java自带的一个数组输出方法，效果与下面定义的方法效果相同。 
        static void shuchu(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            //如果是第一个元素，加一个 [
            if (i==0){
                System.out.print("[");
                System.out.print(arr[i]);
            }
            //其他的数组元素后面加一个，
            if (i>0 && i<arr.length-1){
                System.out.print(arr[i]+",");
            }
            //如果是第一个元素，直接输出元素 + ]
            if (i==arr.length-1){
                System.out.print(arr[i]);
                System.out.print("]");
            }
        }

    }
        
         */
    }

    //创建一个返回值为整数数组的方法reverse，这个方法的参数为一个整数数组list
    //方法效果：数组元素反向排列
    public static int[] reverse(int[] list) {

        //创建一个与数组list长度相同的整数数组result
        int[] result = new int[list.length];

        //赋值数组result的元素为list数组元素的反顺序排列
        for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
            result[j] = list[i];
        }

        //返回数组result
        return result;
    }
}

Ctrl Alt M ：选中操作程序后快速创建方法

G.多维数组

多维数组可以看成是数组的数组，如二维数组可以看成是一定数量的普通一维数组组成的数组。

1.多维数组的动态初始化（以为二位数组为例）

直接为每一维分配空间，格式如下：

type[][] typeName = new type[typeLength1][typeLength2];

type 可以为基本数据类型和复合数据类型，arraylenght1 和 arraylenght2 必须为正整数，arraylenght1 为行数，arraylenght2 为列数。

比如，定义一个二维数组：

int a[][] = new int[2][5];

上面的数组可以看成一个两行三列的数组。

2.多维数组的引用（以二维数组为例）

对二维数组的每个元素，引用方式为 arrayName[index1][index2],如

num[1][2];

3.获取数组长度

a.length获取二维数组的第一位数组的长度，a[0].length才是获取第二维第一个数组的长度。

H.Arrays类

数组的工具类为java.util.Arrays

数组对象本身没有什么方法让我们调用，但API中提供了一个工具类Arrays让我们使用，从而对数据对象进行一些基本操作，

文档简介：

此类包含用来操作数组（比如排序和搜索）的各种方法，还包含一个允许将数组作为列表来查看的静态工厂。除非特别注明，否则如果指定数组引用为null，则此类方法都会抛出NullPointerException.

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）。

java.util.Arrays类能方便地操作数组，使用之前需要导入包！

具有以下常用功能：

• 给数组赋值：通过fill方法

• 对数组排序：通过sort方法，按升序

• 比较数组：通过equals方法比较数组中元素值是否相等

• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

a.打印数组

public static void main(String[] args){
    int[] a = {1,2,};
    System.out.println(a);//[I@1b6d3586
    System.out.println(Arrays,toString(a));//[1,2]
}

b.数组排序

对指定的int型数组按数字升序进行排序

public static void main(String[] args){
    int[] a = {1,2,5,3,9,74,,6,4,9,4,3};
    System.out.println(Arrays.toString(a));
    Arrarys.sort(a);
    System.out.println(Arrays,toString(a));
}

c.二分法查找

在数组中查找指定元素并返回其下标

注意：使用二分法查找指定数组指定值前必须对数组进行排序，否则结果是不确定的。

如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

public static void main(String[] args) {
    int[] a = {1,2,323,23,543,12,59};
    Arrays.sort(a);   //使用二分法查找，必须先对数组进行排序
    System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));
}

d.元素填充

public static void main(String[] args) {
    int[] a = {1,2,323,23,543,12,59};
    Arrays.sort(a);   //使用二分法查找，必须先对数组进行排序
    Arrays.fill(a, 2, 4, 100);  //将2到4索引的元素替换为100
    System.out.println(Arrays.toString(a));
}

e.数组转换为List集合

int[] a = {3,5,1,9,7};
List<int[]> list = Arrays.asList(a);

I.常见排序方法

1.冒泡排序

public static void main(String[] args){
    
    //定义创建数组A
    int[] A = {1,5,9,4,6,3,8,7,6,3,56,64,6,32,9,966,531,546,465};
    
    //对数组A进行排序
    paiXv(A);
    
    //将排序后的数组A输出出去
    shuChu(A);
}

//定义创建输出的方法shuChu
public static void shuChu(int[] A){
    for(int i = 0;i<A.length;i++){
        
        //输出左半边[和A[0]
        if(i==0){
            System.out.print("[");
            System.out.print(A[i]);
            
            //输出A[1]到A[A.length-2]并在中间加上“,”
        }else if(i>0&&i<A.length-1){
            System.out.print(",");
            System.out.print(A[i]);
            
            //输出A[A.length-1]和右半边]
        }else{
            System.out.print(","+A[i]);
            System.out.print("]");
        }
    }
}

//定义创建排序方法paiXv
public static void paiXv(int[] A){
    
    //将下面过程循环A.legth-1次
    for(int i=0;i<A.length-1;i++){
        
        //将数组中的最大元素放到最后面
        for(int k=0;k<A.length-1;k++){
           if(A[k]>A[k+1]){
                int B;
                B = A[k];
                A[k] = A[k+1];
               A[k+1] = B;       
           }
        }
    }
}