数组和数据存储

已于 2023-06-04 15:35:12 修改
阅读量81 收藏
点赞数
文章标签： jvm java 算法
于 2023-05-27 10:58:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70416180/article/details/130897156
版权

目录

数组的定义

创建数组和初始化

数组的声明方式

数组的初始化

 数组常见操作

  数组的遍历

数组的拷贝

 java.util.Arrays类

 多维数组

二维数组的声明

二维数组的静态初始化

二维数组的动态初始化 

Comparable接口

数组的定义

数组是相同类型数据的有序集合，其中，每一个数据称为一个元素，每个元素可以通过一个索引（下标）来访问它们，数组的四个基本特点：

1.长度是确定的。数组一旦创建，它的大小是不允许被改变的。

2.其元素的类型必须是相同类型，不允许出现混合类型。

3.数组类型可以是任意数据类型，包括基本数据类型和引用类型。

4.数组变量属于引用类型，数组也是对象，数组中的元素相当于对象中的属性。

创建数组和初始化

数组的声明方式

type[ ]  arr_name;  //方式一

type  arr_name[ ];  //方式二

注意事项：

        1.声明时候并没有实例化对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。

        2.声明一个数组时候并没有数组真正被创建。

        3.构造一个数组，必须指定长度。

【创建一个基本类型的一维数组】

public class Test{
    public static void main(String args[]){
        int[] s;  //声明数组；
        s=new int[10];  //给数组分配空间
        for(int i=0;i<10;i++){
        s[i]=2*i+1;         //给数组元素赋值；数组是对象，数组中的元素就是对象的属性
        System.out.println(s[i]);
        }
    }
}

【创建引用类型的一维数组】

class Man{
    private int age;
    private int id;
    public Man(int id,int age){
        super();
        this.age=age;
        this.id=id;
        
    }
}
public class AppMan{
    public static void main(String[] args){
        Man[] mans;   //声明引用数据类型
        mans = new Man[10];  //给引用类型数组分配空间

        Man m1=new Man(1,11); //使用构造方法创建一个 id为1，age为11的m1对象
        Man m2=new Man(2,22);
        mans[0]=m1; //给引用类型数组元素赋值
        mans[1]=m2;

    }
}

数组的初始化

数组的初始化总共有三种：静态初始化、动态初始化、默认初始化。

1.静态初始化

        除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[ ] a={1,2,3};   //静态初始化基本数据类型数组

Man[ ] mans={new Man(1,1),new Man(2,2)};  //静态初始化引用类型数组

2.动态初始化

        数组定义与数组元素分配空间并赋值的操作分开进行。

int[ ] a1=new int[2];  //动态初始化数组，先分配空间

a1[0]=1;    //给数组元素赋值；

a2[1]=2;

3.数组的默认初始化

        数组是对象，它的元素相当于对象的属性；每个元素也按照属性的方式被默认初始化。 

int a[ ] =new int[2];           //默认值是0

boolean[ ] b=new boolean[2];        //默认值是false，false

