java动态数组的实现_动手编写—动态数组（Java实现）
目录
数组基础回顾
自定义动态数组
动态数组的设计
抽象父类接口设计
抽象父类设计
动态数组之DynamicArray
补充数组缩容
全局的关系图
声明
数组基础回顾
1、数组是一种常见的数据结构，用来存储同一类型值的集合
2、数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致
3、数组是一种顺序存储的线性表，所有元素的内存地址是连续的
4、例如：new 一个int基本类型的数组array
int[] array = new int[]{11,22,33};
5、数组的优势与劣势
数组具有很高的随机访问能力，通过数组下标就可以读取对应的值
数组在插入与删除元素时，会导致大量的元素移动
数组的长度是固定的，无法动态扩容，在实际开发中，我们更希望数组的容量是可以动态改变的
总结——数组适用于读操作多，写操作少的场景
自定义动态数组
动态数组的设计
/**
* 元素的数量
*/
protected int size;
/**
* 数组所有元素及内存地址指向
*/
private E[] elements;
图示结构：
抽象父类接口设计
将动态数组与链表共同的属性与方法抽取出，作为抽象类，提高复用性
抽象父类接口——List
public interface List {
//查无元素的返回标志
int ELEMENT_NOT_FOUND = -1;
/**
* 元素的数量
* @return
*/
int size();
/**
* 是否为空
* @return
*/
boolean isEmpty();
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
E set(int index, E element);
/**
* 获取index位置的元素
* @param index
* @return
*/
E get(int index);
/**
* 是否包含某个元素
* @param element
* @return
*/
boolean contains(E element);
/**
* 查看元素的索引
* @param element
* @return
*/
int indexOf(E element);
/**
* 添加元素到尾部
* @param element
*/
void add(E element);
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
void add(int index, E element);
/**
* 删除index位置的元素
* @param index
* @return
*/
E remove(int index);
/**
* 删除指定元素
* @param element
* @return
*/
public E remove(E element);
/**
* 清除所有元素
*/
void clear();
抽象父类设计
抽象父类AbstractList是对接口List的实现
public abstract class AbstractList implements List {
/**
* 元素的数量
*/
protected int size;
/**
* 元素的数量
* @return
*/
public int size() {
return size;
}
/**
* 是否为空
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 是否包含某个元素
* @param element
* @return
*/
public boolean contains(E element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
/**
* 添加元素到尾部
* @param element
*/
public void add(E element) {
add(size, element);
}
/**
* 非法索引访问数组异常
* @param index
*/
protected void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
/**
* 索引检查函数
* @param index
*/
protected void rangeCheck(int index) {
if (index < 0 || index >= size) {
outOfBounds(index);
}
}
/**
* 数组添加元素的索引检查函数
* @param index
*/
protected void rangeCheckForAdd(int index) {
//index > size,元素可以添加在数组size位置，即数组尾部下一存储单元
if (index < 0 || index > size) {
outOfBounds(index);
}
}
}
动态数组之DynamicArray
public class DynamicArray extends AbstractList {
/**
* 数组所有元素及内存地址指向
*/
private E[] elements;
//数组的默认初始化值
private static final int DEFAULT_CAPACITY = 10;
/**
* 带参构造函数，参数是数组初始化值
* @param capacity
*/
public DynamicArray(int capacity) {
//如果传入的capacity>默认初始值，取capacity，否则取默认值
capacity = Math.max(capacity, DEFAULT_CAPACITY);
//通过new Object[]，动态数组可以实现多对象化
elements = (E[]) new Object[capacity];
}
/**
* 构造函数，将数组初始化
*/
public DynamicArray() {
this(DEFAULT_CAPACITY);
}
/**
* 设置index位置的元素值
* @param index
* @param element
* @return old
*/
public E set(int index,E element){
//检查索引是否合法
rangeCheck(index);
//
E old = elements[index];
elements[index] = element;
return old;
}
/**
* 获取数组index位置的元素
* @param index
* @return elements[index];
*/
public E get(int index){
rangeCheck(index);
return elements[index];
}
/**
* 查看元素的索引
* @param element
* @return
*/
public int indexOf(E element){
//如果元素为空，单独判断，防止NPE
if (element == null){
for (int i = 0;i < size;i++){
if (elements[i] == null) return i;
}
}else {
//元素不为空
for (int i = 0;i < size;i++){
if (element.equals(elements[i])) return i;
}
}
//查无此元素
return ELEMENT_NOT_FOUND;
}
/**
* 添加元素到数组指定位置
* @param index
* @param element
*/
public void add(int index,E element){
//检查索引是否合法
rangeCheckForAdd(index);
//检查数组容量是否足够
ensureCapacity(size + 1);
for (int i = size;i > index;i--){
elements[i] = elements[i - 1];
}
elements[index] = element;
size++;
}
/**
* 删除指定元素
* @param element
* @return
*/
public E remove(E element){
//调用indexOf获取索引，通过索引删除指定元素
return remove(indexOf(element));
}
/**
* 删除指定index位置的元素
* @param index
* @return
*/
public E remove(int index){
//检查索引是否合法
rangeCheck(index);
E old = elements[index];
for (int i = index + 1;i < size;i++){
elements[i - 1] = elements[i];
}
//将数组原来尾部最后的元素所在的位置置为null，释放原来地址引用对应的对象内存
elements[--size] = null;
//检测是否需要缩容
trim();
return old;
}
/**
* 清除所有元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
/**
* 保证要有capacity的容量
* @param capacity
*/
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
//如果数组容量足够，return
if (oldCapacity >= capacity) return;
//否则的话，数组扩容，数组扩容1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
//将原有数组元素复制到新数组中
for (int i = 0;i < size;i++){
newElements[i] = elements[i];
}
//指向新数组
elements = newElements;
System.out.println(oldCapacity + "扩容为" + newCapacity);
}
/**
* 重写toString函数，打印数组
* @return
*/
@Override
public String toString() {
// size=3, [99, 88, 77]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
补充数组缩容
在每次删除数组元素时及清空数组时，进行缩容检查
/**
* 如果内存使用比较紧张，动态数组有比较多的剩余空间，可以考虑进行缩容操作
* 例如：经过扩容后的数组很大，在经过删除操作后，数组元素数量不多，而数组所占空间够大
* 比如剩余空间占总容量的一半时，就进行缩容 (规则可以自定义)
*/
private void trim(){
int oldCapacity = elements.length;
int newCapacity = oldCapacity >> 1;
//如果元素的数量大于缩容后数组长度，或者小于初始量，不进行缩容操作
if (size >= (newCapacity) || size <= DEFAULT_CAPACITY) return;;
// 剩余空间还很多
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
System.out.println(oldCapacity + "缩容为" + newCapacity);
}
/**
* 清除所有元素
*/
public void clear() {
// 数组清空，应该根据情况缩容，避免内存浪费
if (elements != null && elements.length > DEFAULT_CAPACITY) {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}else {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
}
size = 0;
}
全局的关系图
声明
个人能力有限，有不正确的地方，还请指正
文章为原创，欢迎转载，注明出处即可
本文的代码已上传github,欢迎star
GitHub地址
java动态数组的实现_动手编写—动态数组（Java实现）相关推荐
- java自定义错误码类_如何编写和应用Java的自定义异常类
11.7.1编写自定义异常类的模式 编写自定义异常类实际上是继承一个API标准异常类,用新定义的异常处理信息覆盖原有信息的过程.常用的编写自定义异常类的模式如下: public class Custo ...
- java 2维数据便利_计算机等级考试二级java数组辅导
数组(array)是相同类型变量的集合,可以使用共同的名字引用它.数组可被定义为任何类型,可以是一维或多维.数组中的一个特别要素是通过下标来访问它.数组提供了一种将有联系的信息分组的便利方法. 注意: ...
- scala本地调试_如何编写自己的Java / Scala调试器
scala本地调试 在本文中,我们将探讨Java / Scala调试器的编写和工作方式. 诸如Windows的WinDbg或Linux / Unix的gdb之类的本机调试器通过操作系统直接提供给它们的 ...
- 明解C语言入门篇_第8章_动手编写各种程序吧
前言 本文为业余学习<明解C语言入门篇>的记录,包含代码清单和练习题. 开始学习时间:2022年8月21日 +++++++++++++++++++++++++++++++ 第1章 初识C语 ...
- java代码解锁华为_如何编写可怕的Java代码？
我决定告诉你如何编写可怕的Java代码.如果你厌倦了所有这些美丽的设计模式和最佳实践,并且想写些疯狂的东西,请继续阅读. 如果你正在寻找有关如何编写良好代码的建议,请查看其它文章! 对一切使用异常 你 ...
- java 字符数组与字符串_用于字符串和数组的5种简单有效的Java技术
java 字符数组与字符串 Java通常会排在前五种最流行的编程语言中,因此可以理解. 它是一种通用语言,非常容易学习,因为它是一种高级语言,并且可以满足许多用例. 由于这些原因,Java是一门很棒的 ...
- apachejmeter_java源码_自定义编写jmeter的Java测试代码
我们在做性能测试时,有时需要自己编写测试脚本,很多测试工具都支持自定义编写测试脚本,比如LoadRunner就有很多自定义脚本的协议,比如"C Vuser","JavaV ...
- java记事本教程_Java实战_手把手编写记事本
Java运用SWT插件编写桌面记事本应用程序 可实现windows系统桌面记事本基本功能.傻瓜式教学,一步一步手把手操作.小白也可自己编写出完整的应用程序. 须要工具:Eclipse(带SWT插件) ...
- java如何编写windows木马_如何编写可怕的 Java 代码？
原标题:如何编写可怕的 Java 代码? 作者:武培轩 我决定告诉你如何编写可怕的Java代码.如果你厌倦了所有这些美丽的设计模式和最佳实践,并且想写些疯狂的东西,请继续阅读. 如果你正在寻找有关如何 ...
最新文章
- ARM WFI和WFE指令【转】
- QT 实用代码片段 (持续更新)
- 在Kaggle上免费使用GPU
- 程序员愤怒了：我们不仅要当管理者还要当CEO！
- mysql全套基础知识_mysql系列--基础知识
- verilog实现多周期处理器之——（零）GUN工具链的安装
- delphi开发回忆录——面向对象的基础，继承
- 第十三届蓝桥杯大赛个人赛全国总决赛准考证开放下载
- UltraISO（制作U盘ISO启动镜像）制作U盘启动盘
- 焊缝标注vlx实用程序_【CAD自动标注插件下载】CAD自动标注插件yjbz.VLX v1.0 最新版-开心电玩...
- 如何快速开通微信小程序的流量主功能
- iOS 10.1发现新漏洞：可绕过“激活锁”强行进入主屏
- 【iOS越狱开发】iOS越狱步骤2之SSH连接
- 运营商劫持是什么、运营商DNS网络劫持如何解决
- 什么是 DeFi（去中心化金融）?
- 中国广电明年推进5G覆盖乡镇，用户：和中国移动相比信号有何优势？
- 2021年新安装的Win7系统，Windows Update无法更新，提示错误代码80072EFE
- 1213_SCons初步了解以及安装试用
- 系统平台拼多多商家如何补充订单
- 每天记账，是穷人才会做的事？
热门文章
- 2021考研——复习规划（408篇）
- 博奥智源公司分享麻醉药品管理系统功能设计模块
- 区块链布道者-----Shell Wallet
- 快速恢复Safengine Protector的Shadow DLL
- 计网 | C语言Socket编程获取本机IP及指定域名IP
- ElasticSearch、ES-head、Kibana最新版安装教程
- XML的四个神话：XML属于世界
- 阿里云服务器优势和特点
- 一张涵盖Linux云所有知识点的思维导图（含K8S），你需要吗？
- httpd: Could not reliably determine the server‘s fully qualifie...essageHint: Some lines were ellip