java简单实现数组的增删改查方法

时间:2021-12-19 05:56:26

1.一维数组​

概念:一组数据的容器(数组可以存放多个数据)

​ 注意:

​ 1.数组是引用数据类型

​ 2.数组中的数据又叫做元素

​ 3.每个元素都有编号叫做下标/索引

​ 4.下标从0开始

​ 5.数组初始化后,会在内存中开辟一连串连续的空间

​ 6.数组一旦初始化后长度不可以改变(数组没有扩容和删除)

​ 7.数组的操作:添加、修改、查询​

​ 数组的声明:数据类型[] 数组名;​

数组的初始化:

​ 静态初始化:数据由程序员指定,长度由系统分配

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static void main(String[] args){
        //静态初始化1
        //String[] names = new String[]{"小明","小红","铁蛋","二狗","大*"};
        //静态初始化2
        //String[] names;
        //names = new String[]{"小明","小红","铁蛋","二狗","大*"};
        //静态初始化3
        String[] names = {"小明","小红","铁蛋","二狗","大*"};
        //设置指定下标上的元素
        names[3] = "大狗";
        //获取指定下标上的元素
        String n = names[3];
        System.out.println("获取指定下标上的元素:" + n);//林成
        //ArrayIndexOutOfBoundsException - 数组下标越界异常
        //System.out.println(names[100]);
        //获取元素个数
        int len = names.length;
        System.out.println("获取元素个数:" + len);//5
        System.out.println("-----------");
        //遍历 - for循环
        for(int i = 0;i<names.length;i++){
            System.out.println(names[i]);
        }
        System.out.println("-----------");
        //遍历 - foreach(增强for循环)
        for(String str:names){//遍历数组,依次把元素赋值给str
            System.out.println(str);
        }
        /**
            遍历时要使用到下标,就用for循环遍历
            遍历时要不使用到下标,就用foreach遍历 
        */
    }

动态初始化:长度由程序员指定,数据由系统分配(默认值)

​ 整数类型:0

​ 浮点类型:0.0

​ 字符类型:' '

​ 布尔类型:false

​ 引用类型:null(空)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static void main(String[] args){
        //动态初始化1
        String[] names = new String[5];//5->5个长度
        //设置指定下标上的元素
        names[0] = "小明";
        names[1] = "铁蛋";
        names[2] = "二狗";
        //获取指定下标上的元素
        String n = names[2];
        System.out.println("获取指定下标上的元素:" + n);//二狗
        //ArrayIndexOutOfBoundsException - 数组下标越界异常
        //System.out.println(names[100]);
        //获取元素个数
        int len = names.length;
        System.out.println("获取元素个数:" + len);//5
        System.out.println("-----------");
        //遍历 - for循环
        for(int i = 0;i<names.length;i++){
            System.out.println(names[i]);
        }
        System.out.println("-----------");
        //遍历 - foreach(增强for循环)
        for(String str:names){//遍历数组,依次把元素赋值给str
            System.out.println(str);
        }
        /**
            遍历时要使用到下标,就用for循环遍历
            遍历时要不使用到下标,就用foreach遍历 
        */

2.数组的扩容

前面讲到数组一旦初始化后长度不可以改变(数组没有扩容和删除),那我们如何在原来的数组上添加数据。数组没有扩容,但是可以将数组中的数据从小的容器放到大的容器里。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args){
        //源数组
        String[] names = {"小明","小红","铁蛋","二狗"};
        //新数组
        //(names.length>>1在此次可以理解为(names.length/2)
        int capacity = names.length + (names.length>>1);//新容量:是源数组长度的1.5倍
        String[] newNames = new String[capacity];
        //把源数组所有的数据迁移到新数组中
        for(int i = 0;i<names.length;i++){
            newNames[i] = names[i];
        }
        //将新数组的地址赋值给源数组
        names = newNames;
        //遍历源数组
        for(String name:names){
            System.out.println(name);
        }
    }

小明小红铁蛋二狗 null null

3.数组的复制

1.直接将数组赋值给新数组

String[] names = {“小明”,“小红”,“铁蛋”,“二狗”};

String[] newNames = names;

