java中常见对象——数组
数组冒泡排序：
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
demo： |
public class ArrayDemo { public static void main(String[] args) { // 定义一个数组 int[] arr = { 24, 69, 80, 57, 13 }; System.out.println("排序前："); printArray(arr);
/* // 第一次比较 // arr.length - 1是为了防止数据越界 // arr.length - 1 - 0是为了减少比较的次数 for (int x = 0; x < arr.length - 1 - 0; x++) { if (arr[x] > arr[x + 1]) { int temp = arr[x]; arr[x] = arr[x + 1]; arr[x + 1] = temp; } } System.out.println("第一次比较后："); printArray(arr);
// 第二次比较 // arr.length - 1是为了防止数据越界 // arr.length - 1 - 1是为了减少比较的次数 for (int x = 0; x < arr.length - 1 - 1; x++) { if (arr[x] > arr[x + 1]) { int temp = arr[x]; arr[x] = arr[x + 1]; arr[x + 1] = temp; } } System.out.println("第二次比较后："); printArray(arr);
// 第三次比较 // arr.length - 1是为了防止数据越界 // arr.length - 1 - 2是为了减少比较的次数 for (int x = 0; x < arr.length - 1 - 2; x++) { if (arr[x] > arr[x + 1]) { int temp = arr[x]; arr[x] = arr[x + 1]; arr[x + 1] = temp; } } System.out.println("第三次比较后："); printArray(arr);
// 第四次比较 // arr.length - 1是为了防止数据越界 // arr.length - 1 - 3是为了减少比较的次数 for (int x = 0; x < arr.length - 1 - 3; x++) { if (arr[x] > arr[x + 1]) { int temp = arr[x]; arr[x] = arr[x + 1]; arr[x + 1] = temp; } } System.out.println("第四次比较后："); printArray(arr); */
// 既然听懂了，那么上面的代码就是排序代码 // 而上面的代码重复度太高了，所以用循环改进 // for (int y = 0; y < 4; y++) { // for (int x = 0; x < arr.length - 1 - y; x++) { // if (arr[x] > arr[x + 1]) { // int temp = arr[x]; // arr[x] = arr[x + 1]; // arr[x + 1] = temp; // } // } // }
/* // 由于我们知道比较的次数是数组长度-1次，所以改进最终版程序 for (int x = 0; x < arr.length - 1; x++) { for (int y = 0; y < arr.length - 1 - x; y++) { if (arr[y] > arr[y + 1]) { int temp = arr[y]; arr[y] = arr[y + 1]; arr[y + 1] = temp; } } } System.out.println("排序后："); printArray(arr); */
//由于我可能有多个数组要排序，所以我要写成方法 bubbleSort(arr); System.out.println("排序后："); printArray(arr); }
//冒泡排序代码 public static void bubbleSort(int[] arr){ for (int x = 0; x < arr.length - 1; x++) { for (int y = 0; y < arr.length - 1 - x; y++) { if (arr[y] > arr[y + 1]) { int temp = arr[y]; arr[y] = arr[y + 1]; arr[y + 1] = temp; } } } }
// 遍历功能 public static void printArray(int[] arr) { System.out.print("["); for (int x = 0; x < arr.length; x++) { if (x == arr.length - 1) { System.out.print(arr[x]); } else { System.out.print(arr[x] + ", "); } } System.out.println("]"); } } |
数组排序之选择排序：
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
Demo: |
public class ArrayDemo { public static void main(String[] args) { // 定义一个数组 int[] arr = { 24, 69, 80, 57, 13 }; System.out.println("排序前："); printArray(arr);
/* // 第一次 int x = 0; for (int y = x + 1; y < arr.length; y++) { if (arr[y] < arr[x]) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } System.out.println("第一次比较后："); printArray(arr);
// 第二次 x = 1; for (int y = x + 1; y < arr.length; y++) { if (arr[y] < arr[x]) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } System.out.println("第二次比较后："); printArray(arr);
// 第三次 x = 2; for (int y = x + 1; y < arr.length; y++) { if (arr[y] < arr[x]) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } System.out.println("第三次比较后："); printArray(arr);
// 第四次 x = 3; for (int y = x + 1; y < arr.length; y++) { if (arr[y] < arr[x]) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } System.out.println("第四次比较后："); printArray(arr); */
/* //通过观察发现代码的重复度太高，所以用循环改进 for(int x=0; x<arr.length-1; x++){ for(int y=x+1; y<arr.length; y++){ if(arr[y] <arr[x]){ int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } } System.out.println("排序后："); printArray(arr); */
//用方法改进 selectSort(arr); System.out.println("排序后："); printArray(arr);
}
public static void selectSort(int[] arr){ for(int x=0; x<arr.length-1; x++){ for(int y=x+1; y<arr.length; y++){ if(arr[y] <arr[x]){ int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } } }
// 遍历功能 public static void printArray(int[] arr) { System.out.print("["); for (int x = 0; x < arr.length; x++) { if (x == arr.length - 1) { System.out.print(arr[x]); } else { System.out.print(arr[x] + ", "); } } System.out.println("]"); } } |
把字符串中的字符进行排序:
举例："dacgebf"
结果："abcdefg"
分析：
A:定义一个字符串
B:把字符串转换为字符数组
C:把字符数组进行排序
D:把排序后的字符数组转成字符串
E:输出最后的字符串
Demo: |
public class ArrayTest { public static void main(String[] args) { // 定义一个字符串 String s = "dacgebf";
// 把字符串转换为字符数组 char[] chs = s.toCharArray();
// 把字符数组进行排序 bubbleSort(chs);
//把排序后的字符数组转成字符串 String result = String.valueOf(chs);
//输出最后的字符串 System.out.println("result:"+result); }
// 冒泡排序 public static void bubbleSort(char[] chs) { for (int x = 0; x < chs.length - 1; x++) { for (int y = 0; y < chs.length - 1 - x; y++) { if (chs[y] > chs[y + 1]) { char temp = chs[y]; chs[y] = chs[y + 1]; chs[y + 1] = temp; } } } } }
|
数据的二分查找：
查找：
基本查找:数组元素无序(从头找到尾)
二分查找(折半查找):数组元素有序
分析：
A:定义最大索引，最小索引
B:计算出中间索引
C:拿中间索引的值和要查找的值进行比较
相等：就返回当前的中间索引
不相等：
大 左边找
小 右边找
D:重新计算出中间索引
大 左边找
max = mid - 1;
小 右边找
min = mid + 1;
E:回到B
Demo: |
public class ArrayDemo { public static void main(String[] args) { //定义一个数组 int[] arr = {11,22,33,44,55,66,77};
//写功能实现 int index = getIndex(arr, 33); System.out.println("index:"+index);
//假如这个元素不存在后有什么现象呢? index = getIndex(arr, 333); System.out.println("index:"+index); }
/* * 两个明确： * 返回值类型：int * 参数列表：int[] arr,int value */ public static int getIndex(int[] arr,int value){ //定义最大索引，最小索引 int max = arr.length -1; int min = 0;
//计算出中间索引 int mid = (max +min)/2;
//拿中间索引的值和要查找的值进行比较 while(arr[mid] != value){ if(arr[mid]>value){ max = mid - 1; }else if(arr[mid]<value){ min = mid + 1; }
//加入判断 if(min > max){ return -1; }
mid = (max +min)/2; }
return mid; } } |
Arrays:针对数组进行操作的工具类。比如说排序和查找。
1:public static String toString(int[] a) 把数组转成字符串
2:public static void sort(int[] a) 对数组进行排序
3:public static int binarySearch(int[] a,int key) 二分查找
public class ArraysDemo {
public static void main(String[] args) {
// 定义一个数组
int[] arr = { 24, 69, 80, 57, 13 };
// public static String toString(int[] a) 把数组转成字符串
System.out.println("排序前：" + Arrays.toString(arr));
// public static void sort(int[] a) 对数组进行排序
Arrays.sort(arr);
System.out.println("排序后：" + Arrays.toString(arr));
// [13, 24, 57, 69, 80]
// public static int binarySearch(int[] a,int key) 二分查找
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));
System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));
}
}
源码：
demo： |
public static String toString(int[] a) public static void sort(int[] a) 底层是快速排序，知道就可以了。有空看，有问题再问我 public static int binarySearch(int[] a,int key)
开发原则： 只要是对象，我们就要判断该对象是否为null。
int[] arr = { 24, 69, 80, 57, 13 }; System.out.println("排序前：" + Arrays.toString(arr));
public static String toString(int[] a) { //a -- arr -- { 24, 69, 80, 57, 13 }
if (a == null) return "null"; //说明数组对象不存在 int iMax = a.length - 1; //iMax=4; if (iMax == -1) return "[]"; //说明数组存在,但是没有元素。
StringBuilder b = new StringBuilder(); b.append('['); //"[" for (int i = 0; ; i++) { b.append(a[i]); //"[24, 69, 80, 57, 13" if (i == iMax) //"[24, 69, 80, 57, 13]" return b.append(']').toString(); b.append(", "); //"[24, 69, 80, 57, " } } -----------------------------------------------------
int[] arr = {13, 24, 57, 69, 80}; System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));
public static int binarySearch(int[] a, int key) { //a -- arr -- {13, 24, 57, 69, 80} //key -- 577 return binarySearch0(a, 0, a.length, key); }
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) { //a -- arr -- {13, 24, 57, 69, 80} //fromIndex -- 0 //toIndex -- 5 //key -- 577
int low = fromIndex; //low=0 int high = toIndex - 1; //high=4
while (low <= high) { int mid = (low + high) >>> 1; //mid=2,mid=3,mid=4 int midVal = a[mid]; //midVal=57,midVal=69,midVal=80
if (midVal < key) low = mid + 1; //low=3,low=4,low=5 else if (midVal > key) high = mid - 1; else return mid; // key found } return -(low + 1); // key not found. } |
