一维数组

Array:

*   1 java语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是Object类

*

*   2 数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）

*   数组：字面意思是“一组数据”

*

*   3 数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。

*

*   4 数组因为是引用类型，所以数组对象是堆内存当中的。（数组是存储在堆内存当中的。）

*

*   5 数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象。

*

*   6 数组一旦创建，在java中规定，长度不可变。（数组长度不可变）

*

*   7 数组的分类：一维数组、二维数组、三维数组、多维数组...（一维数组较多，二维数组偶尔使用）

*

*   8 所有的数组对象都有length属性（Java自带的），用来获取数组中的元素个数。

*

*   9 Java中的数据要求数组中的元素的类型统一，比如int类型数组只能存储int类型，Person类型数组只能存储Person类型。

*   例如：超市购物，购物袋中只能装苹果，不能同时装苹果和橘子（数组中存储的元素类型统一）。

*

*   10 数组在内存方面存储的时候，数组中的元素内存地址（存储的每一个元素都是有规则的挨着排列的）是连续的。

*   这是数组存储元素的特点（特色）、数组实际上是一种简单的数据结构。

*

*   11 所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。（数组中的首元素的内存地址作为整个数组对象的内存地址。）

*

*   12 数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是:length - 1

*   下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。

*

*   13 数组这种数据结构的优点和缺点是什么？

*       优点:查询/查找/检索某个下表上的元素时效率极高。可以说是查询效率最高的一个数据结构。

*           为什么检索效率高？

*               第一：每一个元素的内存地址在空间存储上是连续的。

*               第二：每一个元素类型相同，所以占用空间大小一样。

*               第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式

*               就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的。

*

*               数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，因为数组中元素查找的时候不会

*               一个一个找，是通过数学表达式计算出来的。

*       缺点：

*           第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低。

*               因为随机增删元素会设计到后面元素统一向前或向后位移的操作。

*           第二：数组不能存储大数据量，为什么？

*               因为很难在内存上找到一块特别大的连续的内存空间。

*

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

*

*   14 怎么声明/定义一个一维数组？

*       语法格式：

*           int[] array1;

*           double[] array2;

*           boolean[] array4;

*           String[] array5;

*           Object[] array6;

*

*   15 怎么初始化一个一维数组呢？

*       包括两种方式:静态初始化一维数组，动态初始化一维数组。

*       静态初始化语法格式：

*           int[] array = {100,200,300,55};

*       动态初始化语法格式：

*           int[] array = new int[5];//这里的5表示数组的元素个数。初始化一个5个长度的int类型数组，每个元素默认值0

*           String[] names = new String[6];//初始化6个长度的String类型数组，每个元素默认值null。

 

 

数组在内存图中的表达方式：

 

数组内存图：

数组的概念和数组的定义:

