数组的基本操作和一些比较简单的排序算法
假设创建如下数组：
double [] mylist=new double[10];
下面是一些处理数组的例子
-
随机初始化数组
//使用0.0到100.0之间，但小于100.0的随机初始化数组 for(int i=0;i<mylist.length;i++){ mylist[i]=Math.random()*100; } -
使用输入值初始化数组
java.util.Scanner input=new java.util.Scanner(System.in); System.out.println("请输入"+mylist.length+"个数"); for (int i = 0; i < mylist.length; i++) { mylist[i]=input.nextDouble(); } -
输出数组
for (int i = 0; i <mylist.length ; i++) { System.out.println(mylist[i]+" "); } -
求和
double total=0; for (int i = 0; i <mylist.length ; i++) { total+=mylist[i]; } -
找出最大元素
double max=mylist[0]; for (int i = 1; i <mylist.length; i++) { if(mylist[i]>max){ max=mylist[i]; } } -
找出最大元素的最小下标值
double max=mylist[0]; int indexOfMax=0; for (int i = 1; i <mylist.length; i++) { if(mylist[i]>max){ max=mylist[i]; indexOfMax=i; } } -
随机打乱
for(int i=mylist.length-1;i>0;i--){ //产生一个随机的下标j(0=<j<=i) int j=(int)(Math.random()*(i+1)); double temp=mylist[i]; mylist[i]=mylist[j]; mylist[j]=temp; } -
移动元素
//获取第一个数组元素 double temp=mylist[0]; //从第二个元素开始向前移动一个位置 for(int i=1;i<mylist.length;i++){ mylist[i-1]=mylist[i]; } //将第一个元素放到最后一个元素的位置 mylist[mylist.length-1]=temp; -
foreach循环
for (double e : myList) System.out.print(e); //对myList中每个元素e进行以下操作，即遍历整个数组。 //注意：变量e的数据类型必须与数组类型相同。 -
复制数组
- 利用for循环逐个复制
- 利用静态方法arraycopy（注意此方法copy的c没有大写）
arraycopy(原数组，原数组起始位置，目标数组，目标数组起始位置，元素个数） System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length); System.arraycopy(source, 0, t, 0, source.length); //用此方法前要先声明目标数组并分配内存空间。 -
数组传递给方法后值会改变
-
对于基本数据类型参数，传递的是实参的值。
-
而对于数组，传递的是引用。最好的描述为传递共享信息。
-
比如：要使用方法来改变数组，最好把数组传进去，不要使用数组下标的类型如int来定义方法参数.
swap(a[0], a[1]) public static void swap(int a1, int a2){} //这样改变的只是实参，而不会涉及数组。 × swap(a) public static void swap(int[] array){} //这样传递的是整个数组。 √
-
-
二分查找法 需要先从小到大排好序
public class BinarySearch { //二分查找法（不含main函数） public static int binarySearch(int[] list, int key) { int low = 0; int high = list.length - 1; while (high >= low) { //此处不能用 > ，不然对只有一个元素的数组无法处理。 int mid = (low + high) / 2; if (key < list[mid]) high = mid - 1; else if (key == list[mid]) return mid; else { low = mid + 1; } } return -low-1; } } -
选择排序算法
public class SelectSort { public static void main(String[] args) { //模拟数据 int[] array = {52,63,14,59,68,35,8,67,45,99}; System.out.println("原数组："); for (int i : array) { System.out.print(i+" "); } System.out.println(); selectSort(array); System.out.println("排序后："); for (int i : array) { System.out.print(i+" "); } } public static void selectSort(int[] arr){ for(int i=0;i<arr.length-1;i++){ int min=i; for(int j=i+1;j<arr.length;j++){ if(arr[j]<arr[min]){ min=j; } } if(min!=i){ swap(arr,i,min); } } } //完成数组两元素间交换 public static void swap(int[] arr,int a,int b){ int temp = arr[a]; arr[a] = arr[b]; arr[b] = temp; } } -
Arrays类
-
使用import.util.Arrays导入
Arrays.sort(list, indexStart, indexEnd);//从小到大对start和end里面进行排序，不包括end。 Arrays.parallelSort();//同上，但是多处理器这个会快些。 Arrays.binarySearch();//二分查找法，必须提前按升序排好。 Arrays.equals(list1, list2);//严格比较相等，一对一。 Arrays.fill(list1, 5);//使用5填充整个数组。 Arrays.fill(list1, 1, 5, 8);//使用8填充1至5地址，不包括5。 Arrays.toString(list);//将数组返回成一个字符串
-
-
冒泡排序
public class BubbleSort { public static void main(String[] args) { int[] arr={6,3,8,2,9,1}; System.out.println("排序前数组为："); for(int num:arr){ System.out.print(num+" "); } for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数 for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次 if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } System.out.println(); System.out.println("排序后的数组为："); for(int num:arr){ System.out.print(num+" "); } } } -
Java填充替换数组元素实例详解（提供多种重载形式）(这里只写两种常用的)
数组中的元素定义完成后，可通过 Arrays 类的静态方法 fill() 来对数组中的元素进行替换，该方法通过各种重载形式可完成任意类型的数组元素的替换。 fill() 方法有两种参数类型，下面以 int 型数组为例介绍 fill() 方法的使用方法。
（1） fill(int[] a, int value)
该方法可将指定的 int 值分配给 int 型数组的每个元素。
a：要进行元素替换的数组； value：要存储数组中所有元素的值。
例1：在项目中创建类Swap ，在主方法中创建一维数组，并实现通过fill()方法填充数组元素，最后将数组中的各个元素输出。
import java.util.Arrays; public class Swap { public static void main(String[] args) { int arr[]=new int[10]; Arrays.fill(arr,1); for(int i = 0;i<arr.length;i++) { System.out.println("第" + i+ "个元素是：" + arr[i]); } } }2） fill(int[] a, int frimIndex, int toIndex, int value)
该方法将指定的int 值分配给int型数组指定范围内的每个元素。
import java.util.Arrays; public class Swap { public static void main(String[] args) { int arr[]=new int[]{1,2,3,4,5,6,7,8,9}; Arrays.fill(arr,1,3,666); Arrays.fill(arr,5,8,555); for(int i = 0;i<arr.length;i++) { System.out.println("第"+i+"个元素是："+ arr[i]); } } } -
数组排序
Java API对Arrays类的说明是：此类包含用来操作数组（比如排序和搜索）的各种方法。
1.对基本数据类型的数组的排序
说明：(1)Arrays类中的sort()使用的是“经过调优的快速排序法”;
(2)比如int[]，double[]，char[]等基数据类型的数组，Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。
(3)要对基础类型的数组进行降序排序，需要将这些数组转化为对应的封装类数组，如Integer[]，Double[]，Character[]等，对这些类数组进行排序。(其实还不如先进行升序排序，自己在转为将序)。
用默认的升序对数组排序
函数原型：static **void sort**(int[] a)对指定的 int 型数组按数字升序进行排序。static void
**sort**(int[] a, int fromIndex, int toIndex)对指定 int 型数组的指定范围按数字升序进行排序。代码实例：
import java.util.Arrays; public class ArraysSort{ public static void main(String args[]) { int[] a={1,4,-1,5,0}; Arrays.sort(a);//内部是优化快排 //数组a[]的内容变为{-1,0,1,4,5} for(int i=0;i<a.length;i++) System.out.print(a[i]+" "); } }2.对复合数据类型的数据的排序
函数原型： (1)public static void sort(T[] a，Comparator c) 根据指定比较器产生的顺序对指定对象数组进行排序。
(2)public static void sort(T[] a，int fromIndex，int toIndex，Comparator c) 根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
说明：这个两个排序算法是“经过调优的合并排序”算法。
代码实例：
import java.util.Arrays; import java.util.Comparator; public class Arraysort { Point[] arr; Arraysort(){ arr=new Point[4]; //定义对象数组arr，并分配存储的空间 for(int i=0;i<4;i++) arr[i]=new Point(); } public static void main(String[] args) { Arraysort sort=new Arraysort(); sort.arr[0].x=2;sort.arr[0].y=1; //初始化，对象数组中的数据 sort.arr[1].x=2;sort.arr[1].y=2; sort.arr[2].x=1;sort.arr[2].y=2; sort.arr[3].x=0;sort.arr[3].y=1; Arrays.sort(sort.arr, new MyComprator()); //使用指定的排序器，进行排序 for(int i=0;i<4;i++) //输出排序结果 System.out.println("("+sort.arr[i].x+","+sort.arr[i].y+")"); } } class Point{ int x; int y; } //比较器，x坐标从小到大排序；x相同时，按照y从小到大排序 class MyComprator implements Comparator { public int compare(Object arg0, Object arg1) { Point t1=(Point)arg0; Point t2=(Point)arg1; if(t1.x != t2.x) return t1.x>t2.x? 1:-1; else return t1.y>t2.y? 1:-1; } } -
数组复制
使用 copyOf() 方法和 copyOfRange() 方法
Arrays 类的 copyOf() 方法与 copyOfRange() 方法都可实现对数组的复制。copyOf() 方法是复制数组至指定长度，copyOfRange() 方法则将指定数组的指定长度复制到一个新数组中。
1. 使用 copyOf() 方法对数组进行复制
Arrays 类的 copyOf() 方法的语法格式如下：
Arrays.copyOf(dataType[] srcArray,int length);其中，srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度。
使用这种方法复制数组时，默认从原数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。如果 length 大于 srcArray.length，则目标数组中采用默认值填充；如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。
注意：目标数组如果已经存在，将会被重构。
例 1
假设有一个数组中保存了 5 个成绩，现在需要在一个新数组中保存这 5 个成绩，同时留 3 个空余的元素供后期开发使用。
使用 Arrays 类的 CopyOf() 方法完成数组复制的代码如下：
import java.util.Arrays; public class Test19{ public static void main(String[] args) { // 定义长度为 5 的数组 int scores[] = new int[]{57,81,68,75,91}; // 输出原数组 System.out.println("原数组内容如下："); // 循环遍历原数组 for(int i=0;i<scores.length;i++) { // 将数组元素输出 System.out.print(scores[i]+"\t"); } // 定义一个新的数组，将 scores 数组中的 5 个元素复制过来 // 同时留 3 个内存空间供以后开发使用 int[] newScores = (int[])Arrays.copyOf(scores,8); System.out.println("\n复制的新数组内容如下："); // 循环遍历复制后的新数组 for(int j=0;j<newScores.length;j++) { // 将新数组的元素输出 System.out.print(newScores[j]+"\t"); } } }在上述代码中，由于原数组 scores 的长度为 5，而要复制的新数组 newScores 的长度为 8，因此在将原数组中的 5 个元素复制完之后，会采用默认值填充剩余 3 个元素的内容。
因为原数组 scores 的数据类型为 int，而使用 Arrays.copyOf(scores,8) 方法复制数组之后返回的是 Object[] 类型，因此需要将 Object[] 数据类型强制转换为 int[] 类型。同时，也正因为 scores 的数据类型为 int，因此默认值为 0。
运行的结果如下所示。
原数组内容如下： 57 81 68 75 91 复制的新数组内容如下： 57 81 68 75 91 0 0 02. 使用 CopyOfRange() 方法对数组进行复制
Arrays 类的 CopyOfRange() 方法是另一种复制数组的方法，其语法形式如下：
Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)其中：
- srcArray 表示原数组。
- startIndex 表示开始复制的起始索引，目标数组中将包含起始索引对应的元素，另外，startIndex 必须在 0 到 srcArray.length 之间。
- endIndex 表示终止索引，目标数组中将不包含终止索引对应的元素，endIndex 必须大于等于 startIndex，可以大于 srcArray.length，如果大于 srcArray.length，则目标数组中使用默认值填充。
注意：目标数组如果已经存在，将会被重构。
例 2
假设有一个名称为 scores 的数组其元素为 8 个，现在需要定义一个名称为 newScores 的新数组。新数组的元素为 scores 数组的前 5 个元素，并且顺序不变。
使用 Arrays 类 copyOfRange() 方法完成数组复制的代码如下：
public class Test20 { public static void main(String[] args) { // 定义长度为8的数组 int scores[] = new int[] { 57, 81, 68, 75, 91, 66, 75, 84 }; System.out.println("原数组内容如下："); // 循环遍历原数组 for (int i = 0; i < scores.length; i++) { System.out.print(scores[i] + "\t"); } // 复制原数组的前5个元素到newScores数组中 int newScores[] = (int[]) Arrays.copyOfRange(scores, 0, 5); System.out.println("\n复制的新数组内容如下："); // 循环遍历目标数组，即复制后的新数组 for (int j = 0; j < newScores.length; j++) { System.out.print(newScores[j] + "\t"); } } }在上述代码中，原数组 scores 中包含有 8 个元素，使用 Arrays.copyOfRange() 方法可以将该数组复制到长度为 5 的 newScores 数组中，截取 scores 数组的前 5 个元素即可。
该程序运行结果如下所示。
原数组内容如下： 57 81 68 75 91 66 75 84 复制的新数组内容如下： 57 81 68 75 91 -
数组查询
Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定的数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查询需要。binarySearch()方法有两种参数类型。
（1）binarySearch(Object[], Object key)
语法：binarySeach(Object[] a, Object key)
a：要搜索的数组。
key：要搜索的值。
如果key包含在数组中，则返回搜索的索引；否则返回“-1”或“-”（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。
import java.util.Arrays;//导入java.util.Arrays public class Reference { public static void main(String[] args){ int arr[] = new int[]{1, 8, 9, 4, 5};//定义int型数组 Arrays.sort(arr);//将数组进行排序 int index = Arrays.binarySearch(arr, 4);//查找元素4的索引位置 System.out.println("4的索引位置是："+index);//输出索引 } }（2）binarySearch(Object[]., int fromIndex, int toIndex, Object key)
语法：binarySearch(Object[]., int fromIdex, int toIndex, Object key)a：要进行检索的数组。
fromIndex：指定范围的开始处索引（包含）。
toIndex：指定范围的结束处索引（不包含）。
key：要搜索的元素。
注意：如果指定的返回大于或等于数组的长度，则会报出ArrayIndexoutOfBoundsException异常
import java.util.Arrays;//导入java.util.Arrays public class Rakel { public static void main(String[] args){ String str[] = new String[]{"ab", "cd", "ef", "yz"};//定义String型数组str Arrays.sort(str);//对数组进行排序 int index = Arrays.binarySearch(str, 0, 2, "cd");//在制定范围内搜索元素“cd”的索引位置 System.out.println("cd的索引位置是："+index);//将索引输出 } }
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
