JavaSE（基础篇）——数组

每日一语：路在脚下，梦在远方，只要一息尚存，就绝不会放弃。

前言：

引用的狂神Java基础视频——狂神Java基础视频 

目录

数组概述

1.数组的定义：

2.数组的四个基本的特点：

数组声明创建

1.声明数组：

2.创建数组

3.内存分析

 4.三种初始化

静态初始化

动态初始化

数组的默认初始化

5.数组边界

 6.小结

数组的使用

1.For-Each

2.数组作为方法传入

3.数组做返回值

多维数组

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

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

3.获取数组长度：

Arrays 类

 1.打印数组

2.数组排序

 3.二分查找

4.元素填充

5.数组转换为List集合

冒泡排序

---

 

数组概述

1.数组的定义：

数组是类型相同的有序集合。

数组是描述相同类型的若干个数据，按照一定的先后次序排列组合而成。

其中每一个数据称作数组元素，可以通过下标来访问其元素。 

2.数组的四个基本的特点：

1.数组的长度是确定的，一旦被创建，他的大小就是不能被改变的。

2.其元素类型必须相同，不能出现混合类型。

3.数组中的元素可以是任何的数据类型，可以是基本类型也可以是引用类型。

4.数组是引用类型，数组也可以看作对象，数组中的成员变量相当于该对象的成员变量，数组本身就是对象，Java对象是在堆中的，所以数组无论是保存原始类型还是其他类型，数组本身就是在堆里。 

数组声明创建

1.声明数组：

dataType[] arrayRefVar; // 首选的方法 
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

double[] myList; // 首选的方法 
或
double myList[]; // 效果相同，但不是首选方法

2.创建数组

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

arrayRefVar = new dataType[arraySize];

 以上语法做了两件事：

1.使用dataType[arraySize]创建了一个数组。

2.把数组赋值给变量arrayRefVar。

数组是通过索引访问的，从0到array.length-1.

获取数组的长度语法为：

array.length

【演示创建一个数组，并赋值和进行访问】

public class java1 {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        int sum = 0;
        for (int l = 0; l < nums.length; l++) {
            sum += l;


        }
        System.out.println("总和为"+sum);

    }
}

结果：

3.内存分析

 Java内存分析：

1.声明的时候并不会实例化任何对象，只有在实例化数组对象的时候，JVM才会分配空间，这是才和长度有关，因此声明数组的时候不能指定其长度，错误示范： int a[5]。

2.声明一个数组的时候，数组并没有被真正的创建。

3.构造一个数组必须声明其长度。

//1.声明一个数组 
int[] myList = null;

//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;

 4.三种初始化

静态初始化

除了用 new 关键字来产生数组以外 , 还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = {1,2,3}; 
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化

数组定义、为数组元素分配空间、赋值的操作、分开进行。

int[] a = new int[2]; 
a[0]=1; 
a[1]=2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

public static void main(String[] args) { 
int[] a=new int[2]; 
boolean[] b = new boolean[2]; 
String[] s = new String[2]; 
System.out.println(a[0]+":"+a[1]); //0,0 
System.out.println(b[0]+":"+b[1]); //false,false 
System.out.println(s[0]+":"+s[1]); //null, null
 }

5.数组边界

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

public static void main(String[] args) {
 int[] a=new int[2]; 
System.out.println(a[2]); 
}

 6.小结

数组是相同数据类型(数据类型可以为任意类型)的有序集合。

数组也是对象。数组元素相当于对象的成员变量(详情请见内存图)。

数组长度的确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds。

---

数组的使用

1.For-Each

JDK1.5引进了一种新型循环类型，被称为For-Each循环或者加强型循环，它们在不使用下标的情况下遍历数组。

语法格式为：
 

for(type element: array){
 System.out.println(element); 
}

【示例】

public static void main(String[] args) { 
double[] myList = {1.9, 2.9, 3.4, 3.5}; // 打印所有数组元素 
for (double element: myList) { 
System.out.println(element);
 } 
}

2.数组作为方法传入

数组可以做参数传递给方法。

例如下面一个例子就是打印数组：

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

3.数组做返回值

public static int[] reverse(int[] list) { 
int[] result = new int[list.length]; 
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) { 
result[j] = list[i];
 }
return result; 
}

上述例子中result作为数组返回。 

---

多维数组

多维数组可以看作是数组的数组，比如一个二维数组就是一个一维数组组成的一维数组。

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

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

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

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

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

arraylenght1 为行数， arraylenght2 为列数。

比如定义一个二维数组：

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

解析：二维数组 a 可以看成一个两行三列的数组。

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

num[1] [0];

其实二维甚至多维数组十分好理解，我们把两个或者多个值当做定位就好。

原来的数组就是一条线，我们知道一个位置就好 。

二维就是一个面，两点确定一个位置。

三维呢，就需要三个点来确定。

依次理解就可以。

3.获取数组长度：

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

---

Arrays 类

数组中的工具类java.util.Arrays。

由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从

而可以对数据对象进行一些基本的操作。

文档简介

Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用" 而不是 "不能")

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

具有一下常用功能：

1.给数组赋值：通过 fifill 方法。

2.对数组排序：通过 sort 方法,按升序。

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

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

 【具体说明请看下表】

 1.打印数组

public class java1 {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;

        System.out.println(Arrays.toString(nums));

    }
}

 

2.数组排序

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

public class java1 {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 6;
        nums[2] = 55;
        nums[3] = 15;
        nums[4] = 45;

        System.out.println(Arrays.toString(nums));
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

    }
}

 输出：

 3.二分查找

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

注意：使用二分搜索法来搜索指定的数组，以获得指定的值。必须在进行此调用之前对数组进行排序(通过sort方法等)。如果没有对数组进行排序，则结果是不确定的。

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

public class java1 {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 6;
        nums[2] = 55;
        nums[3] = 15;
        nums[4] = 45;


        Arrays.sort(nums);
        System.out.println("该元素的索引"+Arrays.binarySearch(nums,45));

    }
}

 输出：

4.元素填充

public class java1 {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 6;
        nums[2] = 55;
        nums[3] = 15;
        nums[4] = 45;


        Arrays.sort(nums);
        Arrays.fill(nums,2,3,100);
        System.out.println(Arrays.toString(nums));

    }
}

 输出：

5.数组转换为List集合

 List<int[]> list = Arrays.asList(nums);

冒泡排序

public class java1 {
    public static void main(String[] args) {
        int[] nums = new int[5];
        nums[0] = 1;
        nums[1] = 6;
        nums[2] = 55;
        nums[3] = 15;
        nums[4] = 45;
        int [] b = sort(nums);
        System.out.println(Arrays.toString(b));



    }
    public static int[] sort(int[] nums){
        int temp = 0;
        for (int i = 0; i<nums.length-1 ; i++) {
            for(int j = 0 ; j < nums.length - i-1 ; j++){
                if (nums[j] > nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        return  nums ;

    }
}

输出：

---