java基础---数组的数据结构

最新推荐文章于 2024-08-15 12:41:05 发布
原创 最新推荐文章于 2024-08-15 12:41:05 发布 · 491 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了在Java中自定义数组的实现方法，包括数组的定义、基本操作如增删改查，以及如何使用泛型增强数组的通用性。同时，文章还介绍了动态数组的实现，讨论了在增加和删除元素时如何处理数组空间的动态调整。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

引言

在学习JAVA的基础的时候，我们只是简单的学习了数组的定义和怎么访问数组的元素，而且JAVA内部也替我们实现了数组的基本操作，我们没有过多的去考虑数组底层实现，所以本篇文章主要讲有关于数据结构里面的数组的基本操作，不会利用JAVA数组本身实现的操作，我们自己实现这些内部的底层。

数组的定义

数组是相同类型的 、用一个标识符名称来封装到一起的一个对象序列或基本类型的数据序列；也就是说数组充当一个容器，专门存储同种类型的数据或对象。

数组的使用

声明一个数组：int [] a = new int[10]或者int a[] = new int[10];

通过下标使用： a[0]—>获取数组的第一个元素

数组的基本操作

  1. 数组的定义

    public class MyArray {
	private int[] data;
	private int size;
	//有参构造函数，根据传入参数构造数组的容量
	public MyArray(int cap){
		this.data = new int[cap];
		this.size = 0;
	}
	//无参构造函数,默认数组的容量为10
	public MyArray(){
		this(10);
	}
}

  2. 获取数组的基本数据

    	//获取数组的容量
	public int getCapacity(){
		return this.data.length;
	}
	//获取数组中元素的个数
	public int getSize(){
		return this.size;
	}
	//判断数组是否为空
	public boolean isEmpty(){
		return this.size==0;
    }

  3. 数组的增删改

    /**
	 * 往数组中添加元素
	 * @param index:索引
	 * @param e:添加的元素
	 */
	public void add(int index, int e){
		if(this.size == this.data.length){
			throw new IllegalArgumentException("添加失败，数组已经满了！");
		}
		if(index <0 || index >this.size){
			throw new IllegalArgumentException("添加失败，插入的索引出错！");
		}
		for(int i = this.size; i > index; i--){
			data[i] = data[i-1];
		}
		this.data[index]=e;
		this.size++;
	}
	//往数组首位置添加元素
	public void addFirst(int e){
		this.add(0, e);
	}
	//在所有数组元素后添加元素
	public void addLast(int e){
		this.add(this.size, e);
	}
	//获取index位置的元素
	public int getElement(int index){
		if(index < 0 || index >=this.size){
			throw new IllegalArgumentException("getElement-->index出错！");
		}
		return this.data[index];
	}
	//修改index位置的元素
	public void setElement(int index, int e){
		if(index < 0 || index >=this.size){
			throw new IllegalArgumentException("setElement-->index出错！");
		}
		this.data[index]=e;
	}
	//查找元素e是否在数组中，返回索引
	public int find(int e){
		for(int i =0 ; i< this.size; i++){
			if(this.data[i] == e)return i;
		}
		return -1;
	}
	//查看数组是否包含该元素
	public boolean contains(int e){
		return this.find(e) != -1;
	}
	//删除index元素，并返回删除元素
	public int remove(int index){
		if(index <0 || index >=this.size){
			throw new IllegalArgumentException("删除失败-->index出错");
		}
		int res = this.data[index];
		for(int i = index; i<this.size; i++){
			this.data[i]=this.data[i+1];
		}
		this.size--;
		return res;
	}
	//删除数组第一个元素
	public int removeFirst(){
		return this.remove(0);
	}
	//删除数组最后一个元素
	public int removeLast(){
		return this.remove(this.size-1);
	}

  4. 复写toString方法和测试

    @Override
	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        sb.append('[');
        for(int i = 0 ; i < this.size ; i ++){
            sb.append(this.data[i]);
            if(i != this.size - 1)
                sb.append(", ");
        }
        sb.append(']');
        return sb.toString();
 
	}
	public static void main(String[] args) {
		MyArray arr = new MyArray(20);
        for(int i = 0 ; i < 20 ; i ++)
            arr.addLast(i);
        System.out.println(arr);

        arr.add(1, 100);
        System.out.println(arr);

        arr.addFirst(-1);
        System.out.println(arr);
       
        System.out.println( arr.getElement(4));
        
        arr.setElement(4,50);
        System.out.println(arr);
        
        System.out.println(arr.find(50));
        System.out.println(arr.find(150));
        
        System.out.println(arr.contains(50));
        System.out.println(arr.contains(150));
        
        System.out.println(arr.remove(13));
        System.out.println(arr);
        
        System.out.println(arr.removeFirst());
        System.out.println(arr);
        
        System.out.println(arr.removeLast());
        System.out.println(arr);
	}

  5. 使用泛型

    上述数组的数据结构明显只能存储int类型的属性，并只能对int类型的数据进行操作，没有通用性可言，现在使用泛型来解决我们的问题，与上述的实现有以下的区别。

    • 首先要声明泛型才能使用泛型
    • 增删查改的元素都是泛型
    • 有参构造函数需要进行强制类型转换
    public class ArrayGeneric<E> {
		private E[] data;
		private int size;
		//有参构造函数，根据传入参数构造数组的容量
		public ArrayGeneric(int cap){
			this.data = (E[]) new Object[cap];
			this.size = 0;
		}
		//无参构造函数,默认数组的容量为10
		public ArrayGeneric(){
			this(10);
		}
		//获取数组的容量
		public int getCapacity(){
			return this.data.length;
		}
		//获取数组中元素的个数
		public int getSize(){
			return this.size;
		}
		//判断数组是否为空
		public boolean isEmpty(){
			return this.size==0;
		}
		/**
		 * 往数组中添加元素
		 * @param index:索引
		 * @param e:添加的元素
		 */
		public void add(int index, E e){
			if(this.size == this.data.length){
				throw new IllegalArgumentException("添加失败，数组已经满了！");
			}
			if(index <0 || index >this.size){
				throw new IllegalArgumentException("添加失败，插入的索引出错！");
			}
			
			for(int i = this.size; i > index; i--){
				data[i] = data[i-1];
			}
			this.data[index]=e;
			this.size++;
		}
		//往数组首位置添加元素
		public void addFirst(E e){
			this.add(0, e);
		}
		//在所有数组元素后添加元素
		public void addLast(E e){
			this.add(this.size, e);
		}
		//获取index位置的元素
		public E getElement(int index){
			if(index < 0 || index >=this.size){
				throw new IllegalArgumentException("getElement-->index出错！");
			}
			return this.data[index];
		}
		//修改index位置的元素
		public void setElement(int index, E e){
			if(index < 0 || index >=this.size){
				throw new IllegalArgumentException("setElement-->index出错！");
			}
			this.data[index]=e;
		}
		//查找元素e是否在数组中，返回索引
		public int find(E e){
			for(int i =0 ; i< this.size; i++){
				if(this.data[i] == e)return i;
			}
			return -1;
		}
		//查看数组是否包含该元素
		public boolean contains(E e){
			return this.find(e) != -1;
		}
		//删除index元素，并返回删除元素
		public E remove(int index){
			if(index <0 || index >=this.size){
				throw new IllegalArgumentException("删除失败-->index出错");
			}
			E res = this.data[index];
			for(int i = index; i<this.size; i++){
				this.data[i]=this.data[i+1];
			}
			this.size--;
			return res;
		}
		//删除数组第一个元素
		public E removeFirst(){
			return this.remove(0);
		}
		//删除数组最后一个元素
		public E removeLast(){
			return this.remove(this.size-1);
		}
		// 将数组空间的容量变成newCap大小
	    private void resize(int newCap){
	        E[] newData = (E[])new Object[newCap];
	        for(int i = 0 ; i < size ; i ++)
	            newData[i] = this.data[i];
	        this.data = newData;
	    }

		@Override
		public String toString() {
			StringBuffer sb = new StringBuffer();
			sb.append(String.format("Array: size = %d , cap = %d\n", size, data.length));
	        sb.append('[');
	        for(int i = 0 ; i < this.size ; i ++){
	            sb.append(this.data[i]);
	            if(i != this.size - 1)
	                sb.append(", ");
	        }
	        sb.append(']');
	        return sb.toString();
	 
		}
}

    使用泛型的数组存储的对象的实例

    public class Student {
	private String name;
	private int age;
	
	public Student(String name, int age){
		this.name=name;
		this.age=age;
	}
	@Override
	public String toString() {
		return String.format("Student(name:%s,age:%d)", this.name,this.age);
	}
	public static void main(String[] args) {
		ArrayGeneric<Student> arr = new ArrayGeneric<Student>();
	        arr.addLast(new Student("Tan", 100));
	        arr.addLast(new Student("Ldx", 66));
	        arr.addLast(new Student("AAA", 88));
	        System.out.println(arr);
	}
}

  6. 动态数组的实现

    • 在增加元素的时候，需要判断是否要开辟空间
    • 在删除元素的时候，如果删除的元素过多，导致内存空间利用率低，而选择重新分配空间（进行缩减空间）
    • 除了增加和删除的操作需要做出相应的修改，其他的操作不需要修改（仅上部分代码）
    		/**
		 * 往数组中添加元素
		 * @param index:索引
		 * @param e:添加的元素
		 */
		public void add(int index, E e){
			if(index <0 || index >this.size){
				throw new IllegalArgumentException("添加失败，插入的索引出错！");
			}
			//扩容
			if(this.size == this.data.length){
				this.resize(this.getCapacity()*2);
			}
		
			for(int i = this.size; i > index; i--){
				data[i] = data[i-1];
			}
			this.data[index]=e;
			this.size++;
		}
		//删除index元素，并返回删除元素
		public E remove(int index){
			if(index <0 || index >=this.size){
				throw new IllegalArgumentException("删除失败-->index出错");
			}
			E res = this.data[index];
			for(int i = index; i<this.size-1; i++){
				this.data[i]=this.data[i+1];
			}
			this.size--;
			this.data[size]=null;
			if(this.size <= this.data.length/2)this.resize(this.data.length/2);
			return res;
		}
		// 将数组空间的容量变成newCap大小
		private void resize(int newCap){
			E[] newData = (E[])new Object[newCap];
			for(int i = 0 ; i < size ; i ++)
		        newData[i] = this.data[i];
		    this.data = newData;
		}
