java 数组排序-数组排序java

注意：数组提供了一个属性length，用于获取数组的长度。

格式：数组名.length

class ArrayTest {

public static void main(String[] args) {

//定义数组

int[] arr = {11,22,33,44,55};

//获取每一个元素

//如何获取呢?我们知道数组名结合编号(索引)就可以找到数据

System.out.println(arr[0]);

System.out.println(arr[1]);

System.out.println(arr[2]);

System.out.println(arr[3]);

System.out.println(arr[4]);

System.out.println("--------------------");

//虽然这种做法可以，但是不是我想要的

//我们发现，代码的重复度很高

//输出语句，数组名都是相同的，仅仅是索引是变化的

//我们就可以使用循环搞定索引值

for(int x=0; x

//x=0,1,2,3,4

System.out.println(arr[x]);

}

System.out.println("--------------------");

//从0开始我们是明确的，但是为什么到5呢，我们是数了一下数组的个数

//继续看下个数组如何遍历

int[] arr2 = {1,2,3,4,5,6,7,8,9,10,11,2,2,3,4,5,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8};

//而我们在很多时候，数组的元素不能靠数

//这个时候，数组就给我们提供了一个属性：length专门用于获取数组的长度

//格式：数组名.length 返回数组的长度

System.out.println(arr.length);

System.out.println(arr2.length);

System.out.println("--------------------");

//改进第一个程序

for(int x=0; x

System.out.println(arr[x]);

}

System.out.println("--------------------");

//我们如果想要对多个数组进行遍历，每个数组的遍历我们都把代码写一遍，麻烦不

//麻烦，所以，我们准备用方法改进。

//用方法改进后，请调用

printArray(arr);

System.out.println("--------------------");

printArray(arr2);

System.out.println("--------------------");

printArray2(arr);

}

/*

遍历数组的方法

两个明确：

返回值类型：void

参数列表：int[] arr

*/

public static void printArray(int[] arr) {

for(int x=0; x

System.out.println(arr[x]);

}

}

//请看改进版本

public static void printArray2(int[] arr) {

System.out.print("[");

for(int x=0; x

if(x == arr.length-1) { //这是最后一个元素

System.out.println(arr[x]+"]");

}else {

System.out.print(arr[x]+", ");

}

}

}

}

分析：

A:定义一个数组，并对数组的元素进行静态初始化。

B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。

C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

D:最后参照物里面保存的就是最大值。

class ArrayTest2 {

public static void main(String[] args) {

//定义一个数组

int[] arr = {34,98,10,25,67};

//请获取数组中的最大值

/*

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x

//依次获取和参照物进行比较，如果大就留下来，如果小，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

System.out.println("max:"+max);

*/

//把这个代码用方法改进

//调用方法

int max = getMax(arr);

System.out.println("max:"+max);

//请获取数组中的最小值

int min = getMin(arr);

System.out.println("min:"+min);

}

/*

需求：获取数组中的最大值

两个明确：

返回值类型：int

参数列表：int[] arr

*/

public static int getMax(int[] arr) {

//从数组中任意的找一个元素作为参照物

int max = arr[0];

//然后遍历其他的元素

for(int x=1; x

//依次获取和参照物进行比较，如果大就留下来，如果小java 数组排序，就离开。

if(arr[x] > max) {

max = arr[x];

}

}

//最后参照物里面保存的就是最大值。

return max;

}

public static int getMin(int[] arr) {

//从数组中任意的找一个元素作为参照物

int min = arr[0];

//然后遍历其他的元素

for(int x=1; x

//依次获取和参照物进行比较java 数组排序，如果小就留下来，如果大，就离开。

if(arr[x] < min) {

min = arr[x];

}

}

//最后参照物里面保存的就是最小值。

return min;

}

}

/*

分析：

A:定义一个数组，并进行静态初始化。

B:思路

把0索引和arr.length-1的数据交换

把1索引和arr.length-2的数据交换

...

只要做到arr.length/2的时候即可。

*/

class ArrayTest3 {

public static void main(String[] args) {

//定义一个数组，并进行静态初始化。

int[] arr = {12,98,50,34,76};

//逆序前

System.out.println("逆序前：");

printArray(arr);

//逆序后

System.out.println("逆序后：");

//reverse(arr);

reverse2(arr);

printArray(arr);

}

需求：数组逆序

两个明确：

返回值类型：void (有人会想到应该返回的是逆序后的数组，但是没必要，因为这两个数组其实是同一个数组)

参数列表：int[] arr

public static void reverse(int[] arr) {

//第一次交换

int temp = arr[0];

arr[0] = arr[arr.length-1-0];

arr[arr.length-1-0] = temp;

//第二次交换

int temp = arr[1];

arr[1] = arr[arr.length-1-1];

arr[arr.length-1-1] = temp;

//第三次交换

int temp = arr[2];

arr[2] = arr[arr.length-1-2];

arr[arr.length-1-2] = temp;

*/

//用循环改进

for(int x=0; x

int temp = arr[x];

arr[x] = arr[arr.length-1-x];

arr[arr.length-1-x] = temp;

}

}

public static void reverse2(int[] arr) {

for(int start=0,end=arr.length-1; start