首页 > > 程序设计 > Java技术 >

java基础（07）、数组（Array）

2018-06-18 02:18:49来源：未知阅读 ()

java基础--数组（Array）

一.　　关于数组

二.　　数组的内存结构

三.　　数组定义常见问题

四.　　数组的应用

五.　　二维数组

一些笔记

数组的存放位置：放在内存的堆中，应用的是内存的地址。进行方法参数传递时，传递的就是引用地址，若形参中更改了内存地址里的元素，则引用该内存地址的数组变量也会进行更改。

arr.length：表示数组arr的长度

数组的索引：是从0开始的

数组的遍历：用于访问数组中的每个元素，很常用：
1 int[] arr = {1,2,3,4};
2 for(int i = 0;i<arr.length;i++){
3     System.out.print(arr[i] + " ");
4 }

一.　　关于数组

数组的概念

　　同一种类型数据的集合。（可以是基本数据类型，也可以是引用数据类型）

数组的特点

数组存储的都是相同数据类型的元素
数组的长度也就是数组中元素的个数：arr.length （表示arr的数组长度）
元素从0开始编号，编号也称“索引”:index(下标,角标)
数组中元素的访问方式是通过数组名+索引的方式，如int [0]

数组的定义格式

初始化方式分为：动态初始化和静态舒适化

　　动态初始化：数组的创建和元素的赋值分开进行

1 /*
2 元素类型[ ] 数组名 = new 元素类型[数组长度];
3 */
4     int[ ] arr = new int [3];

　　静态初始化：数组创建时就给数组元素赋值

1 /*
2 元素类型[ ] 数组名 = new 元素类型[ ]{元素1,元素2,…};
3 */
4     int[ ] arr = new int[ ]{2,0,3,1};
5     int[ ] arr = {2,0,3,1};    //静态初始化的简化写法

二、数组的内存结构

2.1　　关于内存结构

Java程序在运行时，为了提高运行效率，对内存进行了不同区域的划分，每一种区域都有特定的处理数据的方式和内存管理方式，主要有以下几种：

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放；

堆内存：存放数组和对象，通过new建立的实例都存放在堆内存中

　　每一个实例都有内存地址值；

　　实例中的变量都有默认初始化值；

　　当实例不再被使用，会在不确定的时间被垃圾回收器回收。

方法区：存放类文件和方法

本地方法栈：供本地方法使用，与操作系统相关

程序计数器--Program Counter：对字节码文件计数

2.2　数组的内存结构

也就是根据数据的长度和相应的类型，开辟一个内存空间。（如：int[] arr = new int[5] ；就是开辟了int类型的5个位置,可以放置int类型的元素）

使用数组元素的方式是：数组名+索引（如：int [0] ）。

三.　　数组的常见问题

数组索引越界异常(ArrayIndexOutOfBoundsException)

1 int[] arr = new int[2];        //创建了可以放2个int类型元素的数组
2 System.out.println(arr[2]);    //索引是从0开始，该语句是打印索引为2的元素
3 //原因：访问到了数组中的不存在的索引发生异常

空指针异常(NullPointerException)

1 int[] arr = new int[2];
2 arr = null;
3 System.out.println(arr[0]);
4 //原因：arr引用没有指向数组，却在操作数组中的元素

四.　　数组的应用

数组的遍历
求最值
求和
求平均值
合并
复制
查找某元素第一次出现的索引

数组的遍历

数组遍历：依次访问每个元素，访问的次数就是元素的个数。
访问次数：length属性判断数组的长度，来确定访问的次数。
只要一种方式访问数组中的元素：数组名[索引]

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

求最值

　　思路：遍历数组的元素，依次做对比，根据需要的最值（最大或最小），保留相应的元素，最后留下来的就是需要的最值。

 1 /*
 2  *求最大值
 3  */
 4 public class Max{
 5     public static void main(String[] args){
 6         int[] arr = {1,2,3,4};
 7         int max = arr[0];
 8         for(int i = 1;i < arr.length;i++){
 9             if(arr[i] > max){
10                 max = arr[i];
11             }
12         }
13         System.out.println("最大值是："+max);
14     }
15 }
16 /*
17  *求最小值
18  */
19 public class Min{
20     public static void main(String[] args){
21         int[] arr = {1,2,3,4};
22         int min = arr[0];
23         for(int i = 1;i < arr.length;i++){
24             if(arr[i] < min){
25                 min = arr[i];
26             }
27         }
28         System.out.println("最小值是："+min);
29     }
30 }

求和

　　思路：遍历数组，将每个元素利用求和思想依次累加赋值，即可得到元素之和。

 1 /*
 2  *数组求和
 3  */
 4  public class SumArray{
 5      public static void main(String[] args){
 6          int[] arr = {1,2,3,4,5};
 7          int sum = 0;
 8          for(int i = 0;i < arr.length;i++){
 9              sum += arr[i];
10          }
11          System.out.println("数组元素之和为："+sum);
12      }
13  }

求平均值

