Java数组总结（详细）

自己在学习过程中对Java数组的总结

---

一、数组的概念，作用以及其特性

概念：

• 数组是一组类型相同的数据的集合，也就是说，数组中可以同时存储多个元 素但其类型必须相同

作用：

• 1.数组能够作为数据的容器使用，把多个数据集中存储
• 2.存在数组中的数据都有索引值，通过索引可以来调用或修改

特性

• Java的数组是引用类型；
• 数组与类、接口、枚举、注解并列，是引用类型中的一种；
• Java的数组长度一经确定不能改变；
  例如，一个数组的长度是10，那么最多能存10个数据，如果保存第11个就会出错；
• 数组在内存中是连续分配，所以读取速度快
• 实际应用中，常常无法确定变量的数量，后续我们将学习集合框架，实现可变长度的数据容器；

二、数组的维数

1.一维数组

• 如果一个数组中存储元素都是单个数据，称为一维数组；

2.二维数组

二维数组，也可以理解为用一维数组保存的元素为一维数组。对于三维数组，等等，都可以这样划分。不过我们在编程中使用三维以上的数组比较少。因为那样使用起来非常不方便。

3.一维数组和二维数组的声明格式

    //一维数组声明的三种形式
    int[] a = new int[5];  //a的长度为5，默认值为0
    int[] b = new int[]{1,6,5,3,2}; //a的长度为5，默认值为1，6，5，3，2
    int[] c = {1,6,5,3,2}; //a的长度为5，默认值为1，6，5，3，2
    //二维数组的声明的三种形式
    int[][] a1 = new int[2][3]; 
    int[][] a2 = new int[][]{{1,2},{2,3,5}}; 
    int[][] a3 = {{1,2},{2,3,5}}; 

4.如何调用数组的指定位置元素

• 语法：
  数组名[索引]
• 说明:

1. 这里索引也叫下标
2. 索引从0开始,到数组的长度-1结束
3. 超过数组的长度-1会报数组越界异常

public static void main(String[] args) 
{ int[] a=new int[]{1,2,3,4,5};
 System.out.println(a[0]);//1 
 System.out.println(a[4]);//5 
 System.out.println(a[5]);// java.lang.ArrayIndexOutOfBoundsException: 5 }

5.数组的长度

• 语法
  数组变量名.length
  length是数组的属性,返回数组的长度
• 注意
  在创建数组的时候，一定要确定数组的长度；
  数组的长度将在初始化数组元素的时候同时初始化到内存中；
  使用 数组变量名.length 可以返回数组的长度；

int[] a1=new int[5];
 int[] a2=new int[]{1,4,10};
  int[] a3={34,23,4,10}; 
System.out.println("a1的长度："+a1.length);//5 
System.out.println("a2的长度："+a2.length);//3 
System.out.println("a3的长度："+a3.length);//4

6.数组的遍历

很多时候我们需要对数组中的元素一个一个取出来使用，这个过程叫遍历；
遍历数组需要使用到循环控制；
循环的次数用数组的长度控制；
先简单理解数组遍历的循环语句，包括传统的for循环和增强for循环两种

• 遍历一维数组

int[] a=new int[]{1,2,10}; 
//使用for循环遍历
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
    }
//使用增强for循环遍历
for(int x:a){
 System.out.println(x);
  }

• 遍历二维数组

public class Test1 {
    public static void main(String[] args) {
        int[][] a = new int[2][3];
        a[0][0] = 1;
        a[0][1] = 2;
        a[0][2] = 3;
        a[1][0] = 11;
        a[1][1] = 12;
        a[1][2] = 13; //遍历二维数组
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.println(a[i][j]);
            }
        }
    }
 }

7.数组元素的默认初始化值

• 数组元素是整型,默认初始化值是0
• 数组元素是浮点型,默认初始化值是0.0
• 数组元素是char型,默认初始化值是\u0000(即为0,而非’0’)
• 数组元素是boolean型,默认初始化值是false
• 数组元素是引用数据类型,默认初始化值是null

8.课堂练习

写程序实现向数组里放从1到100的值,然后使用for循环遍历数组,取出每一个元素累加,计算数组元素的总和在控制台输出总和.

public class Test1 {
    public static void main(String[] args) {
        int[] a = new int[100];
        //赋值
        for (int i = 0; i < 100; i++) {
                a[i] = i+1;
        }
        //累加
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            sum = sum+a[i];
        }
        System.out.println(sum);

    }

 }

三、基础排序的算法实现

排序是算法中很重要的一个环节，很多查询的基础就是排序，关于排序的算法非常多,而且各有优缺点.记下来介绍几种最为简单容易理解的排序算法:

选择排序
冒泡排序
插入排序

1.选择排序

