Code666 (代码贴、代码片段)

[Java] 仿照JDK源码实现数组的增删功能 →→→→→进入此内容的聊天室

来自 , 2020-01-27, 写在 Java, 查看 120 次.
URL http://www.code666.cn/view/52947e0a
  1. package cn.bjsxt.array;
  2. /**
  3.  * 根据StringBuilder类的相关源码创建属于自己的数组类
  4.  * 该类与jdk中的数组的区别在于该类中可以存储任何的对象
  5.  * jdk中的数组只能存储char
  6.  * @author 刘涛
  7.  *
  8.  */
  9. public class MyArrayList {
  10.         private Object[] value;//定义数组
  11.         private int size;//数组的长度`
  12.         public MyArrayList(){
  13.                 //无参构造器，默认初始化长度为16的数组
  14.                 //value = new Object[16];
  15.                 this(16);//此行代码和上面的代码含义相同，
  16.         }
  17.         public MyArrayList(int size){
  18.                 value = new Object[size];
  19.         }
  20.         public void add(Object obj){
  21.                 //因为默认的size初始化值为0，所以从0开始，然后自增会继续往后加
  22.                 value[size] = obj;
  23.                 size++;
  24.                 //对数组进行扩容，如果初始化数组的长度无法满足数组时便会进行自动的扩容操作
  25.                 if(size >= value.length){
  26.                         int newCapacity = size*2;
  27.                         Object[] newList = new Object[newCapacity];
  28.                         for(int i = 0; i < value.length;i++){
  29.                                 newList[i] = value[i];
  30.                         }
  31.                         value = newList;
  32.                 }
  33.         }
  34.         public Object get(int index){
  35.                 if(index < 0 || index >= size){
  36.                         try {
  37.                                 throw new Exception();
  38.                         } catch (Exception e) {
  39.                                 // TODO Auto-generated catch block
  40.                                 e.printStackTrace();
  41.                         }
  42.                 }
  43.                 return value[index];
  44.         }
  45.         /**
  46.          * 删除数组中指定位置的元素，采取方式为数组中的最后一个元素替换将要删除的元素的
  47.          * @param index 要删除的元素的位置
  48.          */
  49.         public void deleteCharAt(int index){
  50.                 if (index < 0 || index > size) {
  51.                         try {
  52.                                 throw new Exception();
  53.                         } catch (Exception e) {
  54.                                 // TODO Auto-generated catch block
  55.                                 e.printStackTrace();
  56.                         }
  57.                 } else {
  58.                         //将数组中的最后一个元素替换删除元素的即可
  59.                         value[index] = value[size - 1];
  60.                         //删除后数组的长度减1
  61.                         size --;
  62.                         //创建一个新的数组数组的长度为原来数组的长度减1，并将原来的数组中的元素复制到新数组中
  63.                         Object[] newList = new Object[size];
  64.                         for(int i = 0; i < size; i++){
  65.                                 newList[i] = value[i];
  66.                         }
  67.                         //System.arraycopy(value, 0, newList, 0, size);//将原始数组中的数据复制到新数组中的另一种方法
  68.                           value = newList;
  69.                 }
  70.         }
  71.         /**
  72.          * 删除数组中指定位置的元素，删除方式为删除指定位置的元素后，后面的元素向前移动
  73.          * @param index
  74.          */
  75.         public void removeCharAt(int index){
  76.                 //判断删除元素的位置是否在数组的长度范围内，若不在范围内则抛出异常
  77.                 if (index < 0 || index > size) {
  78.                         try {
  79.                                 throw new Exception();
  80.                         } catch (Exception e) {
  81.                                 // TODO Auto-generated catch block
  82.                                 e.printStackTrace();
  83.                         }
  84.                 } else {
  85.                         for(int i = 0; i < size; i ++){
  86.                                 value[i + index] = value[i + index + 1];
  87.                         }
  88.                         size --;
  89.                         Object[] newList = new Object[size];
  90.                         for(int i = 0; i < size; i ++){
  91.                                 newList[i] = value[i];
  92.                         }
  93.                         //System.arraycopy(value, 0, newList, 0, size);//将原始数组中的数据复制到新数组中的另一种方法
  94.                         value = newList;
  95.                 }
  96.         }
  97.         public void insertCharAt(int index,Object obj){
  98.                 if (index < 0 || index > size ) {
  99.                         try {
  100.                                 throw new Exception();
  101.                         } catch (Exception e) {
  102.                                 // TODO Auto-generated catch block
  103.                                 e.printStackTrace();
  104.                         }
  105.                 } else {
  106.                         value[size] = obj;
  107.                         size++;
  108.                         Object[] newList = new Object[size];
  109.                         System.arraycopy(value, 0, newList, 0, size);
  110.                         value = newList;
  111.                 }
  112.         }
  113.         /***
  114.          * 该方法还需要进行调整 目前还无法实现
  115.          * @param index
  116.          * @param obj
  117.          */
  118.         public void insert(int index,Object obj){
  119.                 if (index < 0 || index > size ) {
  120.                         try {
  121.                                 throw new Exception();
  122.                         } catch (Exception e) {
  123.                                 // TODO Auto-generated catch block
  124.                                 e.printStackTrace();
  125.                         }
  126.                 } else {
  127.                         size++;
  128.                         for(int i = 0;i < size; i ++){
  129.                                 System.out.println(i);
  130.                                 if((index + i + 1) > size){
  131.                                         value[index + i + 1] = null;
  132.                                         return;
  133.                                 }else{
  134.                                         value[index + 2 + i] = value[index + i + 1];
  135.                                         value[index] = obj;
  136.                                 }
  137.                         }
  138.                         Object[] newList = new Object[size];
  139.                         System.arraycopy(value, 0, newList, 0, size);
  140.                         value = newList;
  141.                 }
  142.         }
  143.         /**
  144.          * 删除数组中指定区间的元素
  145.          * @param start 区间起始位置
  146.          * @param end 区间结束位置
  147.          */
  148.         public void remove(int start,int end){
  149.                 if(start < 0 || end > size || end < 0 || start > size){
  150.                         try {
  151.                                 throw new Exception();
  152.                         } catch (Exception e) {
  153.                                 // TODO Auto-generated catch block
  154.                                 e.printStackTrace();
  155.                         }
  156.                 }else{
  157.                         for(int i = 0; i < size; i ++){
  158.                                 if(i+end > size){
  159.                                         value[i + start] = null;
  160.                                 }else{
  161.                                         value[i + start] = value[i + end];
  162.                                 }
  163.                         }
  164.                         size -= end - start;
  165.                         Object[] newList = new Object[size];
  166.                         for(int i = 0 ; i < size; i ++){
  167.                                 newList[i] = value[i];
  168.                         }
  169.                         //System.arraycopy(value, 0, newList, 0, size);//将原始数组中的数据复制到新数组中的另一种方法
  170.                         value = newList;
  171.                 }
  172.         }
  173.         public static void main(String[] args) {
  174.                 MyArrayList my = new MyArrayList(2);
  175.                 my.add("aaa");
  176.                 my.add("bbb");
  177.                 my.add("ccc");
  178.                 my.add(new Human("孙悟空",500,true));
  179. //              Human h = (Human) my.get(3);
  180. //              System.out.println(h.getName());
  181. //              System.out.println(h.isGender());
  182. //              System.out.println(h.getAge());
  183. //              System.out.println(my.get(2));
  184.                 System.out.println(my.size);
  185. //              my.insertCharAt(3, "eee");
  186. //              my.insert(4, "fff");
  187.                 System.out.println();
  188. //              my.deleteChar(1);
  189. //              my.removeCharAt(1);
  190. //              my.remove(1, 3);
  191.                 my.insert(3, "fff");
  192.                 for(int i = 0; i < my.size; i ++){
  193.                         System.out.println(my.get(i));
  194.                 }
  195.                 System.out.println(my.size);
  196.                 /*System.out.println(my.size);
  197.                 Human h1 = (Human) my.get(1);
  198.                 System.out.println(h1.getAge());*/
  199.         }
  200. }
  201.  

回复 "仿照JDK源码实现数组的增删功能"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666