Java如何自定义类数组的创建和初始化

目录
  • 自定义类数组的创建和初始化
  • 自定义类封装数组,添加类方法实现数据

自定义类数组的创建和初始化

刚刚在慕课学习Java的集合类List过程中,向集合中添加元素时,遇到一个问题:

定义了一个Course类

public class Course {
    private String id;
    private String name;  //课程名称
    //get  set方法
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

在测试类中有一个Course类的List集合allCourses,一个向该List集合添加元素的方法addToAllCourses() ;

public class ListTest {
    private List allCourses;  //用于存放备选课程的List
    //构造函数,初始化allCourses
    public ListTest() {
        this.allCourses = new ArrayList();
    }
    public void addToAllCourses(String id, String name) {
        //List的add(Object e), 添加一个元素
        Course cs = new Course();  //创建一个Course对象,并设置其参数
        cs.setId(id);
        cs.setName(name);
        allCourses.add(cs);
        // List的addAll(Collection c)方法
        Course[] courses = new Course[3];
        courses[0].setId("2");
        courses[0].setName("C语言");
        courses[1].setId("3");
        courses[1].setName("数据库");
        courses[2].setId("4");
        courses[2].setName("计算机网络");
        allCourses.addAll(Arrays.asList(courses));
        //在该方法中 参数必须为collection类型,因此必须用工具类进行类型转换
     }
}

主函数测试

    public static void main(String[] args) {
        ListTest list = new ListTest();
        list.addToAllCourses("1", "数据结构");
        List<Course> li = list.getAllCourses();
        for(int i = 0; i < li.size(); i++) {
            System.out.println((i + 1) + ": " + li.get(i).getId()
                               + " " + li.get(i).getName());
        }
    }

乍看是没有问题的,但是一运行,问题就来了,myeclipse报出了空指针异常。异常抛出点为addToAllCourses()方法中 Course类数组courses在赋值时的代码。

  

既然是空指针异常,也就是说,courses[0], courses[1], courses[2]都是没有被初始化的。

  

一般而言,如下的数组定义在myeclipse中是不会报错的:

String[] s = new String[3];
s[0] = "000000";
System.out.println(s[0]);

但是,我的代码中,数组的类型为自定义的类,而非Java本身提供的类(如String类),因而我怀疑是不是我的数组定义出了问题. 查阅资料后发现,自定义类的数组定义后的初始化应该如下:

