菜鸟教程 -- 学的不仅是技术,更是梦想!

Java 教程
(追記) (追記ここまで)

Java 数组

数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。

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

你可以声明一个数组变量,如 numbers[100] 来代替直接声明 100 个独立变量 number0,number1,....,number99。

本教程将为大家介绍 Java 数组的声明、创建和初始化,并给出其对应的代码。

声明数组变量

首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法:

dataType[]arrayRefVar; // 首选的方法 或 dataTypearrayRefVar[]; // 效果相同,但不是首选方法

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

实例

下面是这两种语法的代码示例:

double[]myList; // 首选的方法 或 doublemyList[]; // 效果相同,但不是首选方法

创建数组

Java语言使用new操作符来创建数组,语法如下:

arrayRefVar = new dataType[arraySize];

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

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

数组变量的声明,和创建数组可以用一条语句完成,如下所示:

dataType[] arrayRefVar = new dataType[arraySize];

另外,你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0, value1, ..., valuek};

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

实例

下面的语句首先声明了一个数组变量 myList,接着创建了一个包含 10 个 double 类型元素的数组,并且把它的引用赋值给 myList 变量。

TestArray.java 文件代码:

publicclassTestArray{publicstaticvoidmain(String[]args){// 数组大小intsize = 10; // 定义数组double[]myList = newdouble[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; // 计算所有元素的总和doubletotal = 0; for(inti = 0; i < size; i++){total += myList[i]; }System.out.println("总和为: " + total); }}

以上实例输出结果为:

总和为: 11367.373

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

java数组结构说明

处理数组

数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环或者 For-Each 循环。

示例

该实例完整地展示了如何创建、初始化和操纵数组:

TestArray.java 文件代码:

publicclassTestArray{publicstaticvoidmain(String[]args){double[]myList = {1.9, 2.9, 3.4, 3.5}; // 打印所有数组元素for(inti = 0; i < myList.length; i++){System.out.println(myList[i] + ""); }// 计算所有元素的总和doubletotal = 0; for(inti = 0; i < myList.length; i++){total += myList[i]; }System.out.println("Total is " + total); // 查找最大元素doublemax = myList[0]; for(inti = 1; i < myList.length; i++){if(myList[i] > max)max = myList[i]; }System.out.println("Max is " + max); }}

以上实例编译运行结果如下:

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

For-Each 循环

JDK 1.5 引进了一种新的循环类型,被称为 For-Each 循环或者加强型循环,它能在不使用下标的情况下遍历数组。

语法格式如下:

for(type element: array)
{
 System.out.println(element);
}

实例

该实例用来显示数组 myList 中的所有元素:

TestArray.java 文件代码:

publicclassTestArray{publicstaticvoidmain(String[]args){double[]myList = {1.9, 2.9, 3.4, 3.5}; // 打印所有数组元素for(doubleelement: myList){System.out.println(element); }}}

以上实例编译运行结果如下:

1.9
2.9
3.4
3.5

数组作为函数的参数

数组可以作为参数传递给方法。

例如,下面的例子就是一个打印 int 数组中元素的方法:

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

下面例子调用 printArray 方法打印出 3,1,2,6,4 和 2:

printArray(newint[]{3, 1, 2, 6, 4, 2});

数组作为函数的返回值

publicstaticint[]reverse(int[]list){int[]result = newint[list.length]; for(inti = 0, j = result.length - 1; i < list.length; i++, j--){result[j] = list[i]; }returnresult; }

以上实例中 result 数组作为函数的返回值。

多维数组

多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:

String[][]str = newString[3][4];

多维数组的动态初始化(以二维数组为例)

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

type[][]typeName = newtype[typeLength1][typeLength2];

type 可以为基本数据类型和复合数据类型,typeLength1 和 typeLength2 必须为正整数,typeLength1 为行数,typeLength2 为列数。

例如:

int[][]a = newint[2][3];

解析:

二维数组 a 可以看成一个两行三列的数组。

2. 从最高维开始,分别为每一维分配空间,例如:

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

解析:

s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间,也就是为最高维限制其能保存数据的最长的长度,然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。

多维数组的引用(以二维数组为例)

对二维数组中的每个元素,引用方式为 arrayName[index1][index2],例如:

num[1][0];

Arrays 类

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

具有以下功能:

  • 给数组赋值:通过 fill 方法。
  • 对数组排序:通过 sort 方法,按升序。
  • 比较数组:通过 equals 方法比较数组中元素值是否相等。
  • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表:

序号 方法和说明
1 public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
2 public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
3 public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
4 public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

练习

Java 数组测验

AI 思考中...

11 篇笔记 写笔记

  1. #0

    Jabin

    957***[email protected]

    144

    数组倒序实例:

    public class Test2 {
 public static void main(String[] args){
 int[] test= {1,2,4,5,7};
 for (int i : test) {
 System.out.print(i+" ");
 }
 System.out.println("\n");
 test = Test2.reverse(test);
 for (int i : test) {
 System.out.print(i+" ");
 }
 }
 public static int[] reverse(int[] arr){
 int[] result = new int[arr.length];
 for (int i = 0,j=result.length-1; i < arr.length; i++,j--) {
 result[j] = arr[i];
 }
 return result;
 }
}

    Jabin

    957***[email protected]

    9年前 (2017年04月03日)
  2. #0

    飞翔的蒲公英

    dar***[email protected]

    74
    // 声明二维数组:有两行,列数待定,数组结构 = { { }, { } }
String s[][] = new String[2][]; 
// 确定每行的元素个数,第一行有2个元素,第二行有3个元素,
// 数组结构 = {{"E1", "E2"}, {"E1", "E2", "E3"}}
s[0] = new String[2];
s[1] = new String[3];

    飞翔的蒲公英

    dar***[email protected]

    9年前 (2017年04月15日)
  3. #0

    angelra

    264***[email protected]

    45

    实现数组和字符串的转换处理

    public class Test {
 public static void main(String args[]) {
 String str = "helloworld";
 char[] data = str.toCharArray();// 将字符串转为数组
 for (int x = 0; x < data.length; x++) {
 System.out.print(data[x] + " ");
 data[x] -= 32;
 System.out.print(data[x] + " ");
 }
 System.out.println(new String(data));
 }
}

    angelra

    264***[email protected]

    9年前 (2017年09月12日)
  4. #0

    Hantn

    473***[email protected]

    57

    冒泡排序

    public class BubbleSort {
/**
 * N个数字要排序完成,总共进行N-1趟排序,每i趟的排序次数为(N-i)次,所以可以用双重循环语句,外层控制循环多少趟,内层控制每一趟的循环次数。
 * @param args
 */
 public static void main(String[] args) {
 int arr[] = {26,15,29,66,99,88,36,77,111,1,6,8,8};
 for(int i=0;i < arr.length-1;i++) {//外层循环控制排序趟数
 for(int j=0; j< arr.length-i-1;j++) {
 //内层循环控制每一趟排序多少次
 // 把小的值交换到前面
 if (arr[j]>arr[j+1]) {
 int temp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = temp;
 }
 }
 System.out.print("第"+(i+1)+"次排序结果:");
 //列举每次排序的数据
 for(int a=0;a<arr.length;a++) {
 System.out.print(arr[a] + "\t");
 }
 System.out.println("");
 }
 System.out.println("最终排序结果:");
 for(int a = 0; a < arr.length;a++) {
 System.out.println(arr[a] + "\t");
 }
 }
}

    Hantn

    473***[email protected]

    9年前 (2017年11月06日)
  5. #0

    WaterHole

    710***[email protected]

    52

    选择排序:(比冒泡排序更快,运行次数更少):

    public class Start
{
 public static void main(String[] args)
 {
 int[] arr={20,60,51,81,285,12,165,51,81,318,186,9,70};
 for(int a:arr)
 {
 System.out.print(a+" ");
 }
 
 System.out.println("\n"+"---------------从小到大---------------");
 
 arr=toSmall(arr);
 for(int a:arr)
 {
 System.out.print(a+" ");
 }
 
 System.out.println("\n"+"---------------从大到小---------------");
 
 arr=toBig(arr);
 for(int a:arr)
 {
 System.out.print(a+" ");
 }
 }
// 从大到小
 public static int[] toSmall(int[] arr)
 {
//遍历数组里除最后一个的其他所有数,因为最后的对象没有与之可以相比较的数
 for(int i=0;i<arr.length-1;i++)
 {
/*遍历数组里没有排序的所有数,并与上一个数进行比较
 *“k=i+1”因为自身一定等于自身,所以相比没有意义
 *而前面已经排好序的数,在比较也没有意义
 */
 for(int k=i+1;k<arr.length;k++)
 {
 if(arr[k]<arr[i])//交换条件(排序条件)
 {
 int number=arr[i];
 arr[i]=arr[k];
 arr[k]=number;
 }//交换
 }
 }
 return arr;
 }
// 从小到大
//和前面一样
 public static int[] toBig(int[] arr)
 {
 for(int i=0;i<arr.length-1;i++)
 {
 for(int k=i+1;k<arr.length;k++)
 {
 if(arr[k]>arr[i])
 {
 int number=arr[i];
 arr[i]=arr[k];
 arr[k]=number;
 }
 }
 }
 return arr;
 }
}

    WaterHole

    710***[email protected]

    9年前 (2018年01月03日)
  6. #0

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

    • 给数组赋值:通过fill方法。
    • 对数组排序:通过sort方法,按升序。
    • 比较数组:通过equals方法比较数组中元素值是否相等。
    • 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。
    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));
 }
}

    输出结果:

    填充数组: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
    9年前 (2018年01月04日)
  7. #0

    支上上

    849***[email protected]

    45

    数组容量如果不够用可以使用 Arrays.copyOf() 进行扩容:

    Array.copy(E[] e,newLength);

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

    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]);
 }
 }
}

    默认补 0,输出结果为: 10 20 30 40 50 0

    支上上

    849***[email protected]

    8年前 (2018年03月20日)
  8. #0

    支上上

    849***[email protected]

    22

    数组实现的一个小游戏

    程序随机产生5个按一定顺序排列的字符,作为猜测结果。

    玩家可以猜测多次,每猜一次,若猜测的完全正确则游戏结束,并计算玩家的游戏得分并输出。若没有猜对,则提示猜测结果,如猜对了几个字符,以及猜对了几个字符的位置信息,并提示玩家游戏继续。若中途输入EXIT,则游戏提前结束

    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;
 }
}
    支上上

    支上上

    849***[email protected]

    8年前 (2018年04月02日)
  9. #0

    tfbyly

    905***[email protected]

    20

    数组这里有一个问题容易搞不清楚的。

    在 java 中,关于数组描述正确的是( B,D )

    • A.数组中的索引下标从1开始
    • B.存储在数组当中的数据都属于同一数据类型
    • C.通过数组名.length()能获得数组的长度
    • D.数组的最大索引下标是数组的长度减1

    比如说一个 int 类型的数组: 

    int[] arr = { 'a', 25, 45, 78, 'z' };
