数组

概述

        所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。
        数组是用于储存多个相同类型数据的集合。


一维数组

声明数组

  • 第一种方式

    first
    1
    double[] myList;  //dataType[] arrayRefVar，首选的方法

  • 第二种方式

    second
    1
    double myList[];  //dataType arrayRefVar[]，效果相同，但不是首选方法

    建议使用 dataType[] arrayRefVar的声明风格声明数组变量。 dataType[] arrayRefVar风格是来自 C/C++语言 ，在Java中采用是为了让C/C++程序员能够快速理解java语言。


创建数组

创建数组
1
arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

  • 使用 dataType[arraySize]创建了一个数组
  • 把新创建的数组的引用赋值给变量 arrayRefVar


数组变量的声明和创建数组可以用一条语句完成

  • 第一种方式
    first
    1
    dataType[] arrayRefVar = new dataType[arraySize];

这种方式直接在创建数组时给定了数组的长度：arraySize

  • 第二种方式
    second
    1
    dataType[] arrayRefVar = {value0, value1, ..., valuek};

    这种方式直接在创建数组时赋值：value0, value1, …, valuek

  • 第三种方式
    third
    1
    dataType[] arrayRefVar = new dataType[]{value0, value1, ..., valuek};

    这种方式是在第二种方式的=后面补全：new dataType[]


数组访问方式

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1
语法：

  • 数组名[索引]


数组元素分配的初始值

数组元素类型 默认初始值
byte、short、int、long 0
float、double 0.0
char ‘\u0000’
boolean false
引用数据类型 null


实例

数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      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);
   }
}
  • 运行结果
end
1
总和为： 11367.373


图示

  • 下面的图片描绘了数组 myList
  • myList 数组里有 10 个 double 元素，它的下标从 0 到 9


遍历数组

采用for循环来遍历数组

for
1
2
3
4
5
6
7
8
9
10
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }  
   }
}
  • 运行结果
end
1
2
3
4
1.9
2.9
3.4
3.5

在需要获取元素下标时使用该方法


采用foreach循环来遍历数组

foreach
1
2
3
4
5
6
7
8
9
10
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}
  • 运行结果
end
1
2
3
4
1.9
2.9
3.4
3.5

在JDK 1.5 引进
被称为foreach 循环或者加强型循环，它能在不使用下标的情况下遍历数组。


常用方法

计算总和

count
1
2
3
4
5
6
7
8
9
10
11
12
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
   }
}
  • 运行结果
end
1
Total is 11.7


查找最大元素

foundMax
1
2
3
4
5
6
7
8
9
10
11
12
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 查找最大元素
      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);
   }
}
  • 运行结果
end
1
Max is 3.5


传参遍历数组

遍历
1
2
3
4
5
public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}
  • 调用函数
get
1
printArray(new int[]{3, 1, 2, 6, 4, 2});
  • 运行结果
end
1
3 1 2 6 4 2


数组倒排

倒排
1
2
3
4
5
6
7
8
public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}
  • 调用函数
get
1
printArray(reverse(new int[]{1,2,3,4,5,6}));
  • 运行结果
end
1
6 5 4 3 2 1


数组和字符串的转换

转换
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Test {
    public static void main(String args[]) {
       String str = "helloworld";
        char[] data = str.toCharArray();// 将字符串转为数组
        System.out.println(data);
        for (int x = 0; x < data.length; x++) {
            System.out.print(data[x] + "  ");
            data[x] -= 32;    //转化成大写
            System.out.print(data[x] + "  ");
        }
        System.out.println("\n"+new String(data));
    }
}
  • 运行结果
end
1
2
3
helloworld
h  H  e  E  l  L  l  L  o  O  w  W  o  O  r  R  l  L  d  D 
HELLOWORLD


java.util.Arrays类操作数组

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

  • 给数组赋值：通过fill方法。
  • 对数组排序：通过sort方法,按升序。
  • 比较数组：通过equals方法比较数组中元素值是否相等。
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
方法 说明
public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)
public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
Arrays
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.Arrays;

