[数据结构与算法] JavaSE—

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 数据结构与算法 -> JavaSE——数组 -> 正文阅读

[数据结构与算法]JavaSE——数组

数组

一、数组Array

Java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object。
数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。）
数组：字面意思是“一组数据”
数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。
数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的）
数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象。
数组一旦创建，在java中规定，长度不可变。（数组长度不可变）
数组的分类：一维数组、二维数组、三维数组、多维数组…（一维数组较多，二维数组偶尔使用！）
所有的数组对象都有length属性(java自带的)，用来获取数组中元素的个数。
java中的数组要求数组中元素的类型统一。比如int类型数组只能存储int类型，Person类型数组只能存储Person类型。

（数组中存储的元素类型统一）
数组在内存方面存储的时候，数组中的元素内存地址(存储的每一个元素都是有规则的挨着排列的)是连续的。内存地址连续。
这是数组存储元素的特点（特色）。数组实际上是一种简单的数据结构。
所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。
（数组中首元素的内存地址作为整个数组对象的内存地址。）
数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length - 1
下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。
数组这种数据结构的优点和缺点是什么？
优点：查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构。
为什么检索效率高？
第一：每一个元素的内存地址在空间存储上是连续的。
第二：每一个元素类型相同，所以占用空间大小一样。
第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以
通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位
元素，所以数组的检索效率是最高的。

? 缺点：
? 第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，
效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
? 第二：数组不能存储大数据量，为什么？
? 因为很难在内存空间上找到一块特别大的连续的内存空间。

注意：对于数组中最后一个元素的增删，是没有效率影响的。

二、一维数组

怎么声明/定义一个一维数组？
语法格式：
int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
怎么初始化一个一维数组呢？
包括两种方式：静态初始化一维数组，动态初始化一维数组。
静态初始化语法格式：
int[] array = {100, 200, 300, 55};
动态初始化语法格式：
int[] array = new int[5]; // 这里的5表示数组的元素个数。
// 初始化一个5个长度的int类型数组，每个元素默认值0
String[] names = new String[6]; // 初始化6个长度的String类型数组，每个元素默认值null。

public class ArrayTest01 {
public static void main(String[] args) {
// 声明一个int类型的数组，使用静态初始化的方式
int[] a = {1, 100, 10, 20, 55, 689};
// 下面是C++风格，不建议java中使用。
//int a[] = {1, 100, 10, 20, 55, 689};

    // 所有的数组对象都有length属性
    System.out.println("数组中元素的个数" + a.length);

    // 数组中每一个元素都有下标
    // 通过下标对数组中的元素进行存和取。
    // 取（读）
    System.out.println("第一个元素 = " + a[0]);
    System.out.println("最后一个元素 = " + a[5]);
    System.out.println("最后一个元素 = " + a[a.length - 1]);

    // 存（改）
    // 把第一个元素修改为111
    a[0] = 111;
    // 把最后一个元素修改为0
    a[a.length - 1] = 0;

    System.out.println("第一个元素 = " + a[0]);
    System.out.println("最后一个元素 = " + a[5]);

    // 一维数组怎么遍历呢？
    for(int i = 0; i < a.length; i++){
        System.out.println(a[i]); // i是从0到5，是下标
    }

    // 下标为6表示第7个元素，第7个元素没有，下标越界了。会出现什么异常呢？
    //System.out.println(a[6]); //ArrayIndexOutOfBoundsException（比较著名的异常。）

    // 从最后一个元素遍历到第1个元素
    for (int i = a.length - 1; i >= 0; i--) {
        System.out.println("颠倒顺序输出-->" + a[i]);
    }
}

}


3.  什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？
 当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。
 当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间。

package Array;

public class ArrayTest02 {
public static void main(String[] args) {
// 声明/定义一个数组，采用动态初始化的方式创建
int[] a = new int[4]; // 创建长度为4的int数组，数组中每个元素的默认值是0
// 遍历数组
for (int i = 0; i < a.length; i++) {
System.out.println(“数组中下标为” + i + “的元素是：” + a[i]);
}

    System.out.println("===============================");
    
    // 后期赋值
    a[0] = 1;
    a[1] = 100;
    a[2] = 111;
    a[3] = 222; // 注意下标别越界。

    for (int i = 0; i < a.length; i++) {
        System.out.println("数组中下标为" + i + "的元素是：" + a[i]);
    }

    System.out.println("===============================");

    // 初始化一个Object类型的数组，采用动态初始化方式
    Object[] objs = new Object[3]; // 3个长度，动态初始化，所以每个元素默认值是null
    for (int i = 0; i < objs.length; i++) {
        System.out.println(objs[i]);
    }

    System.out.println("===============================");

    String[] strs = new String[3];
    for (int i = 0; i < strs.length; i++) {
        System.out.println(strs[i]);
    }

    System.out.println("===============================");

    // 采用静态初始化的方式
    String[] strs2 = {"abc", "def", "xyz"};
    for (int i = 0; i < strs2.length; i++) {
        System.out.println(strs2[i]);
    }

    System.out.println("===============================");
    
    // 存储Object，采用静态初始化呢？
    /*Object o1 = new Object();
    Object o2 = new Object();
    Object o3 = new Object();
    Object[] objects = {o1, o2, o3};*/

    Object[] objects = {new Object(), new Object(), new Object()};

    for (int i = 0; i < objects.length; i++) {
        /*Object o = objects[i];
        System.out.println(o);*/
        System.out.println(objects[i]);
    }
}

}


