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

05 数组

2019-04-29 08:50:20来源：博客园阅读 ()

1.1 数组(Array)

数组是相同类型数据的有序集合。

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素(item),每个数组元素可以通过一个下标(index)来访问它们.

[1]数组的长度是固定的。通过length属性来标记数组的长度。，

[2]数组元素必须是相同类型。整形数组必须存整数数据，不能存储其他数据。

[3]数组的元素有序。通过下标/索引(index)来标记每个元素的位置。index从0开始。

数组在内存中的表现

数组在内存中是一段连续的内存空间。

1.1.1 内存分区(A)

计算机内存分很多区，根据内存的使用情况可以分为

栈区(stack):八大基本数据类型的变量分配在该区，该区的内存使用完成后，系统会自动回收，栈区占整个内存的比例较小。

堆区(heap):引用数据类型分配在堆区，该区内存使用完成后，系统不会自动回收，jvm会通过垃圾回收机制帮开发者回收。堆区占整个内存的比例较大。

1.1.2 数组内存图

数组是引用数据类型,其内存分配在堆区。声明数组的语法

推荐写法:

数据类型[]  变量名

也可以:

数据类型  变量名[]

public class Test04{

 

public static void main(String[] args){

// 声明了一个数组arr

int[] arr = null;

// arr = new int[5];

System.out.println(arr.length);

}

}

arr 是一个引用数据类型，分配在栈区，其所指内存分配在堆区。

null 是一个java关键字，表示空引用，没有引用堆中的任何空间。

1.1.3 数组声明

public class Test04{

 

public static void main(String[] args){

// 【1】声明了一个数组arr

int[] arr = null;

// 【2】分配内存

arr = new int[5];

// length属性用于访问数组的空间个数

System.out.println(arr.length);

 

// 【3】赋值

arr[0] = 10;

arr[1] = 20;

 

 

// 【4】使用数组

System.out.println(arr[4]);

}

}

总结：

[1]数组的最大下标永远比length小1

[2]数组的访问通过下标来访问，形式arr[index] index取值范围[0,length-1],经常会出现的错误:数组越界

数组的三种声明和赋值写法

1.1.4 数组的遍历思考：数组申请完空间后，空间中有没有值？

需求:动态从键盘录入一些信息(整形),然后输出该数组信息。

import java.util.Scanner;

public class Test06{

 

public static void main(String[] args){

 

// 动态从键盘录入一些信息(整形),然后输出该数组信息。

int[] arr = new int[6];

Scanner sc = new Scanner(System.in);

int temp = 0;

// 列举法

for(int i=0;i<arr.length;i++){

temp = sc.nextInt();

arr[i] = temp;

}

 

// 遍历输出数组元素

for(int i=0;i<arr.length;i++){

System.out.print(arr[i]+"\t");

}

 

}

}

练习：从键盘输入5个学生的成绩，求学生成绩的平均分。

1.2 数组相关的算法

1.2.1 查找算法

import java.util.Scanner;

public class Test08{

public static void main(String[] args){

 

// 数组的查找

 

int[] arr = {8,4,2,1,23,344,12};

Scanner sc = new Scanner(System.in);

//

System.out.println("请键盘输入一个数:");

int t = sc.nextInt();

 

int loc = -1;

for(int i=0;i<arr.length;i++){

if(t == arr[i]){

loc = i;

break;

}

}

 

if(loc < 0){

System.out.println("没找到元素");

}else{

System.out.println("找到元素："+loc);

}

}

}

1.2.2 数组的插入算法

需求:有一个有序的数组，向数组中添加一个元素后，依然保持数组有序。

public class Test09{

public static void main(String[] args){

 

// 数组的查找

// {1,3,5,9,12};

int[] arr = new int[6];

arr[0] = 1;

arr[1] = 3;

arr[2] = 5;

arr[3] = 9;

arr[4] = 12;

int t = 0;

 

// 【1】找位置

int loc = -1;

for(int i=0;i<arr.length-1;i++){

if(arr[i] > t){

loc = i;

break;

}

}

// System.out.println("loc="+loc);

 

// 【2】移动元素

if(loc < 0){

// 数组中的元素比要添加的数都小

arr[arr.length-1] = t;

}else{

// 在数组中找到位置

for(int i = arr.length-1;i>loc;i--){

arr[i] = arr[i-1];

}

arr[loc] = t;

}

 

// 【3】遍历元素

for(int i=0;i<arr.length;i++){

System.out.print(arr[i]+"\t");

}

 

 

}

}

列举测试

1.2.3 数组的删除算法

需求:有一个有序的数组，删除数组一个元素，依然保持数组有序。

public class Test10{

public static void main(String[] args){

 

// 数组元素的删除

int[] arr = {1,3,5,9,12};

int t = 3;

 

// 【1】找位置

int loc = -1;

for(int i=0;i<arr.length;i++){

if(t == arr[i]){

loc = i;

break;

}

}

 

if(loc < 0){

System.out.println("数组中没有找到目标元素");

}else{

for(int i=loc;i<arr.length-1;i++){

arr[i] = arr[i+1];

}

 

// 覆盖残留值

arr[arr.length-1] = 0;

}

 

// 【3】遍历

for(int i=0;i<arr.length;i++){

System.out.print(arr[i]+"\t");

}

 

}

}

1.3 排序算法

java中存在8大排序算法。

以冒泡为例，先搞清楚思想。