　　思路：求和之和，除以数组的长度即可；注意返回的类型，平均值出现小数需要用double类型接收。

 1 /*
 2  *数组求平均值
 3  */
 4  public class AverageArray{
 5      public static void main(String[] args){
 6         int[] arr = {1,2,3,4,5};
 7         int sum = 0;
 8         for(int i = 0;i<arr.length;i++){
 9             sum += arr[i];    //遍历数组，将元素赋值给sum累加
10         }
11         double average = sum / arr.length;    //数组的元素之和除以元素的长度，即可得到每个元素的平均值（平均数可能是小数，所以用double接收）。
12         System.out.println("数值的平均值为："+average);
13      }

合并

　　思路：1、新数组的长度等于需要合并的数组长度之和；2、赋值完第一个数组时注意，之和的数组赋值需要从上一次付完值的索引开始。

 1 /*
 2  *两个数组合并
 3  */
 4  public class MergeArray{
 5      public static void main(String[] args){
 6         int[] arr = {1,2,3,4,5};
 7         int[] brr = {6,7,8};
 8         //创建一个用于合并的新数组crr，其长度等于另外两个数组长度之和。
 9         int[] crr = new int[arr.length + brr.length];    
10         int index = 0;
11         //第一个for循环将arr的元素赋值给crr
12         for(int i = 0;i < arr.length;i++){
13             crr[index++] = arr[i];
14         }
15         //第二个for循环将brr的元素赋值给crr,接收的索引从接收完arr后开始
16         for(int i = 0;i < brr.length;i++){
17             crr[index++] = brr[i];    //index在上面用了i++，所以这里就是从arr赋值完的地方开始接收。
18         }
19         System.out.print("合并后的新数组为：");
20         //打印新数组crr
21         for(int i = 0;i < crr.length;i++){
22             System.out.print(crr[i]+" ");
23         }
24      }
25  }

数组的复制

　　思路：直接引用数组的话，引用的是地址值；所以复制需要创建一个新数组来接收元素。

　　　　1、创建一个新数组，长度和被复制的数据一致；

　　　　2、使用遍历数组，将被复制的数组元素依次赋值给新数组即可。

 1 /*
 2  *数组的复制：
 3  *    直接引用数组的话，引用的是地址值；所以复制需要创建一个新数组来接收元素
 4  */
 5  public class CopyArray{
 6      public static void main(String[] args){
 7         int[] arr = {1,2,3,4,5};
 8         //创建一个用于接收复制元素的新数组，其数组长度和被复制的数组长度一致。
 9         int[] arr1 = new int[arr.length];
10         //遍历被复制的数组，将其元素一次复制给数组即可。
11         for(int i = 0;i < arr.length;i++){
12             arr1[i] = arr[i];
13         }
14         
15         //打印复制后的数组arr1
16         System.out.print("复制后的数据为:");
17         for(int i = 0;i < arr1.length;i++){
18             System.out.print(arr1[i]+" ");
19         }
20      }
21  }

查找某元素第一次出现的索引

　　思路：直接遍历数据，遇到需要查询的元素就停止循环，返回索引值。

 1 /*
 2  *查找某元素第一次出现的索引
 3  */
 4  public class FirstValueArray{
 5      public static void main(String[] args){
 6         int[] arr = {1,2,3,4,5};
 7         int value = 2;    //需要查询的元素值
 8         
 9         //遍历数组，若出现的元素和需要查询的值相同，则停止循环，此时的i就是出现的索引。
10         int i = 0;    //for()循环括号中定义的变量i只作用与循环内，故将变量定义在for循环上方，用于后面调用i的值确认索引。
11         for(;i < arr.length;i++){
12             if(arr[i] == value){
13                 break;
14             }
15         }
16         System.out.println("值"+value+"第一次出现的索引是："+i);
17      }
18  }

五.　　二维数组

概念：元素为一维数组的一维数组，即二维数组。

　　元素的类型可以是基本数据类型，或引用数据类型，当元素类型是一维数组时，就构成了二维数组

二维数组的定义

方式1：int[ ] [ ] arr = new int [3] [2];

　　表示定义一个二维数组，第一维长度是3，第一维里面的每个元素分别指向一个长度为2的数组。

　　数组元素的值是默认值。

　　相当于一维数组的动态初始化：指定了长度，不指定初始化值。

方式2：int[ ] [ ] arr = new int [2] [ ];

　　定义一个数组，第一维长度是2；没有指定每个元素所要指定的一维数组，可以在以后的程序中动态指定，例如：

　　arr[0] = new int [2];

　　arr[1] = new int [3];

方式3：int[ ] [ ] arr = new int[ ] [ ] {{1,2},{2,3,4},{2,6,7};　或简化为： int [ ] [ ] arr = {{1,2},{2,3,4},{2,6,7};

　　相当于一维数组的静态初始化，创建数组和元素的赋值同时进行；只不过二维数组的元素是一个一维数组，需要使用{}括起来；元素之间使用英文逗号分隔。

也就是说：把数组（一堆元素），当作另一个数组的元素。

二维数组的运用：杨辉三角形

 1 /*
 2     杨辉三角形
 3     
 4 1
 5 1 1
 6 1 2 1
 7 1 3 3 1
 8 1 4 6 4 1
 9 
10 规律:
11 每行行首和最后一个元素肯定为1;
12 其它元素等于:对应上一行相同位置的元素和此元素之前的元素之和
13 每行元素个数和行数相等.
14 
15 */
16 public class YangHuiDemo{
17     public static void main(String[] args){
18         int[][] arr = new int[8][];
19         //变量二维数组,动态给每个元素赋值
20         for(int i = 0;i<arr.length;i++){
21             arr[i] = new int[i + 1];
22             
23             //给每个元素赋值
24             for(int j = 0;j<arr[i].length;j++){
25                 if(j == 0 || j == arr[i].length - 1){
26                     arr[i][j] = 1;
27                 }else{
28                     arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
29                 }
30             }
31         }
32         
33         for(int i = 0;i<arr.length;i++){
34             for(int j = 0;j<arr[i].length;j++){
35                 System.out.print(arr[i][j] + "\t");
36             }
37             System.out.println();
38         }
39         
40     }
41 }