4. 当一个方法上，参数的类型是一个数组的时候。

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

       int[] x = {1,2,3,4};
       printArray(x);

       // 创建String数组
       String[] stringArray = {"abc", "def", "hehe", "haha"};
       printArray(stringArray);

       String[] strArray = new String[10];
       printArray(strArray); // 10个null

       System.out.println("================================");
       printArray(new String[3]);
       System.out.println("***********************************");
       printArray(new int[4]);

   }

   public static void printArray(int[] array){
       for(int i = 0; i < array.length; i++){
           System.out.println(array[i]);
       }
   }

   public static void printArray(String[] args){
       for(int i = 0; i < args.length; i++){
           System.out.println("String数组中的元素：" + args[i]);
       }
   }

}

// 当一个方法的参数是一个数组的时候，我们还可以采用这种方式传。

public class ArrayTest04 {
public static void main(String[] args) {
// 静态初始化一维数组
int[] a = {1,2,3};
printArray(a);

       System.out.println("============================");
       // 没有这种语法。
       //printArray({1,2,3});
       // 如果直接传递一个静态数组的话，语法必须这样写。
       printArray(new int[]{1,2,3});

       // 动态初始化一维数组
       int[] a2 = new int[4];
       printArray(a2);

       System.out.println("=============================");
       printArray(new int[3]);
   }

   // 为什么要使用静态方法？方便，不需要new对象啊。
   public static void printArray(int[] array){
       for (int i = 0; i < array.length; i++) {
           System.out.println(array[i]);
       }
   }

}


5. main方法上面的“String[] args”有什么用？
    分析以下：谁负责调用main方法（JVM）
    JVM调用main方法的时候，会自动传一个String数组过来。

public class ArrayTest05 {
// 这个方法程序员负责写出来，JVM负责调用。JVM调用的时候一定会传一个String数组过来。
public static void main(String[] args) {
// JVM默认传递过来的这个数组对象的长度？默认0
// 通过测试得出：args不是null。
System.out.println(“JVM给传递过来的String数组参数，它这个数组的长度是？” + args.length);

       // 以下这一行代码表示的含义：数组对象创建了，但是数组中没有任何数据。
       //String[] strs = new String[0];
       //String[] strs = {}; // 静态初始化数组，里面没东西。
       //printLength(strs);

       // 这个数组什么时候里面会有值呢？
       // 其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会被转换为“String[] args”
       // 例如这样运行程序：java ArrayTest05 abc def xyz
       // 那么这个时候JVM会自动将“abc def xyz”通过空格的方式进行分离，分离完成之后，自动放到“String[] args”数组当中。
       // 所以main方法上面的String[] args数组主要是用来接收用户输入参数的。
       // 把abc def xyz 转换成字符串数组：{"abc","def","xyz"}
       // 遍历数组
       for (int i = 0; i < args.length; i++) {
           System.out.println(args[i]);
       }

   }

   public static void printLength(String[] args){
       System.out.println(args.length); // 0
   }

}


模拟一个系统，必须输入正确的用户名和密码才能登陆系统，使用系统。

public class ArrayTest06 {
// 用户名和密码输入到String[] args数组当中。
public static void main(String[] args) {
if(args.length != 2){
System.out.println(“使用该系统时请输入程序参数，参数中包括用户名和密码信息，例如：zhangsan 123”);
return;
}

       // 程序执行到此处说明用户确实提供了用户名和密码。
       // 接下来你应该判断用户名和密码是否正确。
       // 取出用户名
       String username = args[0];
       // 取出密码
       String password = args[1];

       // 假设用户名是admin，密码是123的时候表示登录成功。其它一律失败。

       // 判断两个字符串是否相等，需要使用equals方法。

       //if(username.equals("admin") && password.equals("123")){
       // 这样编写是不是可以避免空指针异常。

       // 采用以下编码风格，即使username和password都是null，也不会出现空指针异常。（这是老程序员给的一条编程经验。）
       if("admin".equals(username) && "123".equals(password)){
           System.out.println("登录成功，欢迎[" + username + "]回来");
           System.out.println("您可以继续使用该系统....");
       }else{
           System.out.println("验证失败，用户名不存在或者密码错误！");
       }
   }

}