        Course[] courses = new Course[3];
        courses[0] = new Course();
        courses[0].setName("0000000");
        System.out.println(courses[0].getName());

也就是说,在声明了自定义类的数组之后,对每一个数组元素的初始化,都要为其new一个对象出来使得指针指向该对象,Java语言本身是不提供在自定义类数组声明时候自动创建新对象的方式的。

  

此处顺便再补充一下类二维数组的定义及初始化,

/*Java提供类*/
        //方式一:
        String[][] s = new String[][] { {"a", "b", "c"},
                                        {"d", "e", "f"}  };
        //方式二
        int r = 0;
        String[][] s = new String[2][3];
        for (int i = 0; i < 2; i++)
            for (int j = 0; j < 3; j++) {
                s[i][j] = String.valueOf(r++);
            }
/*自定义类*/
        Course[][] courses = new Course[2][3];  //声明
        courses[0][0] = new Course();  //使用时new一个实例
        courses[0][0].setId("0");
        courses[0][0].setName("000000");
        System.out.println(courses[0][0].getId() + "  "
                           + courses[0][0].getName());
        //测试 不报空指针异常

自定义类封装数组,添加类方法实现数据

1、具体见注释

2、后续或有更新

public class MyArray {
    private long[] array;
    private int cnt; // 自定义数组类的元素个数
    /**
    使用自定义类封装数组,添加类方法实现数据操作
    */
    public MyArray() {
        array = new long[50];
    }
    public MyArray(int size) {
        array = new long[size];
    }
    /**
    插入数据,返回值为空
    */
    public void insert(long insertValue) {
        array[cnt++] = insertValue;
    }
    /**
    显示数据,返回值为空
    */
    public void display() {
        System.out.print("[");
        for (int i = 0; i < cnt ; ++i) {
            System.out.print(array[i]);
            if (i != cnt - 1) {
                System.out.print(",");
            }
        }
        System.out.println("]");
    }
    /**
    按值查找数据,返回索引值
    算法:线性查找
    */
    public int search(long targetValue) {
        int i;
        int searchResult;
        for (i = 0; i < cnt; ++i) {
            if (targetValue == array[i]) {
                break;
            }
        }
        if (i == cnt) {
            searchResult = -1;
        } else {
            searchResult = i;
        }
        return searchResult; // 保持单一出口
    }
    /**
    按索引查找数据,返回值为目标数据
    */
    public long get(int targetIndex) {
        if (targetIndex < 0 || targetIndex >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            return array[targetIndex];
        }
    }
    /**
    按值删除数据,返回其索引值
    */
    public int deleteByValue(long deleteValue) {
        int i;
        int deleteResult;
        for (i = 0; i < cnt; ++i) {
            if (array[i] == deleteValue) {
                int j;
                for (j = i; j < cnt-1; ++j) {
                    array[j] = array[j+1];
                }
                array[j] = array[--cnt];
                break; // 仅删除从左到右第一个找到的目标值
            }
        }
        if (i == cnt) {
            deleteResult = -1;
        } else {
            deleteResult = i;
        }
        return deleteResult; // 保持单一出口
    }
    /**
    按索引删除数据,返回值为空
    */
    public void delete(int index) {
        if (index < 0 || index >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            int i;
            for (i = index; i < cnt - 1; ++i) {
                array[i] = array[i + 1];
            }
            //array[i] = array[cnt - 1];
            //cnt--;
            array[i] = array[--cnt]; // 替换上两行
        }
    }
    /**
    根据索引值,更新数据,返回值为空
    */
    public void update(int index, int newValue) {
        if (index < 0 || index >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            array[index] = newValue;
        }
    }
    public static void main(String[] args) {
        MyArray array = new MyArray(3);
        array.insert(13);
        array.insert(34);
        array.insert(90);
        array.display();
        array.deleteByValue(34);
        array.display();
    }
}

3、添加自定义有序数组类

public class MyOrderArray {
    private long[] array;
    private int cnt; // 自定义数组类的元素个数
    /**
    使用自定义类封装数组,添加类方法实现数据操作
    */
    public MyOrderArray() {
        array = new long[50];
    }
    public MyOrderArray(int size) {
        array = new long[size];
    }
    /**
    按序插入数据,返回值为空
    */
    public void insert(long insertValue) {
        int i;
        for (i = 0; i < cnt; ++i) {
            if (array[i] > insertValue) {
                break;
            }
        }
        int j;
        for (j = cnt; j > i; --j) {
            array[j] = array[j - 1];
        }
        array[i] = insertValue;
        cnt++;
    }
    /**
    显示数据,返回值为空
    */
    public void display() {
        System.out.print("[");
        for (int i = 0; i < cnt ; ++i) {
            System.out.print(array[i]);
            if (i != cnt - 1) {
                System.out.print(",");
            }
        }
        System.out.println("]");
    }
    /**
    按值查找数据,返回索引值
    算法:线性查找
    */
    public int search(long targetValue) {
        int i;
        int searchResult;
        for (i = 0; i < cnt; ++i) {
            if (targetValue == array[i]) {
                break;
            }
        }
        if (i == cnt) {
            searchResult = -1;
        } else {
            searchResult = i;
        }
        return searchResult; // 保持单一出口
    }
    /**
    按索引查找数据,返回值为目标数据
    */
    public long get(int targetIndex) {
        if (targetIndex < 0 || targetIndex >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            return array[targetIndex];
        }
    }
    /**
    按值删除数据,返回其索引值
    */
    public int deleteByValue(long deleteValue) {
        int i;
        int deleteResult;
        for (i = 0; i < cnt; ++i) {
            if (array[i] == deleteValue) {
                int j;
                for (j = i; j < cnt-1; ++j) {
                    array[j] = array[j+1];
                }
                array[j] = array[--cnt];
                break; // 仅删除从左到右第一个找到的目标值
            }
        }
        if (i == cnt) {
            deleteResult = -1;
        } else {
            deleteResult = i;
        }
        return deleteResult; // 保持单一出口
    }
    /**
    按索引删除数据,返回值为空
    */
    public void delete(int index) {
        if (index < 0 || index >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            int i;
            for (i = index; i < cnt - 1; ++i) {
                array[i] = array[i + 1];
            }
            //array[i] = array[cnt - 1];
            //cnt--;
            array[i] = array[--cnt]; // 替换上两行
        }
    }
    /**
    根据索引值,更新数据,返回值为空
    */
    public void update(int index, int newValue) {
        if (index < 0 || index >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            array[index] = newValue;
        }
    }
    public static void main(String[] args) {
        MyOrderArray array = new MyOrderArray(3);
        array.insert(90);
        array.insert(13);
        array.insert(34);
        array.display();
        array.deleteByValue(34);
        array.display();
    }
}

4、MyArray类与MyOrderArray类目前仅区别于insert方法,后续或有更新

5、MyOrderArray类新增二分查找方法binarySearch,具体细节见该方法代码

public class MyOrderArray {
    private long[] array;
    private int cnt; // 自定义数组类的元素个数
    /**
    使用自定义类封装数组,添加类方法实现数据操作
    */
    public MyOrderArray() {
        array = new long[50];
    }
    public MyOrderArray(int size) {
        array = new long[size];
    }
    /**
    按序插入数据,返回值为空
    */
    public void insert(long insertValue) {
        int i;
        for (i = 0; i < cnt; ++i) {
            if (array[i] > insertValue) {
                break;
            }
        }
        int j;
        for (j = cnt; j > i; --j) {
            array[j] = array[j - 1];
        }
        array[i] = insertValue;
        cnt++;
    }
    /**
    显示数据,返回值为空
    */
    public void display() {
        System.out.print("[");
        for (int i = 0; i < cnt ; ++i) {
            System.out.print(array[i]);
            if (i != cnt - 1) {
                System.out.print(",");
            }
        }
        System.out.println("]");
    }
    /**
    按值查找数据,返回索引值
    算法:线性查找
    */
    public int search(long targetValue) {
        int i;
        int searchResult;
        for (i = 0; i < cnt; ++i) {
            if (targetValue == array[i]) {
                break;
            }
        }
        if (i == cnt) {
            searchResult = -1;
        } else {
            searchResult = i;
        }
        return searchResult; // 保持单一出口
    }
    /**
    按值查找数据,返回索引值
    算法:二分查找
    */
    public int binarySearch(long targetValue) {
        int middle = 0;
        int low = 0;
        int top = cnt;
        while (true) {
            middle = (top + low) / 2;
            if (targetValue == array[middle]) {
                return middle;
            } else if (low > top) {
                return -1;
            } else if (targetValue < array[middle]) {
                top = middle - 1; // 切记减一
            } else if (targetValue >= array[middle]) {
                low = middle + 1; // 切记加一
            }
        }
    }
    /**
    按索引查找数据,返回值为目标数据
    */
    public long get(int targetIndex) {
        if (targetIndex < 0 || targetIndex >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            return array[targetIndex];
        }
    }
    /**
    按值删除数据,返回其索引值
    */
    public int deleteByValue(long deleteValue) {
        int i;
        int deleteResult;
        for (i = 0; i < cnt; ++i) {
            if (array[i] == deleteValue) {
                int j;
                for (j = i; j < cnt-1; ++j) {
                    array[j] = array[j+1];
                }
                array[j] = array[--cnt];
                break; // 仅删除从左到右第一个找到的目标值
            }
        }
        if (i == cnt) {
            deleteResult = -1;
        } else {
            deleteResult = i;
        }
        return deleteResult; // 保持单一出口
    }
    /**
    按索引删除数据,返回值为空
    */
    public void delete(int index) {
        if (index < 0 || index >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            int i;
            for (i = index; i < cnt - 1; ++i) {
                array[i] = array[i + 1];
            }
            //array[i] = array[cnt - 1];
            //cnt--;
            array[i] = array[--cnt]; // 替换上两行
        }
    }
    /**
    根据索引值,更新数据,返回值为空
    */
    public void update(int index, int newValue) {
        if (index < 0 || index >= cnt) {
            throw new ArrayIndexOutOfBoundsException();
        } else {
            array[index] = newValue;
        }
    }
    public static void main(String[] args) {
        MyOrderArray array = new MyOrderArray(3);
        array.insert(90);
        array.insert(13);
        array.insert(34);
        array.display();
        //array.deleteByValue(34);
        System.out.println(array.binarySearch(90));
        array.display();
    }
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Java 数组声明、创建、初始化详解

