1. /**
  2. * @Author:jimisun
  3. * @Description:
  4. * @Date:Created in 22:10 2018-07-18
  5. * @Modified By:
  6. */
  7. public class JimisunArray<E> {
  8.  
  9. private E[] data;
  10. private int size;
  11.  
  12. /**
  13. * 构造函数,传入数组的容量capacity构造Array
  14. *
  15. * @param capacity
  16. */
  17. public JimisunArray(int capacity) {
  18. data = (E[]) new Object[capacity];
  19. size = 0;
  20. }
  21.  
  22. /**
  23. * 构造函数,如果没有传入数组容量,默认数组初始值10
  24. */
  25. public JimisunArray() {
  26. this(10);
  27. size = 0;
  28. }
  29.  
  30. /**
  31. * 获取数组的元素个数
  32. *
  33. * @return
  34. */
  35. public int getSize() {
  36. return size;
  37. }
  38.  
  39. /**
  40. * 获取数组的容量
  41. *
  42. * @return 数组的容量
  43. */
  44. public int getCapacity() {
  45. return data.length;
  46. }
  47.  
  48. /**
  49. * 返回数组是否为null
  50. *
  51. * @return
  52. */
  53. public Boolean isEmpty() {
  54. return size == 0;
  55. }
  56.  
  57. /**
  58. * 向所有元素后添加一个新的元素
  59. *
  60. * @param e
  61. */
  62. public void addLast(E e) {
  63. add(size, e);
  64. }
  65.  
  66. /**
  67. * 向数组的头部添加一个新元素e
  68. *
  69. * @param e
  70. */
  71. public void addFirst(E e) {
  72. add(0, e);
  73. }
  74.  
  75. /**
  76. * 向指定索引添加元素
  77. *
  78. * @param index
  79. * @param e
  80. */
  81. public void add(int index, E e) {
  82.  
  83. if (index < 0 || index > size) {
  84. throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");
  85. }
  86.  
  87. if (size == data.length) {
  88. resize(2 * data.length);
  89. }
  90.  
  91. for (int i = size - 1; i >= index; i--) {
  92. data[i + 1] = data[i];
  93. }
  94. data[index] = e;
  95. size++;
  96. }
  97.  
  98. /**
  99. * 扩充数组长度
  100. *
  101. * @param newCapacity
  102. */
  103. private void resize(int newCapacity) {
  104. E[] newData = (E[]) new Object[newCapacity];
  105. for (int i = 0; i < size; i++) {
  106. newData[i] = data[i];
  107. }
  108. data = newData;
  109. }
  110.  
  111. /**
  112. * 从数组中删除index位置的元素,返回删除的元素
  113. *
  114. * @param index
  115. */
  116. public E remove(int index) {
  117. if (index < 0 || index >= size) {
  118. throw new IllegalArgumentException("Delete failed,Array is full, require index>0 && index<size");
  119. }
  120. E ret = data[index];
  121. for (int i = index + 1; i < size; i++) {
  122. data[i - 1] = data[i];
  123. }
  124. size--;
  125. //将最后一个变量设置为null,而并不是留着,垃圾回收机制无法回收,如果重新添加一个变量就会使原来的引用解除关联,很快就会垃圾回收
  126. data[size] = null;
  127.  
  128. //进行数组的懒减弱,防止算法震荡,增加算法的复杂度
  129. if (size == data.length / 4 && data.length / 2 != 0) {
  130. resize(data.length / 2);
  131. }
  132.  
  133. return ret;
  134. }
  135.  
  136. /**
  137. * 删除第一个元素
  138. *
  139. * @return
  140. */
  141. public E removeFirst() {
  142. return remove(0);
  143. }
  144.  
  145. /**
  146. * 删除最后一个元素
  147. *
  148. * @return
  149. */
  150. public E removeLast() {
  151. return remove(size - 1);
  152. }
  153.  
  154. /**
  155. * 从数组中删除元素e
  156. *
  157. * @param e
  158. */
  159. public boolean removeElement(E e) {
  160. int index = find(e);
  161. if (index != -1) {
  162. remove(index);
  163. return true;
  164. }
  165. return false;
  166. }
  167.  
  168. /**
  169. * 删除数组中所有的元素e
  170. * @param e
  171. */
  172. public void removeAllElement(E e) {
  173. while (removeElement(e) == true) {
  174. removeElement(e);
  175. }
  176. }
  177.  
  178. /**
  179. * 获取指定索引的值
  180. *
  181. * @param index
  182. * @return
  183. */
  184. public E get(int index) {
  185. if (index < 0 || index >= size) {
  186. throw new IllegalArgumentException("get failed ,index is illagel.");
  187. }
  188. return data[index];
  189. }
  190.  
  191. /**
  192. * 修改指定位置索引的值
  193. *
  194. * @param index
  195. * @param e
  196. */
  197. public void set(int index, E e) {
  198. if (index < 0 || index >= size) {
  199. throw new IllegalArgumentException("get failed ,index is illagel.");
  200. }
  201. data[index] = e;
  202. }
  203.  
  204. /**
  205. * 查找数组中是否有元素e
  206. *
  207. * @param e
  208. * @return
  209. */
  210. public boolean contains(int e) {
  211. for (int i = 0; i < size; i++) {
  212. if (data[i].equals(e)) {
  213. return true;
  214. }
  215. }
  216. return false;
  217. }
  218.  
  219. /**
  220. * 查找数组中元素e所在的索引,如果不存在则返回-1
  221. *
  222. * @param e
  223. * @return
  224. */
  225. public int find(E e) {
  226. for (int i = 0; i < size; i++) {
  227. if (data[i].equals(e)) {
  228. return i;
  229. }
  230. }
  231. return -1;
  232. }
  233.  
  234. @Override
  235. public String toString() {
  236. StringBuilder res = new StringBuilder();
  237. res.append(String.format("Array:size = %d,capacity=%d\n", size, data.length));
  238. res.append("[");
  239. for (int i = 0; i < size; i++) {
  240. res.append(data[i]);
  241. if (i != size - 1) {
  242. res.append(",");
  243. }
  244. }
  245. res.append("]");
  246. return res.toString();
  247. }
  248.  
  249. /**
  250. * 主方法测试
  251. *
  252. * @param args
  253. */
  254. public static void main(String[] args) {
  255. JimisunArray<Integer> array = new JimisunArray(10);
  256. for (int i = 0; i < 10; i++) {
  257. array.addLast(i);
  258. }
  259. for (int i = 0; i < 5; i++) {
  260. array.removeFirst();
  261. }
  262. System.out.print(array.toString());
  263. }
  264.  
  265. }

