码迷，mamicode.com
首页 > 编程语言 > 详细

Java编程基础-数组

时间：2017-02-20 12:45:10      阅读：186      评论：0      收藏：0      [点我收藏+]

标签：默认值   基础   turn   清除   数组   sys   arc   引用   超出   

一、数组的定义。

1、数组的含义：数组是一组具有相同数据类型的元素的有序集合。数组可以分为一维数组和多维数组。(数组是一个引用类型的容器，从0开始编号存储相同数据类型的数据。)

2、数组的定义语法格式：

(1)、格式一：数据类型  [ ] 数组名=new 数据类型[元素的个数或数组的长度];

例如:int[ ] arr=new int[3];//定义了一个整型数组，数组中有3个元素（数组长度为3）

附：数组名放在[ ] 前面也是可以的,即int arr[ ] =new int[3];//但一般不建议这么定义。

(2)、格式二：数据类型  [ ] 数组名=new 数据类型[ ]{元素1,元素2,元素3,......};

例如:int[ ] arr=new int[ ]{1,2,3,4,5};//直接给数组进行赋值，需要注意的是new int[ ] 的括号中不能够指定数组中存放元素的个数，因为我们不清楚后面定义的数组个数。如果写了元素个数，JVM虚拟机在运行的时候会报错。

(3)、格式三:数据类型  [ ] 数组名={元素1,元素2,元素3,......};

例如：int[ ] arr= {1,2,3,4,5};//属于直接赋值的方式

格式二和格式三也称静态初始化，就是在定义数组的同时就为数组的每个元素赋值。

注意：

a)arr(即数组名)是引用数据类型中的数组类型，arr存的是地址值。该变量必须指向一个有效的数组对象，如果该变量的值为null，arr不再指向堆内存中的数组，此时通过该变量访问数组中的元素会出现空指针异常(NullPointerException)。堆内存中数组被虚拟机视为垃圾，(虚拟机会启动垃圾回收机制)不定时间内最终被清除。

b)数组中元素最小的索引(下标、角标)是0，最大的索引是数组的长度-1.访问元素时超出了数组的索引范围会出现数组角标越界异常（ArrayIndexOutOfBoundsException）。在Java中，为了方便获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。

c)不同数据类型数组的元素都有默认初始化值，其中byte、short、int、long的默认初始化值为0,float和double类型的默认初始化值为0.0,char类型的默认初始化值为一个空字符，即"\u0000",boolean类型的默认初始化值为false,引用类型的默认初始化值为null，表示变量不引用任何对象。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int[] arr = new int[3];// 声明一个数组arr,并开辟内存空间  
  5.         System.out.println("数组的长度为：" + arr.length);  
  6.         // 数组元素的访问通过数组名[下标]的方式访问  
  7.         System.out.println("数组的第一个元素为：" + arr[0]);//由于未初始化，所以访问的元素为默认值  
  8.         System.out.println("数组的第二个元素为：" + arr[1]);  
  9.         System.out.println("数组的第三个元素为：" + arr[2]);  
  10.   
  11.         System.out.println(arr[3]);  
  12.         // 由于数组arr的最大下标为length-1,即最大下标为2,所以访问下标为3的元素会报数组角标越界异常  
  13.         //arr = null;  
  14.         //System.out.println(arr[0]);  
  15.         // 由于数组的引用为null,不再指向内存中的数组地址值,此时再访问数组中的0角标元素会报空指针异常  
  16.   
  17.     }  
  18.   
  19. }  

输出结果为：

数组的长度为：3
数组的第一个元素为：0
数组的第二个元素为：0
数组的第三个元素为：0
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at Demo.main(Demo.java:11)

//Exception in thread "main" java.lang.NullPointerException
at Demo.main(Demo.java:14)

二、数组的常见操作。

1、数组的遍历

在操作数组时，经常需要依次访问数组中的每一个元素，这种操作称作数组的遍历。由于数组中元素类型的相同，而且元素是有序的，从0开始到最大下标，所以常用循环的方式遍历数组。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int[] arr = { 5, 12, 21, 9, 7 };// 声明并初始化一个长度为5的int类型数组  
  5.         for (int i = 0; i < arr.length; i++) {// 循环遍历数组中的每一个元素  
  6.             System.out.println("arr[" + i + "]=" + arr[i]);// 打印输出元素值  
  7.         }  
  8.         // 使用增强for循环的方式遍历输出数组中的元素  
  9.         for (int a : arr) {  
  10.             System.out.print(a+" ");  
  11.         }  
  12.   
  13.     }  
  14.   
  15. }  

输出的结果为：

