【Java数据结构与算法】动态数组、线性表、数组、动态数组、动态数组接口设计、清除所有元素、添加元素、 删除元素、清空数组、是否包含某个元素、扩容、打印数组、泛型、对象数组、内存管理细节、动态数组源码

已于 2022-03-21 12:02:44 修改
阅读量459 收藏
点赞数 1
分类专栏： 数据结构与算法(Java) 文章标签： java 单例模式 开发语言
于 2022-03-16 19:23:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58313733/article/details/123533740
版权

动态数组

在实际应用中，根据使用场景来选择最合适的数据结构

文章目录

线性表

线性表是具有 n 个相同类型元素的有限序列（ n ≥ 0 ）

在这里插入图片描述

  • a1是首节点(首元素)，an是尾节点(尾元素)
  • a1是a2的前驱，a1是a1的后继

常见的线性表有：

  • 数组
  • 链表
  • 栈
  • 队列
  • 哈希表(散列表)

数组（Array）

数组是一种顺序存储的线性表，所有元素的内存地址是连续的

int[] arry = new int[]{ 11, 22, 33 };

在这里插入图片描述

在很多编程语言中，数组都有个致命的缺点： 无法动态修改容量

实际开发中，我们更希望数组的容量是可以动态改变的

动态数组（Dynamic Array）

动态数组接口设计

int size(); //元素的数量
boolean isEmpty(); //是否为空
boolean contains(E element); //是否包含某个元素
void add(E element); //添加元素到最后面
E get(int index); //返回index位置对应的元素
E set(int index, E element); //设置index位置的元素
void add(int index, E element); //往index位置添加元素
E remove(int index); //删除index位置对应的元素
int indexOf(E element); //查看元素位置
void clear(); //清楚所有元素

动态数组的结构：

  • size
  • elements

在这里插入图片描述

Java 中，成员变量会自动初始化，比如：

  • int 类型自动初始化为 0
  • 对象类型自动初始化为 null

清除所有元素 - clear()

核心代码是 size = 0，实际上不需要执行 elements = null，size = 0 的操作已经对用户来说保证了无法访问动态数组中的元素了

添加元素 - add(E element)、add(int index, E element)

add(E element)：默认往数组最后添加元素；

在这里插入图片描述

add(int index, E element)：在 index 位置插入一个元素；

比如要往 index = 2 的地方添加元素：

正确的顺序应当是：从后往前开始将 index = 2 以后的元素依次后移，然后赋值：

在这里插入图片描述

如果从前往后开始移动元素，会造成如下错误的后果：

在这里插入图片描述

代码实现

/**
 * 在index位置插入一个元素
 * @param index
 * @param element
 */
public void add(int index, E element){ 
	rangeCheckForAdd(index); // 检查下标越界
	ensureCapacity(size + 1); // 确保容量够大
	// 0 1 2 3 4 5 6 7 8 9	(index)
	// 1 2 3 4 5 6 x x x x	(原数组)
	// 在index=2处，插入9，元素全部后移
	// 1 2 9 3 4 5 6 x x x	(add后数组)
	// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
	for (int i = size - 1; i > index; i--) {
		elements[i + 1] = elements[i];
	}
	elements[index] = element; // 复制
	size++;
}
/**
 * 添加元素到数组最后
 */
public void add(E element){
	add(size, element);
}

删除元素 - remove(int index)、清空数组 - clear()

例如，删除 index = 3 的数组元素，应当从前往后开始移动，用后面的元素覆盖前面的元素

在这里插入图片描述

思考：最后一个元素如何处理？

  • 如果存放 int 类型，size-- 后，最后一个元素已经无法访问了
  • 如果使用泛型，数组要注意内存管理（将元素置 null）
    使用泛型技术可以让动态数组更加通用，可以存放任何数据类型：
public class ArrayList<E> {
    private int size;
    private E[] elements;
}