选择排序的主要思想是寻找未排序中最小的元素加入到已有序列,直到未排序序列为空。

public class Test1 {
    public static void main(String[] args) {
        int[] a = {3,6,5,4,1};

        for (int i = 0; i < a.length; i++) {
            int min = i;            
            for (int j = 0; j < a.length; j++) {
                //找到这次查找最小的值
                if(a[j]<a[min]){               
                    min = j;
                }
                //如果不等于此时的i，则交换位置
                if(min!=i){
                    int tmp = a[i];
                    a[i] = a[min];
                    a[min] = tmp;
                }
            }

        }
        //增强for循环遍历数组
        for (int i : a) {
            System.out.println(i);
        }
    }
 }

2.冒泡排序

冒泡排序主要的思想是进行相邻的两个元素之间比较并且交换，有利于利用原有元素在集合中的位置优势，冒泡排序的原则是大的下沉小的上浮（跟最终的排序要求保持一致）

public class Test1 {
    public static void main(String[] args) {
        int[] a = {3, 6, 5, 4, 1};
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-i-1; j++) {
                //相邻两个比较，前面比后面大了，就交换位置
                if (a[j] > a[j + 1]) {
                    int tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                }
            }
        }
        //增强for循环遍历数组
        for (int i : a) {
            System.out.println(i);
        }
    }
 }

3.插入排序

插入排序与选择排序类似，需要将数组分为有序与无序两部分。
但插入不会去到无序部分选择，而是随意选取一个无序部分元素到有序部分中寻找它所在的位置进行插入保持有序部分仍然有序，如果要对数据进行排序把待排序的数据插入到已经排好序的数据中，直到所有的数据插入完成，即就是直接插入排序。
一般第一个数认为是有序部分,待排序的区间是第二个数到最后一个数。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入

public class Test1 {
    public static void main(String[] args) {
        int[] a = {3, 6, 5, 4, 1};
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j>0 && a[j-1]>a[j]; j--) {
                //a[j]和a[j-1]交换位置
                    int tmp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = tmp;
            }
        }
        //增强for循环遍历数组
        for (int i : a) {
            System.out.println(i);
        }
    }
 }

三、数组工具 Arrays的用法

1.填充数组：fill

 int []arr = new int[5];
  Arrays.fill(arr, 2);

结果是：[2, 2, 2, 2, 2]
分析：给所有值赋值2

int []arr = new int[5];
 Arrays.fill(arr, 1,3,8);

结果是：[0, 8, 8, 0, 0]
分析：给第1位（0开始）到第3位（不包括）赋值8

2.数组元素排序：sort

int []arr = {3,2,1,5,4}; 
Arrays.sort(arr);

结果是：[1, 2, 3, 4, 5]
分析：给所有数按升序排序

int []arr = {3,2,1,5,4};
 Arrays.sort(arr,1,3);

结果是：[3, 1, 2, 5, 4]
分析：给第1位（0开始）到第3位（不包括）排序

3.比较数组元素是否相等：equals

int []arr1 = {1,2,3}; 
int []arr2 = {1,2,3}; 
System.out.println(Arrays.equals(arr1,arr2));

结果是：true
分析：如果是arr1.equals(arr2),则返回false，因为equals比较的是两个对象的地址，不是里面的数，而Arrays.equals重写了equals，所以，这里能比较元素是否相等。

4. 二分查找法binarySearch

int []arr = {10,20,30,40,50};
 System.out.println(Arrays.binarySearch(arr, 20));

结果是：1
分析：能找到该元素，返回下标为1（0开始）

int []arr = {10,20,30,40,50}; 
System.out.println(Arrays.binarySearch(arr, 35));

结果是：-4
分析：找不到元素，返回-x，从-1开始数，如题，返回-4

int []arr = {10,20,30,40,50}; 
System.out.println(Arrays.binarySearch(arr, 0,3,30));

结果是：2
分析：从0到3位（不包括）找30，找到了，在第2位，返回2

int []arr = {10,20,30,40,50}; 
System.out.println(Arrays.binarySearch(arr, 0,3,40));

结果是：-4
分析：从0到3位（不包括）找40，找不到，从-1开始数，返回-4

5.截取数组：copeOf和copeOfRange

int []arr = {10,20,30,40,50};
 int []arr1 = Arrays.copyOf(arr, 3); 
 System.out.println(Arrays.toString(arr1));

结果：10 20 30
分析：截取arr数组的3个元素赋值给姓数组arr1

int []arr = {10,20,30,40,50}; 
int []arr1 = Arrays.copyOfRange(arr,1,3);
System.out.println(Arrays.toString(arr1));

结果：20 30
分析：从第1位（0开始）截取到第3位（不包括）