arr[0]=5
arr[1]=12
arr[2]=21
arr[3]=9
arr[4]=7
5 12 21 9 7 
2、数组的最值

在操作数组时，经常需要获取数组中元素的最值。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         int[] arr = { 5, 1, 2, 8, 7, 21, 12 };// 定义一个数组  
  6.         int max = getMax(arr);// 调用获取元素最大值的方法  
  7.         System.out.println("max=" + max);// 打印最大值  
  8.         System.out.println("最大值为：" + getMax_2(arr));  
  9.   
  10.         int min = getMin(arr);// 调用获取元素最小值的方法  
  11.         System.out.println("min=" + min);// 打印最小值  
  12.         System.out.println("最小值为：" + getMin_2(arr));  
  13.   
  14.     }  
  15.   
  16.     public static int getMax(int[] arr)// 定义了一个求最大值的方法  
  17.     {  
  18.         int max = arr[0];// 定义变量max用于记住最大数，先假设第一个元素为最大值  
  19.         // 需要注意的是：在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值,  
  20.         // for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。  
  21.         for (int x = 1; x < arr.length; x++)// 通过for循环遍历数组中的元素  
  22.         {  
  23.             if (arr[x] > max)// 比较arr[x]的值是否大于max  
  24.             {  
  25.                 max = arr[x]; // 条件成立，将arr[x]的值赋给max  
  26.             }  
  27.         }  
  28.         return max;// 返回最大值  
  29.     }  
  30.   
  31.     public static int getMax_2(int[] arr) {// 获取最大值的第二种方法，初始化为数组中元素任意一个角标。  
  32.         int max = 0;  
  33.         for (int x = 1; x < arr.length; x++) {  
  34.             if (arr[x] > arr[max]) {  
  35.                 max = x;  
  36.             }  
  37.         }  
  38.         return arr[max];  
  39.   
  40.     }  
  41.   
  42.     public static int getMin(int[] arr)// 定义了一个求最小值的方法  
  43.     {  
  44.         int min = arr[0];// 定义变量min用于记住最小数，先假设第一个元素为最小值  
  45.         for (int x = 1; x < arr.length; x++)// 通过for循环遍历数组中的元素  
  46.         {  
  47.             if (arr[x] < min)// 比较arr[x]的值是否小于min  
  48.             {  
  49.                 min = arr[x]; // 条件成立，将arr[x]的值赋给min  
  50.             }  
  51.         }  
  52.         return min;// 返回最小值  
  53.     }  
  54.   
  55.     public static int getMin_2(int[] arr) {// 获取最小值的第二种方法  
  56.         int min = 0;  
  57.         for (int x = 1; x < arr.length; x++) {  
  58.             if (arr[x] < arr[min]) {  
  59.                 min = x;  
  60.             }  
  61.         }  
  62.         return arr[min];  
  63.     }  
  64. }  

输出结果为：

max=21
最大值为：21
min=1
最小值为：1
3、数组的排序

在操作数组时，经常需要对数组中的元素进行排序，数组排序的方法有很多种，比如选择排序，冒泡排序，插入排序，希尔排序等。(这里就只简答介绍选择和冒泡排序。)

(1)、选择排序

每一次从待排序的数据元素中选取最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

代码实现：

 

[java] view plain copy
  1. public static void selectSort(int[] arr)// 定义选择排序方法  
  2.     {  
  3.         for (int x = 0; x < arr.length - 1; x++) {  
  4.             for (int y = x + 1; y < arr.length; y++) {  
  5.                 if (arr[x] > arr[y]) // 满足条件，进行位置置换  
  6.                 {  
  7.                     int temp = arr[x];  
  8.                     arr[x] = arr[y];  
  9.                     arr[y] = temp;  
  10.                 }  
  11.             }  
  12.         }  
  13.     }  

(2)、冒泡排序

遍历要排序的数列，依次比较相邻两个元素，如果符合条件，把顺序错误的交换过来，让较大的数往下沉，较小的数往上冒。重复进行直到没有要交换的。

代码实现：

 

[java] view plain copy
  1. public static void bubbleSort(int[] arr)// 定义冒泡排序方法  
  2.     {  
  3.         for (int x = 0; x < arr.length - 1; x++) {  
  4.             for (int y = 0; y < arr.length - x - 1; y++) // -x:让每一次比较元素减少。-1：避免角标越界。  
  5.             {  
  6.                 if (arr[y] > arr[y + 1])// 满足条件，进行位置置换  
  7.                 {  
  8.                     int temp = arr[y];  
  9.                     arr[y] = arr[y + 1];  
  10.                     arr[y + 1] = temp;  
  11.                 }  
  12.             }  
  13.         }  
  14.     }  