elements = (E[])new Object[capacity];
ArrayList<Integer> list = new ArrayList<>();

代码实现

/**
 * 删除index位置的元素
 * @param index
 * @return
 */
public E remove(int index){
	rangeCheck(index);
	// 0 1 2 3 4 5 	(index)
	// 1 2 3 4 5 6 	(原数组)
	// 删除index为2的元素，元素前移
	// 1 2 4 5 6	(remove后的数组)
	// 从前往后开始移, 用后面的元素覆盖前面的元素
	E old = elements[index];
	for (int i = index; i < size - 1; i++) {
		elements[i] = elements[i + 1];
	}
	// 下面是使用泛型后需要写的(如果存储的是int型数据, 则不需要)
	elements[--size] = null; // 删除元素后, 将最后一位设置为null
	return old;
}
/**
 * 清除所有元素
 */
public void clear(){
	// 使用泛型数组后要注意内存管理(将元素置null)
	for (int i = 0; i < size; i++) {
		elements[i] = null;
	}
	size = 0;
}

是否包含某个元素 - contains(E element)

关于 null 的处理主要看你的业务需求：是否可以存储 null 数据？

/**
 * 是否包含某个元素
 * @param element
 * @return
 */
public boolean contains(E element){
	return indexOf(element) != ELEMENT_NOT_FOUND; // 找的到该元素则返回True
}
/**
* 查看元素的索引
 * @param element
 * @return
 */
public int indexOf(E element){
	/*
	// 不对 null 进行处理也可以，但是健壮性不够
	for (int i = 0; i < size; i++) {
		if(elements[i].equals(element)) return i;
	}
	 */
	if(element == null){ // 对 null 进行处理
		for (int i = 0; i < size; i++) {
			if(elements[i] == null) return i;
		}
	}else{
		for (int i = 0; i < size; i++) {
			if(elements[i].equals(element)) return i;
		}
	}
	return ELEMENT_NOT_FOUND;
}

扩容 - ensureCapacity(int capacity)

在这里插入图片描述

代码实现

/**
 * 扩容操作
 */
private void ensureCapacity(int capacity){
	int oldCapacity = elements.length;
	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("size="+oldCapacity+", 扩容到了"+newCapacity);
}

打印数组（toString）

  • 重写 toString 方法
  • 在 toString 方法中将元素拼接成字符串
  • 字符串拼接建议使用 StringBuilder
@Override
public String toString() {
	// 打印形式为: size=5, [99, 88, 77, 66, 55]
	StringBuilder string = new StringBuilder();
	string.append("size=").append(size).append(", [");
	for (int i = 0; i < size; i++) {
		if(0 != i) string.append(", ");
		string.append(elements[i]);
	}
	string.append("]");
	return string.toString();
}

泛型

使用泛型技术可以让动态数组更加通用，可以存放任何数据类型

public class ArrayList<E> {
	private int size;
	private E[] elements;
}

elements = (E[]) new Object[capacity];

ArrayList<Integer> list = new ArrayList<>();

对象数组 - Object[]

Object[] objects = new Object[7];
  • 由于 Object 可以存放任何类型，因此无法固定 Object 占多少内存空间（根据传入不同的自定义对象，占用的空间都不同），因此实际上 Object 数组中存放的是对象的地址
  • 想要销毁对象，只需要将指向该对象的地址赋值为 null，没有地址引用该对象，则会自动被垃圾回收

在这里插入图片描述

内存管理细节

public void clear() {
	for (int i = 0; i < size; i++) {
		elements[i] = null; // 管理内存
	}
	size = 0;
}

public E remove(int index) {
	rangeCheck(index);
	E oldElement = elements[index];
	for (int i = index; i < size - 1; i++) {
		elements[i] = elements[i + 1];
	}
	elements[--size] = null; // 管理内存
	return oldElement;
}

int型动态数组源码

public class ArrayList {
	private int size;		// 元素数量	
	private int[] elements; // 所有的元素

