JavaSE-05-Java数组和枚举

最新推荐文章于 2023-06-29 07:30:00 发布

苍煜

最新推荐文章于 2023-06-29 07:30:00 发布

阅读量1k

点赞数

分类专栏： JAVASE 文章标签： java javase

本文链接：https://blog.csdn.net/qq_41694906/article/details/106617037

版权

JAVASE 专栏收录该内容

27 篇文章 1 订阅

订阅专栏

Table of Contents

1：public static boolean equals （数组参数 1, 数组参数 2

2：public static boolean deepEquals （数组参数 1, 数组参数 2 ）

3：public static void fill （数组,数组参数）

4：public static void fill （数组,int fromIndex, int toIndex, 数据参数）

5：public static void sort （数组）

6：public static 数组 copyOf （数组,int newLength ）

7：public static 数组 copyOfRange （数组,int from,int to ）

Java数组和枚举

1：数组的声明与创建

1.1：数组的声明

数组是由相同类型的若干项数据组成的一个数据集合，数组中的每个数据称为元素。也就是说数组是用来集合相同类型的对象，可以是原始数据类型或引用数据类型。

数组声明实际是创建一个引用，通过代表引用的这个名字来引用数组。数组声明格式如下：数据类型标识符[]

1.2：数组的创建

数据对象和其他 Java 对象一样，使用关键字 new 创建。创建的时候要指明数组的长度。

s = new char [20];
p = new Point [100];

第一行创建了一个20个char类型元素的数组，在堆区为数组分配内存空间，每个元素都是char 类型的，占 2 个字节，因此整个数组对象再内存中占用 40 个字节。为每个元素赋予其数据类型的默认值，即'\u0000'。返回数组对象的引用赋值给变量 s。

用来指示单个数组元素的下标必须总是从 0 开始，并保持在合法范围之内－－大于 0 或等于并小于数组长度。任何访问在上述界限之外的数组元素的企图都会引起运行时出错。

1.3：数组初始化；

当创建一个数组时，每个元素都被自动使用默认值进行初始化。在上述 char 数组s的例子中，每个值都被初始化为 0 (\u0000-null)字符；

注意－－所有变量的初始化(包括数组元素)是保证系统安全的基础，变量绝不能在未初始化状态使用。

Java 编程语言允许使用下列形式快速创建数组，直接定义并初始化：

String names[] = { "Georgianna", "Jen", "Simon" };

其结果与下列代码等同：

String names[];
names = new String[3];
names[0]="Georgianna";
names[1]="Jen";
names[2]="Simon";

1.4：数组内存的分配

数组一旦被创建，在内存里面占用连续的内存地址。数组还具有一个非常重要的特点——数组的静态性：数组一旦被创建，就不能更改数组的长度。

比如，定义数组如下：
Point[] p = new Point [3];

其中 p 是数组名，数组长度是 3，数组在被创建的时候，内存示意图如下：

为数组初始化：
p[0] = new Point() ;
p[1] = new Point() ;
p[2] = new Point() ;

内存示意图如下：

2：数组元素的访问

2.1：使用数组的length属性

int [] a = new int[5];

那么该数组的length属性为5；代表该数组中有五个元素；

2.2：优化后的for语句

在访问数组的时候，经常使用 for 循环语句。从 JDK5.0 开始，提供了一个更好的 for 循环语句的写法，示例如下：

public class TestMain {
    public static void main(String args[]) {
        int a[] = new int[3];
        // 旧的写法，赋值
        for (int i = 0; i < a.length; i++) {
            a[i] = i;
        }
        // 新的写法，取值
        for (int i : a) {
            System.out.println(i);
        }
    }


}

3：多维数组

3.1：多维数组的基础知识

Java 编程语言没有象其它语言那样提供多维数组。因为一个数组可被声明为具有任何基础类型，所以你可以创建数组的数组(和数组的数组的数组，等等)。一个二维数组如下例所示：

