个人中心
gpt4 book ai didi

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

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章java简单实现数组的增删改查方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

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 。

最后此篇关于java简单实现数组的增删改查方法的文章就讲到这里了,如果你想了解更多关于java简单实现数组的增删改查方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： 解决javaBean规范导致json传参首字母大写将永远获取不到问题
文章推荐： Android编程之非调用系统界面实现发送彩信的方法(MMS)
文章推荐： Android开发笔记之Android中数据的存储方式（二）
文章推荐： 带你了解Java常用类小结
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com