Java语言描述——理解Java中构造方法的内涵实现线性表的存储结构及相关操作

Java语言描述——理解Java中构造方法的内涵实现线性表的存储结构及相关操作

一.知晓构造方法的定义及使用来理解构造函数的内涵：

定义：构造方法的(也被称为构造器)，是类的一个特殊成员，在类的实例化的时候会被自动调用。
定义格式：

[修饰符] 方法名([参数表列]){
方法体;
}

需满足条件：

1.方法名与类名相同
2.在方法名前面无返回值类型
3.在构造方法内不能使用return语句返回值，可以直接return;作为方法结束
4.可重写构造方法，但参数表列必须不同
5.当一个类中无构造方法时，系统会调用类中默认的一个无参构造方法，当创建了其他构造方法时，该无参构造方法不复存在
在创建引用构建实例化对象时，可以理解为是对构造方法创建引用进行实例化的

创建对象：(new完后自动分配存储空间，默认拥有构造方法内的所有内容)

类名 对象名 = new 类名([参数表列]);

构造方法的内涵：

1.构造方法是用来初始化的，在里面设置了什么，构建的引用对象就会拥有什么，

2.即对new出的构造方法对象会拥有其对应的构造方法内的所有内容。

3.同时，对构造方法new出的对象，可以引用该类中的所有成员方法及成员变量。
格式为：对象名.成员变量及成员方法

4.当创建引用对象时，若没有new操作，即只有类名 对象名;，此时对象不进行分配存储空间，不指向任何内容。只是一个单纯的类类型变量。

5.构造方法尽量使用public修饰符，不能通过私有构造方法来创建对象。

二.利用构造方法的特殊性实现顺序表的基本功能：

1.顺序存储结构的基本实现原理：

• 定义：线性表的顺序存储结构是把线性表中的所有元素按照其逻辑顺序依次存储到从计算机存储器中指定存储位置开始的一块连续的存储空间中。线性表的顺序存储结构称为顺序表

• 原理：连续的存储空间，当查找元素时是可以通过索引实现的。其实顺序表的原理与ArrayList集合中的实现原理相同，因为ArrayList集合内部就是一个线性表结构，我们可以查看ArrayList集合中的源码，会发现在其构造函数内，创建了一个包装类数组，从而达到快速的查找效果。当我们自己敲代码实现线性表时，实现方法同样也是在构造方法中创建一个包装类数组实现基本功能；当然也可以使用继承ArrayList集合去实现，但是此次我们自己建立方法实现其功能。

(因为ArrayList集合的存储结构为顺序表，所以下面我们统称我们自己创建的顺序表为集合) 1.首先建立一个类，在类中定义包装类数组：
代码为：

public class Set {
 final int maxsize = 100;
    int size;
    Integer[] data;
    public Set(){
        data =  new Integer[maxsize];
        size = 0;
    }
 }

建立一个set集合，在构造方法外定义一个包装类数组及识别数组大小的size变量，设置数组容量maxsize，这里我们没有实现数组容量的自动扩充，读者可自行修改代码进行实现，了解原理之后，这个修改应该是不难的。
注意：为何需要使用包装类数组：在Java中，很多类的方法都需要接收引用类型的对象(类类型)，此时无法将一个基本数据类型传入，所以需要使用包装类。这里不对包装类进行详解

2.在实现增删查之前我们应首先知道此时的集合中的size大小：

public int getSize() {
        return size;
    }

3.同时需要往该顺序表内添加、删除、查找元素：

//    向集合中添加元素e，若集合中已存在元素e，则不添加，若集合中不存在则添加
    public boolean add(Integer e){
        if(IsIn(e))
            return false;
        else{
            data[size] = e;
            size++;
            return true;
        }
    }

//    删除集合中某个元素e
    public boolean delete(Integer e){
        int i=0;
        while(i<size&&data[i]!=e)
            i++;
        if(i>=size)
            return false;
        for(int j=i+1;j<size;j++)
            data[j-1] = data[j];
        size--;
        return false;
    }

//查找其中的一个元素
 public Integer get(int i){
        return data[i];
    }

