java简单实现数组的增删改查⽅法⽬录
1.⼀维数组
2.数组的扩容
3.数组的复制
1.直接将数组赋值给新数组
2.创建⼀个新的数组，再将原数组的数据逐个赋值
4.数组的删除
5.数组的排序
6.数组的查
1.顺序查：从头到尾遍历(简单除暴，效率相对较低)
2.⼆分法查
总结
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.数组的复制
冒泡排序java代码详解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;
}
}
}
总结
本篇⽂章就到这⾥了，希望能给你带来帮助，也希望您能够多多关注的更多内容！
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论