int twoDim[][] = new int[4][];
twoDim[0] = new int[5];
twoDim[1] = new int[5];

首次调用 new 而创建的对象是一个数组，它包含 4 个元素，每个元素对类型 array of int 的元素都是一个 null 引用并且必须将数组的每个点分别初始化。

因为这种对每个元素的分别初始化，所以有可能创建非矩形数组的数组。也就是说，twoDim 的元素可按如下方式初始化：

twoDim[0] = new int [2];
twoDim[1] = new int [4];
twoDim[2] = new int [6];
twoDim[3] = new int [8];

也可以这样创建：

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

可被用来创建一个每个数组有 4 个整数类型的 3 个数组的数组。可以理解成为如下表格所示：

twoDim[0][0]  twoDim[0][1]  twoDim[0][2]  twoDim[0][3]
twoDim[1][0]  twoDim[1][1]  twoDim[1][2]  twoDim[1][3]
twoDim[2][0]  twoDim[2][1]  twoDim[2][2]  twoDim[2][3]

3.2：多维数组的本质

N 维数组就是一维的 N-1 维数组，比如：三维数组就是一维的二维数组。

三维以至多维数组都是一个思路，一维数组——〉二维数组——〉三维数组的实例:

public class TestMain {
    public static void main(String args[]) {
        int[][][] M = new int[4][5][3];
        for (int row = 0; row < 4; row++) {
            for (int col = 0; col < 5; col++) {
                for (int ver = 0; ver < 3; ver++) {
                    M[row][col][ver] = row + col + ver;
                }
            }
        }
    }

}

3.3：多维数组的内存

4：数组的复制

数组一旦创建后，其大小不可调整。然而，你可使用相同的引用变量来引用一个全新的数组：

int myArray []= new int [6];
myArray = new int [10]

在这种情况下，第一个数组被有效地丢失，除非对它的其它引用保留在其它地方。

Java 编程语言在 System 类中提供了一种特殊方法拷贝数组，该方法被称作arraycopy()。例如，araycopy 可作如下使用：

