【笔记】尚学堂2021--数组

最新推荐文章于 2024-07-15 22:27:18 发布

萌萌萌ya

最新推荐文章于 2024-07-15 22:27:18 发布

阅读量85

点赞数

分类专栏： java 文章标签： java

原文链接：https://blog.csdn.net/qq_21579045/article/details/103306564

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. 数组概述和特点

数组的定义

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。数组的三个基本特点：
1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型，不允许出现混合类型。
3. 数组类型可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
数组声明
- 数组的声明方式有两种(以一维数组为例)
```
type[]   arr_name; //（推荐使用这种方式）
type    arr_name[];
```
- 注意事项
  1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
  2. 声明一个数组的时候并没有数组真正被创建。
  3. 构造一个数组，必须指定长度。
初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。下面针对这三种方式分别讲解。

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;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；
```
3.数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
```
int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null
```

2. 数组的遍历

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。使用循环遍历初始化和读取数组。

public class Test {
    public static void main(String[] args) {
        int[] a = new int[4];
        //初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i] = 100*i;
        }
        //读取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

for-each循环：增强for循环for-each是JDK1.5新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历。

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

注意事项
1. for-each增强for循环在遍历数组过程中不能修改数组中某元素的值。
2. for-each仅适用于遍历，不涉及有关索引(下标)的操作。

3. 数组的拷贝

System类里也包含了一个static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

public class testCopy {
    public static void main(String[] args) {
        String[] s1 = {"aa", "bb", "cc", "dd", "ee"};
        String[] s2 = new String[10];
        System.arraycopy(s1, 2, s2, 6, 3);

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

        System.out.println("########");
        removeElement(s1, 2);
        System.out.println("########");
        extendRange(s1);
    }

    // 删除数组中指定索引位置的元素，并将原数组返回
    private static String[] removeElement(String[] s, int index){
        System.arraycopy(s, index+1, s, index, s.length-index-1);
        s[s.length-1] = null;

        for (String m:
             s) {
            System.out.println(m);
        }
        return s;
    }

    // 数组的扩容（本质上时：先定义一个更大的数组，然后将原数组内容原封不动拷贝到新数组中）
    private static String[] extendRange(String[] s){
        String[] s2 = new String[s.length + 10];
        System.arraycopy(s, 0, s2, 0, s.length);

        for(String x: s2){
            System.out.println(x);
        }
        return s2;
    }
}

4. java.util.Arrays类

JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。

import java.util.Arrays;

public class TestArrays {
    public static void main(String[] args) {
        int[] a = {100, 20, 30, 5, 150, 80, 200};
        System.out.println(a);
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        // 二分法查找
        System.out.println(Arrays.binarySearch(a, 30));

        // 数组填充，前闭后开
        Arrays.fill(a, 2, 4, 800);
        System.out.println(Arrays.toString(a));
    }
}

5. 多维数组

多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实际开发中用的非常少。最多到二维数组(学习容器后，我们一般使用容器，二维数组用的都很少)。

二维数组的声明

public class Test {
    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];//非法
    }
}

二维数组的静态初始化

public class Test {
    public static void main(String[] args) {
        int[][] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
        System.out.println(a[2][3]);
    }
}

二维数组的动态初始化

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[][] a = new int[3][];
        // a[0] = {1,2,5}; //错误，没有声明类型就初始化
        a[0] = new int[] { 1, 2 };
        a[1] = new int[] { 2, 2 };
        a[2] = new int[] { 2, 2, 3, 4 };
        System.out.println(a[2][3]);
        System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
        System.out.println(Arrays.toString(a[2]));
    }
}

获取数组长度

//获取的二维数组第一维数组的长度。
System.out.println(a.length);
//获取第二维第一个数组长度。
System.out.println(a[0].length);

数组存储表格数据

package com.bjsxt.array;
import java.util.Arrays;
public class Test05 {
    public static void main(String[] args){
        Emp emp0=new Emp(1001,"gxq1",18,"程序员","2019-10-9");
        Emp emp1=new Emp(1002,"gxq2",19,"程序员","2019-10-9");
        Emp emp2=new Emp(1003,"gxq3",17,"程序员","2019-10-9");
        Emp emp3=new Emp(1004,"gxq4",16,"程序员","2019-10-9");

        //Emp[] emps={emp0,emp1,emp2,emp3};
        Emp[] emps=new Emp[4];
        emps[0]=emp0;
        emps[1]=emp1;
        emps[2]=emp2;
        emps[3]=emp3;


        //遍历数据
        for(int i=0;i<emps.length;i++){
            System.out.println(emps[i].getId()+"\t"+emps[i].getName());
        }


    }
}
class  Emp{
    private int id;
    private String name;
    private int age;
    private String job;
    private String hiredate;

    public Emp(){}
    public Emp(int id,String name,int age,String job,String hiredate){
        this.id=id;
        this.age=age;
        this.name=name;
        this.hiredate=hiredate;
        this.job=job;
    }

    @Override
    public String toString(){
        return id+"\t"+name+"\t"+age+"\t"+job+"\t"+hiredate;
    }


   public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;                   //ctrl+fn+insert
    }

}

数据存储表格数据（2）

package com.bjsxt.array;
import java.util.Arrays;

public class Test04 {

        public static void main(String[] args) {
            Object[] a1 = {1001,"高淇",18,"讲师","2006-2-14"};
            Object[] a2 = {1002,"高小七",19,"助教","2007-10-10"};
            Object[] a3 = {1003,"高小琴",20,"班主任","2008-5-5"};
            Object[][]  emps = new Object[3][];
            emps[0] = a1;
            emps[1] = a2;
            emps[2] = a3;
            System.out.println(Arrays.toString(emps[0]));
            System.out.println(Arrays.toString(emps[1]));
            System.out.println(Arrays.toString(emps[2]));

            //使用二维数组的内容（表格数据打印）[方法二]
            for(int i=0;i<emps.length;i++){
                System.out.println(Arrays.toString(emps[i]));
            }
            //使用嵌套循环打印二维数组（打印表格数据）【方法三】
            for(int i=0;i<emps.length;i++){

                for (int j =0;j<emps[i].length;j++){
                    System.out.println(emps[i][j]+"\t");
                }
                System.out.println();
            }
        }
    }

注意事项：此处基本数据类型”1001”，本质不是Object对象。JAVA编译器会自动把基本数据类型“自动装箱”成包装类对象。大家在下一章学了包装类后就懂了。

萌萌萌ya

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【笔记】尚学堂2021--数组

1. 数组概述和特点数组的定义数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。数组的三个基本特点：长度是确定的。数组一旦被创建，它的大小就是不可以改变的。其元素必须是相同类型，不允许出现混合类型。数组类型可以是任何数据类型，包括基本类型和引用类型。数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当
复制链接

扫一扫