6.偏头痛杨的Java入门教学系列之数组篇

复习

1.Java有多少种数据类型，数据类型的分类？数据类型的大小排序？默认类型？默认值？

2.Java的工作机制？

3.Java中有多少种循环？分别是什么？

4.什么是变量，如何定义变量？Java中有多少种变量？分别是什么以及区别？

5.循环体内return、continue、break的区别？

6.++与--放在变量前面与后面的区别？

7.for循环的三个表达式的作用？

8.基本数据类型的包装类型分别是什么？

9.方法有几种？分别是什么？区别是什么？

10.JDK&JRE&JVM分别是什么以及他们的关系？

前文链接

1.偏头痛杨的Java入门教学系列之认识Java篇

http://blog.csdn.net/piantoutongyang/article/details/70138697

2.偏头痛杨的Java入门教学系列之变量&数据类型篇

http://blog.csdn.net/piantoutongyang/article/details/70193622

3.偏头痛杨的Java入门教学系列之表达式&运算符&关键字&标识符&表达式篇

http://blog.csdn.net/piantoutongyang/article/details/71027446

4.偏头痛杨的Java入门教学系列之初级面向对象篇

http://blog.csdn.net/piantoutongyang/article/details/78135129

5.偏头痛杨的Java入门教学系列之流程控制语句篇

http://blog.csdn.net/piantoutongyang/article/details/71698589

---

前戏

数组是数据结构中一个非常基础的知识点，也是后面学习哈希表，集合等数据结构的基础。

千万不要忽视数组的作用，数组的应用也是非常广泛，例如ArrayList、HashMap的底层都会用到。

如果我们现在需要声明100个整型变量，并对这100个整型变量进行一些操作，那我们该怎么办？

这样吗？

int a = 1;

int b = 2;

...

int xxx = 100;

其实我们有一种更好的办法，声明一个数组变量，来操作这一系列的数据。

---

什么是数组

数组可以看成是多个相同类型数据的组合，实现对这些数据的统一管理。

例如：｛1，2，3，4，5｝；｛"apple","pear","banana","grape"｝；

数组对于每一门编程语言来说都是重要的数据结构之一，

当然不同语言对数组的实现及处理也不尽相同。

Java语言中提供的数组是用来存储固定大小的同类型元素。

数组中的每一个数据可以看成是数组的一个元素（element），

而在数组中找到某个元素则需要下标（index）来定位，也可以把下标叫做索引。

数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型，

但前提在一个数组中，大家的数据类型必须全部一致。

数组中元素的个数，称为数组的长度（length），长度只有大于0的时候才有意义。

---

数组初始化

数组可以分为两种初始化，分别是静态初始化与动态初始化。

静态初始化

初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组长度。

静态初始化数组语法分为两种：

数据类型[] 数组名  = {元素1,元素2,元素3};

数据类型[] 数组名  = new 数据类型[]{元素1,元素2,元素3};

（当然[]也可以放到数组名的后面，但一般不推荐这么做。）

String[] c = {"a","b","c"};
int[] a = new int[]{1,2,3,4};

（把新创建的数组的引用赋值给变量。）

动态初始化

初始化时程序员只指定数组长度，由系统为数组元素分配初始值。

动态初始化数组语法：数据类型[] 数组名 = new 数据类型[元素的个数];

int[] a = new int[5];
String[] b = new String[3];

注意：

JAVA语言中声明数组时不能指定其长度。例如：int  a[5];//非法。

---

操作数组

数组的元素是通过索引（元素下标）访问的。数组元素的下标从0开始，

所以元素下标值从0到数组的长度减1。

比如数组的长度是3，那么下标分别是：0，1，2。

获取数组中的元素并进行赋值的语法：

数组名[元素的下标] = 元素值;

// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
   total += myList[i];
}
System.out.println("总和为： " + total);

---

数组与循环（遍历数组）

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，

我们通常使用基本循环或者 foreach 循环。

