Java笔记(13)：常见对象--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工具类的其他方法。

posted @ 2017-05-28 18:50  花醉红尘  阅读(533)  评论(0)  编辑  收藏  举报