// 原始数组
int myArray[] = { 1, 2, 3, 4, 5, 6 };
// 新的数组，比原始数组大
int hold[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// 把原始数组的值拷贝到新的数组
//没有返回值
//          原数组  源开始位置，目的数组，目的开始位置，复制长度
System.arraycopy(myArray, 0, hold, 0, myArray.length);

5：数组的排序方法

在 java.util.Arrays 类中有一个静态方法 sort，可以用这个类的 sort 方法来对数组进行排序。示例如下：

public class TestMain {
    public static void main(String[] args) {
        // 需要排序的数组，目前是按照升序排列的
        int a[] = new int[5];
        a[0] = 3;
        a[1] = 4;
        a[2] = 1;
        a[3] = 5;
        a[4] = 2;
        // 数组排序
        java.util.Arrays.sort(a);
        // 检测一下排序的结果
        for (int i2 : a) {
            System.out.println("i=" + i2);
        }
    }

}

6：数组实用类 Arrays

在 java.util 包中，有一个用于操纵数组的实用类 Arrays。它提供了一系列静态方法，帮助开发人员操作数组

1：public static boolean equals （数组参数 1, 数组参数 2

比较两个数组参数是否相同，数组参数可以是基本数据类型，也可以是引用数据类型。只有当两个数组中的元素数目相同，并且对应位置的元素也相同时，才表示数组相同。

2：public static boolean deepEquals （数组参数 1, 数组参数 2 ）

如果两个指定数组彼此是深层相等的，则返回 true。此方法适用于任意深度的嵌套数组。用于比较多维数组

3：public static void fill （数组,数组参数）

向数组中填充数据参数，把数组中所有元素的值设置为该数据。数组和数据参数的类型必须一致，或可以自动转化，数组和元素可以是基本数据类型，也可以是引用数据类型。

4：public static void fill （数组,int fromIndex, int toIndex, 数据参数）

向数组中指定的范围填充数据参数，此范围包含 fromIndex，但不包含 toIndex。数组和数据参数的类型必须一致，或可以自动转化，数组和元素可以是基本数据类型，也可以是引用数据类型。包前不包后

5：public static void sort （数组）

把数组中的数组按升序排列。数组可以是基本数据类型，也可以是引用数据类型。

6：public static 数组 copyOf （数组,int newLength ）

赋值指定的数组，截取下标 0（包括）至 newLength（不包括）范围。返回新数组；

7：public static 数组 copyOfRange （数组,int from,int to ）

将数组的指定范围复制到一个新数组。数组可以是基本数据类型，也可以是引用数据类型。

7：枚举类型

7.1：什么是枚举

枚举类型 enum 是一种新的类型，在 JDK5.0 加入，允许用常量来表示特定的数据片断，这些数据是分配时预先定义的值的集合，而且全部都以类型安全的形式来表示。在枚举类型没有加入到 Java 前，我们要想表达常量的集合，通常采用如下的方式：

public class Test {
    public static final int A = 1;
    public static final int B = 2;
    public static final int C = 3;
    public static final int D = 4;
    public static final int E = 5;
}

那么我们在使用的时候就采用如下代码：Test.A 或者 Test.B 之类的代码。

但是在这样做的时候，我们需要记住这类常量是 Java 中 int 类型的常量，这意味着该方法可以接受任何 int 类型的值，即使它和 Test 中定义的所有级别都不对应。因此需要检测上界和下界，在出现无效值的时候，可能还要包含一个IllegalArgumentException。而且，如果后来又添加另外一个级别（例如 TEST.F，那么必须改变所有代码中的上界，才能接受这个新值。

枚举就为处理上述问题提供了更好的方法。把上面的例子改成用枚举的方式：

public class TestMain {
    public enum StudentGrade {
        A, B, C, D, E, F
    }


    public static void main(String[] args) {
        System.out.println("学生的平均成绩为==" + StudentGrade.B);
    }

}

上面的示例都相当简单，但是枚举类型提供的东西远不止这些。您可以逐个遍历枚举值，也可以在 switch 语句中使用枚举值，枚举是非常有价值的。

7.2：遍历枚举

public class TestMain {
    public enum StudentGrade {
        A, B, C, D, E, F
    }

    public static void main(String[] args) {
        for (StudentGrade score : StudentGrade.values()) {
            System.out.println("学生成绩取值可以为==" + score);
        }
    }

}

还有一个常用的方法：valueOf(String)：功能是以字符串的形式返回某一个具体枚举元素的值，示例如下：

public class TestMain {
    public enum StudentGrade {
        A, B, C, D, E, F
    };
    public static void main(String[] args) {
        StudentGrade score = StudentGrade.valueOf("A");
        System.out.println("你的成绩是:" + score);
    }
}

7.3:在在 switch 中使用枚举

public class TestMain {
    public enum StudentGrade {
        A, B, C, D, E, F
    };
    public static void main(String[] args) {
        StudentGrade score = StudentGrade.C;
        switch (score) {
            case A:
                System.out.println("你的成绩是优秀");
                break;
            case B:
                System.out.println("你的成绩是好");
                break;
            case C:
                System.out.println("你的成绩是良");
                break;
            case D:
                System.out.println("你的成绩是及格");
                break;
            default:
                System.out.println("你的成绩是不及格");
                break;
        }
    }
}

苍煜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaSE-05-Java数组和枚举

Java数组和枚举1：数组的声明与创建1.1：数组的声明数组是由相同类型的若干项数据组成的一个数据集合，数组中的每个数据称为元素。也就是说数组是用来集合相同类型的对象，可以是原始数据类型或引用数据类型。数组声明实际是创建一个引用，通过代表引用的这个名字来引用数组。数组声明格式如下：数据类型标识符[]1.2：数组的创建数据对象和其他 Java 对象一样，使用关键字 new 创建。创建的时候要指明数组的长度。s = new char [20];p = new Point ...
复制链接

扫一扫