一、概述
1、定义
- 数组是相同类型数据的有序集合;
2、特点
- 长度是确定的;
- 元素必须是相同类型,可以是基本类型和引用类型;
3、本质
- 数组是对象,每个元素可以看作是对象的属性;
- 数组无论存基本类型还是引用类型,数组对象本身是在堆中存储的;
二、数组的创建和基本使用
1、创建
int[] a = { 1, 2, 3 };// 静态初始化基本类型数组;
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组;
int[] a1 = new int[2];//动态初始化数组,先分配空间;
a1[0]=1;//给数组元素赋值;
a1[1]=2;//给数组元素赋值;
2、遍历
- 普通 for 循环
- 增强 for 循环:不能修改元素;不能操作索引;
3、数组拷贝
public class Test {
public static void main(String args[]) {
String[] s = {"阿里","京东","搜狐","网易"};
String[] sBak = new String[6];
System.arraycopy(s,0,sBak,0,s.length);
for (int i = 0; i < sBak.length; i++) {
System.out.print(sBak[i]+ "\t");
}
}
}
4、Arrays 工具类
(1)Arrays类包含:数组的排序、查找、填充、打印内容等常见的操作
(2)排序
- 基本类型:Arrays.sort();
- 引用类型:该引用类型要实现 Comparable 接口
class Man implements Comparable {
int age;
String name;
public Man(int age, String name) {
super();
this.age = age;
this.name = name;
}
public String toString() {
return this.name;
}
public int compareTo(Object o) {
Man man = (Man) o;
if (this.age < man.age) {
return -1;
}
if (this.age > man.age) {
return 1;
}
return 0;
}
}
(3)查找:二分查找
Arrays.sort(arr); //使用二分法查找,必须先对数组进行排序;
Arrays.binarySearch(arr, 12);
(4)填充:Arrays.fill(arr, 2, 4, 100) 将2到4索引的元素替换为100
(5)打印:Arrays.toString(arr)
三、多维数组
1、二维数组创建
int[][] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
int[][] a = new int[3][];
a[0] = new int[] { 1, 2 };
a[1] = new int[] { 2, 2 };
a[2] = new int[] { 2, 2, 3, 4 };
2、二维数组长度:arr.length 和 arr[0].length
3、存储表格数据
Object[] a1 = {1001,"高大",18,"讲师","2006-2-14"};
Object[] a2 = {1002,"高小七",19,"助教","2007-10-10"};
Object[] a3 = {1003,"高小琴",20,"班主任","2008-5-5"};
Object[][] emps = new Object[3][];
emps[0] = a1;
emps[1] = a2;
emps[2] = a3;
四、数组的数据操作
1、冒泡排序
(1)基础算法
public static void bubbleSort(int[] values) {
int temp;
for (int i = 0; i < values.length; i++) {
for (int j = 0; j < values.length - 1 - i; j++) {
if (values[j] > values[j + 1]) {
temp = values[j];
values[j] = values[j + 1];
values[j + 1] = temp;
}
}
}
}
(2)优化算法
public static void bubbleSort(int[] values) {
int temp;
int i;
// 外层循环:n个元素排序,则至多需要n-1趟循环
for (i = 0; i < values.length - 1; i++) {
// 定义一个布尔类型的变量,标记数组是否已达到有序状态
boolean flag = true;
/*内层循环:每一趟循环都从数列的前两个元素开始进行比较,比较到无序数组的最后*/
for (int j = 0; j < values.length - 1 - i; j++) {
// 如果前一个元素大于后一个元素,则交换两元素的值;
if (values[j] > values[j + 1]) {
temp = values[j];
values[j] = values[j + 1];
values[j + 1] = temp;
//本趟发生了交换,表明该数组在本趟处于无序状态,需要继续比较;
flag = false;
}
}
//根据标记量的值判断数组是否有序,如果有序,则退出;无序,则继续循环。
if (flag) {
break;
}
}
}
(3) 总结:
- 采用嵌套 for 循环;
- 外层循环控制趟数;
- 内层循环控制每趟比较的次数;
- 优化就是加入一个有序的判断;
2、二分查找
public static int binarySearch(int[] array, int value){
int low = 0;
int high = array.length - 1;
while(low <= high){
int middle = (low + high) / 2;
if(value == array[middle]){
return middle; //返回查询到的索引位置
}
if(value > array[middle]){
low = middle + 1;
}
if(value < array[middle]){
high = middle - 1;
}
}
return -1; //上面循环完毕,说明未找到,返回-1
}