public class TestArrays {
    public static void output(int[] array) {
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + " ");
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] array = new int[5];
        // 填充数组
        Arrays.fill(array, 5);
        System.out.println("填充数组：Arrays.fill(array, 5)：");
        TestArrays.output(array);
        // 将数组的第2和第3个元素赋值为8
        Arrays.fill(array, 2, 4, 8);
        System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
        TestArrays.output(array);
        int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };
        // 对数组的第2个到第6个进行排序进行排序
        Arrays.sort(array1, 2, 7);
        System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
        TestArrays.output(array1);
        // 对整个数组进行排序
        Arrays.sort(array1);
        System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
        TestArrays.output(array1);
        // 比较数组元素是否相等
        System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n" + Arrays.equals(array, array1));
        int[] array2 = array1.clone();
        System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n" + Arrays.equals(array1, array2));
        // 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
        Arrays.sort(array1);
        System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)：" + "\n" + Arrays.binarySearch(array1, 3));
        // 如果不存在就返回负数
        System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)：" + "\n" + Arrays.binarySearch(array1, 9));
    }
}
  • 运行结果
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
填充数组：Arrays.fill(array, 5)：
5 5 5 5 5 
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：
5 5 8 8 5 
对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：
7 8 2 3 3 6 12 5 4 
对整个数组进行排序：Arrays.sort(array1)：
2 3 3 4 5 6 7 8 12 
比较数组元素是否相等:Arrays.equals(array, array1):
false
克隆后数组元素是否相等:Arrays.equals(array1, array2):
true
元素3在array1中的位置：Arrays.binarySearch(array1, 3)：
1
元素9在array1中的位置：Arrays.binarySearch(array1, 9)：
-9


Arrays.copyOf()进行扩容

Array.copy(E[] e,newLength);
其第一个形参指的是需要扩容的数组，后面是扩容后的大小，其内部实现其实是使用了 System.arrayCopy(); 在内部重新创建一个长度为 newLength 类型是 E 的数组。

copyOf()
1
2
3
4
5
6
7
8
9
10
import java.util.Arrays;  
public class Main {
    public static void main(String[] args) {
        int[] a= {10,20,30,40,50};
        a= Arrays.copyOf(a,a.length+1);
        for(int i=0;i<a.length;i++) {
            System.out.println(a[i]);
        }
    }
}
  • 运行结果
end
1
10 20 30 40 50 0    //默认补 0


数组小游戏

程序随机产生5个按一定顺序排列的字符，作为猜测结果。
玩家可以猜测多次，每猜一次，若猜测的完全正确则游戏结束，并计算玩家的游戏得分并输出。若没有猜对，则提示猜测结果，如猜对了几个字符，以及猜对了几个字符的位置信息，并提示玩家游戏继续。若中途输入EXIT，则游戏提前结束

小游戏
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import java.util.Scanner;

