线性数据结构-----数组（Java）

最新推荐文章于 2023-02-24 15:24:28 发布
最新推荐文章于 2023-02-24 15:24:28 发布
阅读量250 收藏
点赞数
分类专栏： Java 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40928946/article/details/90478323
版权

1.数组

（1）定义：相同数据类型的数据的集合(可以重复可以无序固定容量capacity)

eg: {1,2,3,4,5,6,4,2,2}

（2）举例：

package cn.ArrayTest;

public class Main {
	public static void main(String[] args) {
		int[] arr = new int[10];             //声明数组1
		for(int i=0; i<arr.length; i++){
			System.out.println(arr[i] = i);
		}
		
		int [] scores = new int [] {100, 99, 88};//声明数组2
		for(int i=0; i<scores.length; i++){
			System.out.println(scores[i]);
		}
		
	}

}

（3）数组理解

 （4）优点与缺点

快速查询    scores[2]

增删效率低

（5）增删改查

基本变量：数据元素--data    数组容量--capacity    元素索引--size

package cn.ArrayTest;

public class Array {
	//定义变量
	private int[] data;
	private int size;
	//构造函数 传入数组容量capacity构造Array
	public Array(int capacity){
		data = new int [capacity];
		size = 0;
	}
	//无参构造函数，默认数组容量为capacity=10
	public Array(){
		this(10);
	}
	//获取数组元素个数吧
	public int getSize(){
		return size;
	}
	//获取数组容量
	public int getCapacity(){
		return data.length;
	}
	//返回数组是否为空
	public boolean isEmpty(){
		return size == 0;
	}
	public static void main(String[] args) {
		
	}
}

 数组尾部添加元素

	//想数组元素后添加一个新元素
	public void addLast(int e){
		if(size == data.length){
			throw new IllegalArgumentException("AddLast failed, Array si full.");
		}
			
		data[size] = e;
		size++;
	}

向指定位置添加元素：向指定位置添加元素和之后元素都向后挪一位，即把最后一个元素向后挪一位，依次直到指定索引位置为空为止, 再size++

	//在第index个位置插入新元素e
	public void add(int index, int e){
		if(size == data.length)
			throw new IllegalArgumentException("Add failed, Array is full.");
		if(index < 0 || index > size)
			throw new IllegalArgumentException("Add failed, require index >= 0 and index <size .");
		for(int i = size-1; i >= index; i--)
			data[i+1] = data[i];
		data[index] = e;
		size++;	
	}
	

package cn.ArrayTest;

public class Array {
	//定义变量
	private int[] data;
	private int size;
	//构造函数 传入数组容量capacity构造Array
	public Array(int capacity){
		data = new int [capacity];
		size = 0;
	}
	//无参构造函数，默认数组容量为capacity=10
	public Array(){
		this(10);
	}
	//获取数组元素个数吧
	public int getSize(){
		return size;
	}
	//获取数组容量
	public int getCapacity(){
		return data.length;
	}
	//返回数组是否为空
	public boolean isEmpty(){
		return size == 0;
	}
	//想数组元素后添加一个新元素
	public void addLast(int e){
		if(size == data.length){
			throw new IllegalArgumentException("AddLast failed, Array is full.");
		}
			
		data[size] = e;
		size++;
	}
	//在所有元素前添加一个新元素
	public void addFirst(int e){
		add(0,e);
	}
	
	//在第index个位置插入新元素e
	public void add(int index, int e){
		if(size == data.length)
			throw new IllegalArgumentException("Add failed, Array is full.");
		if(index < 0 || index > size)
			throw new IllegalArgumentException("Add failed, require index >= 0 and index <size .");
		for(int i = size-1; i >= index; i--)
			data[i+1] = data[i];
		data[index] = e;
		size++;	
	}
	//获取index索引位置的元素
	int get(int index){
		if(index<0 || index>= size){
			throw new IllegalArgumentException("get failed, Index is illegal.");
		}
		return data[index];
	}
	//修改index索引位置的元素为e
	void set (int index, int e){
		if(index<0 || index>= size){
			throw new IllegalArgumentException("get failed, Index is illegal.");
		}
		data[index] = e;
	}
	
