• java入门 数组

    数组

    存储数据的容器

    1. java 语言中的数组 是 引用数据类型，不属于基本数据类型。属于object。
    2. 数组实际上 是一个容器，可以容纳多个元素。（数据的集合）
    3. 数组中 可以存储 基本类型数据 也可以 存储 引用类型数据。
    4. 数组是 引用类型， 所以数组对象 在堆heap 中保存。
    5. 数组中 如果存储的是java对象， 实际上 是 对象的 引用地址。
    6. 一旦创建，长度不可变。
    7. 数组中 存储 元素 类型 统一。
    8. 数组中，元素的内存地址是连续的。
    9. 所有数组的内存地址，都是第一个元素的内存地址。
    10. 数組中每一个元素都是有下标的，下标从0开始，以1递增。晨后一个元素的下标是：length- 1.

    在这里插入图片描述

    在这里插入图片描述

    存放方式

    在这里插入图片描述

    数组分类

    一维数组、二維数组、三维数組、多维数组

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

    java中的数组要求数组中元素的类型统一。
    比如int类型数组只能存储int类型，Person类型数组只能存储person类型。

    数组优点

    在这里插入图片描述

    数组缺点

    在这里插入图片描述

    创建数组

    在这里插入图片描述
    静态初始化 数组

    
/*
1. java 语言中的数组 是 引用数据类型，不属于基本数据类型。属于object。
2. 数组实际上 是一个容器，可以容纳多个元素。（数据的集合）
3. 数组中 可以存储 基本类型数据 也可以 存储 引用类型数据。
4. 数组是 引用类型， 所以数组对象 在堆heap 中保存。
5. 数组中 如果存储的是java对象， 实际上 是 对象的 引用地址。
6. 一旦创建，长度不可变。

 */
public class Test {
    public static void main(String[] args) {
        int[] a1 = {1,100,10,20,55,689};
        System.out.println(a1.length);
        System.out.println("第一个元素:" + a1[0]);
        System.out.println("最后一个元素:" + a1[a1.length-1]);
        //改第一个元素
        a1[0] = 111;

        // 遍历
        for (int i = 0; i < a1.length; i++){
            System.out.print(a1[i] + " ");
        }
        System.out.println();
        for (int i = a1.length - 1; i >= 0; i--){
            System.out.print(a1[i] + " ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    动态初始化 数组

    public class Test {
    public static void main(String[] args) {
        int[] a = new int[4]; //动态初始化： 没有指定赋值

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

        Object[] ojbs = new Object[3];
        for (int i = 0; i < ojbs.length; i++){
            System.out.print(ojbs + " ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    0 0 0 0 
[Ljava.lang.Object;@1540e19d [Ljava.lang.Object;@1540e19d [Ljava.lang.Object;@1540e19d 

    • 1
    • 2

    在这里插入图片描述

    关于args的作用

    在这里插入图片描述

    在这里插入图片描述
    修改这里

    然后运行

    
public class Test {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++){
            System.out.println(args[i]);
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    结果为

    abc
kk
xyf

    • 1
    • 2
    • 3
    

/*
模拟一个系统，假定这个系统要使用，必须 输入用户名 和 密码。
 */
public class Test {
    public static void main(String[] args) {

        if (args.length != 2){
            System.out.println("使用该系统时请输入程序参数，参数中包括用户名和密码信息，例如：zhangsan 123");
            return;
        }

        String username = args[0];

        String password = args[1];
// 采用以下编码风格，及时sername 利password部是nuLL，也不会出现空指针异常。
        //if (username.equals("admin") && password.equals("123")){
       if ("admin".equals(username) && "123".equals(password)){
            System.out.println("success！");
        } else {
            System.out.println("fail");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    数组拷贝

    在这里插入图片描述

    /*
关于1维 数组的扩容：
    先新建一个大容量的数组，再把小容量的数组内的数拷贝到 大容量的数组中。
 */

public class Test {
    public static void main(String[] args) {
    // java中的数组 如何拷贝呢
//        System.arraycopy(5个参数);
        // 拷贝源
        int[] src = {1,11,22,3,4};
        // 拷贝目标
        int[] dest = new int[20];

        System.arraycopy(src,1,dest,3,2);

        //遍历目标数组
        for (int i: dest){
            System.out.print(i + " ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    0 0 0 11 22 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

    • 1
    public class Test {
    public static void main(String[] args) {
    // java中的数组 如何拷贝呢
//        System.arraycopy(5个参数);
        // 拷贝源
        int[] src = {1,11,22,3,4};
        // 拷贝目标
        int[] dest = new int[20];

//        System.arraycopy(src,1,dest,3,2);
        System.arraycopy(src,0,dest,0,src.length);
        //遍历目标数组
        for (int i: dest){
            System.out.print(i + " ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    1 11 22 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

    • 1

    数组模拟栈

    在这里插入图片描述

    tips:
    Object[] 是一个王能口袋，这个口袋可以 装 任何引用数据类型

    import javax.management.OperationsException;

public class Test {
    public static void main(String[] args) {
        // Object[] 是一个王能口袋，这个口袋可以 装 任何引用数据类型
        Object[] arr = {new Husband(), new Wife(), "abc"};
    }
}


class Husband{
}

class Wife{
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    public class Mystack {

    // 选用Object类型数组，因为这个栈可以存储java中的任何引用类型的数据
    // 栈的默认初始化容量为10.
    private Object[] elements;
//    private Object[] elements = new Object[10]; 这种也可以

    // 栈帧 永远指向 栈最顶部
    private int index = -1; // 栈帧指向顶部元素

    public Mystack(){
        this.elements = new Object[10];
    }

    // 属性private私有化 一定要 写上get 和 set方法
    public Object[] getElements() {
        return elements;
    }

    public void setElements(Object[] elements) {
        this.elements = elements;
    }

    // 压栈方法
    public void push(Object obj){
        if(this.index >= this.elements.length - 1){
            System.out.println("The stack is already full!");
            return;
        }
        this.index++;
        this.elements[index] = obj;
        System.out.println("push successful: " + obj + " | the pointer points " + index);
    }

    // 弹栈
    // 从数组中 往外取元素
//    public Object pop(){
    public void pop(){
        if(index < 0){
            System.out.println("The stack is already empty!");
            return;
//            return null;
        }
        System.out.println("pop stack successful : " + elements[index--]);
//        return this.elements[index--];
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    测试

    import javax.management.OperationsException;

public class Test {
    public static void main(String[] args) {
        Mystack mystack = new Mystack();
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());
        mystack.push(new Object());

        // stack pop
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
        mystack.pop();
    }
}




    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    array数组工具类：自动排序

    import java.util.Arrays;

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

        int[] arr = {112, 3, 4, 56, 67, 1};

        Arrays.sort(arr);

        for (int i : arr){
            System.out.print(i + " ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
  • 相关阅读:
    真良心干货保姆级手把手教你Python网络编程，学不会我去你家教你
    Elasticserch教程(35) ik中文分词器+pinyin拼音分词器+同义词
    常用的几种异步实现方式
    解决Build failed:Could not resolve com.android.tools.build:gradle:7.4.0-alpha10.
    为什么有35岁「职业危机」的程序员不转做测试呢？
    用moment插件分别取时间戳的年、月、日、时、分、秒
    Aspect Android埋点统计activity页面使用时长 onResume onPause，并保存时长
    管控软件开发进度 4大关键项需要重视
    前端登录加密解密方法
    女生学java开发难吗？女生适合学java吗？
  • 原文地址：https://blog.csdn.net/weixin_46969441/article/details/125401976