java 返回类型为数组类型的数据_JAVA 数据类型数组

普通int：

public class Array {

//成员变量

private int[] data;

private int size;

//构造函数，传入数组的容量capacity构造Array

public Array(int capacity){

data=new int[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(int e){

add(size, e);

}

//在所有元素前面添加一个新元素

public void addFirst(int e){

add(0, e);

}

//获取index索引的位置的元素

int get(int index){

if(index<0||index>=size)

throw new IllegalArgumentException("Get failed.Index is illegal.");

return data[index];

}

//修改index索引位置的元素为e

void set(int index,int e){

if(index<0||index>=size)

throw new IllegalArgumentException("Get failed.Index is illegal.");

data[index]=e;

}

//查找数组中是否有元素e

public boolean contains(int e){

for(int i=0;i

if(data[i]==e){

return true;

}

}

return false;

}

//查找数组中元素e所在的索引，如果不存在元素e，则返回-1

public int find(int e){

for(int i=0;i

if(data[i]==e){

return i;

}

}

return -1;

}

//从数组中删除index位置的元素，返回删除的元素

public int remove(int index){

if(index<0||index>=size)

throw new IllegalArgumentException("Remove failed.Index is illegal.");

int ret=data[index];

for(int i=index+1;i

data[i-1]=data[i];

size--;

return ret;

}

//从数组中删除第一个元素，返回删除的元素

public int removeFirst(){

return remove(0);

}

//从数组中删除最后一个元素，返回删除的元素

public int removeLast(){

return remove(size-1);

}

//从数组中删除元素e

public void removeElement(int e){

int index=find(e);

if(index!=-1)

remove(index);

}

//在第index个位置插入一个新元素e

public void add(int index,int 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.");

for(int i=size-1;i>=index ;i--)

data[i+1]=data[i];

data[index]=e;

size++;

}

@Override

public String toString(){

StringBuilder res=new StringBuilder();

res.append(String.format("Array:size=%d,capacity=%d\n", size,data.length));

res.append('[');

for(int i=0;i

res.append(data[i]);

if(i!=size-1)//判断是否是最后一个元素

res.append(",");

}

res.append(']');

return res.toString();

}

}

泛型：

public class Array {

//成员变量

private E[] data;

private int size;

//构造函数，传入数组的容量capacity构造Array

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){

add(size, e);

}

//在所有元素前面添加一个新元素

public void addFirst(E e){

add(0, e);

}

//获取index索引的位置的元素

public E get(int index){

if(index<0||index>=size)

throw new IllegalArgumentException("Get failed.Index is illegal.");

return data[index];

}

//修改index索引位置的元素为e

public void set(int index,E e){

if(index<0||index>=size)

throw new IllegalArgumentException("Get failed.Index is illegal.");

data[index]=e;

}

//查找数组中是否有元素e

public boolean contains(E e){

for(int i=0;i

if(data[i].equals(e){

return true;

}

}

return false;

}

//查找数组中元素e所在的索引，如果不存在元素e，则返回-1

public int find(E e){

for(int i=0;i

if(data[i].equals(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

data[i-1]=data[i];

size--;

data[size]=null;//loitering objects!=memory leak

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);

}

//在第index个位置插入一个新元素e

public void add(int index,E e){

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++;

}

@Override

public String toString(){

StringBuilder res=new StringBuilder();

res.append(String.format("Array:size=%d,capacity=%d\n", size,data.length));

res.append('[');

for(int i=0;i

res.append(data[i]);

if(i!=size-1)//判断是否是最后一个元素

res.append(",");

}

res.append(']');

return res.toString();

}

//扩容

private void resize(int newCapacity){

E[] newData=(E[])new Object[newCapacity];

for(int i=0;i

newData[i]=data[i];

data=newData;

}

测试：

public class Student {

private String name;

private int score;

public Student(String studentName,int studentScore){

name=studentName;

score=studentScore;

}

public String toString(){

return String.format("Student(name:%s,score:%d)", name,score);

}

public static void main(String[] args){

Array arr=new Array<>();

arr.addLast(new Student("Alice", 100));

arr.addLast(new Student("Bob", 66));

arr.addLast(new Student("CharLie", 88));

System.out.println(arr);

}

}