JAVA数组和JAVA数组常用的几个工具类

概述

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素;保证多个数据的数据类型要一致。

今天说说:

• Java 数组的声明
• 创建
• 初始化
• java数组常用的几个工具类:

1. Arrays.toString(数组);
2. Arrays.sort(数组);
3. Arrays.copyOf(数组，新的长度);
4. System.arraycopy(原数组,源数组的起始下标,目标数组,目标数组的起始下标,要复制的元素个数); 。

---

Java 数组的声明

注意:

• 数组是一种数据类型(引用类型)

• 相同数据类型元素的集合(即数组的元素类型必须和数组的引用类型一致)

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

int[] arr;   // 首选的方法
 
或
 
int arr[];  // 效果相同，但不是首选方法,这种声明风格是C/C++ 语言使用的多

接下俩我们声明整型数组arr试一下，包含10个元素，每个元素都是int型，默认值为0

int[] arr = new int[10];

---

Java数组的创建与初始化

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

int[] a = new int[5];

程序创建数组 int[] a = new int[5]; 时发生了什么?

1. 在内存中开辟了一个空间,用来存放数据,长度是5
2. 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
3. 数组完成初始化会分配一个唯一的地址值
4. 把唯一的地址值交给引用类型的变量a去保存

注意:数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

数组的创建方式一般分为动态初始化和静态初始化

• 动态初始化
• int[] a = new int[5];
• 先创建数组,之后再根据需求赋值
• 静态初始化
• int[] b = new int[]{1,2,3,4,5};
• int[] c = {1,2,3,4,5};
• 在创建的同时赋好了值

数组赋值的三种方法

int[] arr = new int[3]; //这种创建就已经有值,默认值为0,0,0
//赋值
arr[0]=1;
arr[1]=2;
arr[2]=3;
//注意:
//int型只能赋整数值
//下标是从0开始的.

//第一种方法
int[] arr1 = {1,4,7};
//第二种方法
int[] arr2 = new int[]{1,4,7}; 
//第三种方法
int[] arr3;
arr3 = new int[]{1,4,7}; 

注意 : 默认值

byte,short,int,long,char-----------------0       //默认值为0
float,double-----------------------------0.0     //默认值为0.0
boolean----------------------------------false   //默认值为false

通过 length属性可以获得数组的长度

• 数组的长度用 length属性来表示,数组一旦创建，长度不可改变
• 数组的长度允许为0

//以下的数组元素都为空

int[] arr=new int[0];//这里的0是指数组的长度
int[] brr={};//这里大括号没东西即元素为0;

访问：-----访问的是数组中的元素

通过数组名.length可以获取数组的长度(元素的个数)

int[] arr = new int[3];
System.out.println(arr.length); 

//输出结果为3

通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组的长度-1)

int[] arr = new int[3];
System.out.println(arr[0]); //0，输出第1个元素的值
arr[0] = 100; //给arr中的第1个元素赋值为100
arr[1] = 200; //给arr中的第2个元素赋值为200
arr[2] = 300; //给arr中的第3个元素赋值为300
//arr[3] = 400; //运行时会发生数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值

遍历/迭代：从头到尾挨个走一遍

int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
    arr[i] = (int)(Math.random()*100); //给每一个元素赋值为0到99的随机数
    System.out.println(arr[i]); //输出每个元素的值
}

随机数方法之一

int num = (int)(Math.random()*100+1); //1到100之内的随机数
推导过程:
Math.random()------------0.0到0.9999999999999999...//当前方法只产生0.0到1之间的数
*100---------------------0.0到99.99999999999999...  //把随机到的数乘100得到0.0到99.99...的数
+1-----------------------1.0到100.9999999999999... //加一后为1.0到100.99的数
(int)--------------------1到100   
//因为生成的是浮点型,强转为int型则会把小数位忽略掉(在学习多态的时候会提到)所以会得到1到100的数

---

数组常用工具类

Arrays.toString(数组);

把数组里的所有元素,用字符串的形式输出

int[] a = {10,20,30,40,50};
System.out.println(Arrays.toString(a));
//输出的结果为:
//[10, 20, 30, 40, 50]

---

Arrays.sort(数组);

对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高 对引用类型数组,使用的是优化后的合并排序算法

注意:

只能是以从小到大的方式排列

int[] arr={10,20,50,41,65,98,75};
Arrays.sort(arr);//使用工具类给数组排序
System.out.println(Arrays.toString(arr));//以字符串的形式输出数组的所有元素

//输出的结果为:
//[10, 20, 41, 50, 65, 75, 98]

---

Arrays.copyOf(数组，新的长度);

数组复制 : 把指定数组赋值成一个指定长度的新数组

注意:这种形式的复制是创建一个新的数组(原数组会被释放即删除)并指定长度然后再把原数组复制过去;如果新数组长度小于原数组则多出部分会被删除,反过来则新加的长度补默认值零

int[] a = {10,20,30,40,50};
//a:源数组
//b:目标数组
//6:目标数组的长度
//----若目标数组的长度>源数组长度，则在末尾补默认值
//----若目标数组的长度<源数组长度，则将末尾的截掉
int[] b = Arrays.copyOf(a,6);
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

//输出的结果为:
10
20
30
40
50
0

数组的扩容:
新数组的长度 大于 原数组, 相当于复制,并增加位置

//数组的扩容
int[] a = {10,20,30,40,50};
//数组的扩容(创建了一个更大的新的数组，并将数据复制进去了)
a = Arrays.copyOf(a,a.length+1);
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}

//输出的结果为:
10
20
30
40
50
0

数组的缩容:
新数组的长度 小于 原数组, 相当于截取一部分数据

//数组的缩容
int[] a = {10,20,30,40,50};

a = Arrays.copyOf(a,a.length-1);//缩容
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}

//输出的结果为:
10
20
30
40

---

System.arraycopy(原数组,源数组的起始下标,目标数组,目标数组的起始下标,要复制的元素个数);

本方法数组复制灵活性好.

int[] a = {10,20,30,40,50};
int[] b = new int[6]; //默认值0,0,0,0,0,0
//a:源数组
//1:源数组的起始下标
//b:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,b,0,4); //这种复制方法可以指定复制灵活性好
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

//输出结果:
20
30
40
50
0
0

---