java定义一个自增长数组_Java自定义数组

前言

今天有点无聊,写了一个自定义数组,里边主要实现很多js中数组的方法，例如：排序、数组连接、删除、剪切。算是加深对java的一些基础操作的印象。

代码/**

* @Auther dbc

* @Date 2020/9/5 22:03

* 自定义数组,数组元素为Object类

* 构造方法：

* MyArrayList() 初始化数组,长度为0

* MyArrayList(int size) 创建长度为size的数组

* MyArrayList(Object... objects) 初始化即加入一些元素

* 主要方法：

* String join() 方法用于根据分隔符把数组中的所有元素放入一个字符串,默认分隔符为","逗号.

* String join(String separator) example: 元素为0,1,2,3的数组 使用join("-")得到：0-1-2-3

* String toString() 得到数组字符串形式

* boolean add(int index,Object o) 在指定索引后增加元素

* void add(Object... objects) 在数组末尾添加元素

* Object pop() 删除并返回数组最后一个元素

* MyArrayList splice(int index,int length) 在原数组从索引index开始剪切length长度个元素,返回剪切后的新的数组

* MyArrayList update(int index,Object o) 修改指定索引的元素

* Object shift() 删除并返回数组的第一个元素

* void unShift(Object... objects) 在数组开头添加元素

* MyArrayList slice(int start,int end) 方法可从已有的数组中返回选定的元素

* void sortAsc() 对数组进行升序排序(选择排序) 前提:数组元素均为Integer、Double、Float中的一种

* void sortDesc() 对数组进行降序排序(冒泡排序) 前提:数组元素均为Integer、Double、Float中的一种

* MyArrayList concat(MyArrayList... allList) 方法用于连接两个或多个数组(该方法不会改变现有的数组)

* void reverse() 颠倒数组中的元素

* Object charAt(int index) 获取索引index处的元素

* int indexOf(Object o,int startIndex) 从startIndex开始向后获取某个元素在数组的索引,没有则返回-1

* int lastIndexOf(Object o,int startIndex) 从startIndex开始向前获取某个元素在数组的索引,没有则返回-1

*

*/

public class MyArrayList {

private Object[] elementData;//元素

private int size;//数组长度

private static final float DEFAULT_EXPAND_FACTOR = 0.75f;//扩容因子

private static final float DEFAULT_NARROW_FACTOR = 0.5f;//缩小容量的因子

private static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量

private static String joinSeparator =","; //join方法默认的分隔符

/**

* 从startIndex开始向前获取某个元素在数组的索引,没有则返回-1

* @param o

* @param startIndex

* @return

*/

public int lastIndexOf(Object o,int startIndex){

if(startIndex<0) startIndex=0;

if(startIndex>=size) startIndex=size-1;

for(int i=startIndex;i>=0;i--){

if(elementData[i].equals(o)) return i;

}

return -1;

}

/**

* 从startIndex开始向后获取某个元素在数组的索引,没有则返回-1

* @param o

* @param startIndex

* @return

*/

public int indexOf(Object o,int startIndex){

if(startIndex<0) startIndex=0;

if(startIndex>=size) startIndex=size-1;

for(int i=startIndex;i

if(elementData[i].equals(o)) return i;

}

return -1;

}

/**

* 颠倒数组中的元素

*/

public void reverse(){

Object o;

for(int i=0;i

o=elementData[i];

elementData[i] = elementData[size-i-1];

elementData[size-i-1] =o;

}

}

/**

* 连接多个数组

* @param allList

* @return

*/

public MyArrayList concat(MyArrayList... allList){

MyArrayList concatData =new MyArrayList(this.getElementData());

for (MyArrayList myArrayList:allList) {

concatData.add(myArrayList.getElementData());

}

return concatData;

}

/**

* 对数组进行升序排序

*/

public void sortAsc(){

if(!isAllNumArray()) return;

Object o;

//选择排序

for(int i=0;i

int min = i;//最小数的索引

for(int j=i+1;j

if(Double.parseDouble(elementData[i].toString())>Double.parseDouble(elementData[j].toString())){

min = j;

}

}

if(min ==i) continue;

o = elementData[i];

elementData[i]=elementData[min];

elementData[min] = o;

}

}

/**

* 对数组进行降序排序

*/

public void sortDesc(){

if(!isAllNumArray()) return;

Object o;

//冒泡排序

for(int i=0;i

for(int j=i+1;j

if(Double.parseDouble(elementData[i].toString())

o=elementData[i];

elementData[i]=elementData[j];

elementData[j]=o;

}

}

}

}

/**

* 方法可从已有的数组中返回选定的元素

* @param start

* @param end

* @return

*/

public MyArrayList slice(int start,int end){

if(start<0) return new MyArrayList();

if(end>=size) end=size-1;

Object[] sliceData =new Object[end-start+1];

for(int i=start;i<=end;i++){

sliceData[i-start]=elementData[i];

}

return new MyArrayList(sliceData);

}

/**

* 在数组开头添加元素

* @param objects

*/

public void unShift(Object... objects){

int len =objects.length;

ensureCapacity(len);

for(int i=size+len-1;i>=len;i--){

elementData[i]=elementData[i-len];

}

for (int i=0;i

elementData[i]=objects[i];

}

size+=len;

}

/**

* 删除并返回数组的第一个元素

* @return

*/

public Object shift(){

if(size<=0) return null;

Object o = elementData[0];

for(int i=0;i

elementData[i]=elementData[i+1];

}

size--;

return o;

}

/**

* 修改指定位置的元素

* @param index

* @param o

* @return

*/

public MyArrayList update(int index,Object o){

if(index<0 || index>=size) return this;

this.elementData[index]=o;

return this;

}

/**

* 删除元素,并返回被删除的元素数组

* @param index 从index索引开始删除

* @param length 删除的长度。若删除超过数组下标,默认从索引index一直删除到数组的最后一个元素。

* @return

*/

public MyArrayList splice(int index,int length){

if(index<0 || index>size-1) return new MyArrayList();

if(length<=0) return new MyArrayList();

if(index+length>size) length =size-index;

Object[] removeList =new Object[length];

//开始删除

for(int i=0;i

removeList[i] =elementData[index+i];

if(i+length

elementData[index+i] =elementData[index+length+i];

}else {

elementData[index+i]=null;

}

}

for(int i=index+length;i

if(i+length>=elementData.length) break;

elementData[i] = elementData[i+length];

}

size-=length;

return new MyArrayList(removeList);

}

/**

* 删除并返回数组的最后一个元素

*/

public Object pop(){

if(size<=0) return null;

Object removeEle=elementData[size-1];

elementData[--size]=null;

return removeEle;

}

/**

* 增加元素 方式二:指定下标的后面添加

* @param o 新元素

* @param index 索引

*/

public boolean add(int index,Object o){

if(index<0 || index>=size) return false;

ensureCapacity(1);//检测容量

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

elementData[i] =elementData[i-1];

}

elementData[index+1]=o;

size++;

return true;

}