Java数据结构和算法(二)——数组
iaiti的专栏
09-23 1万+
Java数据结构和算法(二)——数组
Java基础-----数组和数据存储
qq_48788523的博客
12-03 687
关于数组,你知道吗?
Java数据结构数组
Madridcrls7的博客
08-02 494
数组 自定义数组类MyOrderArray实现数组的增删改查 public class MyOrderArray { private long [] arr; private int elements; //表示数组的有效数据的个数 public MyOrderArray(){ arr=new long[50]; //设置长度为50 } public MyOrderA...
java数据结构-数组详解
weixin_42139800的博客
12-09 785
java数据结构之数组详解开篇说明数组Arrays类 开篇说明 上篇详细总结了字符串的使用String详解，很多都是边看源码边总结的，印象非常深刻。建议大家在学习时也要敲代码记笔记，真的比单看这些文章有用多啦～ 这篇开始记录数组，会涉及数组与其他数据结构的转换，常用方法、底层原理等等。每天进步一点点，冲鸭！！！ 现在是12月6日晚上10.42，这会儿我的一个舍友在播放“改革春风吹满地，中国人民真争气”这首歌，刚刚加班回来一直在唱，虽然有点烦，但是大家都是程序猿，也能理解压力，哈哈哈我现在也被稍稍洗脑了???
数据结构——数组篇java版（完整+简洁+通俗易懂）
guo214214的博客
08-15 2370
讲解通俗易懂，适合初学的小白、复习巩固的老手。如果您准备刷力口，也可以看一下这篇文章，里面包含数组大量的方法，会让您做题更加得心应手。
java之数组
weixin_30243533的博客
11-04 375
数组概述： 1、数组可以看成是多个相同数据类型数据的组合，对这些数据的统一管理。 2、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 3、数组中的元素可以是任何类型，包括基本类型和引用类型。 一维数组的声明： 1、一维数组的声明方式： type var[]; 或type[] var; 例如: int a1[]; int[] a2; ...
04-Java基础-第4天（数组switch语句）-讲义共
11-21
【Java基础】数组与switch语句是Java编程中的核心概念，它们在实际开发中有着广泛的应用。本讲义主要探讨这两个关键知识点，并结合实例进行深入解析。 数组在Java中是存储相同类型数据集合的一种方式，它允许我们一...
Python-100-Days-java入门 - 数组基础
03-15
数组是一个可以存储一系列相同类型元素的数据结构，在Java中，数组的长度一旦确定就不能改变。对于初学者而言，理解数组的定义、初始化、元素访问、遍历和修改等基础知识至关重要。这些基础知识不仅能够帮助初学者...
JavaKeeper-java入门 - 数组基础
最新发布
03-15
对于初学者来说，掌握Java基础知识至关重要，其中数组作为基本的数据结构，是学习Java不可或缺的部分。JavaKeeper-java入门-数组基础，主要涵盖了数组的定义、声明、初始化、使用、特点等核心知识点。 一、数组定义...
blog-java入门 - 数组基础
03-15
数组是Java编程中一个非常基础且重要的概念，它是用于存储一系列类型相同的数据结构。理解数组的使用对于每一个Java入门者来说是至关重要的一步。 在Java中，数组可以被视为一个对象，其具有固定大小，一旦创建，其...
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
Java-数据结构-数组
weixin_45532984的博客
08-05 913
数组是在程序设计中，把具有相同类型的若干元素按有序的形式组织起来的一种形式。数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素。 数组作为线性表的实现方式之一，数组中的元素在内存中是连续存储的，且每个元素占相同大小的内存。...............
数据结构之数组（Java）
weixin_50637583的博客
03-01 482
自身的特点 内存数据的连续性，申请的内存空间也是连续性的 数组内都是相同的数据类型 适合解决的问题 随机访问 （根据下标） 时间复杂度 根据下标随机访问，时间复杂度为 O(1) 不根据下标访问，时间复杂度不确定，一个一个找时间复杂度为 O(n)，二分查找O(logn) 不适合的场景（一定要保证数据的连续性） 插入 有序数组 最好的时间复杂度 O(1) ，末尾插入，不需要移动数据插入 最坏的时间复杂度O(n) , 开头插入，所有...
Java版-数据结构-数组
weixin_34400525的博客
03-11 195
数组知识点回顾 声明Java数组时，会在内存中开辟一块连续指定大小的空间，用来存储固定大小的同类型元素 在java中定义个名为scores，长度为8，类型为int类型的数组如下： public static void main(String[] args) { int[] scores = new int[8]; } 复制代码为了便于理解，我们看下它在内存的中的分布示意图： 图中的一个个...
java数组数据结构_数据结构---Java---数组
weixin_34688479的博客
02-16 234
**************************************************************前言**********************************************************1、在Java中，数组是一种引用数据类型；数组的 引用变量 与 数组元素分别存储于 栈内存、堆内存中；只能通过 数组的 引用变量 来访问...
JAVA数据结构之数组详细教程
韩韩的博客
04-12 866
本文整理了java数据结构的数组操作。希望对刚入门数据结构的同志们有帮助。 java数组非常简单。只要有JAVA语言基础就可以看这篇博文。大家不要害怕。。。非常简单。。 整理博客真的很花费时间，如果对大家有帮助，麻烦点赞评论，让我有动力继续更新下去，谢谢大家。 数组基础 数组的结构如下： 我们在存数据的时候，存在数组里面，以索引来读取数据。可以通过数组名【索引】的形式访问。每一个格子都存放一个数据...
Java数组的数据结构
peanut的博客
02-08 1272
1.Java一维数组与内存结构 数组是相同类型变量的结合，可以通过下标来访问数组 一维数组 连续的内存 第一个元素下标为0 创建方式 int array[]=new int[10];//一旦指定长度就不可以再改变 int [] array={1,2,3,4}; 2.一维数组常见的操作 定义数组 int [] array1=new int [5]; int [] array2=...
Java数据结构之数组
沉淀~成长
03-23 322
一直以来，对Java的泛型都是似懂非懂的状态，近来决定好好研究一下。ok,接下来，我们直奔主题。 Part1，泛型的简单使用 看一个类上的泛型定义。 public interface Test{ T get(); void set(T t); } 这里的T呢，就代表某一个具体的类型。我们可以实现该接口. public class Str
java 数组 数据结构_数据结构-JAVA实现数组
weixin_39621379的博客
02-16 222
这篇文章是展示如何使用JAVA语言实现Array这种数据结构。​1.整型数组的实现public class Array {private int[] data;private int size;/*** 构造函数，传入数组的容量 capacity 构造 Array* @param capacity*/public Array(int capacity){data = new int[capacit...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值