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

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

目录1.一维数组​2.数组的扩容3.数组的复制1.直接将数组赋值给新数组2.创建一个新的数组，再将原数组的数据逐个赋值4.数组的删除5.数组的排序6.数组的查找1.顺序查找：从头到尾遍历(简单除暴，效率相对较低)2.二分法查找总结

1.一维数组​

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

​ 注意：

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

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

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

​ 4.下标从0开始

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

​ 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

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

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

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

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[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

for(int j = 0;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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

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

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

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

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[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

for(int j = 0;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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

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

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

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[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

for(int j = 0;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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

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

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[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

for(int j = 0;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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

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[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

for(int j = 0;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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

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

for(int j = 0;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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

for(int j = 0;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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

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

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

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;

}

}

}

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。