java手写的动态数组JimisunArray的更多相关文章

  1. 教你如何使用Java手写一个基于数组实现的队列

    一.概述 队列,又称为伫列(queue),是先进先出(FIFO, First-In-First-Out)的线性表.在具体应用中通常用链表或者数组来实现.队列只允许在后端(称为rear)进行插入操作,在 ...

  2. 教你如何使用Java手写一个基于链表的队列

    在上一篇博客[教你如何使用Java手写一个基于数组的队列]中已经介绍了队列,以及Java语言中对队列的实现,对队列不是很了解的可以我上一篇文章.那么,现在就直接进入主题吧. 这篇博客主要讲解的是如何使 ...

  3. 代理模式精讲(手写JDK动态代理)

    代理模式是一种架构型模式,表现出来就是一个类代表另一个类的功能,一般用在想对访问一个类的时候做一些控制,同时又不想影响正常的业务,这种代理模式在现实的生活中应用的也非常的广泛,我用穷举法给举几个好理解 ...

  4. java 手写 jvm高性能缓存

    java 手写 jvm高性能缓存,键值对存储,队列存储,存储超时设置 缓存接口 package com.ws.commons.cache; import java.util.function.Func ...

  5. java手写多级缓存

    多级缓存实现类,时间有限,该类未抽取接口,目前只支持两级缓存:JVM缓存(实现 请查看上一篇:java 手写JVM高性能缓存).redis缓存(在spring 的 redisTemplate 基础实现 ...

  6. 纯数据结构Java实现(1/11)(动态数组)

    我怕说这部分内容太简单后,突然蹦出来一个大佬把我虐到哭,还是悠着点,踏实写 大致内容有: 增删改查,泛型支持,扩容支持,复杂度分析.(铺垫: Java语言中的数组) 基础铺垫 其实没啥好介绍的,顺序存 ...

  7. Java手写数组栈

    public class ArrayStack{ private String[] items; //数组 private int count; //栈内元素 private int n; //栈大小 ...

  8. 使用java语言实现一个动态数组(详解)(数据结构)

    废话不多说,上代码 1.从类名开始(我真是太贴心了) public class Array<E> 首先数组类需要带有泛型,这个不多说.需要注意的是在java中,数组只能存放同一个类型的. ...

  9. 基于Apache Zookeeper手写实现动态配置中心(纯代码实践)

    相信大家都知道,每个项目中会有一些配置信息放在一个独立的properties文件中,比如application.properties.这个文件中会放一些常量的配置,比如数据库连接信息.线程池大小.限流 ...

随机推荐

  1. nodejs 的好基友:pm2

    安装:npm install pm2 -g #全局安装pm2 查看版本:pm2 -v 自动重启: pm2 start hello.js --watch 查看列表:pm2 list 查看日志: pm2 ...

  2. spring in action小结2

    1 @Component注解声明的类都会创建为bean,并且bean的id为首字母小写的类名. 2 解决bean自动装配奇异性问题,可以使用@Qualifier("name")限定 ...

  3. Java数据结构和算法(一):简介

    本系列博客我们将学习数据结构和算法,为什么要学习数据结构和算法,这里我举个简单的例子. 编程好比是一辆汽车,而数据结构和算法是汽车内部的变速箱.一个开车的人不懂变速箱的原理也是能开车的,同理一个不懂数 ...

  4. Hadoop-2.2.0中文文档—— Shell命令

    FS Shell 调用文件系统(FS)Shell命令应使用 bin/hadoop fs <args>的形式. 全部的的FS shell命令使用URI路径作为參数.URI格式是scheme: ...

  5. SPD

    一般是在内存条上的.1.SPD是SERIAL PRESENCE DETECT的缩写,中文意思是模组存在的串行检测.也即是通过上面讲的IIC串行接口的EEPROM对内存插槽中的模组存在的信息检查.这样的 ...

  6. Android 线性布局(LinearLayout)相关官方文档 - 布局參数部分

    Android 线性布局(LinearLayout)相关官方文档 - 布局參数部分 太阳火神的漂亮人生 (http://blog.csdn.net/opengl_es) 本文遵循"署名-非商 ...

  7. 页面跳转时候拼接在url后面的多个 参数获取

    function GetRequest() { var url = location.search; var theRequest = new Object(); if (url.indexOf(&q ...

  8. spring oauth2相关资料

    理解OAuth 2.0  *****http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html Secure REST API with oauth2 ...

  9. linux进程同步机制_转

    转自:Linux进程同步机制 具体应用可参考:线程同步       IPC之信号量 为了能够有效的控制多个进程之间的沟通过程,保证沟通过程的有序和和谐,OS必须提供一 定的同步机制保证进程之间不会自说 ...

  10. php5共存php7

    PHP7与PHP5共存于CentOS7 原文参考 原理 思路很简单:PHP5是通过yum安装的在/usr/,套接字在/var/run/php-fpm.socket,PHP7自己编译装在/usr/loc ...