6. 一维数组深入

数组中存储的类型为：引用数据类型

对于数组来说，实际上只能存储java对象的“内存地址”。数组中存储的每个元素是“引用”。

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

       int[] array = {1,2,3};
       for (int i = 0; i < array.length; i++) {
           /*int temp = array[i];
           System.out.println(temp);*/
           System.out.println(array[i]);
       }

       // 创建一个Animal类型的数组
       Animal a1 = new Animal();
       Animal a2 = new Animal();
       Animal[] animals = {a1, a2};

       // 对Animal数组进行遍历
       for (int i = 0; i < animals.length; i++) {
       
           /*Animal a = animals[i];
           a.move();*/
           
           // 代码合并
           animals[i].move(); // 这个move()方法不是数组的。是数组当中Animal对象的move()方法。
       }

       // 动态初始化一个长度为2的Animal类型数组。
       Animal[] ans = new Animal[2];
       // 创建一个Animal对象，放到数组的第一个盒子中。
       ans[0] = new Animal();

       // Animal数组中可以存放Cat类型的数据，因为Cat是一个Animal。
       // Cat是Animal的子类。
       ans[1] = new Cat();

       // 创建一个Animal类型的数组，数组当中存储Cat和Bird
       Cat c = new Cat();
       Bird b = new Bird();
       Animal[] anis = {c, b};

       //Animal[] anis = {new Cat(), new Bird()}; // 该数组中存储了两个对象的内存地址。
       for (int i = 0; i < anis.length; i++){
           // 这个取出来的可能是Cat，也可能是Bird，不过肯定是一个Animal
           // 如果调用的方法是父类中存在的方法不需要向下转型。直接使用父类型引用调用即可。
           //anis[i]
           //Animal an = anis[i];
           //an.move();

           //Animal中没有sing()方法。
           //anis[i].sing();

           // 调用子对象特有方法的话，需要向下转型！！！
           if(anis[i] instanceof Cat){
               Cat cat = (Cat)anis[i];
               cat.catchMouse();
           }else if(anis[i] instanceof Bird){
               Bird bird = (Bird)anis[i];
               bird.sing();
           }
       }

   }

}

class Animal{
public void move(){
System.out.println(“Animal move…”);
}
}

// Cat是子类
class Cat extends Animal {
public void move(){
System.out.println(“猫在走猫步！”);
}
// 特有方法
public void catchMouse(){
System.out.println(“猫抓老鼠！”);
}
}

// Bird子类
class Bird extends Animal {
public void move(){
System.out.println(“Bird Fly!!!”);
}
// 特有的方法
public void sing(){
System.out.println(“鸟儿在歌唱！！！”);
}
}


7. 关于一维数组的扩容。

在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？

数组满了，需要扩容。

java中对数组的扩容是：先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。


结论：数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意：尽可能少的进行数组的拷贝。

可以在创建数组对象的时候预估计以下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。

public class ArrayTest08 {
public static void main(String[] args) {
// java中的数组是怎么进行拷贝的呢？
//System.arraycopy(5个参数);

       // 拷贝源（从这个数组中拷贝）
       int[] src = {1, 11, 22, 3, 4};

       // 拷贝目标（拷贝到这个目标数组上）
       int[] dest = new int[20]; // 动态初始化一个长度为20的数组，每一个元素默认值0

       // 调用JDK System类中的arraycopy方法，来完成数组的拷贝
       //System.arraycopy(src, 1, dest, 3, 2);

       // 遍历目标数组
       /*
       for (int i = 0; i < dest.length; i++) {
           System.out.println(dest[i]); // 0 0 0 11 22 ... 0
       }
        */

       System.arraycopy(src, 0, dest, 0, src.length);
       for (int i = 0; i < dest.length; i++) {
           System.out.println(dest[i]);
       }

       // 数组中如果存储的元素是引用，也可以拷贝。
       String[] strs = {"hello", "world!", "study", "java", "oracle", "mysql", "jdbc"};
       String[] newStrs = new String[20];
       System.arraycopy(strs, 0, newStrs, 0, strs.length);
       for (int i = 0; i < newStrs.length; i++) {
           System.out.println(newStrs[i]);
       }

       System.out.println("================================");
       Object[] objs = {new Object(), new Object(), new Object()};
       Object[] newObjs = new Object[5];
       // 思考一下：这里拷贝的时候是拷贝对象，还是拷贝对象的地址。（地址。）
       System.arraycopy(objs, 0, newObjs, 0, objs.length);
       for (int i = 0; i < newObjs.length; i++) {
           System.out.println(newObjs[i]);
       }
   }

}