	@Override
	public String toString(){
		StringBuilder res = new StringBuilder();
		res.append(String.format("Array: size = %d, capacity = %d\n",size,data.length));
		res.append('[');
		for(int i = 0; i < size; i++){
			res.append(data[i]);
			if(i != size - 1)
				res.append(", ");
		}
		res.append(']');
		return res.toString();
		
	}

}

package cn.ArrayTest;

public class Main {
	public static void main(String[] args) {
//		int[] arr = new int[10];             //声明数组1
//		for(int i=0; i<arr.length; i++){
//			System.out.println(arr[i] = i);
//		}
//		
//		int [] scores = new int [] {100, 99, 88};//声明数组2
//		for(int i=0; i<scores.length; i++){
//			System.out.println(scores[i]);
//		}
//		
		Array arr = new Array(20);
		for(int i = 0; i < 10; i++)
			arr.addLast(i);
		System.out.println(arr);
		arr.add(1, 100);
		System.out.println(arr);
		arr.addFirst(-1);
		System.out.println(arr);
		
	}

}

 数组中的包含、搜索和删除元素

删除的理解：删除索引为3的元素，即将索引为4的元素挪到所因为3的位置，再size--

	//查找数组中是否有元素e
	public boolean contains(int e){
		for(int i=0; i < size; i++){
			if(data[i]==e)
				return true;
		}
		return false;
	}
	//删除索引index的元素,返回删除元素
	public int remove(int index){
		if(index < 0 || index > size)
			throw new IllegalArgumentException("Add failed, require index >= 0 and index <size .");
		int ret = data[index];
		for(int i= index+1; i< size;i++)
			data[i-1]=data[i];
		size--;
		return ret;
	}
	//删除数组中第一个元素，返回删除元素
	public int removeFirst(){
		return remove(0);
	}
	//删除数组最后一个元素，返回删除的元素
	public int removeLast(){
		return remove(size-1);
	}
	
	//从数组中删除元素e
	public void removeElement(int e){
		int index = find(e);
		if(index != -1)
			remove(index);
	}
	
	public int find(int e){
		for(int i=0; i < size; i++){
			if(data[i]==e)
				return i;
		}
		return -1;
	}
	
package cn.ArrayTest;

public class Array {
	//定义变量
	private int[] data;
	private int size;
	//构造函数 传入数组容量capacity构造Array
	public Array(int capacity){
		data = new int [capacity];
		size = 0;
	}
	//无参构造函数，默认数组容量为capacity=10
	public Array(){
		this(10);
	}
	//获取数组元素个数吧
	public int getSize(){
		return size;
	}
	//获取数组容量
	public int getCapacity(){
		return data.length;
	}
	//返回数组是否为空
	public boolean isEmpty(){
		return size == 0;
	}
	//想数组元素后添加一个新元素
	public void addLast(int e){
		if(size == data.length){
			throw new IllegalArgumentException("AddLast failed, Array is full.");
		}
			
		data[size] = e;
		size++;
	}
	//在所有元素前添加一个新元素
	public void addFirst(int e){
		add(0,e);
	}
	
