【javaSE】java数组及其常用封装方法（函数）

什么是数组

当我们需要用到很多个相同数据类型变量时，如果我们一个一个创建的话，像下边这样会很麻烦，

	int a=0;
    int b=0;
    int c=0;
    int d=0;

因此就有了数组的概念，数组的存在使得我们可以同时创建多个相同数据类型变量
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。比如说我们学校里的宿舍：

在java中，包含6个整形类型元素的数组，就相当于上图中连在一起的6个宿舍，从上图中可以看到：

1. 数组中存放的元素其类型相同
2. 数组的空间是连在一起的
3. 每个空间有自己的编号，起始位置的编号为0，后面一次增加，即是数组的下标。

数组的创建及初始化

数组的创建

T [] 数组名 = new T[N] ;

T：表示数组中存放元素的类型
T[]：表示数组的类型
N：表示数组的长度

int[] array1 = new int[10]; 
// 创建一个可以容纳10个int类型元素的数组 
double[] array2 = new double[5]; 
// 创建一个可以容纳5个double类型元素的数组 
String[] array3 = new double[3]; 
// 创建一个可以容纳3个字符串元素的数组 

---

数组的初始化

静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

 int[]array={1,2,3,4};
 int[]array=new int[]{1,2,3,4};
 //这两种是一样的

动态初始化：在创建数组时，直接指定数组中元素的个数

int[]array=new int[10];

在Java中，不可以像下面这样初始化数组

 //error 这样初始化是错误的     
int []array=new int[10]{1,2,3,4,5};

【注意事项】
1.静态初始化虽然没有指定数组的长度，但编译器在编译时会根据{}中元素个数来确定数组的长度。
2.静态初始化时, {}中数据类型必须与[]前数据类型一致。
3.静态初始化可以简写，省去后面的new T[]。
4.如果不确定数组当中内容时，使用动态初始化，否则建议使用静态态初始化。
5.在动态创建数组时，不同的数据类型数组有其默认值
基础数据类型的初值如下图

如果数组中的元素是引用类型，其默认值是null;

引用类型

数组其实也是引用类型
基础数据类型有8种，（我前面的博客有详细介绍过），储存的是变量本身的值；而引用类型则不是；看下面代码

int a=10;
char b='h';
int[]arr=new int[]{1,2,3,4};
System.out.println(a);
System.out.println(b);
System.out.println(arr);

运行结果

我们可以看到不同于基础数据类型，引用类型储存的是一个数值·，这个数值我们可以理解为是内存中某一处的地址，不同于·C语言的是，这个地址不是真实地址，而是经过编译器处理过的地址
引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。
数组的创建在内存中是连续的，arr引用变量其内部保存的内容可以简单理解成是数组在堆空间中的首地址

数组的使用

基础使用

试用数组下标访问对应数据

int[]arr=new int[]{1,2,3,4};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);

for遍历数组，

数组名.length //可得到数组的长度

 int[]array=new int[]{1,2,3,4};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

foreach遍历数组

int[]array=new int[]{1,2,3,4};
for (int x:array) {
            System.out.println(x);
        }

上面两中遍历数组运行结果是一样的

使用数组封装对象Arrays

在java中，我们可以使用数组封装对象Arrays，他包含很多方法都很实用，包括排序数组，数组内容之间的对比，数组克隆等等，要记得引包import java.util.Arrays;，相当于c语言中引头文件

一·判断两个数组的各个元素是否相同
使用·Arrays.equals(),返回值是一个布尔类型的值 ，即是false 或true

import java.util.Arrays;

public class BoKe {
    public static void main(String[] args) {
        int[]array1=new int[]{1,2,3,4};
        int[]array2=new int[]{1,2,3};
        int[]array3=new int[]{1,2,3};

        System.out.println(Arrays.equals(array1,array2));
        System.out.println(Arrays.equals(array2,array3));
    }
}

运行结果·

---

二·排序数组
Arrays.sort(); 可排序数组

Arrays.toString(array)；可将数组内容变成一串字符串，并返回一个字符串，如下代码

int[]array=new int[]{1,3,5,8,7,9};
System.out.println("排序前"+Arrays.toString(array));
Arrays.sort(array);
System.out.println("排序后"+Arrays.toString(array));

运行结果

---

三.拷贝数组

第一种拷贝方法
数组1=数组2.clone();
把数组2的内容拷贝给数组1；

int[]array1=new int[]{1,3,5,8,7,9};
        int []array2=new int[8];
        System.out.println("拷贝前"+Arrays.toString(array2));
        array2=array1.clone();
        System.out.println("拷贝后"+Arrays.toString(array2));

运行结果

第二种拷贝方法
数组1=Arrays.copyOf(数组2 ，拷贝的个数);

int[]array1=new int[]{1,3,5,8,7,9};
int []array2=new int[8];
System.out.println("拷贝前"+Arrays.toString(array2));
 array2=Arrays.copyOf(array1,6);
 System.out.println("拷贝后"+Arrays.toString(array2));

引用类型深入扩展

我们上面说到：引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。
总结起来就是：引用数据变量名的储存值就是内存的地址。

int[]array={1,2,3,4};

在内存中有一个对象的内容为{1, 2，3, 4}，假设他的内存首地址为0x11，那么数组array的值就是这个地址，

那么引用变量能不能引用 另一个引用变量呢？
这个说法是不妥的，只能说
引用变量引用了另一个引用变量指向的对象
举例如下

int[]array1=new int[]{1,3,5,8,7,9};
int []array2=new int[8];
System.out.println(array1);
System.out.println(array2);
System.out.println("=======分割线======");
array2=array1;
System.out.println(array1);
System.out.println(array2);

运行结果，我们可以看到引用变量array1=array2后；他们储存的值就相同了，指向了同一块内存空间

---

引用变量做方法参数

我们再看下面这个代码，如果你看得懂，那么你基本上就理解引用类型变量了

public class BoKe {
    public static void main(String[] args) {
		int[]array1=new int[]{1,3,5,8,7,9};
        int[]array2=new int[]{1,3,5,8,7,9};
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        channge1(array1);
        channge2(array1);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
    public static  void channge1(int[]arr){
        for (int i = 0; i < arr.length; i++) {
            arr[i]=i;
        }
    }
    public static void channge2(int[]arr){
        arr=new int[]{1,2,3,4};
    }

}

如图所示，最后array1引用的对象的内容被方法change1改变了；而array2引用的对象内容则没有发生改变