	private static final int DEFAULT_CAPACITY = 10; // 初始容量
	private static final int ELEMENT_NOT_FOUND = -1;
	
	public ArrayList(int capacity) { // 容量小于10一律扩充为10
		capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
		elements = new int[capacity];
	}
	public ArrayList(){
		this(DEFAULT_CAPACITY);
	}
	/**
	 * 元素的数量
	 * @return
	 */
	public int size(){
		return size;
	}
	/**
	 * 是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}
	/**
	 * 是否包含某个元素
	 * @param element
	 * @return
	 */
	public boolean contains(int element){
		return indexOf(element) != ELEMENT_NOT_FOUND; //找的到该元素则返回True
	}
	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	public void add(int index, int element){
		rangeCheckForAdd(index); // 检查下标越界
		ensureCapacity(size + 1); // 确保容量够大
		
		// 0 1 2 3 4 5 6 7 8 9	(index)
		// 1 2 3 4 5 6 x x x x	(原数组)
		// 在index=2处，插入9，元素全部后移
		// 1 2 9 3 4 5 6 x x x	(add后数组)
		// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
		for (int i = size - 1; i > index; i--) {
			elements[i + 1] = elements[i];
		}
		elements[index] = element; // 赋值
		size++;
	}
	/**
	 * 添加元素到最后面
	 */
	public void add(int element){
		add(size, element);
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public int get(int index){
		rangeCheck(index);
		return elements[index];
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public int set(int index, int element){
		rangeCheck(index);
		int old = elements[index];
		elements[index] = element;
		return old;
	}
	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	public int remove(int index){
		rangeCheck(index);
		
		// 0 1 2 3 4 5 	(index)
		// 1 2 3 4 5 6 	(原数组)
		// 删除index为2的元素，元素前移
		// 1 2 4 5 6	(remove后的数组)
		int old = elements[index];
		// 从前往后开始移, 用后面的元素覆盖前面的元素
		for (int i = index; i < size-1; i++) {
			elements[i] = elements[i + 1];
		}
		size--;
		return old;
	}
	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	public int indexOf(int element){
		for (int i = 0; i < size; i++) {
			if(elements[i] == element) return i;
		}
		return ELEMENT_NOT_FOUND;
	}
	/**
	 * 清除所有元素
	 */
	public void clear(){
		size = 0;
	}
	/*
	 * 扩容操作
	 */
	private void ensureCapacity(int capacity){
		int oldCapacity = elements.length;
		if(oldCapacity >= capacity) return;
		// 新容量为旧容量的1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5
		int[] newElements = new int[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[i];
		}
		elements = newElements;
		System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
	}
	/****************封装好的功能函数*******************************/
	// 下标越界抛出的异常
	private void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	private void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加)
	private void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	/****************封装好的功能函数*******************************/
	@Override
	public String toString() {
		// 打印形式为: size=5, [99, 88, 77, 66, 55]
		StringBuilder string = new StringBuilder();
		string.append("size=").append(size).append(", [");
		for (int i = 0; i < size; i++) {
			if(0 != i) string.append(", ");
			string.append(elements[i]);
		}
		string.append("]");
		return string.toString();
	}
}

泛型动态数组源码

@SuppressWarnings("unchecked")
public class ArrayList<E> {
	private int size;		// 元素的数量	
	private E[] elements; 	// 所有的元素

	private static final int DEFAULT_CAPACITY = 10; // 初始容量
	private static final int ELEMENT_NOT_FOUND = -1;
	