	//在第index个位置插入新元素e
	public void add(int index, int e){
		if(size == data.length)
			throw new IllegalArgumentException("Add failed, Array is full.");
		if(index < 0 || index > size)
			throw new IllegalArgumentException("Add failed, require index >= 0 and index <size .");
		for(int i = size-1; i >= index; i--)
			data[i+1] = data[i];
		data[index] = e;
		size++;	
	}
	//获取index索引位置的元素
	int get(int index){
		if(index<0 || index>= size){
			throw new IllegalArgumentException("get failed, Index is illegal.");
		}
		return data[index];
	}
	//修改index索引位置的元素为e
	void set (int index, int e){
		if(index<0 || index>= size){
			throw new IllegalArgumentException("get failed, Index is illegal.");
		}
		data[index] = e;
	}
	//查找数组中是否有元素e
	public boolean contains(int e){
		for(int i=0; i < size; i++){
			if(data[i]==e)
				return true;
		}
		return false;
	}
	//删除索引index的元素,返回删除元素
	public int remove(int index){
		if(index < 0 || index > size)
			throw new IllegalArgumentException("Add failed, require index >= 0 and index <size .");
		int ret = data[index];
		for(int i= index+1; i< size;i++)
			data[i-1]=data[i];
		size--;
		return ret;
	}
	//删除数组中第一个元素，返回删除元素
	public int removeFirst(){
		return remove(0);
	}
	//删除数组最后一个元素，返回删除的元素
	public int removeLast(){
		return remove(size-1);
	}
	
	//从数组中删除元素e
	public void removeElement(int e){
		int index = find(e);
		if(index != -1)
			remove(index);
	}
	
	public int find(int e){
		for(int i=0; i < size; i++){
			if(data[i]==e)
				return i;
		}
		return -1;
	}
	
	@Override
	public String toString(){
		StringBuilder res = new StringBuilder();
		res.append(String.format("Array: size = %d, capacity = %d\n",size,data.length));
		res.append('[');
		for(int i = 0; i < size; i++){
			res.append(data[i]);
			if(i != size - 1)
				res.append(", ");
		}
		res.append(']');
		return res.toString();
		
	}

}

（6）使用泛型

package cn.ArrayTest;

public class Array<E> {
	//定义变量
	private E[] data;
	private int size;
	//构造函数 传入数组容量capacity构造Array
	public Array(int capacity){
		data = (E[]) new Object[capacity];
		size = 0;
	}
	//无参构造函数，默认数组容量为capacity=10
	public Array(){
		this(10);
	}
	//获取数组元素个数吧
	public int getSize(){
		return size;
	}
	//获取数组容量
	public int getCapacity(){
		return data.length;
	}
	//返回数组是否为空
	public boolean isEmpty(){
		return size == 0;
	}
	//想数组元素后添加一个新元素
	public void addLast(E e){
		if(size == data.length){
			throw new IllegalArgumentException("AddLast failed, Array is full.");
		}
			
		data[size] = e;
		size++;
	}
	//在所有元素前添加一个新元素
	public void addFirst(E e){
		add(0,e);
	}
	
	//在第index个位置插入新元素e
	public void add(int index, E e){
		if(size == data.length)
			throw new IllegalArgumentException("Add failed, Array is full.");
		if(index < 0 || index > size)
			throw new IllegalArgumentException("Add failed, require index >= 0 and index <size .");
		for(int i = size-1; i >= index; i--)
			data[i+1] = data[i];
		data[index] = e;
		size++;	
	}
	//获取index索引位置的元素
	public E get(int index){
		if(index<0 || index>= size){
			throw new IllegalArgumentException("get failed, Index is illegal.");
		}
		return data[index];
	}
	//修改index索引位置的元素为e
	void set (int index, E e){
		if(index<0 || index>= size){
			throw new IllegalArgumentException("get failed, Index is illegal.");
		}
		data[index] = e;
	}
	//查找数组中是否有元素e
	public boolean contains(E e){
		for(int i=0; i < size; i++){
			if(data[i].equals(e))
				return true;
		}
		return false;
	}
	//删除索引index的元素,返回删除元素
	public E remove(int index){
		if(index < 0 || index > size)
			throw new IllegalArgumentException("Add failed, require index >= 0 and index <size .");
		E ret = data[index];
		for(int i= index+1; i< size;i++)
			data[i-1]=data[i];
		size--;
		data[size]=null;
		return ret;
	}
	//删除数组中第一个元素，返回删除元素
	public E removeFirst(){
		return remove(0);
	}
	//删除数组最后一个元素，返回删除的元素
	public E removeLast(){
		return remove(size-1);
	}
	