String[ ] s=new String[2];           //默认值是null，null

 数组常见操作

  数组的遍历

        数组元素的下标的合法区间为[0,length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素或者修改元素的值

 for-each循环

        for-each循环专门用于读取数组或容器内的所有元素。

public class Test{
    public static void main(String[] args){
        String[] ss={"aa","bb","cc","dd"};
        for(String temp:ss){
            System.out.println(temp);
        }
    }
}

执行结果为：   aa

                         bb

                         cc

                         dd

注意事项：

1.for-each增强for循环在遍历数组过程中不能修改数组中某元素的值。

2.for-each仅适用与遍历，不涉及有关索引（下标）的操作。

数组的拷贝

System.arraycopy(object src,int srcops,object dest,int destpos,int length)

        该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组多少个元素赋给dest数组的元素。

 java.util.Arrays类

Arrays类包含了：排序、查找、填充、打印内容等常见的数组操作。

        打印操作 Arrays.toString()方法

import java.util.Arrays;
public class Test{
    public static void main(String args[]){
        int[] a={1,2};
        System.out.println(a);  //打印引用的值
        System.out.println(Arrays.toString(a));   //打印数组元素的值
    }
}

执行结果：

[I@15db9742

[1,2]

        此处的Arrays.toString()方法是Arrays类的静态方法，不是见面讲的Object的toString（）方法。

         排序操作 Arrays.sort( )方法

        二分法查找法 Arrays.binarySearch( )

        填充 Arrays.fill( )方法

import java.util.Arrays;
public class Test05 {

    public static void main(String[] args) {
        int[ ] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);    //使用二分法查找必须要先对数组进行排序（从小到大排序）

        System.out.println(Arrays.toString(a));
        //返回排序后新的索引位置,若未找到返回负数。
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 120));

        int [] b = {10,20,30,40,50};
        Arrays.fill(b,2,4,100);  //将2到4索引（第三个元素和第四个元素）的元素替换为100
        System.out.println(Arrays.toString(b));


    }

}

 多维数组

         多维数组可以看成以数组为元素的数组。

二维数组的声明

import java.util.Arrays;

//测试多维数组的初始化
public class Test06 {

    public static void main(String[] args) {
        // Java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[ ][ ] a = new int[3][ ];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        // int a1[ ][ ]=new int[ ][4];//非法
    }

}

二维数组的静态初始化

import java.util.Arrays;

//测试多维数组的初始化
public class Test06 {

    public static void main(String[] args) {
        // Java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[ ][ ] a = new int[3][ ];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        // int a1[ ][ ]=new int[ ][4];//非法
        a[0][0] = 100;
        a[0][1] = 200;

        int[ ][ ] b = {
                        { 1, 2, 3 },
                        { 3, 4 },
                        { 3, 5, 6, 7 }
        };

        System.out.println(b[2][3]);
    }

}

二维数组的动态初始化 

import java.util.Arrays;

//测试多维数组的初始化
public class Test06 {

    public static void main(String[] args) {
        // Java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[ ][ ] a = new int[3][ ];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        // int a1[ ][ ]=new int[ ][4];//非法
        a[0][0] = 100;
        a[0][1] = 200;

        int[ ][ ] b = {
                        { 1, 2, 3 },
                        { 3, 4 },
                        { 3, 5, 6, 7 }
        };

        System.out.println(b[2][3]);

        int[ ][ ] c = new int[3][ ];
        // c[0] = {1,2,5}; //错误，没有声明类型就初始化
        c[0] = new int[ ] { 1, 2 };
        c[1] = new int[ ] { 2, 2 };
        c[2] = new int[ ] { 2, 2, 3, 4 };
        System.out.println(c[2][3]);
        System.out.println(Arrays.toString(c[0]));
        System.out.println(Arrays.toString(c[1]));
        System.out.println(Arrays.toString(c[2]));


    }

}

Comparable接口

Comparable接口只有一个方法：

        public int compareTo(object obj)  //obj为要比较的对象

方法中，当前对象和obj这个对象进行比较，如果大于返回1，等于返回0，小于返回-1

import java.util.Arrays;

//测试Comparable接口
public class Test09 {

    public static void main(String[] args) {

        Man2[ ] msMans = {
                new Man2(3, "a"),
                new Man2(60, "b"),
                new Man2(2, "c") };

        System.out.println(Arrays.toString(msMans));
        Arrays.sort(msMans);  
//调用sort方法对数组元素是对象的数组排序，它所在的类型（Man）必须实现Comparable接口，上面对int类型元素排序不需要实现Comparable接口
        System.out.println(Arrays.toString(msMans));
    }

}

class Man2 implements Comparable {
    int age;
    int id;
    String name;

    public Man2(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public String toString() {
        return this.name;
    }

    public int compareTo(Object o) {
        Man2 man2 = (Man2) o;
        if (this.age < man2.age) {
            return -1;
        }
        if (this.age > man2.age) {
            return 1;
        }
        return 0;
    }
}

lz不理智
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值