Java学习第十一天 数据结构数组

十二类（未包含图结构）

数组

处理数组 增 删 改 查

新建数组

package com.dataStructrue;

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

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

        for (int score:scores){
            System.out.println(score);
        }

        scores[0]=98;
        for (int i = 0; i < scores.length; i++) {
            System.out.println(scores[i]);
        }
    }
}

 

构造函数与数组

package com.dataStructrue;

import sun.font.CreatedFontTracker;

import java.net.BindException;

public class Array2 {

    private int[] data;
    private int size;

    //构造函数，传入数组的容量capacity构造Array2
    public Array2(int capacity) {
        data = new int[capacity];
        size = 0;
    }

    //无参构造函数，默认数组容量capacity=10
    public Array2() {
        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 faild.Array is full.");
        }
        data[size] = e;//最后一位的后一位赋值e
        size++;//数组长度+1
        //add(size,e);调用这个也一样的
    }

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

    //向指定位置添加数组
    public void add(int index, int e) {
        if (size == data.length) {
            throw new IllegalArgumentException("Addlast faild.Array is full.");
        }

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Addlast faild.Require index>=0 and index<=size.");
        }

        for (int i = size - 1; i >= index; i--) {  //size-1代表最后一个元素
            data[i + 1] = data[i];
        }

        data[index] = e;
        size++;
    }

    //在数组中查询与修改元素
    @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(",");
            } else {
                res.append(']');
            }

        }
        return res.toString();
    }

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

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

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

        }
        return false;
    }
    //查找数组中是否有e，如果有，返回索引,如果没有，返回-1
    public int find(int e){
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }

        }
        return -1;
    }

    //从数组中删除元素,并返回删除的元素
    public int remove(int index){
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove faild.Index is illigal..");
        }
        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);
    }
    //查询并删除一个元素
    public void removeElement(int e){
        int index=find(e);
        if(index!=-1){
            remove(index);
        }
    }
}

 

泛型

基本类型与包装类在需要时可以相互转换

package com.dataStructrue;

import sun.font.CreatedFontTracker;

import java.net.BindException;

public class Array3 <E>{

    private E[] data;
    private int size;

    //构造函数，传入数组的容量capacity构造Array2
    public Array3(int capacity) {
        data = (E[])new Object[capacity];//先定义为Object类再强制数据类型转换
        size = 0;
    }

    //无参构造函数，默认数组容量capacity=10
    public Array3 () {
        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 faild.Array is full.");
        }
        data[size] = e;//最后一位的后一位赋值e
        size++;//数组长度+1
        //add(size,e);调用这个也一样的
    }

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

    //向指定位置添加数组
    public void add(int index, E e) {
        if (size == data.length) {
            throw new IllegalArgumentException("Addlast faild.Array is full.");
        }

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Addlast faild.Require index>=0 and index<=size.");
        }

        for (int i = size - 1; i >= index; i--) {  //size-1代表最后一个元素
            data[i + 1] = data[i];
        }

        data[index] = e;
        size++;
    }

    //在数组中查询与修改元素
    @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(",");
            } else {
                res.append(']');
            }

        }
        return res.toString();
    }

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

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

    //查找数组中是否有元素e
    public boolean contain(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {        //这里==改成了equals()  引用比较与值比较
                return true;
            }

        }
        return false;
    }
    //查找数组中是否有e，如果有，返回索引,如果没有，返回-1
    public int find(E e){
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {         //这里==改成了equals()  引用比较与值比较
                return i;
            }

        }
        return -1;
    }

    //从数组中删除元素,并返回删除的元素
    public E remove(int index){
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove faild.Index is illigal..");
        }
        E ret=data[index];
        for (int i = index+1; i < size; i++) {
            data[i-1]=data[i];
        }
        size--;
        //data[size]=null;//loitering objects 闲逛的项目  可以手动去除
        return ret;
    }
    //移除第一个数并返回
    public E removeFirst(){
        return remove(0);
    }
    //移除并返回最后一个数
    public E removeLast(){
        return remove(size-1);
    }
    //查询并删除一个元素
    public void removeElement(E e){
        int index=find(e);
        if(index!=-1){
            remove(index);
        }
    }
}

 

package com.dataStructrue;

public class M {
    public static void main(String[] args){

        Array3<Integer> arr = new Array3(20);  //申明这里用的时泛型中的Integer整型类
        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.removeElement(4);
        System.out.println(arr);
    }
}