//猜字符小游戏
public class Guessing {
    private static Scanner scan;
    // 主方法
    public static void main(String[] args) {
        scan = new Scanner(System.in);
        char[] chs = generate();
        System.out.println(chs);
        int count = 0; // 猜错的次数
        while (true) { // 自造死循环
            System.out.println("猜吧!");
            String str = scan.next().toUpperCase(); // 获取用户输入的字符串
            if (str.equals("EXIT")) { // 判断字符串内容相等
                System.out.println("下次再来吧!");
                break;
            }
            char[] input = str.toCharArray(); // 将字符串转换为字符数组
            int[] result = check(chs, input);
            if (result[0] == chs.length) { // 对
                int score = 100 * chs.length - 10 * count;
                System.out.println("恭喜你，猜对了!得分为:" + score);
                break;
            } else {
                count++;
                System.out.println("字符对个数为:" + result[1] + "，位置对个数为:" + result[0]);
            }
        }
    }
    // 生成随机字符数组chs
    public static char[] generate() {
        char[] chs = new char[5];
        char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
                'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
                'W', 'X', 'Y', 'Z' };
        boolean[] flags = new boolean[letters.length];
        for (int i = 0; i < chs.length; i++) {
            int index;
            do {
                index = (int) (Math.random() * letters.length);
            } while (flags[index] == true);
            chs[i] = letters[index];
            flags[index] = true;
        }
        // i=0 index=0 chs[0]='A' flags[0]=true
        // i=1 index=25 chs[1]='Z' flags[25]=true
        // i=2 index=0/25/0/25/1 chs[2]='B' flags[1]=true
        return chs;
    }

    // 对比:随机字符数组chs与用户输入的字符数组input
    public static int[] check(char[] chs, char[] input) {
        int[] result = new int[2]; // (0,0)
        for (int i = 0; i < chs.length; i++) {
            for (int j = 0; j < input.length; j++) {
                if (chs[i] == input[j]) {
                    result[1]++;
                    if (i == j) {
                        result[0]++;
                    }
                    break;
                }
            }
        }
        return result;
    }
}
  • 运行结果

小游戏可以自行尝试啦，没有固定结果


数组越界异常

当数组的长度为固定值，操作索引>=数组的长度，就会报数组越界异常

Exception
1
2
3
4
5
6
7
8
9
public class Main {
    public static void main(String[] args) {
        int[] i = new int[2];
        i[0]=1;
        i[1]=2;
        i[2]=3;
        printArray(i);
    }
}
  • 运行结果
end
1
2
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
	at Main.main(Main.java:11)

此案例中，数组长度为2，在i[2]添加数据就会报数据越界异常错误


数组基本封装类

为数组而写的封装类，提供了创建，增，删，改，查（索引，二分法）等实用功能

封装
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
public class MyOrderArray {
	private long[] arr;
	//表示有效数据的长度
	private int elements;
	
	public MyOrderArray() {
		arr = new long[50];
	}
	
	public MyOrderArray(int maxsize) {
		arr = new long[maxsize];
	}
	
	/**
	 * 添加数据
	 */
	public void insert(long value) {
		int i;
		for(i = 0; i < elements; i++) {
			if(arr[i] > value) {
				break;
			}
		}
		
		for(int j = elements; j > i; j--) {
			arr[j] = arr[j - 1];
		}
		arr[i] = value;
		elements++;
	}
	
	/**
	 * 显示数据
	 */
	public void display() {
		System.out.print("[");
		for(int i = 0; i < elements; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println("]");
	}
	
	/**
	 * 查找数据
	 */
	public int search(long value) {
		int i;
		for(i = 0; i < elements; i++) {
			if(value == arr[i]) {
				break;
			}
		}
		
		if(i == elements) {
			return -1;
		} else {
			return i;
		}
		
	}
	
	/**
	 * 二分法查找数据
	 */
	public int binarySearch(long value) {
		int middle = 0;
		int low = 0;
		int pow = elements;
		
		while(true) {
			middle = (pow + low) / 2;
			if(arr[middle] == value) {
				return middle;
			} else if(low > pow) {
				return -1;
			} else {
				if(arr[middle] > value) {
					pow = middle - 1;
				} else {
					low = middle + 1;
				}
			}
		}
	}
	
	
	/**
	 * 查找数据，根据索引来查
	 */
	public long get(int index) {
		if(index >= elements || index < 0) {
			throw new ArrayIndexOutOfBoundsException();
		} else {
			return arr[index];
		}
	}
	
	/**
	 * 删除数据
	 */
	public void delete(int index) {
		if(index >= elements || index < 0) {
			throw new ArrayIndexOutOfBoundsException();
		} else {
			for(int i = index; i < elements; i++) {
				arr[index] = arr[index + 1];
			}
			elements--;
		}
	}
	
	/**
	 * 更新数据
	 */
	public void change(int index, int newvalue) {
		if(index >= elements || index < 0) {
			throw new ArrayIndexOutOfBoundsException();
		} else {
			arr[index] = newvalue;
		}
	}
}
  • 调用类
get
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestMyArray {
	public static void main(String[] args) {
		MyArray arr = new MyArray();
		arr.insert(13);
		arr.insert(34);
		arr.insert(90);

		arr.display();
		System.out.println(arr.search(190));

		System.out.println(arr.get(1));

		arr.change(0, 12);
		arr.display();
		MyOrderArray arr1 = new MyOrderArray();
		arr1.insert(90);
		arr1.insert(30);
		arr1.insert(80);
		arr1.insert(10);
		arr1.display();
		
		System.out.println(arr1.binarySearch(30));
	}
}
  • 运行结果
end
1
2
3
4
5
6
[13 34 90 ]
-1
34
[12 34 90 ]
[10 30 80 90 ]
1

在项目中导入该包装类，对于数组操作来言，将是如虎添翼


多维数组

概述

Java中定义和操作多维数组的语法与一维数组类似。在实际应用中，三维及以上的数组很少使用，主要使用二维数组。


二维数组

二维数组可以理解为在一维数组中嵌套一维数组使之成为二维数组，可以看成是数组的数组
语法：

