【数据结构与算法】Java制作一个简单数组类

bobo老师的玩转算法系列–玩转数据结构 简单记录

文章目录

• 不要小瞧数组 - 制作一个数组类
• 1 、使用Java中的数组
• 数组基础
• 简单使用
• 2、二次封装属于我们自己的数组
• 数组基础
• 制作属于我们自己的数组类
• 简单定义Array类
• 3、向数组中添加元素
• 向数组末添加元素e
• 在特定的位置插入一个新元素e
• 复用add
• 2-4 数组中查询元素和修改元素
• toString
• 获取index索引位置的元素
• 修改index索引位置的元素为e
• Test 测试
• 5、包含，搜索和删除
• 删除指定index位置的元素,返回删除的元素
• 删除指定元素e
• 从数组中删除第一个元素，返回删除的元素
• 从数组中删除最后一个元素，返回删除的元素
• 查找数组中是否有元素e
• 查找数组中元素e所在的索引，如果不存在元素e,则返回-1
• Array 类
• Test 测试

不要小瞧数组 - 制作一个数组类

1 、使用Java中的数组

数组基础

• 把数据码成一排进行存放

• 数组名最好要有语义 如： scores

• 索引从零开始 0 1 2 3 4 5

• 数组N个元素 数组最后一个索引 N - 1

简单使用

Array

public class Main {

    public static void main(String[] args) {
        int[] arr = new int[20];
        for (int i = 0; i < arr.length; i++)
            arr[i] = i;

        int[] scores = new int[]{100, 99, 98};
        for (int i = 0; i < scores.length; i++)
            System.out.println(scores[i]);
        
        for(int score: scores)
            System.out.println(score);
    }

}

2、二次封装属于我们自己的数组

数组基础

• 索引可以有语意，也可以没有语意。

• 数组最大的优点：快速查询。scores[1] 指定索引查询对应的值

• 数组最好应用于“索引有语意”的情况。

• 但并非所有有语意的索引都适用于数组

• 数组也可以处理“索引没有语意的“

• 这一章主要处理“索引没有语意的“的情况数组的使用

• 数组创建已经固定了

制作属于我们自己的数组类

• 索引没有语意，如何表示没有元素呢？
• 如何添加元素？如何删除元素？
• …
• 基于java的数据，二次封装属于我们自己的数组类

不同的数据结构增删改查是截然不同的，甚至有些数据结构可能会忽略这四个中的某个一个动作。

数组 容量 capacity

数组中最多可以装多少个元素和实际装了多少个元素是没有关系的 ，两回事。

size 数组中的元素个数

简单定义Array类

Array类

/** 
 * @create 2019-11-14 21:27
 */
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;
    }
}

3、向数组中添加元素

向数组末添加元素e

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

在特定的位置插入一个新元素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 ++;
    }

复用add

	//向所有元素后添加一个新元素
    public void addLast(int e){
        add(size,e);
    }
    //在所有元素前添加一个新元素
    public void addFirst(int e){
        add(0,e);
    }

2-4 数组中查询元素和修改元素

toString

@Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d ,capacity = %d
", 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();
    }

获取index索引位置的元素

 //获取index索引位置的元素
    int get(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed.Index is illegal");
        return data[index];
    }

修改index索引位置的元素为e

// 修改index索引位置的元素为e
    void set(int index, int e){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed.Index is illegal");
        data[index] = e;
    }

Test 测试

Main类

public class Main {

    public static void main(String[] args) {

        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);

        System.out.println(arr.get(0));
        arr.set(0,100);
        System.out.println(arr.get(0));
    }

}

结果：

Array: size = 10 ,capacity = 20
[0,1,2,3,4,5,6,7,8,9]
Array: size = 11 ,capacity = 20
[0,100,1,2,3,4,5,6,7,8,9]
Array: size = 12 ,capacity = 20
[-1,0,100,1,2,3,4,5,6,7,8,9]
-1
100

5、包含，搜索和删除

删除指定index位置的元素,返回删除的元素

//从数组中删除index位置的元素，返回删除的元素
    public  int remove(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed.Index is illegal");
        int ret = data[index];
        for (int i = index + 1; i < size; i ++ ){
            data[i-1] = data[i];
        }
        size --;
        return ret;
    }

删除指定元素e

//从数组中删除元素e
    public void removeElemet(int e){
        int index = find(e);
         if (index != -1){
             remove(index);
         }
    }

从数组中删除第一个元素，返回删除的元素

 // 从数组中删除第一个元素，返回删除的元素
    public  int removeFirst(){
        return remove(0);
    }

从数组中删除最后一个元素，返回删除的元素

// 从数组中删除最后一个元素，返回删除的元素
    public int removeLast(){
        return remove(size-1);
    }

查找数组中是否有元素e

//查找数组中是否有元素e
    public boolean contains(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

查找数组中元素e所在的索引，如果不存在元素e,则返回-1

//查找数组中元素e所在的索引，如果不存在元素e,则返回-1
    public int find(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

Array 类

/**
 * @author Liu Awen Email:willowawen@gmail.com
 * @create 2019-11-14 21:27
 */
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) {
        add(size, e);
    }

    //在所有元素前添加一个新元素
    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索引位置的元素
    public int get(int index) {
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed.Index is illegal");
        return data[index];
    }

    // 修改index索引位置的元素为e
    public 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;
    }

    //查找数组中元素e所在的索引，如果不存在元素e,则返回-1
    public int find(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }
    //从数组中删除index位置的元素，返回删除的元素
    public  int remove(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Get failed.Index is illegal");
        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 removeElemet(int e){
        int index = find(e);
         if (index != -1){
             remove(index);
         }
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d ,capacity = %d
", 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();
    }
}

Test 测试

public class Main {

    public static void main(String[] args) {

        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);
        // [-1,0,100,1,2,3,4,5,6,7,8,9]
        arr.remove(2);
        System.out.println(arr);
        arr.removeElemet(4);
        System.out.println(arr);
        arr.removeFirst();
        System.out.println(arr);
        System.out.println("数组arr是否存在0元素" + arr.contains(0));
        System.out.println("元素0的索引为" + arr.find(0));
    }

}

result：

Array: size = 10 ,capacity = 20
[0,1,2,3,4,5,6,7,8,9]
Array: size = 11 ,capacity = 20
[0,100,1,2,3,4,5,6,7,8,9]
Array: size = 12 ,capacity = 20
[-1,0,100,1,2,3,4,5,6,7,8,9]
Array: size = 11 ,capacity = 20
[-1,0,1,2,3,4,5,6,7,8,9]
Array: size = 10 ,capacity = 20
[-1,0,1,2,3,5,6,7,8,9]
Array: size = 9 ,capacity = 20
[0,1,2,3,5,6,7,8,9]
数组arr是否存在0元素true
元素0的索引为0