精华内容
下载资源
问答
  • Java自定义类数组的初始化 先创建一个A类型 public class A { private int id; public A() { } public A(int id) { this.id = id; } public int getId() { return id; } public void setId(int id)...

    Java自定义类数组的初始化

    先创建一个A类型

    public class A {
        private int id;
    
        public A() {
        }
    
        public A(int id) {
            this.id = id;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("A{");
            sb.append("id=").append(id);
            sb.append('}');
            return sb.toString();
        }
    }
    

    再创建一个B类型

    import java.util.Arrays;
    public class B {
        private String name;
        private A[] a;
        public String getName() {
            return name;
        }
        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("B{");
            sb.append("name='").append(name).append('\'');
            sb.append(", a=").append(a == null ? "null" : Arrays.asList(a).toString());
            sb.append('}');
            return sb.toString();
        }
        public void setName(String name) {
            this.name = name;
        }
        public A[] getA() {
            return a;
        }
        public void setA(A[] a) {
            this.a = a;
        }
    }
    

    再创建一个测试类

    public class Test {
        public static void main(String[] args) {
            int [] ids = {0,1};
            B b  = new B();
            //定义a数组长度为2
            A[] a = new A[ids.length];
            //只是对a进行了声明,没有进行初始化之前,a都为null
            System.out.println(a[0]);
            a[0]=new A(ids[0]);
            a[1]=new A(ids[1]);
            System.out.println(a[1].getId());
            b.setA(a);
            b.setName("zhangsan");
            //如果没有对a进行初始化,就相当于a数组只是分配空间而并没有具体的对象则其指向为null
            b.getA()[1].setId(2);
            System.out.println(b.getA()[1].getId());
            System.out.println(b.toString());
        }
    }
    

    展开全文
  • Java自定义类数组的创建和赋值

    千次阅读 2018-11-27 10:20:37
    //Person public class Person{ private String id; private Student[] studentVo; public String getId() { return id; } public void setId(String id) { this.id ...

     

    //Person类
    public class Person{
        private String id;
        private Student[] studentVo;
        
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        public Student[] getStudentVo() {
            return studentVo;
        }
        public void setStudentVo(Student[] studentVo) {
            this.studentVo = studentVo;
        }
    }
    //Student类
    public class Student{
        private String id;  //ID
        private String name;  //姓名
        
        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;
        }
    }
    //impl
    Person person = new person;
    String nameString = "张三;李四;王五";
    String[] names = nameString.split(";|;");
    int nlength = names.length;
    Student[] students = new Student[nlength];
    
    for(int i=0; i<nlength; i++){
        Student student = new Student();
        student.setName(names[i]);
        students[i] = student;
    }
    person.setStudentVo(students);

     

    展开全文
  • Java自定义类数组的创建和初始化

    万次阅读 多人点赞 2018-03-18 17:00:22
      刚刚在慕课学习Java的集合List过程中,向集合中添加元素时,遇到一个问题: 定义了一个Course; public class Course { private String id; private String name; //课程名称 //get set方法 ...

      刚刚在慕课学习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());
            //测试 不报空指针异常
    展开全文
  • Java自定义动态数组

    千次阅读 2019-02-15 00:38:33
    Java自定义动态数组 1、静态数组向动态数组转变 (1)静态数组数组空间固定长度 这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足   (2)静态数组如何转变成动态数组 第一步:创建...

    Java自定义动态数组

    1、静态数组向动态数组转变

    (1)静态数组,数组空间固定长度

    这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足

     

    (2)静态数组如何转变成动态数组

    第一步:创建一个空间是data数组两倍的newData数组(扩容);

    第二步:把data数组中的元素全部赋值到newData数组;

     

    2、数组扩容程序

    // 数组扩容
    private void resize(int newCapacity){
       
    E[] newData = (E[]) new Object[newCapacity];
        for
    (int i = 0; i < size; i++) {
            newData[i] =
    data[i];
       
    }
       
    data = newData;
    }

    数组添加元素:数组空间不够就会扩容(原来空间2倍)

        // 数组指定位置添加元素
       
    public void add(int index, E e) {
    //        if (size == data.length)
    //            throw new IllegalArgumentException("Add failed.Array is full.");
           
    if (index < 0 || index > size)
               
    throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
            if
    (size == data.length)
                resize(
    2 * data.length);
            for
    (int i = size - 1; i >= index; i--)
               
    data[i + 1] = data[i];
           
    data[index] = e;
           
    size++;
       
    }

    数组删除元素:数组空间空闲太大就会缩容(原来空间的1/2)

    // 从数组中删除index位置的元素,返回删除的元素
    public E remove(int index) {
       
    if (index < 0 || index >= size) {
           
    throw new IllegalArgumentException("Remove failed.Index is illegal");
       
    }
       
    E ret = data[index];
        for
    (int i = index + 1; i < size; i++) {
           
    data[i - 1] = data[i];
       
    }
       
    size--;
        
    // loitering objects != memory leak 手动释放内存空间
       
    data[size] = null;
        if
    (size == data.length / 2) {
            resize(
    data.length / 2);
       
    }
       
    return ret;
    }

     

    3、数组整体代码

    public class Array<E> {
       
    // 定义数组变量,data.length表示数组容量capacity
       
    private E[] data;
       
    // 定义数组中存放数据大小
       
    private int size;

       
    // 有参构造方法,传入数组的容量capacity构造动态数组
       
    public Array(int capacity) {
           
    data = (E[])new Object[capacity];
           
    size = 0;
       
    }

       
    // 无参构造方法,默认初始容量为capacity=10
       
    public Array() {
           
    this(10);
       
    }

       
    // 获取数组中元素个数
       
    public int getSize() {
           
    return size;
       
    }

       
    // 获取数组的容量
       
    public int getCapacity() {
           
    return data.length;
       
    }

       
    // 判断数组是否为空
       
    public boolean isEmpty() {
           
    return size == 0;
       
    }

    /*    // 在数组末尾添加元素
        public void addLast(E e) {
            if (size == data.length)
                throw new IllegalArgumentException("AddLast failed.Array is full.");
            data[size] = e;
            size++;
        }*/

        // 在数组末尾添加元素(复用add方法)
       
    public void addLast(E e) {
            add(
    size, e);
       
    }

       
    // 在数组头部添加元素(复用add方法)
       
    public void addFirst(E e) {
            add(
    0, e);
       
    }

       
    // 数组指定位置添加元素
       
    public void add(int index, E e) {
    //        if (size == data.length)
    //            throw new IllegalArgumentException("Add failed.Array is full.");
           
    if (index < 0 || index > size)
               
    throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
            if
    (size == data.length)
                resize(
    2 * data.length);
            for
    (int i = size - 1; i >= index; i--)
               
    data[i + 1] = data[i];
           
    data[index] = e;
           
    size++;
       
    }

       
    // 获取index索引位置的元素
       
    public E get(int index) {
           
    if (index < 0) {
               
    throw new IllegalArgumentException("Get failed.Index is illegal.");
           
    }
           
    return data[index];
       
    }

       
    // 修改index索引位置的元素
       
    public void set(int index, E e) {
           
    if (index < 0 || index >= size) {
               
    throw new IllegalArgumentException("Set failed.Index is illegal.");
           
    }
           
    data[index] = e;
       
    }

       
    // 查找数组中是否存在元素e
       
    public boolean contains(E e) {
           
    for (int i = 0; i < size; i++) {
               
    if (data[i] == e) {
                   
    return true;
               
    }
            }
            
    return false;
       
    }

       
    // 查找数组中元素e所在的索引,如果不存在元素e,则返回-1
       
    public int find(E e) {
           
    for (int i = 0; i < size; i++) {
               
    if (data[i] == e) {
                   
    return i;
               
    }
            }
           
    return -1;
       
    }

       
    // 从数组中删除index位置的元素,返回删除的元素
       
    public E remove(int index) {
           
    if (index < 0 || index >= size) {
               
    throw new IllegalArgumentException("Remove failed.Index is illegal");
           
    }
           
    E ret = data[index];
            for
    (int i = index + 1; i < size; i++) {
               
    data[i - 1] = data[i];
           
    }
           
    size--;
           
    // loitering objects != memory leak 手动释放内存空间
           
    data[size] = null;
            if
    (size == data.length / 2) {
                resize(
    data.length / 2);
           
    }
           
    return ret;
        
    }

       
    // 删除数组第一个元素,返回删除的元素
       
    public E removeFirst() {
           
    return remove(0);
       
    }

       
    // 删除数组最后一个元素
       
    public E removeLast() {
           
    return remove(size - 1);
       
    }

       
    // 删除数组中指定元素e
       
    public void removeElement(E e) {
           
    int index = find(e);
            if
    (index != -1) {
                remove(index)
    ;
           
    }
        }

       
    // 数组扩容
       
    private void resize(int newCapacity){
           
    E[] newData = (E[]) new Object[newCapacity];
            for
    (int i = 0; i < size; i++) {
                newData[i] =
    data[i];
           
    }
           
    data = newData;
       
    }

       
    // 重写父类toString()方法
       
    @Override
       
    public String toString() {
            StringBuilder sb =
    new StringBuilder();
           
    sb.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
           
    sb.append('[');
            for
    (int i = 0; i < size; i++) {
                sb.append(
    data[i]);
                if
    (i != size - 1) {
                    sb.append(
    ',');
               
    }
            }
            sb.append(
    ']');
            return
    sb.toString();
       
    }
    }

    4、数组测试代码

    public class ArrayTest {
       
    public static void main(String[] args) {
           
    // 测试toString()方法
           
    Array<Integer> arr = new Array(10);
            for
    (int i = 0; i < 10; i++) {
               
    // 测试addLast(int e)方法
                
    arr.addLast(i);
           
    }
            System.
    out.println("添加数组元素:");
           
    System.out.println(arr);

           
    // 测试add(int index, int e)方法
           
    arr.add(1, 200);
           
    System.out.println("在数组指定索引位置插入元素e:");
           
    System.out.println(arr);

           
    // 测试addFirst(int e)方法
           
    arr.addFirst(-10);
           
    System.out.println("在数组头部位置插入元素e:");
           
    System.out.println(arr);

        }
    }

    测试结果如下所示:初始化数组空间大小为10,第一次插入10个元素到数组之后,然后再添加一个元素,此时数组会扩容为原来空间的两倍。

    添加数组元素:

    Array: size = 10 , capacity = 10

    [0,1,2,3,4,5,6,7,8,9]

    在数组指定索引位置插入元素e:

    Array: size = 11 , capacity = 20

    [0,200,1,2,3,4,5,6,7,8,9]

    在数组头部位置插入元素e:

    Array: size = 12 , capacity = 20

    如果感兴趣的童鞋,可以观看我下一篇博客:简单复杂度分析

    展开全文
  • 背景:做笔试的时候 使用自定义类声明成数组使用,但是当我通过不同的下标给数组里不同对象赋值的时候一直报空指针异常 public class Main { public static void main(String[] args) { node[] arr=new node[2]; ...
  • Java自定义类数组的创建和使用

    万次阅读 2016-03-11 19:28:14
    简单介绍Java自定义类数组的创建和使用,具体代码如下: 第一步:创建 // 顶点表结点 private class VertexNode { char vertex; // 顶点域,存储顶点信息 VertexNode firstedge; // 边表头指针 } 第二步:...
  • java自定义对象数组

    2017-12-01 15:09:00
    java创建自定义类数组方法: Student []stu = new Student[3]; for(int i = 0; i < 3; i ++){stu[i] = new Student();//每次调用时,否则会提示空指针异常 } 转载于:...
  • 今天我想初始化一个自定义JAVA类数组,结果发现不能像初始化C++的结构体,或者JAVA中初始化一个基本类型,如int那样: int[] a=new int[]{1,2,3}; 直接在中括号后的大括号里写参数列表会被编译器认为是...
  • Java自定义泛型数组

    千次阅读 2019-02-13 23:31:05
    1、定义泛型数组相关概念 (1)泛型数组让我们可以存放任何数据类型 (2)存放的类型不可以是基本数据类型,只能是对象 boolean、byte、char、short、int、long、float、double (3)每个基本数据类型都...
  • java创建自定义类数组 错题笔记 学习动态规划做例题hdu 2602遇到的问题:创建自定义类后,新建一个自定义类数组,向数组赋值时报如下错误: java.lang.NullPointerException: Cannot assign field "val" because...
  • Java实现自定义动态数组 数组基础回顾 1、数组是一种常见的数据结构,用来存储同一类型值的集合 2、数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致 3、数组是一种顺序存储的线性表,所有元素的内存...
  • Java自定义数组排序

    千次阅读 2019-04-15 21:00:23
    import java.util.Arrays; import java.util.Comparator; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.n...
  • java数组自定义排序

    2017-10-31 15:35:59
    java数组自定义排序,种类繁多,简单实现,可自由操控。
  • 要想改变默认的排列顺序,不能使用基本类型(int,double, char),而要使用它们对应的
  • Java自定义数组列表的实现 主要目的: 解决ArrayList 不能改变大小的问题,主要实现数组列表动态调整大小。 数组类型如何选择?由于我们不清楚数组中具体存入什么类型的数据, 我们可以声明一个对象Object [ ] ...
  • java 创建自定义数组

    2020-09-02 01:43:52
    本篇文章是关于java 如何自己创建自定义数组,这里给大家一个小实例,希望能帮助有所需要的同学
  • FileInputStream和FileOutputStream可以将数组,等写入如文件并读取。 public class UserList implements Serializable{ public void writeRank(){ try { // FileInputStream f=new FileInputStream(...
  • Java数组列表和单链表目录如何创建自定义数组列表功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 示例 public class Student{ String name; Integer id; public void setName(String ... } } } 出现空指针异常是因为调用了未初始化或不存在的对象 创建数组的时候数组中的对象都为null,需要进行初始化后使用
  • JNI返回自定义结构体数组Java

    千次阅读 2017-11-01 20:42:58
    网上关于jni返回自定义结构体数组的文章大部分参差不齐,有的这样写有的那样写,多多少少有 bug,然后就自己探索了一下,基本下面这种写法应该算比较标准的,有任何问题可以评论交流下。
  • Java自定义对象数组、集合排序

    千次阅读 2015-01-18 14:41:37
    //实体: package CategoryDp2; import java.util.Comparator; public class Cat implements Comparator,Comparable{ private int weight; public int getWeight() { return weight; } ...
  • 主要介绍了Java数组扩容实现方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java类对象数组的赋值问题

    千次阅读 2020-04-03 22:43:58
    对象数组在应用是可能会忽略再次实例化对象的一个过程, 下面是代码: Student[] student = new Student[5]; for(int i = 0; i < 5; i++) { student[i] = new Student(); //此行即是重点 !!! student[i].set...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 257,197
精华内容 102,878
关键字:

java自定义类的数组表示

java 订阅