	//从数组中删除元素e
	public void removeElement(E e){
		int index = find(e);
		if(index != -1)
			remove(index);
	}
	
	public int find(E e){
		for(int i=0; i < size; i++){
			if(data[i].equals(e))
				return i;
		}
		return -1;
	}
	
	@Override
	public String toString(){
		StringBuilder res = new StringBuilder();
		res.append(String.format("Array: size = %d, capacity = %d\n",size,data.length));
		res.append('[');
		for(int i = 0; i < size; i++){
			res.append(data[i]);
			if(i != size - 1)
				res.append(", ");
		}
		res.append(']');
		return res.toString();
		
	}

}


package cn.ArrayTest;

public class Main {
	public static void main(String[] args) {
//		int[] arr = new int[10];             //声明数组1
//		for(int i=0; i<arr.length; i++){
//			System.out.println(arr[i] = i);
//		}
//		
//		int [] scores = new int [] {100, 99, 88};//声明数组2
//		for(int i=0; i<scores.length; i++){
//			System.out.println(scores[i]);
//		}
//		
		Array<Integer> arr = new Array<Integer>(20);
		for(int i = 0; i < 10; i++)
			arr.addLast(i);
		System.out.println(arr);
		arr.add(1, 100);
		System.out.println(arr);
		arr.addFirst(-1);
		System.out.println(arr);
		arr.remove(3);
		System.out.println(arr);
		arr.removeElement(8);
		System.out.println(arr);
		
		
		
	}

}

注意：前后变化<E>    <Integer>

 

 

 

 

 

 

 

 

 

 

风气又波
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-javascript-研究
02-26
在JavaScript中，虽然不像C++或Java那样有内置的数据结构库，但理解并掌握各种数据结构能帮助开发者编写出更高效、更易维护的代码。本研究将深入探讨JavaScript中的数据结构，包括其基本类型、对象、数组、链表、栈...
线性结构-数组
强我强国
05-09 1210
这两种定义方式是等价的，不过第一种更符合Java的编程规范。上面只是声明了一个引用变量array，其本质还是一个指针，而数组本身并不存在，也就是说在内存中还没有开辟那段连续的存储空间。要使用数组，必须先对数组进行初始化。Java中初始化数组有两种方法：静态初始化和动态初始化。静态初始化：定义数组时显式地指定数组的初始值，系统会根据初始值的个数和类型自动为数组在堆内存中开辟空间。//定义数组和初始化数组同时完成 int [ ] array1 = {
C语言最常见的线性结构---数组
Nwk0000000001的博客
07-11 968
C语言最常见的线性结构—数组 数组详解 数组定义:有序数据的集合,用数组名作为标识 数组性质:数组是由一些列相同数据类型组成的线性集合 数组组成：标识符、类型名、维数。其中，维数指定数组中的元素个数。 数组优缺点: 1）与vector类型相比，数组缺陷在于：数组的长度是固定的，不能知晓数组的长度。同时没有size和push_back操作。如果要更改长度，则要创建更大的新数组，再复制原数组的所有元素。 注:vector是C++中的STL容器的一个容器分支,属于动态数组内容 2）数组是被严格限制
[数据结构与算法] 线性表之数组详解
淋曦的进击手记
08-13 1078
数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。
[数据结构]
yc_Cabbage的博客
08-10 272
数据结构
java 线性数组_Java数据结构-线性结构数组（Array）详解
weixin_35427210的博客
02-18 328
一、概述Java中的数组是一种聚合数据类型，是将具有相同类型的若干变量有序地组织在一起的集合。数组可以说是最基本的数据结构，在各种编程语言中都有对应。一个数组可以分解为多个数组元素，按照数据元素的类型，数组可以分为整型数组、字符串数组、浮点型数组、对象数组等。数组还可以分为一维、二维及多维等表现形式。二、数组的优点数组的最大好处就是能都给存储进来的元素自动进行编号.注意编号是从0开始。方便操作这...
Java-Java数据结构二十讲
10-25
链表作为另一种线性数据结构，与数组相比提供了更大的灵活性。单链表、双链表和循环链表各有特点，它们在处理动态数据集合时表现优秀，如Java中的LinkedList类。 递归是编程中的一个强大工具，它通过函数自身调用来...
Java学习资料-数组
06-15
Java中的数组是编程中不可或缺的基础概念，主要用于存储一组...总之，Java数组提供了一种高效、有序的方式来存储和操作一组相同类型的数据，是编程中常用的数据结构。理解和熟练使用数组是掌握Java编程的关键步骤之一。
数据结构--算法相关.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
数据结构-Java
02-14
数组是最基本的线性数据结构，它是一组相同类型元素的集合，通过索引进行访问。Java中，数组可以通过声明`int[] array = new int[10];`来创建。此外，ArrayList和LinkedList是两种常用的动态数组，它们都实现了List...
java线性数组实现学生信息管理
02-25
通过线性数组来储存学生信息，实现了对学生信息的管理，增删改查。
线性数据结构：数组 Array
qq_63815371的博客
02-24 631
数组是数据结构还是数据类型？数组只是个名称，它可以描述一组操作，也可以命名这组操作。数组的数据操作，是通过 idx->val 的方式来处理。它不是具体要求内存上要存储着连续的数据才叫数组，而是说，通过连续的索引 idx，也可以线性访问相邻的数据。那么当你定义了数据的存储方式，也就定义了数据结构。所以它也是被归类为数据结构。
Java基础篇：数组
热门推荐
张维鹏的博客
10-10 3万+
数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。 在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长
Java数据结构-线性结构数组（Array）详解
weixin_34388207的博客
12-14 176
2019独角兽企业重金招聘Python工程师标准>>> ...
（一）线性数组的数据结构和算法
天道酬勤
08-25 3605
 一、数据结构描述：1.       插入操作：对于一般数组（不包括有序数组）而言，插入一个元素，即在数组的最后面添加一项。当然，我们这里讨论的并不全面，因为一个数组的长度定义以后就不能再改变。所以，在添加数据项时，还要保证没有超过数组的长度限制。一旦超过了数组容量，就会报错ArrayIndexOutOfBoundsException。所以，对于长度固定的数组而言，并不适用于实际应用中的所