package com.javase.array;
/*
* Array:
*   1 java语言中的数组是一种引用数据类型，不属于基本数据类型。数组的父类是Object类
*
*   2 数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）
*   数组：字面意思是“一组数据”
*
*   3 数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。
*
*   4 数组因为是引用类型，所以数组对象是堆内存当中的。（数组是存储在堆内存当中的。）
*
*   5 数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象。
*
*   6 数组一旦创建，在java中规定，长度不可变。（数组长度不可变）
*
*   7 数组的分类：一维数组、二维数组、三维数组、多维数组...（一维数组较多，二维数组偶尔使用）
*
*   8 所有的数组对象都有length属性（Java自带的），用来获取数组中的元素个数。
*
*   9 Java中的数据要求数组中的元素的类型统一，比如int类型数组只能存储int类型，Person类型数组只能存储Person类型。
*   例如：超市购物，购物袋中只能装苹果，不能同时装苹果和橘子（数组中存储的元素类型统一）。
*
*   10 数组在内存方面存储的时候，数组中的元素内存地址（存储的每一个元素都是有规则的挨着排列的）是连续的。
*   这是数组存储元素的特点（特色）、数组实际上是一种简单的数据结构。
*
*   11 所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。（数组中的首元素的内存地址作为整个数组对象的内存地址。）
*
*   12 数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是:length - 1
*   下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。
*
*   13 数组这种数据结构的优点和缺点是什么？
*       优点:查询/查找/检索某个下表上的元素时效率极高。可以说是查询效率最高的一个数据结构。
*           为什么检索效率高？
*               第一：每一个元素的内存地址在空间存储上是连续的。
*               第二：每一个元素类型相同，所以占用空间大小一样。
*               第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式
*               就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的。
*
*               数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，因为数组中元素查找的时候不会
*               一个一个找，是通过数学表达式计算出来的。
*       缺点：
*           第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低。
*               因为随机增删元素会设计到后面元素统一向前或向后位移的操作。
*           第二：数组不能存储大数据量，为什么？
*               因为很难在内存上找到一块特别大的连续的内存空间。
*
*       注意：对于数组中最后一个元素的增删，是没有效率影响的。
*
*   14 怎么声明/定义一个一维数组？
*       语法格式：
*           int[] array1;
*           double[] array2;
*           boolean[] array4;
*           String[] array5;
*           Object[] array6;
*
*   15 怎么初始化一个一维数组呢？
*       包括两种方式:静态初始化一维数组，动态初始化一维数组。
*       静态初始化语法格式：
*           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]);
        System.out.println("最后一个元素" + a[a.length - 1]);
        
        // 一维数组怎么遍历呢？
        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: Index 6 out of bounds for length 6
        
        // 从最后一个元素遍历到第1个元素
        for (int i = a.length - 1;i >= 0 ;i--){
            System.out.println("颠倒顺序输出" + a[i]);
        }
    }
}

后期对数组赋值案例：

package com.javase.array;
/*
关于每个类型的默认值还有印象吗？
    数据类型            默认值
    ------------------------
    byte                0
    short               0
    int                 0
    long                0L
    float               0.0F
    double              0.0
    boolean             false
    char                u0000
    引用数据类型          null
    
    什么时候采用静态初始化方式？什么时候采用静态初始化方式呢？
        当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态数组的方式。
        当你创建数组的时候，不确定将来数组中存储哪些数据，你可采用动态初始化的方式，预先分配内存空间。
*/
public class ArrayTest02 {
    public static void main(String[] args) {
        // 声明/定义一个数组，采用动态初始化的方式创建
        int[] b = new int[4];
        // 遍历数组
        for(int i = 0; i < b.length; i++){
            System.out.println(b[i]);
        }
        
        // 后期赋值
        b[0] = 111;
        b[1] = 222;
        b[2] = 333;
        b[3] = 444;// 注意下标别越界。
    
        // 遍历数组
        for(int i = 0; i < b.length; i++){
            System.out.println(b[i]);
        }
        
        // 声明/定义一个数组，采用动态初始化的方式创建。
        int[] a = new int[4];// 创建长度为4的int数组，数组中每个元素的默认值是0
        // 遍历数组
        for (int i = 0; i < a.length ; i++){
            System.out.println("数组中的下标为" + i + "的元素为：" + a[i]);
        }
        // 初始化一个Object类型的数组，采用动态初始化方式
        Object[] objects = new Object[3]; // 3个长度，动态初始化，所以每个元素默认值是null
        for (int i = 0; i < objects.length; i++){
            System.out.println(objects[i]);
        }
        
        // 采用静态初始化的方式
        String[] strings = {"abc","def","xyz"};
        for (int i = 0; i < strings.length; i++){
            System.out.println(strings[i]);
        }
        
        // 存储Object，采用静态初始化呢？
        /*Object o1 = new Object();
        Object o2 = new Object();
        Object o3 = new Object();
        Object[] objects1 = {o1,o2,o3};*/
        Object[] objects1 = {new Object(),new Object(),new Object()};
        for (int i = 0; i < objects1.length; i++){
            System.out.println(objects1[i]);
        }
    }
}

当一个方法的参数是数组的时候，我们该如何传参

package com.javase.array;
/*
当一个方法数组的时候，我们该如何传参。
*/
public class ArrayTest03 {
    public static void main(String[] args) {
        
        // 调用方法时传一个数组
        int[] i = {1,2,3,4,5};
        printArray(i);
        
        String[] s = {"abc","cde","xyz"};
        printArray(s);
        
        String[] strArray = new String[10];
        printArray(strArray);
    }
    
    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]);
        }
    }
}

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

 

package com.javase.array;
// 当一个方法的参数是一个数组的时候，我们还可以采用这种方式传。
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,8,9,4,56,4});
        
        System.out.println("----------------------------");
        
        // 动态初始化一维数组
        int[] a1 = new int[5];
        printArray(a1);
    
        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]);
        }
    }
}

 

模拟一个系统，假设这个系统要使用，必须输入用户名和密码。案例：

 

package com.javase.array;
/*
模拟一个系统，假设这个系统要使用，必须输入用户名和密码。
*/
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("验证失败，用户名不存在或者密码错误！");
        }
    }
}

一维数组的深入，数组中存储的类型为：引用数据类型案例：

 

