【后端】java-初步认识数组

什么是数组？

定义：数组是一种用于存储多个相同类型的有序集合。

数组的特点：

1.数组必须是同类型的元素，不可以是混合元素；

2.数组的长度是确定的，一旦被创建大小就不可以改变；

3.数组可以是任何类型的数据包括基本数据类型和引用类型；

4.数组变量相属于引用类型，数组也是对象，数组元素相当于对象的属性。

数组的定义和初始化方式：

在java中，数组定义数组格式为int arr[ ]或者int[ ] arr，前者数组名是arr数组。后者数组名是arr；

数组初始化：就是为数组中的数组元素分配空间并为每个元素赋值。

分为静态初始化和动态初始化，格式如下：

：                int [ ]       arr = { 1 , 2 , 3 } ;——静态初始化

                   int [ ]     arr   =  new           int[3];——动态初始化

数组的内存分配：

Java 程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：存储局部变量
定义在方法中的变量，例如：arr
使用完毕，立即消失

堆内存：存储new出来的内容(实体，对象)
数组在初始化时，会为存储空间添加默认值
    整数：0
    浮点数：0.0
    布尔：false
    字符：空字符
    引用数据类型：null
每一个new出来的东西都有一个地址值
使用完毕，会在垃圾回收器空闲时被回收

如图所示：

如何访问数组中的元素：

数组变量访问方式
格式：数组名

数组内部保存的数据的访问方式
格式：数组名[索引]

索引是数组中数据的编号方式
作用：索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名
特征①：索引从0开始
特征②：索引是连续的
特征③：索引逐一增加，每次加1

查找比对数据是否在数组中：

借用字符比对的方法，例子如下：

public class Test1 {
    public static void main(String[] args) {
        int[] a = { 11, 12, 13 };
        // 打印输出
        System.out.println(IntArrLookupInt(a, 11));
    }
/**
     * 判断int数组中是否存在某个值的方法
     * 
     * @param Arr 待查找int数组
     * @param a   需要查找的值
     * @return :存在 true :不存在 false
     */
    public static boolean IntArrLookupInt(int[] intArr, int intt) {
        String b = intt + ""; // 先转换为String类型
        for (int i : intArr) {
            if (b.equals(i + "")) {
                return true;
            }
        }
        return false;
    }
}

数组的遍历（主要讲for循环）：

除此之外还有foreach、forin、file、map等方式。

for（i=0;i<arr.length;i++）

{system.out.println(arr[i]);}
//或者可以输入System.out.println(Arrays.toString(数组名));

冒泡排序原理：

用二重循环实现，外循环变量设为i，内循环变量设为j。假如有n个数需要进行排序，则外循环重复n-1次，内循环依次重复n-1，n-2，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,n-1，对于每一个i，j的值依次为0,1,2,...n-i 。

设数组长度为N：
1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。
2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
3．N=N-1，如果N不为0就重复前面二步，否则排序完成。

例如：

 给定一个整型数组，数组成员10个,求该数组中第二大的数的下标

数据如图：{1, 2, 3, 4, 5, 6, 7, 8, 9, 0} ; --0，1，2，3，4，5，6，7，8，9}

public class TiChu {
    public static void main(String[] args) {
        int [] yuanshi={1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
        int max=0;//最大值初始化；
        int i=0; int j=0;//定义全局变量；
        int max2=0;
        int count=0;//定义下标；
        for (i=0;i<yuanshi.length;i++){
            if (yuanshi[i]>max){
                max=yuanshi[i];
                i++;
            }//循环筛选出最大值并赋值给max；

        }
        for ( j=0;j<yuanshi.length;j++){

            if (yuanshi[j]!=max){//剔除max之后找出最大值赋值给max2；
                if (yuanshi[j]>max2){

                max2=yuanshi[j];
                count++;
                
            }}
        }

            System.out.println("第二大的数是："+max2+"下标为"+count);
        
    }
}

二维数组：

（二维数组其实是一位数组的嵌套（每一行看做一个内层的一维数组）；

格式1: 动态初始化

数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ][ ]  数组名 = new 数据类型[m][n]
数据类型 [ ]   数组名 [ ] = new 数据类型[m][n]

举例：int [ ][ ]  arr=new  int [3][3];  也可以理解为“3行3例”

格式2: 静态初始化

数据类型 [ ][ ]   数组名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};

举例：int [ ][ ]  arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};

静态初始化可用于不规则二维数组的初始化.

数组的拷贝：

arrcopy方法：

static String[] concat(String[] a, String[] b) {

  String[] c= new String[a.length+b.length];

  System.arraycopy(a, 0, c, 0, a.length);

  System.arraycopy(b, 0, c, a.length, b.length);

  return c;

}

需要注意的是：拷贝合并的数组得是同一类型。此外也可以用for循环遍历合并两个甚至多个数组：

例如：

import java.util.Arrays;
   public class Xc {
    public static void main(String[] args) {
        int[] a = {1, 7, 9, 11, 13, 15, 17, 19};
        int[] b = {2, 4, 6, 8, 10};
        int[] c = new int[13];//定义一个新数组
        int i=0;//定义全局变量；
        while ( i<c.length) {//填写条件控制语句
            for (int x = 0; x < a.length; x++) {
                c[i] = a[x];//将数组a数据放入数组c中；
                i++;//全局变量i自增
            }
            for (int y = 0; y < b.length; y++) {
                c[i] = b[y];//将数组b数据放入数组c中，由于全局变量i自增，依然从i开始。
                i++;
            }
        }
        System.out.println(Arrays.toString(c));//输出数组c。
}}