public class Test01{
public static void main(String[] args){

int[] arr = {5,3,1,4,2};
int tmp = 0;
// for循环用于控制趟数
for(int i=0;i<arr.length-1;i++){

// 内层for用于控制两两比较次数
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
tmp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
}
}
// 遍历
for(int i=0;i<arr.length;i++){

System.out.print(arr[i]+"\t");
}
}
}

1.4 命令行参数(C)

在启动Java应用程序时可以一次性地向应用程序中传递0~多个参数----命令行参数

java Test01 参数1 参数2

各个参数用空格分割，如果传递的参数包含空格，请用双引号引起来即可。

1.5 数组的常用方法

import java.util.Arrays;
public class Test03{
public static void main(String[] args){

 
// 【1】toString()：把数组转化成字符串形式
// int[] arr1 = {1,2,3};
String[] arr1 = {"hello","world","java"};
String str1 = Arrays.toString(arr1);
System.out.println(str1);

 

// 【2】排序方法(升序)
// int[] arr2 = {5,1,2,4,3};
String[] arr2 = {"cello","bworld","ava"};
Arrays.sort(arr2);
// 方法的调用可以嵌套
System.out.println(Arrays.toString(arr2));


// 【3】二分法查找算法
int[] arr3 = {5,1,2,4,3};
// {1,2,3,4,5}
Arrays.sort(arr3);

// 对有序的且无重复元素的数组进行查找。
int index = Arrays.binarySearch(arr3,6);
System.out.println("index:"+index);
}
}

1.5.1 二分法(折半查找)查找算法

二分法查找思想:？？？

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];
            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

如果找到返回key在数组中的位置；如果找不到，返回-(插入点+1)。插入点就是key应该插入到数组的具体位置。

import java.util.Arrays;

public class Test04{

public static void main(String[] args){

 

// 【4】equals()：判断两个数组是否相等

// 类型且长度相同，对于位置的值相等

int[] arr1 = {1,2};

int[] arr2 = {1,2,3};

System.out.println(Arrays.equals(arr1,arr2));

 

// 【5】数组的复制

int[] arr3 = {1,2,3};

// 注意:arr3和arr3Cpy是两个不同的内存空间，相互独立

int[] arr3Cpy = Arrays.copyOf(arr3,5);

System.out.println(Arrays.toString(arr3Cpy));

 

// 【6】数组的复制

// System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

// System.arraycopy(源数组,源起始索引,目标数组,目标起始索引,长度)

int[] arr4 = {1,2,3};

int[] arr4Cpy = new int[arr4.length];

System.arraycopy(arr4,1,arr4Cpy,0,3);

System.out.println(Arrays.toString(arr4Cpy));

 

}

}

注意:arraycopy会出现越界的问题。

1.6 二维数组

1.6.1 概念

二维数组本质上就是存储数组的数组。数组的元素是一维数组。

内存图

1.6.2 二维数组的声明

import java.util.Arrays;

public class Test05{

public static void main(String[] args){

 

// 声明二维数组

// (int[])[]  arr

int[][] arr = null;

arr = new int[3][];

 

// 二维数组的赋值

arr[0] = new int[]{1,2,3};

arr[1] = new int[]{1,2,3,4};

arr[2] = new int[]{1,2,3,4,5};

 

// 访问二维数组的元素

System.out.println(arr.length);

// [[I@243532c

System.out.println(arr);

 

//

System.out.println("arr[0][0]="+arr[1][3]);

arr[2][0] = 100;

 

// ==> 二维数组其实就是行列结构 ==>双层for遍历

for(int i=0;i<arr.length;i++){ // 控制行

 

for(int j=0;j<arr[i].length;j++){

System.out.print(arr[i][j]+"\t");

}

System.out.println();

}

 

}

}

数组的其他声明方式

public class Test06{

public static void main(String[] args){

 

// 声明了一个3行4列的二维数组

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

 

arr[0][0] = 1;

arr[0][1] = 2;

arr[0][2] = 3;

arr[0][3] = 4;

 

for(int i=0;i<arr.length;i++){

 

for(int j=0;j<arr[i].length;j++){

System.out.print(arr[i][j]+"\t");

}

System.out.println();

}

 

}

}

字面量声明二维数组

public class Test07{

public static void main(String[] args){

 

// 声明了一个3行4列的二维数组

// 字面量写法

int[][] arr = {

{1,2,3,4},

{1,2,3,4},

{1,2,3,4}

};

 

for(int i=0;i<arr.length;i++){

 

for(int j=0;j<arr[i].length;j++){

System.out.print(arr[i][j]+"\t");

}

System.out.println();

}

}

}

需求:请构造一个3行3列的矩阵

1 0 0

0 1 0

0 0 1

1.7 基本数据类型和引用数据类型的深入

基本数据类型栈区，引用数据类型变量在栈区，内存在堆区。

public class Test09{

public static void main(String[] args){

 

// 在栈区声明了一个空间，取名a，是基本数据类型

int a;

 

// 在栈区声明了个一个空间，取名为b，是引用数据类型，其堆区的内存不存在。

int[] b;

 

}

}

1.7.1 基本数据类型的赋值

public class Test09{

public static void main(String[] args){

 

int a1 = 10;

int b1 = a1;

}

1.7.2 引用类型的赋值

public class Test10{

public static void main(String[] args){

 

int[] arr1 = {1,2,3};

int[] arr2 = null;

arr2 = arr1;

 

arr1[0] = 100;

System.out.println("arr2="+arr2[0]);

}

}