package com.javase.array;
/*
一维数组的深入，数组中存储的类型为：引用数据类型。
对于数组来说，实际上只能存储java对象的"内存地址"。数组中存储的每个元素是"引用"。
*/
public class ArrayTest07 {
    public static void main(String[] args) {
        
        // a是一个数组
        // a[0] 是数组中的一个元素
        // a[1] 是数组中的一个元素
        int[] a = {1,2,3};
        
        int[] ints = {1,2,3};
        for (int i = 0; i < ints.length; i++){
            /*int temp = ints[i];
            System.out.println(temp);*/
            // 这个move()方法不是数组，是数组当中的Anima对象的move(()方法
            // ints[i]这个ints是数组，但是后面[i]是数组中的元素，他的元素不就是Anima这个对象吗，所以他可以调用move()方法。
            System.out.println(ints[i]);
        }
        
        // 创建一个Animal数组
        Anima a1 = new Anima();
        Anima a2 = new Anima();
        Anima[] animas = {a1,a2};
        
        // 对Anima进行遍历
        for(int i = 0; i < animas.length; i++){
            /*Anima a= animas[i];
            a.move();*/
            
            // 代码合并
            animas[i].move();
        }
        
        // 动态初始化一个长度为2的Animal类型数组。
        Anima[] animas1 = new Anima[2];
        
        // 创建一个Animal对象，放到数组的第一个盒子中
        Anima anima = new Anima();
        animas1[0] = anima;
        
        // Animal数组只能存放Animal类型的对象，不能存放Product对象
        /*Pruduct pruduct = new Pruduct();
        animas1[1] = pruduct;*/
        
        // Animal数组中可以存放Cat类型的数据，因为Cat是一个Animal。
        // Cat是Animal的子类。
        animas1[1] = new Cat();
        
        // 创建一个Animal数组，数组当中存放Cat和Bird
        Anima[] animas2 = {new Cat(),new Bird()};
        for (int i = 0;i < animas2.length; i++){
            /*Anima anima1 = animas2[i];
            anima1.move();*/
            
            // 调用子对象特有方法的时候，需要向下转型。
            if(animas2[i] instanceof Cat){
                Cat cat = (Cat)animas2[i];
                cat.move();
                cat.catchMouse();
            }
            
            if(animas2[i] instanceof Bird){
                Bird bird = (Bird)animas2[i];
                bird.move();
                bird.sing();
            }
        }
        
        
        
    }
}


class Anima{
    public void move(){
        System.out.println("Anima move...");
    }
    
    public void catchMouse(){
        System.out.println("猫在捉老鼠");
    }
}


// 商品类
class Pruduct{


}


class Cat extends Anima{
    public void move(){
        System.out.println("猫在走猫步...");
    }
}


// Bird子类
class Bird extends Anima{
    public void move(){
        System.out.println("Bird Fly!!!");
    }
    
    public void sing(){
        System.out.println("鸟儿在歌唱！！");
    }
}

关于一维数组的扩容案例：

 

package com.javase.array;
/*
关于一维数组的扩容。
在java开发中，数组长度一档确定不可改变，那么数组满了怎么办？
    数组满了，需要扩容。
    java中对数组的扩容是：
        先新建一个大容量的数组，然后将小容量数组中的元素一个一个拷贝到大数组当中。


    结论：数组扩容效率较低，因为涉及到拷贝的问题，所以再以后的开发中请注意：尽量少的进行数组拷贝。
    可以在创建数组对象的预估计一下多长合适。最好预估准确，这样可以减少数组的扩容次数，提高效率。
*/
public class ArrayTest08 {
    public static void main(String[] args) {
        // java中的数组是怎么进行拷贝的呢？
        // System.arraycopy(5个参数);
        
        // 拷贝源（从这个数组中拷贝）
        int[] src = {1,2,3,4,5};
        
        // 拷贝目标（拷贝到这个目标上）
        int[] dest = new int[20];//动态初始化一个长度为20的数组，每一个元素默认值0
        
        // 调用JDK System类中的arraycope方法，来完成数组的拷贝
        // System.arraycopy(src,1,dest,3,2);
        
        // 遍历目标数组
       /* for (int i = 0; i < dest.length ; i++){
            System.out.println(dest[i]);
        }*/
       
       System.arraycopy(src,0,dest,0,src.length);
    
        for (int i = 0; i < dest.length ; i++){
            System.out.println(dest[i]);
        }
        
        System.out.println("------------------------------------------------------");
        
        // 数组中如果存储的元素是引用，可以拷贝吗？当然可以。
        String[] strs = {"hello","world","study","java","oracle","mysql","jdbc"};
        String[] newStrs = new String[20];
        System.arraycopy(strs,0,newStrs,0,strs.length);
        
        for (int a = 0; a < newStrs.length; a++){
            System.out.println(newStrs[a]);
        }
    
        System.out.println("------------------------------------------------------");
        
        Object[] objects = {new Object(),new Object(),new Object()};
        Object[] newObj = new Object[20];
        //  思考一下：这里拷贝的时候是拷贝对象，还是拷贝对象的地址。（地址。）
        System.arraycopy(objects,0,newObj,0,objects.length);
        for(int i = 0;i < newObj.length; i++){
            System.out.println(newObj[i]);
        }
    }
}