首页 > 代码库 > Java笔记(07)：常见对象--StringBuffer、二分查找及排序算法
Java笔记(07)：常见对象--StringBuffer、二分查找及排序算法
1、StringBuffer类的构造方法
1 package cn.itcast_01; 2 3 /* 4 * 线程安全(多线程讲解) 5 * 安全 -- 同步 -- 数据是安全的 6 * 不安全 -- 不同步 -- 效率高一些 7 * 安全和效率问题是永远困扰我们的问题。 8 * 安全：医院的网站，银行网站 9 * 效率：新闻网站，论坛之类的 10 * 11 * StringBuffer: 12 * 线程安全的可变字符串。 13 * 14 * StringBuffer和String的区别? 15 * 前者长度和内容可变，后者不可变。 16 * 如果使用前者做字符串的拼接，不会浪费太多的资源。 17 * 18 * StringBuffer的构造方法： 19 * public StringBuffer():无参构造方法 20 * public StringBuffer(int capacity):指定容量的字符串缓冲区对象 21 * public StringBuffer(String str):指定字符串内容的字符串缓冲区对象 22 * 23 * StringBuffer的方法： 24 * public int capacity()：返回当前容量。 理论值 25 * public int length():返回长度（字符数）。 实际值 26 */ 27 public class StringBufferDemo { 28 public static void main(String[] args) { 29 // public StringBuffer():无参构造方法 30 StringBuffer sb = new StringBuffer(); 31 System.out.println("sb:" + sb); 32 System.out.println("sb.capacity():" + sb.capacity()); 33 System.out.println("sb.length():" + sb.length()); 34 System.out.println("--------------------------"); 35 36 // public StringBuffer(int capacity):指定容量的字符串缓冲区对象 37 StringBuffer sb2 = new StringBuffer(50); 38 System.out.println("sb2:" + sb2); 39 System.out.println("sb2.capacity():" + sb2.capacity()); 40 System.out.println("sb2.length():" + sb2.length()); 41 System.out.println("--------------------------"); 42 43 // public StringBuffer(String str):指定字符串内容的字符串缓冲区对象 44 StringBuffer sb3 = new StringBuffer("hello"); 45 System.out.println("sb3:" + sb3); 46 System.out.println("sb3.capacity():" + sb3.capacity()); 47 System.out.println("sb3.length():" + sb3.length()); 48 } 49 }
2、StringBuffer的添加功能
1 package cn.itcast_02; 2 3 /* 4 * StringBuffer的添加功能： 5 * public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身 6 * 7 * public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身 8 */ 9 public class StringBufferDemo { 10 public static void main(String[] args) { 11 // 创建字符串缓冲区对象 12 StringBuffer sb = new StringBuffer(); 13 14 // public StringBuffer append(String str) 15 // StringBuffer sb2 = sb.append("hello"); 16 // System.out.println("sb:" + sb); 17 // System.out.println("sb2:" + sb2); 18 // System.out.println(sb == sb2); // true 19 20 // 一步一步的添加数据 21 // sb.append("hello"); 22 // sb.append(true); 23 // sb.append(12); 24 // sb.append(34.56); 25 26 // 链式编程 27 sb.append("hello").append(true).append(12).append(34.56); 28 System.out.println("sb:" + sb); 29 30 // public StringBuffer insert(int offset,String 31 // str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身 32 sb.insert(5, "world"); 33 System.out.println("sb:" + sb); 34 } 35 }
3、StringBuffer的删除功能
1 package cn.itcast_03; 2 3 /* 4 * StringBuffer的删除功能 5 * public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身 6 * public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身 7 */ 8 public class StringBufferDemo { 9 public static void main(String[] args) { 10 // 创建对象 11 StringBuffer sb = new StringBuffer(); 12 13 // 添加功能 14 sb.append("hello").append("world").append("java"); 15 System.out.println("sb:" + sb); 16 17 // public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身 18 // 需求：我要删除e这个字符，肿么办? 19 // sb.deleteCharAt(1); 20 // 需求:我要删除第一个l这个字符，肿么办? 21 // sb.deleteCharAt(1); 22 23 // public StringBuffer delete(int start,int 24 // end):删除从指定位置开始指定位置结束的内容，并返回本身 25 // 需求：我要删除world这个字符串，肿么办? 26 // sb.delete(5, 10); 27 28 // 需求:我要删除所有的数据 29 sb.delete(0, sb.length()); 30 31 System.out.println("sb:" + sb); 32 } 33 }
4、StringBuffer的替换功能
1 package cn.itcast_04; 2 3 /* 4 * StringBuffer的替换功能： 5 * public StringBuffer replace(int start,int end,String str):从start开始到end用str替换 6 */ 7 public class StringBufferDemo { 8 public static void main(String[] args) { 9 // 创建字符串缓冲区对象 10 StringBuffer sb = new StringBuffer(); 11 12 // 添加数据 13 sb.append("hello"); 14 sb.append("world"); 15 sb.append("java"); 16 System.out.println("sb:" + sb); 17 18 // public StringBuffer replace(int start,int end,String 19 // str):从start开始到end用str替换 20 // 需求：我要把world这个数据替换为"节日快乐" 21 sb.replace(5, 10, "节日快乐"); 22 System.out.println("sb:" + sb); 23 } 24 }
5、StringBuffer的反转功能
1 package cn.itcast_05; 2 3 /* 4 * StringBuffer的反转功能： 5 * public StringBuffer reverse() 6 */ 7 public class StringBufferDemo { 8 public static void main(String[] args) { 9 // 创建字符串缓冲区对象 10 StringBuffer sb = new StringBuffer(); 11 12 // 添加数据 13 sb.append("霞青林爱我"); 14 System.out.println("sb:" + sb); 15 16 // public StringBuffer reverse() 17 sb.reverse(); 18 System.out.println("sb:" + sb); 19 } 20 }
6、StringBuffer的截取功能
1 package cn.itcast_06; 2 3 /* 4 * StringBuffer的截取功能:注意返回值类型不再是StringBuffer本身了 5 * public String substring(int start) 6 * public String substring(int start,int end) 7 */ 8 public class StringBufferDemo { 9 public static void main(String[] args) { 10 // 创建字符串缓冲区对象 11 StringBuffer sb = new StringBuffer(); 12 13 // 添加元素 14 sb.append("hello").append("world").append("java"); 15 System.out.println("sb:" + sb); 16 17 // 截取功能 18 // public String substring(int start) 19 String s = sb.substring(5); 20 System.out.println("s:" + s); 21 System.out.println("sb:" + sb); 22 23 // public String substring(int start,int end) 24 String ss = sb.substring(5, 10); 25 System.out.println("ss:" + ss); 26 System.out.println("sb:" + sb); 27 } 28 }
练习1、StringBuffer和String的相互转换
1 package cn.itcast_07; 2 3 /* 4 * 为什么我们要讲解类之间的转换： 5 * A -- B的转换 6 * 我们把A转换为B，其实是为了使用B的功能。 7 * B -- A的转换 8 * 我们可能要的结果是A类型，所以还得转回来。 9 * 10 * String和StringBuffer的相互转换? 11 */ 12 public class StringBufferTest { 13 public static void main(String[] args) { 14 // String -- StringBuffer 15 String s = "hello"; 16 // 注意：不能把字符串的值直接赋值给StringBuffer 17 // StringBuffer sb = "hello"; 18 // StringBuffer sb = s; 19 // 方式1:通过构造方法 20 StringBuffer sb = new StringBuffer(s); 21 // 方式2：通过append()方法 22 StringBuffer sb2 = new StringBuffer(); 23 sb2.append(s); 24 System.out.println("sb:" + sb); 25 System.out.println("sb2:" + sb2); 26 System.out.println("---------------"); 27 28 // StringBuffer -- String 29 StringBuffer buffer = new StringBuffer("java"); 30 // String(StringBuffer buffer) 31 // 方式1:通过构造方法 32 String str = new String(buffer); 33 // 方式2：通过toString()方法 34 String str2 = buffer.toString(); 35 System.out.println("str:" + str); 36 System.out.println("str2:" + str2); 37 } 38 }
练习2、把数组拼接成指定格式的字符串案例
1 package cn.itcast_07; 2 3 /* 4 * 把数组拼接成一个字符串 5 */ 6 public class StringBufferTest2 { 7 public static void main(String[] args) { 8 // 定义一个数组 9 int[] arr = { 44, 33, 55, 11, 22 }; 10 11 // 定义功能 12 // 方式1：用String做拼接的方式 13 String s1 = arrayToString(arr); 14 System.out.println("s1:" + s1); 15 16 // 方式2:用StringBuffer做拼接的方式 17 String s2 = arrayToString2(arr); 18 System.out.println("s2:" + s2); 19 } 20 21 // 用StringBuffer做拼接的方式 22 public static String arrayToString2(int[] arr) { 23 StringBuffer sb = new StringBuffer(); 24 25 sb.append("["); 26 for (int x = 0; x < arr.length; x++) { 27 if (x == arr.length - 1) { 28 sb.append(arr[x]); 29 } else { 30 sb.append(arr[x]).append(", "); 31 } 32 } 33 sb.append("]"); 34 35 return sb.toString(); 36 } 37 38 // 用String做拼接的方式 39 public static String arrayToString(int[] arr) { 40 String s = ""; 41 42 s += "["; 43 for (int x = 0; x < arr.length; x++) { 44 if (x == arr.length - 1) { 45 s += arr[x]; 46 } else { 47 s += arr[x]; 48 s += ", "; 49 } 50 } 51 s += "]"; 52 53 return s; 54 } 55 }
练习3、字符串反转功能案例
1 package cn.itcast_07; 2 3 import java.util.Scanner; 4 5 /* 6 * 把字符串反转 7 */ 8 public class StringBufferTest3 { 9 public static void main(String[] args) { 10 // 键盘录入数据 11 Scanner sc = new Scanner(System.in); 12 System.out.println("请输入数据："); 13 String s = sc.nextLine(); 14 15 // 方式1：用String做拼接 16 String s1 = myReverse(s); 17 System.out.println("s1:" + s1); 18 // 方式2：用StringBuffer的reverse()功能 19 String s2 = myReverse2(s); 20 System.out.println("s2:" + s2); 21 } 22 23 // 用StringBuffer的reverse()功能 24 public static String myReverse2(String s) { 25 // StringBuffer sb = new StringBuffer(); 26 // sb.append(s); 27 28 // StringBuffer sb = new StringBuffer(s); 29 // sb.reverse(); 30 // return sb.toString(); 31 32 // 简易版 33 return new StringBuffer(s).reverse().toString(); 34 } 35 36 // 用String做拼接 37 public static String myReverse(String s) { 38 String result = ""; 39 40 char[] chs = s.toCharArray(); 41 for (int x = chs.length - 1; x >= 0; x--) { 42 // char ch = chs[x]; 43 // result += ch; 44 result += chs[x]; 45 } 46 47 return result; 48 } 49 }
练习4、判断一个字符串是否对称案例
1 package cn.itcast_07; 2 3 import java.util.Scanner; 4 5 /* 6 * 判断一个字符串是否是对称字符串 7 * 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串 8 * 9 * 分析： 10 * 判断一个字符串是否是对称的字符串，我只需要把 11 * 第一个和最后一个比较 12 * 第二个和倒数第二个比较 13 * ... 14 * 比较的次数是长度除以2。 15 */ 16 public class StringBufferTest4 { 17 public static void main(String[] args) { 18 // 创建键盘录入对象 19 Scanner sc = new Scanner(System.in); 20 System.out.println("请输入一个字符串："); 21 String s = sc.nextLine(); 22 23 // 一个一个的比较 24 boolean b = isSame(s); 25 System.out.println("b:" + b); 26 27 //用字符串缓冲区的反转功能 28 boolean b2 = isSame2(s); 29 System.out.println("b2:"+b2); 30 } 31 32 public static boolean isSame2(String s) { 33 return new StringBuffer(s).reverse().toString().equals(s); 34 } 35 36 37 // public static boolean isSame(String s) { 38 // // 把字符串转成字符数组 39 // char[] chs = s.toCharArray(); 40 // 41 // for (int start = 0, end = chs.length - 1; start <= end; start++, end--) { 42 // if (chs[start] != chs[end]) { 43 // return false; 44 // } 45 // } 46 // 47 // return true; 48 // } 49 50 public static boolean isSame(String s) { 51 boolean flag = true; 52 53 // 把字符串转成字符数组 54 char[] chs = s.toCharArray(); 55 56 for (int start = 0, end = chs.length - 1; start <= end; start++, end--) { 57 if (chs[start] != chs[end]) { 58 flag = false; 59 break; 60 } 61 } 62 63 return flag; 64 } 65 }
练习5、String和StringBuffer分别作为参数传递（注意理解）
1 package cn.itcast_08; 2 3 /* 4 * 面试题： 5 * 1：String,StringBuffer,StringBuilder的区别? 6 * A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。 7 * B:StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高 8 * 9 * 2：StringBuffer和数组的区别? 10 * 二者都可以看出是一个容器，装其他的数据。 11 * 但是呢,StringBuffer的数据最终是一个字符串数据。 12 * 而数组可以放置多种数据，但必须是同一种数据类型的。 13 * 14 * 3:形式参数问题 15 * String作为参数传递 16 * StringBuffer作为参数传递 17 * 18 * 形式参数： 19 * 基本类型：形式参数的改变不影响实际参数 20 * 引用类型：形式参数的改变直接影响实际参数 21 * 22 * 注意： 23 * String作为参数传递，效果和基本类型作为参数传递是一样的。 24 */ 25 public class StringBufferDemo { 26 public static void main(String[] args) { 27 String s1 = "hello"; 28 String s2 = "world"; 29 System.out.println(s1 + "---" + s2);// hello---world 30 change(s1, s2); 31 System.out.println(s1 + "---" + s2);// hello---world 32 33 StringBuffer sb1 = new StringBuffer("hello"); 34 //System.out.println("sb1:" + sb1); 35 StringBuffer sb2 = new StringBuffer("world"); 36 //sb1=sb2;//改变sb1的地址 37 System.out.println(sb1 + "---" + sb2);// hello---world 38 change(sb1, sb2); 39 System.out.println(sb1 + "---" + sb2);// hello---worldworld 40 41 } 42 43 public static void change(StringBuffer sb1, StringBuffer sb2) { 44 // sb1=sb1.append("abc");形式参数的改变直接影响实际参数 45 sb1 = sb2;// 不影响主函数中sb1的引用地址 46 sb2.append(sb1);// sb2地址中的值发生改变 47 } 48 49 public static void change(String s1, String s2) { 50 s1 = s2; 51 s2 = s1 + s2; 52 } 53 }
排序算法：
1、冒泡排序
1 package cn.itcast_01; 2 3 /* 4 * 数组排序之冒泡排序： 5 * 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处 6 */ 7 public class ArrayDemo { 8 public static void main(String[] args) { 9 // 定义一个数组 10 int[] arr = { 24, 69, 80, 57, 13 }; 11 System.out.println("排序前："); 12 printArray(arr); 13 14 /* 15 // 第一次比较 16 // arr.length - 1是为了防止数据越界 17 // arr.length - 1 - 0是为了减少比较的次数 18 for (int x = 0; x < arr.length - 1 - 0; x++) { 19 if (arr[x] > arr[x + 1]) { 20 int temp = arr[x]; 21 arr[x] = arr[x + 1]; 22 arr[x + 1] = temp; 23 } 24 } 25 System.out.println("第一次比较后："); 26 printArray(arr); 27 28 // 第二次比较 29 // arr.length - 1是为了防止数据越界 30 // arr.length - 1 - 1是为了减少比较的次数 31 for (int x = 0; x < arr.length - 1 - 1; x++) { 32 if (arr[x] > arr[x + 1]) { 33 int temp = arr[x]; 34 arr[x] = arr[x + 1]; 35 arr[x + 1] = temp; 36 } 37 } 38 System.out.println("第二次比较后："); 39 printArray(arr); 40 41 // 第三次比较 42 // arr.length - 1是为了防止数据越界 43 // arr.length - 1 - 2是为了减少比较的次数 44 for (int x = 0; x < arr.length - 1 - 2; x++) { 45 if (arr[x] > arr[x + 1]) { 46 int temp = arr[x]; 47 arr[x] = arr[x + 1]; 48 arr[x + 1] = temp; 49 } 50 } 51 System.out.println("第三次比较后："); 52 printArray(arr); 53 54 // 第四次比较 55 // arr.length - 1是为了防止数据越界 56 // arr.length - 1 - 3是为了减少比较的次数 57 for (int x = 0; x < arr.length - 1 - 3; x++) { 58 if (arr[x] > arr[x + 1]) { 59 int temp = arr[x]; 60 arr[x] = arr[x + 1]; 61 arr[x + 1] = temp; 62 } 63 } 64 System.out.println("第四次比较后："); 65 printArray(arr); 66 */ 67 68 // 既然听懂了，那么上面的代码就是排序代码 69 // 而上面的代码重复度太高了，所以用循环改进 70 // for (int y = 0; y < 4; y++) { 71 // for (int x = 0; x < arr.length - 1 - y; x++) { 72 // if (arr[x] > arr[x + 1]) { 73 // int temp = arr[x]; 74 // arr[x] = arr[x + 1]; 75 // arr[x + 1] = temp; 76 // } 77 // } 78 // } 79 80 /* 81 // 由于我们知道比较的次数是数组长度-1次，所以改进最终版程序 82 for (int x = 0; x < arr.length - 1; x++) { 83 for (int y = 0; y < arr.length - 1 - x; y++) { 84 if (arr[y] > arr[y + 1]) { 85 int temp = arr[y]; 86 arr[y] = arr[y + 1]; 87 arr[y + 1] = temp; 88 } 89 } 90 } 91 System.out.println("排序后："); 92 printArray(arr); 93 */ 94 95 //由于我可能有多个数组要排序，所以我要写成方法 96 bubbleSort(arr); 97 System.out.println("排序后："); 98 printArray(arr); 99 } 100 101 //冒泡排序代码 102 public static void bubbleSort(int[] arr){ 103 for (int x = 0; x < arr.length - 1; x++) { 104 for (int y = 0; y < arr.length - 1 - x; y++) { 105 if (arr[y] > arr[y + 1]) { 106 int temp = arr[y]; 107 arr[y] = arr[y + 1]; 108 arr[y + 1] = temp; 109 } 110 } 111 } 112 } 113 114 // 遍历功能 115 public static void printArray(int[] arr) { 116 System.out.print("["); 117 for (int x = 0; x < arr.length; x++) { 118 if (x == arr.length - 1) { 119 System.out.print(arr[x]); 120 } else { 121 System.out.print(arr[x] + ", "); 122 } 123 } 124 System.out.println("]"); 125 } 126 }
2、选择排序
1 package cn.itcast_02; 2 3 /* 4 * 数组排序之选择排序： 5 * 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处 6 */ 7 public class ArrayDemo { 8 public static void main(String[] args) { 9 // 定义一个数组 10 int[] arr = { 24, 69, 80, 57, 13 }; 11 System.out.println("排序前："); 12 printArray(arr); 13 14 /* 15 // 第一次 16 int x = 0; 17 for (int y = x + 1; y < arr.length; y++) { 18 if (arr[y] < arr[x]) { 19 int temp = arr[x]; 20 arr[x] = arr[y]; 21 arr[y] = temp; 22 } 23 } 24 System.out.println("第一次比较后："); 25 printArray(arr); 26 27 // 第二次 28 x = 1; 29 for (int y = x + 1; y < arr.length; y++) { 30 if (arr[y] < arr[x]) { 31 int temp = arr[x]; 32 arr[x] = arr[y]; 33 arr[y] = temp; 34 } 35 } 36 System.out.println("第二次比较后："); 37 printArray(arr); 38 39 // 第三次 40 x = 2; 41 for (int y = x + 1; y < arr.length; y++) { 42 if (arr[y] < arr[x]) { 43 int temp = arr[x]; 44 arr[x] = arr[y]; 45 arr[y] = temp; 46 } 47 } 48 System.out.println("第三次比较后："); 49 printArray(arr); 50 51 // 第四次 52 x = 3; 53 for (int y = x + 1; y < arr.length; y++) { 54 if (arr[y] < arr[x]) { 55 int temp = arr[x]; 56 arr[x] = arr[y]; 57 arr[y] = temp; 58 } 59 } 60 System.out.println("第四次比较后："); 61 printArray(arr); 62 */ 63 64 /* 65 //通过观察发现代码的重复度太高，所以用循环改进 66 for(int x=0; x<arr.length-1; x++){ 67 for(int y=x+1; y<arr.length; y++){ 68 if(arr[y] <arr[x]){ 69 int temp = arr[x]; 70 arr[x] = arr[y]; 71 arr[y] = temp; 72 } 73 } 74 } 75 System.out.println("排序后："); 76 printArray(arr); 77 */ 78 79 //用方法改进 80 selectSort(arr); 81 System.out.println("排序后："); 82 printArray(arr); 83 84 } 85 86 public static void selectSort(int[] arr){ 87 for(int x=0; x<arr.length-1; x++){ 88 for(int y=x+1; y<arr.length; y++){ 89 if(arr[y] <arr[x]){ 90 int temp = arr[x]; 91 arr[x] = arr[y]; 92 arr[y] = temp; 93 } 94 } 95 } 96 } 97 98 // 遍历功能 99 public static void printArray(int[] arr) { 100 System.out.print("["); 101 for (int x = 0; x < arr.length; x++) { 102 if (x == arr.length - 1) { 103 System.out.print(arr[x]); 104 } else { 105 System.out.print(arr[x] + ", "); 106 } 107 } 108 System.out.println("]"); 109 } 110 }
练习：
1 package cn.itcast_03; 2 3 /* 4 * 把字符串中的字符进行排序。 5 * 举例："dacgebf" 6 * 结果："abcdefg" 7 * 8 * 分析： 9 * A:定义一个字符串 10 * B:把字符串转换为字符数组 11 * C:把字符数组进行排序 12 * D:把排序后的字符数组转成字符串 13 * E:输出最后的字符串 14 */ 15 public class ArrayTest { 16 public static void main(String[] args) { 17 // 定义一个字符串 18 String s = "dacgebf"; 19 20 // 把字符串转换为字符数组 21 char[] chs = s.toCharArray(); 22 23 // 把字符数组进行排序 24 bubbleSort(chs); 25 26 //把排序后的字符数组转成字符串 27 String result = String.valueOf(chs); 28 29 //输出最后的字符串 30 System.out.println("result:"+result); 31 } 32 33 // 冒泡排序 34 public static void bubbleSort(char[] chs) { 35 for (int x = 0; x < chs.length - 1; x++) { 36 for (int y = 0; y < chs.length - 1 - x; y++) { 37 if (chs[y] > chs[y + 1]) { 38 char temp = chs[y]; 39 chs[y] = chs[y + 1]; 40 chs[y + 1] = temp; 41 } 42 } 43 } 44 } 45 }
二分查找
1 package cn.itcast_04; 2 3 /* 4 * 查找： 5 * 基本查找:数组元素无序(从头找到尾) 6 * 二分查找(折半查找):数组元素有序 7 * 8 * 分析： 9 * A:定义最大索引，最小索引 10 * B:计算出中间索引 11 * C:拿中间索引的值和要查找的值进行比较 12 * 相等：就返回当前的中间索引 13 * 不相等： 14 * 大 左边找 15 * 小 右边找 16 * D:重新计算出中间索引 17 * 大 左边找 18 * max = mid - 1; 19 * 小 右边找 20 * min = mid + 1; 21 * E:回到B 22 */ 23 public class ArrayDemo { 24 public static void main(String[] args) { 25 //定义一个数组 26 int[] arr = {11,22,33,44,55,66,77}; 27 28 //写功能实现 29 int index = getIndex(arr, 33); 30 System.out.println("index:"+index); 31 32 //假如这个元素不存在后有什么现象呢? 33 index = getIndex(arr, 333); 34 System.out.println("index:"+index); 35 } 36 37 /* 38 * 两个明确： 39 * 返回值类型：int 40 * 参数列表：int[] arr,int value 41 */ 42 public static int getIndex(int[] arr,int value){ 43 //定义最大索引，最小索引 44 int max = arr.length -1; 45 int min = 0; 46 47 //计算出中间索引 48 int mid = (max +min)/2; 49 50 //拿中间索引的值和要查找的值进行比较 51 while(arr[mid] != value){ 52 if(arr[mid]>value){ 53 max = mid - 1; 54 }else if(arr[mid]<value){ 55 min = mid + 1; 56 } 57 58 //加入判断 59 if(min > max){ 60 return -1; 61 } 62 63 mid = (max +min)/2; 64 } 65 66 return mid; 67 } 68 }
二分查找的注意事项：
1 package cn.itcast_04; 2 3 /* 4 * 注意：下面这种做法是有问题的。 5 * 因为数组本身是无序的，所以这种情况下的查找不能使用二分查找。 6 * 所以你先排序了，但是你排序的时候已经改变了我最原始的元素索引。 7 */ 8 public class ArrayDemo2 { 9 public static void main(String[] args) { 10 // 定义数组 11 int[] arr = { 24, 69, 80, 57, 13 }; 12 13 // 先排序 14 bubbleSort(arr); 15 // 后查找 16 int index = getIndex(arr, 80); 17 System.out.println("index:" + index); 18 } 19 20 // 冒泡排序代码 21 public static void bubbleSort(int[] arr) { 22 for (int x = 0; x < arr.length - 1; x++) { 23 for (int y = 0; y < arr.length - 1 - x; y++) { 24 if (arr[y] > arr[y + 1]) { 25 int temp = arr[y]; 26 arr[y] = arr[y + 1]; 27 arr[y + 1] = temp; 28 } 29 } 30 } 31 } 32 33 // 二分查找 34 public static int getIndex(int[] arr, int value) { 35 // 定义最大索引，最小索引 36 int max = arr.length - 1; 37 int min = 0; 38 39 // 计算出中间索引 40 int mid = (max + min) / 2; 41 42 // 拿中间索引的值和要查找的值进行比较 43 while (arr[mid] != value) { 44 if (arr[mid] > value) { 45 max = mid - 1; 46 } else if (arr[mid] < value) { 47 min = mid + 1; 48 } 49 50 // 加入判断 51 if (min > max) { 52 return -1; 53 } 54 55 mid = (max + min) / 2; 56 } 57 58 return mid; 59 } 60 }
Arrays工具类的概述和使用：
1 package cn.itcast_05; 2 3 import java.util.Arrays; 4 5 /* 6 * Arrays:针对数组进行操作的工具类。比如说排序和查找。 7 * 1:public static String toString(int[] a) 把数组转成字符串 8 * 2:public static void sort(int[] a) 对数组进行排序 9 * 3:public static int binarySearch(int[] a,int key) 二分查找 10 */ 11 public class ArraysDemo { 12 public static void main(String[] args) { 13 // 定义一个数组 14 int[] arr = { 24, 69, 80, 57, 13 }; 15 16 // public static String toString(int[] a) 把数组转成字符串 17 System.out.println("排序前：" + Arrays.toString(arr)); 18 19 // public static void sort(int[] a) 对数组进行排序 20 Arrays.sort(arr); 21 System.out.println("排序后：" + Arrays.toString(arr)); 22 23 // [13, 24, 57, 69, 80] 24 // public static int binarySearch(int[] a,int key) 二分查找 25 System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57)); 26 System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577)); 27 } 28 }
通过api文档查看Arrays工具类的其他方法。
Java笔记(07)：常见对象--StringBuffer、二分查找及排序算法
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。