/**

* 增加元素 方式一:末尾添加

* js中的push()方法

*/

public void add(Object... objects){

//检测容量

ensureCapacity(objects.length);

//末尾增加

for(int i=0;i

elementData[size++] =objects[i];

}

}

/**

* 获取数组长度

*

*/

public int getSize(){

return this.size;

}

/**

* toString

*/

public String toString(){

StringBuffer sb =new StringBuffer("[");

for(int i=0;i

sb.append(elementData[i]);

sb.append(",");

}

String str;

if(size>0){

str = sb.substring(0, sb.length() - 1);

str+="]";

}else{

sb.append("]");

str =sb.toString();

}

return str;

}

/**

* join() 方法用于把数组中的所有元素放入一个字符串

* 元素是通过指定的分隔符进行分隔的

* 使用默认的方法

*/

public String join(){

StringBuffer sb =new StringBuffer();

for(int i=0;i

sb.append(elementData[i]);

sb.append(joinSeparator);

}

if(size==0) return "";

return sb.substring(0, sb.length() - 1);

}

/**

* join() 方法用于把数组中的所有元素放入一个字符串

* 元素是通过指定的分隔符进行分隔的

* 使用默认的方法

*/

public String join(String separator){

StringBuffer sb =new StringBuffer();

for(int i=0;i

sb.append(elementData[i]);

sb.append(separator);

}

if(size==0) return "";

return sb.substring(0, sb.length() - 1);

}

/**

* @param addNum 此次添加的数目

* 检测数组容量与实际元素个数是否达到扩容标准,若达到则扩容,否则不管

*/

private void ensureCapacity(int addNum){

//容量*扩容因子>size && 容量*缩容因子

if(size+addNum

&& size+addNum

//达到扩容要求,计算新的容量

int capacity = (int)((size+addNum)/DEFAULT_EXPAND_FACTOR);

//大于最大容量,不管了只有

if(capacity>MAXIMUM_CAPACITY) capacity =MAXIMUM_CAPACITY;

elementData= Arrays.copyOf(elementData,capacity);

}

/**

* 获取所有数组元素

* @return

*/

public Object[] getElementData(){

return Arrays.copyOf(this.elementData,size);

}

/**

* 获取数组某个元素

* @return

*/

public Object charAt(int index){

if(index<0 || index>=size) return null;

return this.elementData[index];

}

/**

* 判断数组元素是否都是数字

* @return

*/

private boolean isAllNumArray(){

for(int i=0;i

if(elementData[i] instanceof Integer || elementData[i] instanceof Float

|| elementData[i] instanceof Double) {

}

else return false;

}

return true;

}

public MyArrayList(){

this.size =0;

this.elementData =new Object[0];

}

/**

* 定义长度为size的空数组

* @param size

*/

public MyArrayList(int size){

if(size<0) size=0;//确保不为负数

this.elementData =new Object[size];

this.size=0;

}

/**

* 初始化数组,并初始化数组内容

* @param objects

*/

public MyArrayList(Object... objects){

this.size=objects.length;

elementData=Arrays.copyOf(objects,size);

ensureCapacity(1);//扩容

}

}