这样做会有一个小缺陷,修改源数组,新数组的数据也随之改变.这是因为赋值号所给到的不是原数组的数据,而是原数组的地址。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Test111 {
    public static void main(String[] args){
        //源数组
        String[] names = {"小明","小红","铁蛋","二狗"};
        //新数组
        String[] newNames = names;
        //遍历新数组
        System.out.print("修改原数据前:");
        for(String name : newNames){
            System.out.print(name+"\t");
        }
        System.out.println();
        //修改源数组
        names[0] = "大*";
        //遍历新数组
        System.out.print("修改原数据后:");
        for(String name : newNames){
            System.out.print(name+"\t");
        }
        System.out.println();
    }
}

修改原数据前:小明 小红 铁蛋 二狗 修改原数据后:大* 小红 铁蛋 二狗

2.创建一个新的数组,再将原数组的数据逐个赋值

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args){
        //源数组
        String[] names = {"小明","小红","铁蛋","二狗"};
        //新数组
        String[] newNames = new String[names.length];
        //将源数组中数据依次赋值给新数组
        for(int i = 0;i<names.length;i++){
            newNames[i] = names[i];
        }
        //修改源数组
        names[0] = "大聪明";
        //遍历新数组
        for(String name : newNames){
            System.out.println(name);
        }
    }

小明 小红 铁蛋 二狗

4.数组的删除

1.新建一个小容量的数组,然后将不删除的数据导入。排除了需要删除的数据

缺点:数组原本是存放数据的,删除元素后,数组长度变短

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void main(String[] args){
        //源数组
        String[] names = {"小明","小红","铁蛋","二狗"};
        //新数组
        String[] newNames = new String[names.length-1];
        //将源数组的数据迁移到新数组中,要删除的元素(深田咏美)除外
        int index = 0;//新数组的下标
        for(String name:names){
            if(!name.equals("小红")){
                newNames[index] = name;
                index++;
            }
        }
        //将新数组的地址赋值给源数组
        names = newNames;
        //遍历源数组
        for(String name:names){
            System.out.println(name);
        }
    }

小明 铁蛋 二狗

2.将需要删除的数据后面的数据整体向前移,覆盖掉删除的数据,这样就可以留出空间了
?
1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String[] args){
        //源数组
        String[] names = {"小明","小红","铁蛋","二狗"};
        //数据的迁移
        for(int i = 1;i<names.length-1;i++){
            names[i] = names[i+1];
        }
        names[names.length-1] = null;
        //遍历源数组
        for(String name:names){
            System.out.println(name);
        }
    }

小明铁蛋二狗 null

5.数组的排序

数组的排序方法有很多种,今天就分享比较简单的冒泡排序

​ 口诀:

​ N个数字来排序

​ 两两相比小靠前

​ 外层循环N-1

​ 内层循环N-1-i

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args){
        int[] is = {39,77,27,20,45,62};
        for(int i = 0;i<is.length-1;i++){
            for(int j = 0;j<is.length-1-i;j++){
                if(is[j] > is[j+1]){
                    int temp = is[j];
                    is[j] = is[j+1];
                    is[j+1] = temp;
                }
            }
        }
        for(int num : is){
            System.out.println(num);
        }
    }

这里分享一个Arrays工具类,导入Arrays包后可直接调用里面的排序方法sort

?
1
2
3
4
5
6
7
public static void main(String[] args){
    import java.util.Arrays;
    int[] a={1,5,8,6};
    for(int num : a){
        System.out.println(num);
    }
}

1 5 6 8

6.数组的查找

1.顺序查找:从头到尾遍历(简单除暴,效率相对较低)

?
1
2
3
4
5
for(int i = 0;i<is.length;i++){
            if(is[i] == num){
                System.out.println("查找到了");
            }
        }

2.二分法查找

​ 前提:先排序(效率高于顺序查找)

​ 排序时就可以使用Arrays.sort(is);

**二分法查找适用于数据量较大时,但是数据需要先排好顺序。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String[] args){
        int[] is = {39,77,27,20,45,62};
        int num = 77;
        //排序
        Arrays.sort(is);
        int start = 0;
        int end = is.length-1;
        while(start <= end){
            int mid = (start+end)/2;
            if(num >is[mid]){
                start = mid+1;
            }else if(num < is[mid]){
                end = mid-1;
            }else{
                System.out.println("查找到了");
                break;
            }
        }
    }

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://blog.csdn.net/Chao0748/article/details/119152386