数组基础详解以及相关问题解析

系统管理员 2023-02-24 08:06 17阅读 0赞

### 目录 ###

*   *   *   *  数组的创建和使用
             *  数组的初始化方式
             *  数组基本使用
             *  反转数组
             *  二维数组
             *  Arrays类
             *  冒泡排序

#### 数组的创建和使用 ####

数据类型[] 变量 = new 数据类型[数组的长度]

比如定义一个存放int类型的数组`int[] i= new int[5]`，如果要给数组里面加上数据的话，数组下标应从0开始，现在在里面添加数据

a[0] = 1;
    a[1] = 2;
    a[2] = 3;
    a[3] = 4;
    a[4] = 5;
    System.out.printIn(i.length）//输出数组的长度
    a[5] = 6;//数组长度不够会造成数组的越界

对于数组，有特定的方法`length`去获取到数组的长度

#### 数组的初始化方式 ####

上面的这一种是动态初始化，定义好数组放入数据，还有另两种初始化方式：

*  默认初始化：当动态初始化的时候没有给数组进行赋值时，那么这些数组会默认初始化，值全为0
 *  静态初始化:直接|赋值 `int[] i = {1,2,3,4,5}`

**数组的特点小结**

*  数组一旦创建，就不可改变
 *  数组在内存中存储相同数据类型连续的一块空间，数组名代表的是内存中的首地址，类型可以是基本数据类型或者引用数据类型，数组的下标从0开始
 *  数据其实就是对象，`对象都是存放在Java内存中的堆空间的`

#### 数组基本使用 ####

/** * @author jektong * @Date 2020/7/8 16:14 */
    public class ArrayTest { 
        public static void main(String[] args) { 
            int[] arrays ={ 1,2,3,4,5};
            //打印全部数组元素
            for(int i = 0; i < arrays.length; i++){ 
                System.out.println(arrays[i]);
            }
            System.out.println("==========");
            //计算所有元素的和
            int sum = 0;
            for(int i = 0; i < arrays.length; i++){ 
              sum = sum + arrays[i];
            }
            System.out.println(sum);
            System.out.println("==========");
            //查找最大元素
            int max = arrays[0];
            for(int i = 0; i < arrays.length; i++){ 
               if(arrays[i] > max){ 
                    max = arrays[i];
               }
            }
            System.out.println(max);//5
        }
    }

結果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]

#### 反转数组 ####

下面再用方法的方式来理解数组的使用方式：

/** * @author jektong * @Date 2020/7/8 18:56 */
    public class ArrayTest { 
        public static void main(String[] args) { 
            int[] arrays= { 1,2,3,4,5};
            ArrayTest.printArray(arrays);
            int[] newArray = ArrayTest.reserve(arrays);
            ArrayTest.printArray(newArray);
    
        }
        //反转数组
        public static int[] reserve(int[] arrays){ 
            int[] newArray = new int[arrays.length];
            for(int i = arrays.length - 1; i >= 0; i--){ 
                newArray[newArray.length - i - 1] = arrays[i];
            }
            return  newArray;
        }
        //输出数组
        public static void printArray(int[] arrays){ 
            for (int i = 0; i <= arrays.length - 1; i++) { 
                System.out.print(arrays[i] + " ");
            }
        }
    }

#### 二维数组 ####

对于二维数组的理解，就是一维数组中的每个元素存了多个数据可以理解为数组的嵌套，比如a\[0\]中存放了多个数据：

初始化二维数组

int[][] a = new int[4][3]//初始化数组
    int[][] a = {
       {1,2,3},{4,5,6}}//直接给数组赋值

代码演示：

/** * @author jektong * @Date 2020/7/8 21:42 */
    public class ArrayTest03 { 
        public static void main(String[] args) { 
            int[][] a = { { 1,2,3},{ 4,5,6},{ 7,8,9}};
            System.out.println(a[0][2]);//3
            System.out.println(a[2][0]);//7
            //遍历数组
            for (int i = 0; i < a.length ; i++) { 
                for (int j = 0; j < a[i].length ; j++) { 
                    System.out.println(a[i][j]);
                }
            }
        }
    }

**数组常见的几个应用拓展**：

#### Arrays类 ####

Java中提供一个操作数组的类Arrays类，里面定义了很多关于数组操作的方法比如数组的排序，数组的重新填充等，这些方法全部是static所以可以用类名直接调用。列举几个常用的方法

/** * @author jektong * @Date 2020/7/9 9:53 */
    public class ArraysApplication { 
        public static void main(String[] args) { 
            int[] a ={ 1,3,45,6,78,78};
            //toString()方法打印数组
            System.out.println(Arrays.toString(a));
            //fill方法给数组重新赋值
            Arrays.fill(a, 0, 1, 3);//将a[0]变为3
            System.out.println(Arrays.toString(a));
            Arrays.sort(a);//排序，从小到大
            System.out.println(Arrays.toString(a));
            Arrays.fill(a, 0);//将数组中的值全部变为0
            System.out.println(Arrays.toString(a));
        }
    }

结果：  
![在这里插入图片描述][20200709102436692.png]

#### 冒泡排序 ####

比较数组中的两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置，对于每一次的比较都会产生一个最大或者最小的数字，每测试一轮就会少一次排序

/** * @author jektong * @Date 2020/7/9 9:53 */
    public class ArraysApplication { 
        public static void main(String[] args) { 
            int[] a ={ 1,3,45,6,78,78};
            ArraysApplication.sort(a);
            System.out.println(Arrays.toString(a));
        }
        public static int[] sort(int[] array){ 
            int temp = 0;
            //定义外部循环了多少次 
            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;
                    }
                }
            }
            return array;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]: /images/20230209/d10fae08a2b74af7a3e3b486e4046f1f.png
[20200709102436692.png]: /images/20230209/160af547ba6f43d38de21a1bc12502f4.png