JavaSE-05-Java数组和枚举

灰太狼 2023-10-06 10:43 40阅读 0赞

**Table of Contents**

Java数组和枚举

1：数组的声明与创建

1.1：数组的声明

1.2：数组的创建

1.3：数组初始化；

1.4：数组内存的分配

2： 数组元素的访问

2.1：使用数组的length属性

2.2：优化后的for语句

3：多维数组

3.1：多维数组的基础知识

3.2：多维数组的本质

3.3：多维数组的内存

4：数组的复制

5：数组的排序方法

6：数组实用类 Arrays

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 ）

7：枚举类型

7.1：什么是枚举

7.2：遍历枚举

7.3:在 在 switch 中使用枚举

--------------------

# 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，数组在被创建的时候，内存示意图如下：

![20200608133727690.png][]

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

内存示意图如下：

![20200608133759653.png][]

# 2： 数组元素的访问 #

## 2.1：使用数组的length属性 ##

int \[\] a = new int\[5\];

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70][]

## 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：多维数组的内存 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 1][]

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

![20200608172805745.png][]

还有一个常用的方法：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;
            }
        }
    }

[20200608133727690.png]: https://img-blog.csdnimg.cn/20200608133727690.png
[20200608133759653.png]: https://img-blog.csdnimg.cn/20200608133759653.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200608134133415.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200608170230816.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNjk0OTA2,size_16,color_FFFFFF,t_70
[20200608172805745.png]: https://img-blog.csdnimg.cn/20200608172805745.png