	public ArrayList(int capacity) { // 容量小于10一律扩充为10
		capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
		elements = (E[])new Object[capacity];
	}
	public ArrayList(){
		this(DEFAULT_CAPACITY);
	}
	/**
	 * 元素的数量
	 * @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; // 找的到该元素则返回True
	}
	/**
	 * 在index位置插入一个元素
	 * @param index
	 * @param element
	 */
	public void add(int index, E element){ 
		rangeCheckForAdd(index); // 检查下标越界
		ensureCapacity(size + 1); // 确保容量够大
		
		// 0 1 2 3 4 5 6 7 8 9	(index)
		// 1 2 3 4 5 6 x x x x	(原数组)
		// 在index=2处，插入9，元素全部后移
		// 1 2 9 3 4 5 6 x x x	(add后数组)
		// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
		for (int i = size - 1; i > index; i--) {
			elements[i + 1] = elements[i];
		}
		elements[index] = element; // 复制
		size++;
	}
	/**
	 * 添加元素到最后面
	 */
	public void add(E element){
		add(size, element);
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public E get(int index){
		rangeCheck(index);
		return elements[index];
	}
	/**
	 * 设置index位置的元素
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public E set(int index, E element){
		rangeCheck(index);
		E old = elements[index];
		elements[index] = element;
		return old;
	}
	/**
	 * 删除index位置的元素
	 * @param index
	 * @return
	 */
	public E remove(int index){
		rangeCheck(index);
		// 0 1 2 3 4 5 	(index)
		// 1 2 3 4 5 6 	(原数组)
		// 删除index为2的元素，元素前移
		// 1 2 4 5 6	(remove后的数组)
		// 从前往后开始移, 用后面的元素覆盖前面的元素
		E old = elements[index];
		for (int i = index; i < size - 1; i++) {
			elements[i] = elements[i + 1];
		}
		elements[--size] = null; // 删除元素后, 将最后一位设置为null
		return old;
	}
	/**
	 * 查看元素的索引
	 * @param element
	 * @return
	 */
	public int indexOf(E element){
		/*
		// 不对 null 进行处理也可以，但是健壮性不够
		for (int i = 0; i < size; i++) {
			if(elements[i].equals(element)) return i;
		}
		 */
		if(element == null){ // 对 null 进行处理
			for (int i = 0; i < size; i++) {
				if(elements[i] == null) return i;
			}
		}else{
			for (int i = 0; i < size; i++) {
				if(elements[i].equals(element)) return i;
			}
		}
		return ELEMENT_NOT_FOUND;
	}
	/**
	 * 清除所有元素
	 */
	public void clear(){
		// 使用泛型数组后要注意内存管理(将元素置null)
		for (int i = 0; i < size; i++) {
			elements[i] = null;
		}
		size = 0;
	}
	/**
	 * 扩容操作
	 */
	private void ensureCapacity(int capacity){
		int oldCapacity = elements.length;
		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("size="+oldCapacity+", 扩容到了"+newCapacity);
	}
	/****************封装好的功能函数**************************/
	// 下标越界抛出的异常
	private void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	private void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加元素)
	private void rangeCheckForAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}
	/****************封装好的功能函数***************************/
	@Override
	public String toString() {
		// 打印形式为: size=5, [99, 88, 77, 66, 55]
		StringBuilder string = new StringBuilder();
		string.append("size=").append(size).append(", [");
		for (int i = 0; i < size; i++) {
			if(0 != i) string.append(", ");
			string.append(elements[i]);
		}
		string.append("]");
		return string.toString();
	}
}

测试运行

public static void main(String[] args) {
	ArrayList<Person> list = new ArrayList<>();
	
	list.add(new Person(10, "jack"));
	list.add(new Person(20, "rose"));
	list.add(null);
	list.add(null);
	
	System.out.println("add()添加元素: " + list);
	
	System.out.println("get()获取元素: " + list.get(0));
	
	list.set(0, new Person(99, "ghost"));
	System.out.println("set()设置元素值: " + list);
	
	list.remove(0);
	System.out.println("remove()删除元素: " + list);
	
	list.clear();
	System.out.println("clear()清空数组: " + list);
}

