zoukankan      html  css  js  c++  java
  • 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工具类的其他方法。

    如欢如殇 授以青春鲜活肢体奔忙 如思如忘 驱以老朽深沉灵魂冥想 始自情热激荡 从未敢终于世事炎凉 无能执手相望 无法去尝试结发同床 无力至心死身僵 一息坚强 ------ 我一直没有放弃,如果你也能看到 修身 修禅
  • 相关阅读:
    KafkaUtils.createDirectStream()参数详解
    Kafka ConsumerRecord Timestamp
    HBase简介
    KAFKA分区、生产者、消费者之间的关系
    Hive中实现SELECT TOP N的方法
    Hive数据模型之历史拉链表
    Scala模式匹配
    sqoop参数详解
    HIVE SQL产生的文件数量及参数调优
    Scala基础语法
  • 原文地址:https://www.cnblogs.com/lz2lhy/p/6915484.html
Copyright © 2011-2022 走看看