//    遍历集合中的元素
    public void display(){
        for(int i=0;i<size;i++){
            if(i==0)
                System.out.print(data[i]);
            else
                System.out.print(" "+data[i]);
        }
        System.out.println();
    }

4.当我们添加元素时，因为集合中不能包含相同元素，所以我们应再设置一个方法实现对元素添加的辨别重复元素的过程：

//    向集合中添加元素e，若集合中已存在元素e，则不添加，若集合中不存在则添加
    public boolean add(Integer e){
        if(IsIn(e))
            return false;
        else{
            data[size] = e;
            size++;
            return true;
        }
    }

此时就已经实现了其基本功能模块，当对集合进行操作时，每一个new出的对象，都默认拥有一个包装类数组及一个对应的size(即构造方法内的全部内容)；不同的对象添加不同的元素及不同元素个数所的得到的包装类数组内容及长度各不相同，其size也不同。
5.实现对集合的交，并，差等操作，完整代码为：

package com.other;
//因为单列集合是数组对象实现的，但这个数组的容量可扩充而且其数据可为任意数据类型，必须是包装类，这是与数组定义不同的地方
public class Set {
    final int maxsize = 100;
    int size;
    Integer[] data;
    public Set(){
        data =  new Integer[maxsize];
        size = 0;
    }

    public int getSize() {
        return size;
    }

    public Integer get(int i){
        return data[i];
    }
//    判断集合中的元素是否等于e，集合中的不能包含重复元素
    public boolean IsIn(Integer e){
        for(int i=0;i<size;i++){
            if(data[i]==e){
                return true;
            }
        }
        return false;
    }
//    向集合中添加元素e，若集合中已存在元素e，则不添加，若集合中不存在则添加
    public boolean add(Integer e){
        if(IsIn(e))
            return false;
        else{
            data[size] = e;
            size++;
            return true;
        }
    }
//    删除集合中某个元素e
    public boolean delete(Integer e){
        int i=0;
        while(i<size&&data[i]!=e)
            i++;
        if(i>=size)
            return false;
        for(int j=i+1;j<size;j++)
            data[j-1] = data[j];
        size--;
        return false;
    }
//    遍历集合中的元素
    public void display(){
        for(int i=0;i<size;i++){
            if(i==0)
                System.out.print(data[i]);
            else
                System.out.print(" "+data[i]);
        }
        System.out.println();
    }
//求两个集合的并集,返回一个Set集合
    public Set Union(Set s1,Set s2){
        Set s3 = new Set();
        for(int i=0;i< s1.getSize();i++){
            s3.add(s1.get(i));
        }
        for(int i=0;i< s2.getSize();i++){
            if(!s1.IsIn(s2.get(i)))
                s3.add(s2.get(i));
        }
        return s3;
    }
//    求两个集合的交集
    public Set Intersection(Set s1,Set s2){
        Set s3 = new Set();
        for(int i=0;i<s1.getSize();i++){
            if(s2.IsIn(s1.get(i)))
                s3.add(s1.get(i));
        }
        return s3;
    }
//    求两个集合的差集
    public Set Difference(Set s1,Set s2){
        Set s3 = new Set();
        for(int i=0;i< s1.getSize();i++){
            if(!s2.IsIn(s1.get(i))){
                s3.add(s1.get(i));
            }
        }
        return s3;
    }
    public static void main(String[] args) {
        Set s1 = new Set();
        s1.add(1);
        s1.add(4);
        s1.add(2);
        s1.add(6);
        s1.add(8);
        System.out.println("集合s1为：");
        s1.display();
        Set s2 = new Set();
        s2.add(2);
        s2.add(5);
        s2.add(3);
        s2.add(6);
        System.out.println("集合s2为：");
        s2.display();
        Set s3= new Set();
        s3 = s3.Union(s1,s2);
        System.out.println("s1与s2的并集为：");
        s3.display();
        s3 = s3.Difference(s1,s2);
        System.out.println("s1与s2的差集为：");
        s3.display();
        s3 = s3.Intersection(s1,s2);
        System.out.println("s1与s2的交集为：");
        s3.display();
    }
}

相关结果为：

如有不解内容，欢迎评论区下方讨论留言哦
若觉得内容稍可，请留下你们的