4、数组元素的查找(折半查找)

折半查找也称二分查找，假设表中元素按升序排列，将表中位置的元素与查找的值比较，如果二者相等，则查找成功。否则从中间将表分成前后两个部分，如果中间位置记录的元素大于查找的元素，则查前部分，否则查后部分，重复直到找到或表已查完。

优点是比较次数少，查找速度快，平均性能好；

缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         int[] arr = { 1, 2, 5, 7, 9, 12, 21, };  
  6.         // 调用折半查找方法查找元素5的位置  
  7.         System.out.println("index=" + halfSearch(arr, 5));  
  8.         System.out.println("index=" + halfSearch(arr, 6));//测试返回-1的情况  
  9.     }  
  10.   
  11.     public static int halfSearch(int[] arr, int key)//arr是已排好的升序数组，返回找到值的下标，返回-1表示没找到。  
  12.     {  
  13.         int min, max, mid;  
  14.         min = 0; // 最小下标  
  15.         max = arr.length - 1; // 最大下标  
  16.         mid = (max + min) / 2; // 中间下标  
  17.   
  18.         while (arr[mid] != key) {  
  19.             if (key > arr[mid])  
  20.                 min = mid + 1;  
  21.             else if (key < arr[mid])  
  22.                 max = mid - 1;  
  23.             if (min > max) // 如果最小的下标大于最大的下标就说明没有折半可能。  
  24.                 return -1;  
  25.             mid = (max + min) / 2;  
  26.         }  
  27.         return mid;  
  28.     }  
  29.   
  30. }  

5、数组工具类(Arrays)

在java.util包中有一个Arrays工具类，该工具类包含操作数组的各种方法，如查找、排序、搜索等。

如使用Arrays实现数组排序：Arrays.sort(arr);该方法有函数重载，可以提供short、long等其他数据类型的排序。

实际中建议使用该方法，因为简单不容易错，但面试切勿这样写。


三、多维数组。

1、多维数组的含义：多维数组可以简单的理解为在数组中嵌套数组，即数组中的元素还是数组。在程序中比较常见的是二维数组。

2、二维数组的语法定义格式：

(1)、格式一：数据类型[ ][ ] 数组名=new [ 二维数组长度][一维数组长度 ];

(2)、格式二：数据类型[ ][ ] 数组名=new [ 二维数组长度][ ];

(3)、格式三：数据类型[ ][ ] 数组名=new [ ][ ]{{元素1,元素2,..},{元素1,元素2,..},{元素1,元素2,..}......};

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

定义格式提醒：数组名可以放在数据类型后面，两个中括号之间以及两个中括号之后。

代码示范上述：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 定义了长度为5的二维数组，每个二维数组中的元素又是一个长度为2的一维数组。  
  5.         int[][] arr1 = new int[5][2];  
  6.         // 定义了长度为3的二维数组，但数组中的每个元素的长度不确定。  
  7.         int[][] arr2 = new int[3][];  
  8.         // 二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2,3},{5,8},{7,3,5}。  
  9.         // 对二维数组元素的访问也是通过角标的方式，如要访问二维数组中第一个元素数组的第二个元素。  
  10.         // 代码为:arr3[0][1];  
  11.         int[][] arr3 = new int[][] { { 1, 2, 3 }, { 5, 8 }, { 7, 3, 5 } };  
  12.   
  13.         // 数组名放在这三个位置都可以  
  14.         int a[][] = new int[1][2];  
  15.         int[] b[] = new int[1][2];  
  16.         int[][] c = new int[1][2];  
  17.     }  
  18.   
  19. }  

3、二维数组的遍历

二维数组的遍历同一维数组一样采用循环遍历，不同的是由于数组中还是数组，需要用到循环嵌套。

代码实现：

 

[java] view plain copy
    1. public class Demo {  
    2.   
    3.     public static void main(String[] args) {  
    4.   
    5.         int[][] arr = { { 1, 2, 3 }, { 5, 8 }, { 7, 3, 5 } };  
    6.         for (int i = 0; i < arr.length; i++) {  
    7.             for (int j = 0; j < arr[i].length; j++) {  
    8.                 System.out.print(arr[i][j]);// 打印元素  
    9.             }  
    10.             System.out.println();// 换行  
    11.         }  
    12.     }  
    13. } 

Java编程基础-数组

标签：默认值   基础   turn   清除   数组   sys   arc   引用   超出   

原文地址：http://www.cnblogs.com/stsinghua/p/6418524.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！