add()添加元素: size=4, [Person [age=10, name=jack], Person [age=20, name=rose], null, null]
get()获取元素: Person [age=10, name=jack]
set()设置元素值: size=4, [Person [age=99, name=ghost], Person [age=20, name=rose], null, null]
remove()删除元素: size=3, [Person [age=20, name=rose], null, null]
clear()清空数组: size=0, []
꙳✧˖
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
数据结构与算法之动态数组的设计与实现
m0_49692893的博客
12-31 371
程序 = 数据结构 + 算法，数据结构在问题解决中主要用来存放要处理的数据与实现算法策略。
c语言数据结构动态数组,C语言数据结构算法——动态数组
weixin_27945229的博客
05-25 365
#include //1.先把所需要的数据信息结构定义下来、struct DynamicArray{//数组存储元素的空间的首地址void **addr;// 存储数据的内存中int capacity; //容量//当前存储数据的内存中有多少个元素int size;//大小};//初始化数组//不推荐使用直接初始化 没有返回值struct DynamicArray * INit_Dynamic...
【数据结构和算法设计】动态数组实现：C++/Java
memcpy0的博客
03-10 374
文章目录一、目标二、数组基础 一、目标 实现一个小型的数据结构库，从0开始用Java实现。包括：数组，栈，队列，链表，二分搜索树，堆，线段树，trie，并查集，AVL，红黑树，哈希表，邻接矩阵，邻接表等。 此外，我还想深入学习一下图论的算法。不过这是在另一个分类专栏中涉及。 二、数组基础 无论是C/C++，还是Java中的数组，都是连续存储的一维线性空间。因为是连续存储的，所以数组拥有索引的特性，...
19-线程安全&非安全容器
titanium的博客
03-14 437
线程安全&非安全容器
Java 设计一个类ArrayBox，比数组更灵活（增删元素时不用纠结长度变化的问题）
Zhangguohao666的博客
04-03 2156
数组的长度是固定的，存储一组元素（但是固定的长度，使用起来不太方便，不太好频繁的添加元素、删除元素） 设计一个类，充当一个小容器 ArrayBox 可以添加元素 获取元素 删除元素 看一看到底有多少个元素 大概功能： 添加元素add() 获取元素get() 删除元素remove() 看元素个数 下面我写了三个类（同包中） Demo.java public class Demo { ...
博文C++数据结构X篇-03-线性表的顺序存储和动态数组案例（基本概念；操作要点；顺序存储算法；动态数组案例实现）配套资源
11-27
C++动态数组的实现源代码
C++线性表与约瑟夫数组_数据结构与算法实验一_艾孜尔江·艾尔斯兰著.zip
01-01
本实验资源内附详细的指导教程和演示案例，通俗易懂，由艾孜尔江·艾尔斯兰亲自实验并撰著而成，均为底层开发，可供研究和学习使用，平时工作中亦可实践，是初学者深入学习数据结构与算法的法宝，基于C++语言实现，...
C++ 数据结构线性表-数组实现
08-30
主要介绍了C++ 数据结构线性表-数组实现的相关资料,需要的朋友可以参考下
数组java代码实现
qq_38900306的博客
01-10 656
public class MyArray { //定义一个数组 private int [] intArray; //定义数组的实际有效长度 private int elems; //定义数组的最大长度 private int length; //默认构造一个长度为50的数组 public MyArray(){ e...
java自定义一个数组类（封装多种方法）
weixin_51373750的博客
02-26 3432
一、自定义数组类的动机 java给定的数组为静态的，我们是无法对齐进行灵活的操作，比如指定位置添加元素，删除元素，判断是否非空等，于是我们便需要利用“面向对象”的设计模式，自定义一个数组类，将这些我们可能需要的方法功能封装进去，使得数组可以灵活进行增删改查判空等操作，即“动态数组”。
添加类_【1/121】从元素中添加或删除类
weixin_29613859的博客
12-25 92
前言本系列是《如何管理HTML DOM》，适用于现代浏览器和IE 11+。正文从这开始~~为元素添加一个类请注意，在IE 11中add方法不支持多个参数。ele.classList.add('class-name');// Add multiple classes (Not supported in IE 11)ele.classList.add('another', 'class', ...
推荐一款结构化数据处理开源库，极大提高开发效率
Java笔记虾
12-24 600
现代Java应用架构越来越强调数据存储和处理分离，以获得更好的可维护性、可扩展性以及可移植性，比如火热的微服务就是一种典型。这种架构通常要求业务逻辑要在Java程序中实现，而不是像传统应用...
8种常用的设计模式(3-1) —— 单例模式之线程同步
Jzandth的博客
10-07 367
回顾多线程的队列和???? 为什么要有队列？因为资源只有一个，如果开启多线程，多个线程同时对于一个资源进行操作，这样得到的各个线程操作之后的资源的值是不可靠、不可用的；并且线程的执行顺序我们是不能控制的，所以最后得到什么结果我们是不能控制的；为了解决这个问题，队列就诞生了，就是让多线程进行排队，一个一个的进行操作，这就解决了哪一个线程先使用资源的问题 有队列了还要????干嘛？因为线程执行的过程我们是不可控的，所以我们不能保证线程执行起来它真的就乖乖地在队列里面等着，而不会干扰正在执行地线程，比如当前A线
线程安全集合 ConcurrentDictionary<TKey, TValue> 类
weixin_30343157的博客
06-04 215
ConcurrentDictionary<TKey, TValue> 类 【表示可由多个线程同时访问的键/值对的线程安全集合。】 支持 .NET Framework 4.0 及以上。 示例代码： class CD_Ctor { // Demonstrates: // ConcurrentDictionary<TKey, ...
线程安全的数据字典Dictionary
xiaogoudiandeng的专栏
01-07 4099
using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Reflection; using System.Runtime; using System.Runtime.InteropServices; using Sy
设计一个类ArrayBox，比数组灵活，不限制长度，提供增删改方法---新手勿喷！
weixin_45020617的博客
07-09 744
//设计一个类 替代数组可以做的事情 能添加 删除 获取元素 public class ArrayBox { //属性 最先的一个容量数组 private static final int chang = 10; private int [] array ; private int size = 0; //记录数组中有效的元素个数 public ArrayBox() { array = new...
java 单例 同步_Java线程同步与单例模式的结合学习
weixin_33622555的博客
02-24 222
最近接触了一个项目的业务，是web客户端执行的备份和还原操作问题，当一个客户端点击了备份或还原操作时，在其它的web客户端则不能同时进行备份或还原，直到第一个客户端执行完全(需要5个小时)，才能进行备份还原操作，并且这个项目是一个重构项目，不能影响之前的业务。在这里我们采用的是线程同步+单例的处理办法来解决的，改最少的代码最终解决问题，自己也好好的学习了一下java线程同步和单例，闲来无事，自己对...
Java中线程安全的加一(+1)操作的三种方式
chenkaibsw的专栏
07-07 8389
1.锁分为乐观锁和悲观锁，悲观锁总是假设每次的临界区操作会产生冲突，如果多个线程同时需要访问临界区资源，就宁可牺牲性能让线程进行等待。而乐观锁，它会假设对资源的访问都是没有冲突的，所有的线程都可以在不停顿的状态下持续执行，如果遇到冲突，乐观锁采用的叫做比较交换（CAS Compare And Swap）来鉴别线程冲突，一旦检测到冲突产生，就尝试当前操作直到没有冲突为止 。 2.锁的必要性： 引...
根据数据元素的总长度len,创建线性表，并在数组中存储数据
最新发布
06-02
好的，我可以给您提供一个简单的示例代码，实现根据数据元素的总长度len创建线性表并在数组中存储数据。请注意，这里假设元素类型为int，数组名称为arr，线性表名称为list。 ```c int len = 5; // 假设元素总长度为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值