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

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

转载作者：qq735679552 更新时间：2022-09-27 22:32:09

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

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

1.一维数组

概念：一组数据的容器（数组可以存放多个数据）

注意:

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

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

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

4.下标从0开始。

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

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

7.数组的操作：添加、修改、查询。

数组的声明：数据类型[] 数组名; 。

数组的初始化：

静态初始化：数据由程序员指定，长度由系统分配。

 
    ? 
   
         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(空) 。

 
    ? 
   
         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.数组的扩容

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

 
    ? 
   
         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,

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

 
    ? 
   
         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.创建一个新的数组，再将原数组的数据逐个赋值

 
    ? 
   
         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.新建一个小容量的数组，然后将不删除的数据导入。排除了需要删除的数据

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

 
    ? 
   
         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.将需要删除的数据后面的数据整体向前移，覆盖掉删除的数据，这样就可以留出空间了

 
    ? 
   
         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 。

 
    ? 
   
         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 。

 
    ? 
   
         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.顺序查找：从头到尾遍历(简单除暴，效率相对较低)

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

2.二分法查找

前提：先排序(效率高于顺序查找) 。

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

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

 
    ? 
   
         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的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐：解决javaBean规范导致json传参首字母大写将永远获取不到问题

文章推荐： Android编程之非调用系统界面实现发送彩信的方法(MMS)

文章推荐： Android开发笔记之Android中数据的存储方式（二）

文章推荐：带你了解Java常用类小结

简单的php数据库操作类代码(增,删,改,查)
数据库操纵基本流程为：　　1、连接数据库服务器　　2、选择数据库　　3、执行SQL语句　　4、处理结果集　　5、打印操作信息　　其中用到的相关函数有 •resource m
Struts2实现CRUD(增删改查)功能实例代码
CRUD是Create（创建）、Read（读取）、Update（更新）和Delete（删除）的缩写，它是普通应用程序的缩影。如果您掌握了某框架的CRUD编写，那么意味可以使用该框架创建普通应用程序了
php开发留言板的CRUD(增，删，改，查)操作
项目结构：添加页面： &
Android操作SQLite数据库(增、删、改、查、分页等)及ListView显示数据的方法详解
本文实例讲述了android操作sqlite数据库(增、删、改、查、分页等)及listview显示数据的方法。分享给大家供大家参考，具体如下：由于刚接触android开发，故此想把学到的基础知识
Pandas 数据框增、删、改、查、去重、抽样基本操作方法
总括 pandas的索引函数主要有三种： loc 标签索引，行和列的名称 iloc 整型索引（绝对位置索引），绝对意义上的几行几列，起始索引为0 ix 是 iloc 和 loc的合体 at
Spring3.1.1+MyBatis3.1.1的增、删、查、改以及分页和事务管理
1. [代码]Mybatis全局配置文件 ? 1

qq735679552

个人简介

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

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城