java线性数组集合_Java集合类快速了解
weixin_42299801的博客
02-28 192
常用的数据结构数组数组和链表都是线性表结构，数组在内存中是一串连续的内存空间，比如定义一个 int 类型数组，int[] array = new int[6]，计算机会为 array 分配一块连续的空间。链表链表是一种最常见的数据结构，其内部数据呈线性排列，属于线性表结构，什么是线性表？表中的数据按顺序依次排列，就像用一条线把数据串联起来一样。问数组和链表有什么区别?数组会在内存当中开辟一块连续的...
java数据结构之线性结构和非线性结构
不一样的花朵的博客
06-09 9296
数据结构包括 ：线性结构和非线性结构。 线性结构 1）：线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 2）：线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表， 顺序表中的存储元素是连续的。 3）：链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。 4）：线性结构常见的有：数组、队...
java实现线性表（数组实现）
u010943460的专栏
08-31 1148
今天复习数据结构的线性表 ，
线性结构之数组
JAVE_LOVER
07-17 2204
数组        把所有节点用一根直线串起来而形成的一种数据结构称为线性结构。        今天我想谈谈线性结构中的数组。大家都知道数组是连续存储的一种线性结构，而数组名为该数组元素的首地址。如int a[3]={1,2,3};a就等价于&a[0],而&a[0]本身是int *类型，所以我们通常利用数组名来与指针建立联系，进而跨函数使用内存对数组进行操作。   实例说明： #incl
模板实现顺序线性表 - Java数据结构基础
"Java数据结构课程，通过模板类实现顺序表示的线性表，由计算机科学与技术学院张宏讲解，涵盖了数据结构的基础概念、算法分析等知识点。" 在计算机科学中，数据结构是编程中至关重要的一部分，它涉及到如何有效地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值