----

#### 三、二维数组

1. 关于二维数组：

（1）二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。

（2）三维数组是什么？
        三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。
        实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。

（3）二维数组静态初始化
        int[][] array = {

{1,1,1},{2,3,4,5},{0,0,0,0},{2,3,4,5},{2,3,4,5},{2,3,4,5},{2,3,4,5}};

public class ArrayTest09 {
public static void main(String[] args) {
// 一维数组
int[] array = {100, 200, 300};
System.out.println(array.length); // 3
System.out.println("=======================");

    // 二维数组
    // 以下代码当中：里面的是4个一维数组。
    int[][] a = {
            {100, 200, 300},
            {30, 20, 40, 50, 60},
            {6, 7, 9, 1},
            {0}
    };
    System.out.println(a.length); // 4
    System.out.println(a[0].length); // 3
    System.out.println(a[1].length); // 5
    System.out.println(a[2].length); // 4
    System.out.println(a[3].length); // 1

    // 里面的是5个一维数组。
    int[][] a2 = {
            {100, 200, 300},
            {30, 20, 40, 50, 60},
            {6, 7, 9, 1},
            {0},
            {1,2,3,4,5}
    };

}

}


2. 关于二维数组中元素的：读和改。

   a 【二维数组中的一维数组的下标][一维数组的下标]

   a【0][0]：表示第1个一维数组中的第1个元素。

   a【3][100]：表示第4个一维数组中的第101个元素。

 注意：对于a【3][100]来说，其中 a[3] 是一个整体。[100]是前面a[3]执行结束的结果然后再下标100.

public class ArrayTest10 {
public static void main(String[] args) {
// 二维数组
int[][] a = {
{34,4,65},
{100,200,3900,111},
{0}
};

    // 请取出以上二位数中的第1个一维数组。
    int[] 我是第1个一维数组 = a[0];
    int 我是第1个一维数组中的第1个元素 = 我是第1个一维数组[0];
    System.out.println(我是第1个一维数组中的第1个元素);

    // 以下代码的由来是因为以上代码的合并导致的。
    System.out.println(a[0][0]);

    // 取出第2个一维数组当中第3个元素
    System.out.println("第二个一维数组中第三个元素：" + a[1][2]);

    // 取出第3个一维数组当中第1个元素
    System.out.println("第3个一维数组中第1个元素：" + a[2][0]);

    // 改
    a[2][0] = 11111;
    System.out.println(a[2][0]);

    // 注意别越界。
    //java.lang.ArrayIndexOutOfBoundsException
    //System.out.println(a[2][1]);
}

}


3. 遍历二维数组

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

       // 二维数组
       String[][] array = {
               {"java", "oracle", "c++", "python", "c#"},
               {"张三", "李四", "王五"},
               {"lucy", "jack", "rose"}
       };

       // 遍历二维数组
       for(int i = 0; i < array.length; i++){ // 外层循环3次。（负责纵向。）
           String[] 一维数组 = array[i];
           // 负责遍历一维数组

           for(int j = 0; j < 一维数组.length; j++){
               System.out.print(一维数组[j] + " ");
           }
           // 输出换行符
           System.out.println();
       }

       // 合并代码
       for(int i = 0; i < array.length; i++){ // 外层循环3次。（负责纵向。）
           for(int j = 0; j < array[i].length; j++){
               System.out.print(array[i][j] + " ");
           }
           System.out.println();
       }
   }

}


4. 动态初始化二维数组

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

       // 3行4列。
       // 3个一维数组，每一个一维数组当中4个元素。
       //int[][] array = new int[3][4];

       // 静态初始化
       int[][] a = {{1,2,3,4},{4,5,6,76},{1,23,4}};
       printArray(a);

       // 没有这种语法
       //printArray({{1,2,3,4},{4,5,6,76},{1,23,4}});

       // 可以这样写。
       printArray(new int[][]{{1,2,3,4},{4,5,6,76},{1,23,4}});
   }

   public static void printArray(int[][] array){
       // 遍历二维数组。
       for (int i = 0; i < array.length; i++) {
           for (int j = 0; j < array[i].length; j++) {
               System.out.print(array[i][j] + " ");
           }
           System.out.println();
       }
   }

}