//基本循环例子
double[] myList = { 1.9, 2.9, 3.9, 3.5 };

// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
    System.out.println(myList[i] + " ");
}
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < myList.length; i++) {
    total += myList[i];
}
System.out.println("Total is " + total);
// 查找最大元素
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
    if (myList[i] > max) {
        max = myList[i];
    }
}
System.out.println("Max is " + max);

//for-each循环例子
double[] myList = {1.9, 2.9, 3.4, 3.5};

// 打印所有数组元素
for (double element: myList) {
   System.out.println(element);
}

---

数组作为方法的参数&返回值

看看这些代码都能看懂吗？在干什么？

int[] a = new int[] { 3, 1, 2, 6, 4, 2 };
int[] b = handleArray(a);
for (int i = 0; i < b.length; i++) {
    System.out.print(b[i] + " ");
}

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

    int[] result = new int[array.length];

    for (int i = 0, j = result.length - 1; i < array.length; i++, j--) {
        result[j] = array[i];
    }
    return result;
}

---

多维数组

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

其每一个元素都是一个一维数组，例如：

String[] a = new String[6];//一维数组
String[][] str = new String[2][6];//二维数组

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

1. 直接为每一维分配空间，格式如下：

type arrayName = new type[arraylenght1][arraylenght2];

type 为数据类型，arraylenght1 和 arraylenght2 必须为正整数。

arraylenght1：当前大数组中包含了多少个小数组，小数组的个数。

arraylenght2：每个小数组的长度。

String[][] str = new String[2][1];
str[0][0] = "a";
str[0][1] = "b";//这里将报错，因为小数组的长度是1，只有str[0][0]才合法。
//可以看成是一个2行1列的数组。

2. 从最高维开始，分别为每一维分配空间，允许出现列不固定的情况，例如：

String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

解析：

s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，

也就是为最高维限制其能保存数据的最长的长度，

然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。

注意：

String s[][] = new String[2][2];//正确写法

String s[][] = new String[2][];//正确写法

String s[][] = new String[][2];//错误写法

//初始化方式1：
int[][] a = {{1,2,3}, {4,5}, {7}} ;
int[][] b = new int[][]{{1,2,3},{4,5},{7}} ;

//初始化方式2：
int[][] a = new int[3][];
a[0] = new int[2];
a[1] = new int[3];
a[2] = new int[4];
a[0][0] = 1;
a[0][1] = 2;

---

Arrays工具类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

给数组赋值

通过fill方法

public static void fill(int[] a, int val)

将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。

对数组排序

通过 sort 方法,按升序

public static void sort(Object[] a)

对指定对象数组根据其元素的自然顺序进行升序排列。

int[] a = new int[]{3,5,1,2};
Arrays.sort(a);
System.out.println(Arrays.toString(a));//输出[1, 2, 3, 5]

比较数组

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

public static boolean equals(long[] a, long[] a2)

如果两个指定的 long 型数组彼此相等，则返回true。如果两个数组包含相同数量的元素，

并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。

换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。

查找数组元素

通过 binarySearch 方法能对排序好的数组进行二分查找法操作

public static int binarySearch(Object[] a, Object key)

用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。

如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

---

数组下标越界异常

对于使用数组中不存在的元素，会引发数组下标越界异常：java.lang.ArrayIndexOutOfBoundsException

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

---

数组与内存（新手可pass）

Java的数组变量是一种引用类型变量，数组变量并不是数组本身，它只是指向堆内存的数组对象。

数组的所有元素保存在堆内存中。

创建一个数组就是在堆中创建 一个数组对象。

数组创建后立即拥有默认值。

索引（下标）从0开始。

连续分配。

---

作业

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

for(int i=0;i

  for(int j=0;j

    a[i][j]=i+j;

  }

},则a[2][3]的值是多少？自己想，不通过编程实现。

---

总结

数组是java中比较重要的数据结构之一，学好数组是为后面的集合打好基础，因此不要忽视它。

哦，对了，数组也是引用数据类型哦。