  • 数组类型 [][] 数组名;
  • 数组类型 数组 [][];
  • 需要强调的是，虽然从语法上看，Java支持多维数组，但从内存分配原理的角度讲，Java中只有一维数组，没有多维数组。或者说，表面上是多维数组，实质上都是一维数组。


初始化

  • 直接为每一维分配空间
初始化
1
2
type[][] arrayName = new type[arraylenght1][arraylenght2];
type arrayName[][]= [arraylenght1][arraylenght2];

type 可以为基本数据类型和复合数据类型，arraylenght1 和 arraylenght2 必须为正整数，arraylenght1 为行数，arraylenght2 为列数。

  • 如：

初始化的额外说明

  • 可以只对部分元素赋初值，未赋初值的元素自动取0值

  • 如对全部元素赋初值，则第一维的长度可以不给出


二维数组的引用

  • 对二维数组中的每个元素，引用方式为 arrayName[index1][index2]
引用
1
num[1][0];


二维数组的空间分布

  • 我们用int a[4][4]举例
  • 说明了一个四行四列的数组，数组名为a，其下标变量的类型为整型，该数组的下标变量共有4×4个
第一列 第二列 第三列 第四列
a[0][0] a[0][1] a[0][2] a[0][3]
a[1][0] a[1][1] a[1][2] a[1][3]
a[2][0] a[2][1] a[2][2] a[2][3]
a[3][0] a[3][1] a[3][2] a[3][3]


二维数组的遍历

public static void main(String[] args){
   int [][] array=new int[][]{{90,32,43,43,23},{42,32,44},{67}};
   int total;
   for(int i=0;i<array.length;i++){
   String str=(i+1)+"班";
   total=0;
   for(int j=0;j<array[i].length;j++){
total+=array[i][j];
   }
   System.out.println(str+"总成绩:"+total);
   }
}
  • 运行结果
end
1
2
3
1班总成绩:231
2班总成绩:118
3班总成绩:67


总结

  • 数组是可以再内存中连续存储多个元素的结构。数组中的所有元素必须属于相同的数据类型。
  • 数组中的元素通过数组下标进行访问，数组下标从0开始。
  • 二维数组实际上是一个一维数组，它的每个元素又是一个一维数组。
  • 使用Array类提供的方法可以方便地对数组中的元素进行排序、查询等操作。
  • JDK1.5之后提供了增强for循环，可以用来实现对数组和集合中数据的访问。


注

赏

谢谢你的喜欢

支付宝
微信
| 总阅读量

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 画沙浊影<br><br> 万家灯火，带领星光，拼出个晚上。 <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;--早安&晚安 <br><br> For dreams, never stop<br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;--为了梦想,永不停歇