文章目录
什么是数组？
数组本质上就是让我们能 “批量” 创建相同类型的变量.它是一块连续的内存，它存放的是一组相同数据类型的集合。
- 例如:
如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b
如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;
但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建. - 注意： 在 Java 中, 数组中包含的变量必须是相同类型
如何创建数组？
基本语法
- 定义数组的第一种方式：静态初始化（这种方式用的最多）
数据类型[] 数组名称 = { 初始化数据 };
如：int[] array1 = {1, 2, 3};
注意事项:
int后的[]里面不能写东西，数据也不可以
静态初始化的时候, 数组元素个数和初始化数据的格式是一致的.
- 定义数组的第二种方式 ：动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
如：int[] array2 = new int[]{1, 2, 3};
注意：等号前面的int后的[]里面不能写东西，数据也不可以.
- 定义数组的第三种方式：初始化数组长度
如：int[] array2 = new int[10];
注意：[10]表示初始化数组长度为10，默认元素为0
- 其实数组也可以写成int arr[] = {1, 2, 3};
这样就和 C 语言更相似了. 但是我们还是更推荐写成 int[] arr 的形式. 因为int和 [] 是一个整体.
数组的使用
代码示例1：获取长度（数组名.length） 和 访问元素
public class TestArray1 {
public static void main1(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
//1.获取数组长度:arr.length
System.out.println("length=" + arr.length);//6
//2.打印数组中的每个元素：
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//3.访问数组中下标为几元素
System.out.println("arr[0]=" + arr[0]);//1
System.out.println("arr[4]=" + arr[4]);//5
arr[4] = 100;
System.out.println("修改后的arr[4]=" + arr[4]);//100打印结果：
注意事项：
- 使用 数组名.length 能够获取到数组的长度; . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
- 使用 [] 按下标取数组元素. 需要注意, 下标从 0 开始计数
- 使用 [] 操作既能读取数据, 也能修改数据.
- 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常。
代码示例2:测试下标越界
public static void main(String[] args) {
int[] arr = {1, 2, 3};
System.out.println(arr[4]);打印结果：使用数组一定要谨防下标越界。
Java中打印数组的方式
方式1：使用for循环 遍历数组
所谓 “遍历” 是指将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句.
代码示例：
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");//打印结果:1 2 3 4 5 6
}
}方式2：使用for-each循环遍历数组，也叫增强for循环
代码示例：
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
for (int x : arr) {
System.out.print(x+" ");//打印结果:1 2 3 4 5 6
}- for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错.
- 冒号左边放的是这个数组里面存放的元素的类型所定义的变量，如上面的数组是int类型，给他一个变量x,代表每一个元素都是整型的，每一个元素都保存到x里面，通过遍历数组打印，保存一个就打印一个;
- 冒号的右边放的是数组名称，它里面放的是一组元素。
讨论：for循环和for-each循环的区别是什么？
答：用for循环可以拿到数组的下标，但for-each循环不可以，因此如果只是打印数组元素，此时不需要使用下标，所以二者都可以使用，但如果跟下标扯上关系就是只能使用for循环，如：将下标为4的元素乘2，arr[4]*2。
方式3：使用Arrays.toString()方法
Arrays：是一个帮助我们操作数组的工具类，它的包是import java.util.Arrays;
它通过调用toString方法，将当前的数组转换为字符串的形式进行输出，toString可以将任意类型的数组都转化为字符串的形式，它的返回值是string因此需要用String 来接收。
代码示例：
public static void main5(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
String ret = Arrays.toString(arr);//用String 来接收
System.out.println(ret);
//也可写成一行的形式打印
System.out.println(Arrays.toString(arr));
}打印结果：但方式3只是用在打印数组，如若要操作数组还得使用方式1和方式2
初识 JVM 内存区域划分
JVM 的内存被划分成了几个区域, 如图所示:
-
程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址.
-
虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存.
-
本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
-
堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )
-
方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域.
- 运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意 从 JDK1.7 开始, 运行时常量池在堆上).
Native 方法:
- JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.
- 这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数.
- 我们发现, 在上面的图中, 程序计数器, 虚拟机栈, 本地方法栈被很多个原谅色的, 名叫 Thread(线程) 的方框圈起来了,
并且存在很多份. 而 堆, 方法区, 运行时常量池, 只有一份. (关于线程, 这是我们后面重点讲解的内容).
关于上面的划分方式, 我们随着后面的学习慢慢理解. 此处我们重点理解 虚拟机栈 和 堆.
局部变量和引用保存在栈上, new 出的对象保存在堆上.
堆的空间非常大, 栈的空间比较小.
堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈).
数组作为方法的参数
基本用法
代码示例: 打印数组内容
public static void printArray(int[] array1) {
for (int x : array1) {
System.out.print(x+" ");//打印结果：1 2 3 4 5
}
}
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5};
printArray(array);
}-
在这个代码中int[] a 是函数的形参, int[] arr 是函数实参.
-
如果需要获取到数组长度, 同样可以使用 a.length。
理解引用类型
代码示例: 参数传内置类型
public static void func(int x) {
x = 10;
System.out.println("x=" + x);//x=10
}
public static void main7(String[] args) {
int num = 0;
func(num);
System.out.println("num=" + num);//num=0
}
执行结果：x=10 num=0;
我们发现, 修改形参 x 的值, 不影响实参的num的值。
代码示例: 参数传数组类型
public static void func(int[] a) {
a[1] = 10;
System.out.println("a[1]=" + a[1]);//a[1]=10
}
public static void main(String[] args) {
int[] arr = {2, 3, 4, 5};
func(arr);
System.out.println("arr[1]=" + arr[1]);//arr[1]=10
}运行结果：a[1]=10 arr[1]=10
我们发现, 在函数内部修改数组内容, 函数外部也发生改变.
此时数组名 arr 是一个 “引用” . 当传参的时候, 是按照引用传参。
这里我们要先从内存开始说起. 如何理解内存? 内存就是指我们熟悉的 "内存". 内存可以直观的理解成一个宿舍楼. 有一个长长的大走廊, 上面有很多房间. 每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿 个这样的房间). 每个房间上面又有一个门牌号, 这个门牌号就称为 地址 那么啥又是引用? 什么是引用? 引用相当于一个 "别名", 也可以理解成一个指针. 创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址. 总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实 只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大)
public static void main06(String[] args) {
int[] array1 = {1, 2, 3, 4, 5, 6};
int[] array2 = new int[10];
int[] array3 = new int[]{1, 2, 3, 4, 5, 6};
}看图理解引用
什么是对象？对象是真正意义上存在的实体。
画图理解引用二
代码示例:交换数组的0号下标和1号下标
public static void swap(int[] array) {
int tmp = array[0];
array[0] = array[1];
array[1] = tmp;
}
public static void main006(String[] args) {
int a = 10;
int b = 11;
int[] array = {a, b};
System.out.println("交换前：" + array[0] + " " + array[1]);
swap(array);
System.out.println("交换后：" + array[0] + " " + array[1]);
}打印结果：
探讨一个问题：
public static void main07(String[] args) {
int[] array1 = {1, 2, 3, 4, 5, 6};
int[] array2 = array1;//这样写是不是代表array2这个引用指向array1这个引用呢？不是
//这样写的意思是array2这个引用指向了array1这个引用所指的对象
//总结：引用不能指向引用，引用只能指向另外一个引用所指的对象
}
认识null
代码示例：null在java中表示”空引用“，也就是一个无效的引用,代表他不指向任何对象。
public static void main9(String[] args) {
int[] arr = null;
System.out.println(arr[0]);打印结果：
注意：
-
null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException.（空指针异常）；
-
Java 中并没有约定null和0号地址的内存有任何关联。
-
如果以后通过null访问尝试访问属性的时候就会报出空指针异常的错误。
-
引用类型如果不知道它将来指向哪个对象，那么初始化的时候就把它初始化为null
数组作为方法的返回值
在C语言里面数组是不能作为返回值的而在java里面数组是可以作为返回值的
让数组扩大两倍的两种方式
代码示例: 写一个方法, 将数组中的每个元素都*2 ( 直接修改原数组的方式)
public static void printArray1(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static void tranform(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2;
}
}
public static void main10(String[] args) {
int[] arr = {1, 2, 4, 6};
tranform(arr);
printArray1(arr);
}打印结果：
提示：这个代码固然可行, 但是破坏了原有数组. 有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来.
代码示例：写一个方法, 将数组中的每个元素都*2 (返回一个新的数组)(第五个：2:56:00画图讲解)
public static void printArray3(int[] arr1) {
for (int i = 0; i < arr1.length; i++) {
arr1[i] *= 2;
}
}
public static int[] tranform1(int[] arr2) {//进入这个函数,返回值是一个数组
int[] ret = new int[arr2.length];//new一个新的数组
for (int i = 0; i < arr2.length; i++) {
ret[i] = arr2[i] * 2;
}
return ret;
}
public static void main(String[] args) {
int[] arr = {1, 2, 4, 6};
System.out.println("执行 printArray3之前arr数组" + Arrays.toString(arr));
printArray3(arr);
System.out.println("执行 printArray3之后arr数组" + Arrays.toString(arr));
System.out.println("执行 tranform1之前arr数组" + Arrays.toString(arr));
int[] ret = tranform1(arr);
printArray3(ret);
System.out.println("执行 tranform1之后arr数组" + Arrays.toString(arr));
System.out.println("执行 tranform1之后，返回的数组" + Arrays.toString(ret));
}打印结果：
注意：由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效.
在java当中数组就是一个对象，只要是一个对象，它的内存就在堆上
数组练习
练习1：数组转字符串
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7};
String newArr = Arrays.toString
}打印结果：
接练习1：实现一个自己版本的数组转字符串
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7};
String ret = toString(arr);
System.out.println(ret);//打印方式1
System.out.println(toString(arr));//打印方式2
}
public static String toString(int[] arr) {
if (arr == null) {
return null;
}
if (arr.length == 0) {
return "";
}
String ret = "[";
for (int i = 0; i < arr.length; i++) {
ret += arr[i]; //借助string+=进行拼接字符串
if (i != arr.length - 1) {//除了最后一个元素之外，其他元素后面都要加上”,“
ret += ",";//在拼上一个逗号
}
}
ret += "]";
return ret;
}打印结果：
练习2:数组的四种拷贝方式（遍历数组元素，拷贝到另外一个新的数组）
方式1：使用for循环进实现数组拷贝
//不使用函数的方法进行数组拷贝
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
int[] newArray = new int[array.length];
System.out.println(Arrays.toString(newArray));//拷贝之前打印一下，拷贝之前默认都为0
for (int i = 0; i < array.length; i++) {//遍历原来的数组
newArray[i] = array[i];
}
System.out.println(Arrays.toString(newArray));//拷贝之后打印一下
}打印结果：
//使用函数的方法通过for循环进行数组拷贝
public static int[] copyArray(int[] array) {
int[] newArray = new int[array.length];
for (int i = 0; i < array.length; i++) {//遍历原来的数组
newArray[i] = array[i];
}
return newArray;//函数有返回值
}
public static void main(String[] args) {
int[] array1={1,2,3,4,5,6,7,8};
int[] ret=copyArray(array1);//返回值是int[] ,所以要用它来接收
System.out.println(Arrays.toString(ret));//拷贝之后
}
//注意：建议不要在子函数进行打印打印结果：
方式2：使用数组工具类Arrays.copyOf()实现数组拷贝
public static void main(String[] args) {
int[] array={1,2,3,4,5,6,7,8};
int[] newArray=Arrays.copyOf(array,array.length);
System.out.println("newArr:"+Arrays.toString(newArray));
array[0]=10;
System.out.println("arr:"+Arrays.toString(array));
System.out.println("newArr:"+Arrays.toString(newArray));
//拷贝数组某个区间范围使用Arrays.copyOfRange
int[] newArr2=Arrays.copyOfRange(array,2,4);//[2,4)
System.out.println("newArr2："+Arrays.toString(newArr2));
}打印结果：
注意：java当中看到有from to这样一个范围，一般情况都是左闭右开的。
方式3：借助System.arraycopy()进行拷贝
/* 源码： public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
源码的意思是：从src（源头）的srcPos开始拷贝，拷贝到dest（目的地）的destPos位置，拷贝的长度是 length*/
/*源码中的native表示本地方法，它的特点是
* 1.是由C/C++代码实现的
* 2.速度很快
* 3.运行是在本地方法栈*/
public static void main15(String[] args) {
int[] array={1,2,3,4,5};
int[] copy=new int[array.length];//自己定义一个copy数组
System.arraycopy(array,0,copy,0,array.length);//进行拷贝
System.out.println(Arrays.toString(copy));//打印结果：[1,2,3,4,5]
}方式4：调用对象的clone克隆方法
public static void main015(String[] args) {
int[] array={1,2,3,4,5,6};
int[] ret=array.clone();//调用克隆，就会产生array的对象的副本，然后给ret
System.out.println(Arrays.toString(ret));
}注意一个问题：
public static void main016(String[] args) {
int[] array={2,4,6,8,10};
int[] ret=array;//这样写是不是拷贝？不是，它只是代表赋值
System.out.println(Arrays.toString(ret));注意事项: 相比于 ret=array 这样的赋值, copyOf 是将数组进行了 深拷贝, 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组.
画图理解是深拷贝、浅拷贝？
练习3： 找数组中的最大元素
要求：给定一个整型数组, 找到其中的最大元素 (找最小元素同理)
public static void main16(String[] args) {
int[] arr={1,2,3,4,5,6};
int ret=max(arr);
System.out.println(ret);
System.out.println("max="+max(arr));
}
public static int max(int[] arr){
int max=arr[0];//从1下标开始
for(int i=1;i<arr.length;i++){
if(arr[i]>max){//从1下标开始，跟max进行比较
max=arr[i];
}
}
return max;
//类似于 "打擂台" 这样的过程. 其中 max 变量作为 擂台, 比擂台上的元素大, 就替换上去, 否则就下一个对
}打印结果：
练习4：求数组中元素的平均值
要求：给定一个整型数组, 求平均值
public static void main17(String[] args) {
int[] arr={2,4,6,8,9};
System.out.println(avg(arr));
}
public static double avg(int[] arr){//求平均值可能结果为小数，注意返回值为double类型
int sum=0;
for (int x:arr){
sum+=x;
}
return (double)sum/(double)arr.length;
}打印结果：
练习5： 查找数组中指定元素(顺序查找)
要求：给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.
public static void main18(String[] args) {
int[] arr={2,4,6,8,9};
System.out.println(find(arr,9));
}
public static int find(int[] arr,int key){//在数组当中找关键字key,找到返回下标，找不到返回-1
for(int i=0;i< arr.length;i++){
if(arr[i]==key){
return i;
}
}
return -1;//表示没找到
}打印结果：
练习6：查找数组中指定元素(二分查找）
针对有序数组, 可以使用更高效的二分查找.
啥叫有序数组?
有序分为 "升序" 和 "降序" 如 1 2 3 4 , 依次递增即为升序. 如 4 3 2 1 , 依次递减即为降序.
以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找.
public static void main19(String[] args) {
int[] arr={1,2,3,4,5,6,7,8,9};
System.out.println(binarySearch(arr,6));
}
public static int binarySearch(int[]arr,int toFind){
int left=0;
int right=arr.length-1;
while(left<=right){
int mid=(left+right)/2;
if(toFind<arr[mid]){
//去左侧区间找
right=mid-1;
}else if(toFind>arr[mid]){
//去右侧区间找
left=mid+1;
}else{
//相等，说明找到了
return mid;
}
}
return -1;//循环结束，没找到
}打印结果：
接练习6：感受二分查找的效率
static int count=0;//创建一个成员变量，记录二分查找循环次数
public static void main(String[] args) {
int[] arr=makeBigArray();
int ret=binarySearch1(arr,9999);
System.out.println("ret="+ret+","+"count="+count);
}
public static int[] makeBigArray(){
int[] arr=new int[10000];
for(int i=0;i<10000;i++) {
arr[i]=i;
}
return arr;
}
public static int binarySearch1(int[] arr,int toFind){
int left=0;
int right=arr.length-1;
while(left<=right){
count++;//使用一个变量来记录循环执行次数
int mid=(left+right)/2;
if(toFind<arr[mid]){
right=mid-1;
}else if(toFind>arr[mid]){
left=mid+1;
}else{
return mid;
}
}
return -1;
}打印结果：
**结论：**可以看到, 针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数
越多, 二分的优势就越大.
练习7： 检查数组的有序性
给定一个整型数组, 判断是否该数组是有序的(升序)
public static void main21(String[] args) {
int[] arr={1,2,3,10,9,7};
System.out.println(isSoretd(arr));//打印结果：false
}
public static boolean isSoretd(int[] arr){
for(int i=0;i<arr.length-1;i++){
if(arr[i]>arr[i+1]){
return false;
}
}
return true;
}给数组排序使用 Arrays.sort()方法
public static void main022(String[] args) {
int[] array={2,1,5,6,10,23,29};
System.out.println("排序之前的数组："+Arrays.toString(array));
Arrays.sort(array);//数组排序
System.out.println("排序之后的数组："+Arrays.toString(array));
}
打印结果：
练习8：数组排序(冒泡排序)
给定一个数组, 让数组升序 (降序) 排序
每次尝试找到当前待排序区间中最小(或最大)的元素, 放到数组最前面(或最后面)
代码示例：
public static void bubbleSort1(int[] array){
for(int i=0;i<array.length-1;i++){//确定趟数
boolean flg=false;//定义一个布尔类型初始值为false，每一趟都要把flg=false
//长度是5，array.length-1表示5-1=4，j<4,所以第一趟j的取值是0,1,2,3
//array.length-1-i表示下一趟比上一趟少1
for(int j=0;j<array.length-1-i;j++){//每一趟j都是从0开始，
if(array[j]>array[j+1]){//上面那个数如果比下面那个数大，就交换
int tmp=array[j+1];
array[j]=array[j+1];
array[j+1]=tmp;
flg=true;//如果交换了就把flg置为true
}
}//第二个for循环里面是一趟冒泡排序
if(flg==false){//flg==false说明从0开始比较没有发生交换,表明此时已经在上一次有序，就可以跳出了，没必要在进行比较了
break;
}
}
}
public static void main023(String[] args) {
int[] array={4,10,6,2,8};
System.out.println("排序之前："+Arrays.toString(array));
bubbleSort(array);
System.out.println("排序之后："+Arrays.toString(array));
}打印结果：
接练习8：更高效的排序算法
public static void main23(String[] args) {
int[] arr={9,7,4,8,3};
Arrays.sort(arr); //这里是用 Arrays.sort方法实现算法的。
System.out.println(Arrays.toString(arr));
}打印结果：
练习9：数组逆序
要求：给定一个数组, 将里面的元素逆序排列
思路
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可.
数组逆序算法思想
public static void main24(String[] args) {
int[] arr={1,2,3,4,5,6,7};
reverse(arr);
System.out.println(Arrays.toString(arr));
}
public static void reverse(int[] arr){
int left=0;
int right=arr.length-1;
while(left<right){
int tmp=arr[left];
arr[left]=arr[right];
arr[right]=tmp;
left++;
right--;
}
}打印结果：
练习10：数组数字排列
要求：给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分 例如 {1, 2, 3, 4} 调整后得到 {4, 2, 3, 1} 基本思路 设定两个下标分别指向第一个元素和最后一个元素. 用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素.依次循环即可.
public static void main26(String[] args) {
int[] arr={1,2,3,4,5,6,7,8,9};
transform(arr);
System.out.println(Arrays.toString(arr));
}
public static void transform(int[] arr){
int left=0;//left找奇数
int right=arr.length-1;//right找偶数
while(left<right){//
while(left<right && arr[left]%2==0){ //该循环结束left就指向了一个奇数
left++;
}
while(left<right && arr[right]%2!=0){ //该循环结束right就指向了一个偶数
right--;
}
// 交换两个位置的元素
int tmp=arr[left];
arr[left]=arr[right];
arr[right]=tmp;
}
}
}
打印结果：
思路
设定两个下标分别指向第一个元素和最后一个元素.
用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素.依次循环即可.
public static void main26(String[] args) {
int[] arr={1,2,3,4,5,6,7,8,9};
transform(arr);
System.out.println(Arrays.toString(arr));
}
public static void transform(int[] arr){
int left=0;//left找奇数
int right=arr.length-1;//right找偶数
while(left<right){//
while(left<right && arr[left]%2==0){ //该循环结束left就指向了一个奇数
left++;
}
while(left<right && arr[right]%2!=0){ //该循环结束right就指向了一个偶数
right--;
}
// 交换两个位置的元素
int tmp=arr[left];
arr[left]=arr[right];
arr[right]=tmp;
}
}
}打印结果：[8,2,6,4,5,3,7,1,9]
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
