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] + " ");
        }
    }
}

动态初始化 数组

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 + " ");
        }
    }
}

0 0 0 0 
[Ljava.lang.Object;@1540e19d [Ljava.lang.Object;@1540e19d [Ljava.lang.Object;@1540e19d 

关于args的作用

修改这里

然后运行

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

    }
}

结果为

abc
kk
xyf

/*
模拟一个系统，假定这个系统要使用，必须 输入用户名 和 密码。
 */
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维 数组的扩容：
    先新建一个大容量的数组，再把小容量的数组内的数拷贝到 大容量的数组中。
 */

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 + " ");
        }
    }
}

0 0 0 11 22 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

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 11 22 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

数组模拟栈

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{
}

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--];
    }

}

测试

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

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 + " ");
        }
    }
}