    一维数组的声明方式: type var[]; 或type[] var; 声明数组时不能指定其长度(数组中元素的个数), Java中使用关键字new创建数组对象,格式为: 数组名 = new 数组元素的类型 [数组元素的个数] 实例: TestNew.java: 程序代码: public class TestNew { public static void main(String args[]) { int[] s ; int i ; s = new int[5] ; for(i = 0 ; i

  • Java 数组的两种初始化方式

    一.数组 1.数组中存储元素的类型是统一的,每一个元素在内存中所占用的空间大小是相同的,知道数组的首元素的内存地址,要查找的元素只要知道下标,就可以快速的计算出偏移量,通过首元素内存地址加上偏移量,就可以快速计算出要查找元素的内存地址.通过内存地址快速定位该元素,所以数组查找元素的效率较高. 2.随机的对数组进行增删元素,当增加元素的时候,为了保证数组中元素在空间存储上是有序的,所以被添加元素位置后面的所有元素都要向后移动,删除元素也是,后面所有的元素要向前移动,所以数组的增删元素​效率很低.

  • Java数组声明、创建、初始化基础

    一维数组的声明方式: type var[]; 或type[] var; 声明数组时不能指定其长度(数组中元素的个数), Java中使用关键字new创建数组对象,格式为: 数组名 = new 数组元素的类型 [数组元素的个数] 实例: TestNew.java: 程序代码: public class TestNew { public static void main(String args[]) { int[] s ; int i ; s = new int[5] ; for(i = 0 ; i

  • java 创建自定义数组

    1.java创建自定义类数组方法: Student []stu = new Student[3]; for(int i = 0; i < 3; i ++) { stu[i] = new Student(); } 2.否则会提示空指针异常 package project; import java.io.*; import java.util.Scanner; class Student { private int id; private String name; private int score

  • Java如何自定义类数组的创建和初始化

    目录 自定义类数组的创建和初始化 自定义类封装数组,添加类方法实现数据 自定义类数组的创建和初始化 刚刚在慕课学习Java的集合类List过程中,向集合中添加元素时,遇到一个问题: 定义了一个Course类 public class Course { private String id; private String name; //课程名称 //get set方法 public String getId() { return id; } public void setId(String id)

  • Java基础教程之数组的定义与使用

    目录 一.数组的基本概念 二.数组的声明 三.数组的创建及初始化 1.数组的创建 2.数组的初始化 四.访问数组元素 五.for each 循环 六.数组的拷贝 七.数组排序 八.二维数组 总结 一.数组的基本概念 数组是一种数据类型,用来存储同一类型值的集合,它在内存中是一段连续的空间.通过一个整形下标(index,或者称之为索引)可以访问数组中的每一个值.例如,如果a是一个整型数组,a[i]就是一个下标为i的一个整数,数组是一种引用类型. 二.数组的声明 声明数组变量时,需要指出数组类型(数

  • 详解java自定义类

    引用数据类型(类) 引用数据类型分类 提到引用数据类型(类),其实我们对它并不陌生,之前使用过的Scanner类.Random类. 我们可以把类的类型为两种: 第一种,Java为我们提供好的类,如Scanner类,Random类等,这些已存在的类中包含了很多的方法与属性,可供我们使用. 第二种,我们自己创建的类,按照类的定义标准,可以在类中包含多个方法与属性,来供我们使用. 这里我们主要介绍第二种情况的简单使用. 自定义数据类型概述 我们在Java中,将现实生活中的事物抽象成了代码.这时,我们可

  • Java实现自定义LinkedList类的示例代码

    目录 一.LinkedList和ArrayList 二.自定义LinkedList类(单向链表) 1.实现思路 2.Node结点类 3.size().isEmpty().get(int index) 4.add(Object o) 5.add(int index,Object element) 6.test类 在正式讲解怎么自定义LinkedList类之前,需要再回顾一下之前学过的一些内容,避免跟ArrayList类混淆. 一.LinkedList和ArrayList -- LinkedList

  • 使用Android studio创建的AIDL编译时找不到自定义类的解决办法

    使用AS创建ADIL文件时AS会在main文件夹下给我们生成一个aidl文件夹和一个相同包名的包,通常我们会把所有和ADIL相关的类或文件放在这个包下,但是如果存在自定义的类时,程序编译时无法通过,提示找不到自定义的包.解决办法如下,在启动Module的build.gradle中加入如下代码: sourceSets { main { manifest.srcFile 'src/main/AndroidManifest.xml' java.srcDirs = ['src/main/java', '

  • 关于Java数组声明、创建、初始化的相关介绍

    本文讲述了Java数组的几个相关的方面,讲述了对Java数组的声明.创建和初始化,并给出其对应的代码. 一维数组的声明方式:type var[]; 或type[] var; 声明数组时不能指定其长度(数组中元素的个数), Java中使用关键字new创建数组对象,格式为:数组名 = new 数组元素的类型 [数组元素的个数] 实例:TestNew.java: 程序代码: public class TestNew { public static void main(String args[]) {

  • Java JDBC自定义封装工具类的步骤和完整代码

    封装JDBC工具类的作用可以优化代码,提高开发效率 步骤 ① 创建配置文件(config.properties),用于存放注册驱动和连接数据库时所需要的参数值 ② 自定义一个类(JDBCUtils.java) ③ 实现构造私有方法 private JDBCUtils(){} ④ 声明所需要的配置变量 private static String driverClass; private static String url; private static String username; priva

  • Java 自定义动态数组方式

    Java自定义动态数组 1.静态数组向动态数组转变 (1)静态数组,数组空间固定长度 这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足 (2)静态数组如何转变成动态数组 第一步:创建一个空间是data数组两倍的newData数组(扩容): 第二步:把data数组中的元素全部赋值到newData数组: 2.数组扩容程序 // 数组扩容 private void resize(int newCapacity){ E[] newData = (E[]) new Object[newCap

  • Java实现自定义ArrayList类的示例代码

    目录 一.总体实现思路 二.add方法 三.size方法 四.isEmpty方法 五.构造方法 六.ArrayList整体代码 七.Test测试类 之前有接触过Collection中的ArrayList类,类中提供了多种可以操作的方法,但是为什么还需要自定义ArrayList类呢?主要是为了学习其中编写程序时的逻辑思维.,今天将简单的介绍ArrayList里面的add方法.size方法.isEmpty方法. 一.总体实现思路 在自定义ArrayList类时需要提前思考多个方面的内容 1.该Arr

随机推荐