1. 首页
  2. 文章中心
  3. java

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

65 阅读 0 评论
我是靠谱客的博主 鲜艳高山，最近开发中收集的这篇文章主要介绍java基础---数组的数据结构，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

引言

在学习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 = %dn", 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 = %dn", 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基础---数组的数据结构的全部内容，希望文章能够帮你解决java基础---数组的数据结构所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(43)

相关文章

PHP数组的底层结构PHP数组PHP5的数组PHP7的数组映射函数哈希碰撞插入、查找、删除扩容重建散列表
PHP数组的底层结构PHP数组PHP5的数组PHP7的数组映射函数哈希碰撞插入、查找、删除扩容重建散列表
Java两种基本的数据结构：数组和链表
Java两种基本的数据结构：数组和链表
聊聊PHP数组底层是如何实现的
聊聊PHP数组底层是如何实现的
JavaScript中shift() 方法
JavaScript中shift() 方法
java基础---数组的数据结构
java基础---数组的数据结构
JavaScript-map手写原理
JavaScript-map手写原理
数组的底层实现
数组的底层实现
javascript 数组原理
javascript 数组原理

评论列表共有 0 条评论

立即
投稿
返回
顶部