System.out.println(Arrays.toString(arr));

    输出结果是:[97, 25, 45, 78, 122]

    存放进去的 char 类型的字符会自动转为 int 类型的 ASCII 码。

    上面的代码中就将 a 转成了 97,z 转成了 122。

    所以数组只能存放同一类型的数据是正确的。

    D选项。

    数组的长度固定时,为了防止下标越界,应该在索引的时候将下标减一。

    int[] arr = { 'a', 25, 45, 78, 'z' };
int arrs = arr[5];
System.out.println(Arrays.toString(arr));
System.out.println(arrs);

    上面的代码中数组总长度为 5,因为数组是索引是从 0 开始取值,索引取值为5的时候就会产生下标越界异常,在这里最大的索引应当为 4。

    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5

    tfbyly

    905***[email protected]

    8年前 (2018年04月18日)
  10. #0

    路过顺便打酱油

    782***[email protected]

    21

    对于上面的冒泡排序,其实没必要那么复杂,最终得到的是结果,我们只需要理解冒泡排序要排多少次就可以了。比如 1-9 比较,1-2,2-3 等,需要 9 次出一个最大最小数,然后再次去比较出第二个数字,所有自然想到了嵌套循环;代码如下:

    //冒泡
int[] num={2,4,9,1,6,7,9,12,63,4,87,54,67,65,4};
int totle;
for(int i=0;i<num.length;i++){
 for(int j=0;j<i;j++){
 if(num[j]>num[i]){
 totle=num[j];
 num[j]=num[i];
 num[i]=totle;
 }
 }
}
for(int i=num.length-1;0<=i;i--){
 for(int j=i;0<=j;j--){
 if(num[j]>num[i]){
 totle=num[j];
 num[j]=num[i];
 num[i]=totle;
 }
 }
}
for (int k : num) {
 System.out.print(k+"===");
}

    两次循环代码都可以出结果,区别在于一个是累加,一个是累减,随便去掉一个循环代码还是能得到结果

    路过顺便打酱油

    782***[email protected]

    7年前 (2019年07月18日)
  11. #0

    好劲的维

    pal***@qq.com

    26

    Java.util.Arrays 类的排序拓展

    java.util.Arrays.sort 只可以用于按升序排列数组,若按降序排序可以使用 Arrays.sort(数组,Collections.reverseOrder())。

    调用的其实 Arrays.sort 的静态方法之一 Arrays.sort(Integer[] a,Comparator cmp)。

    对于 Collections.reverseOrder() 官方解释:

    reverseOrder() 方法用于获取一个比较有否就实现 Comparable 接口的对象的集合的自然顺序相反。

    import java.util.Arrays;
import java.util.Collections;
public class Main {
 public static void main(String []args) {
 Double[] list_double = new Double[10];
 list_double[0] = 1.2;
 list_double[1] = 2.2;
 list_double[2] = 8.2;
 list_double[3] = 4.2;
 list_double[4] = 7.2;
 list_double[5] = 6.2;
 list_double[6] = 5.2;
 list_double[7] = 4.2;
 list_double[8] = 9.2;
 list_double[9] = 10.2;
 java.util.Arrays.sort(list_double);
 System.out.println("升序:");
 for(double emp:list_double)
 {
 System.out.println(emp);
 }
 
 Arrays.sort(list_double,Collections.reverseOrder());
 System.out.println("降序:");
 for(double emp:list_double)
 {
 System.out.println(emp);
 }
 }
}

    好劲的维

    pal***@qq.com

    6年前 (2020年08月10日)

点我分享笔记

  • 昵称 (必填)
  • 邮箱 (必填)
  • 引用地址

AltStyle によって変換されたページ (->オリジナル) /