一、冒泡排序算法优化

主要思想：如果还没有遍历完所有的趟数就已经排好序了，就设置一个判断信息，结束循环。
具体代码实现如下：

  1. //封装方法：传入类型和数组，按传入的类型升序或者降序
  2.     public static void sort(int[] arr,String type) {
  3.         //需要遍历arr.length-1次
  4.         int n = arr.length;
  5.         for(int i=1;i<=n-1;i++) {  //i为遍历当前次数
  6.             //定义一个标记信息，判断是否排好序了排好序了为true
  7.             boolean flag =true;
  8.             //每次需比较n-i次
  9.             for(int j=0;j<=n-i-1;j++) {//j为每趟需比较的次数，同时为数组的下标
  10.                 //根据传入的排序类型进行排序
  11.                 if("升序".equals(type) || "sortUp".equals(type)) {
  12.                     //比较两个数的大小，并根据情况交换位置,此处需要数组的下标，为当前数于下一个数相比较
  13.                     if(arr[j]>arr[j+1]) {
  14.                         //转存arr[numIndex]
  15.                         int num = arr[j];
  16.                         //将arr[numIndex+1]的值赋给arr[numIndex]
  17.                         arr[j]=arr[j+1];
  18.                         //将arr[numIndex]的值(num)赋给arr[numIndex+1]
  19.                         arr[j+1]=num;
  20.                         //如果发生交换，说明还没有排好序，为false
  21.                         flag = false;
  22.                     }
  23.                 }else if("降序".equals(type) || "sortDown".equals(type)){
  24.                     if(arr[j]<arr[j+1]) {
  25.                         int num = arr[j];
  26.                         arr[j]=arr[j+1];
  27.                         arr[j]=num;
  28.                         //如果发生交换，说明还没有排好序，为false
  29.                         flag = false;
  30.                     }
  31.                 }else {
  32.                     throw new RuntimeException("您输入的排序方式有误，请输入“升序”“sortUp”“降序”“sortDown”");
  33.                 }
  35.             }
  36.             if(flag) {
  37.                 System.out.println("排了"+i+"次");
  38.                 return;
  39.             }
  40.         }
  41.     }

二、二分法查找（折半查找）

1、作用

查找一个数是否存在于某个数组

2、主要思想

（1）查找的数组首先需要进行升序排列
（2）将需要查找的值key与该数组的中间索引的值arr[center]相比较“
1）如果key>arr[center]，则下一次的查找范围变成arr[center+1]到arr[end]；
2）如果key 3）如果key=arr[center]，则表示查找到该数key;
4）如果开始下标大于结束下标，则表示该数不在这个数组中。
代码实现如下：

  1. public static void binarySeacher(int[] arr,int num) {//arr表示查找的数组，num：表示要查找的元素
  2.         //定义开始和结束下标
  3.         int startIdx = 0;
  4.         int endIdx = arr.length-1;
  5.         //通过循环来查找
  6.         while(startIdx<=endIdx) {
  7.             //获取中间位置的下标
  8.             int centerIdx = (startIdx+endIdx)/2;
  9.             //如果该元素大于中间位置的元素值
  10.             if(num>arr[centerIdx]) {
  11.                 //将开始下标设置为：中间位置+1
  12.                 startIdx = centerIdx+1;
  13.             }
  14.             //如果该元素小于中间位置的元素值
  15.             if(num<arr[centerIdx]) {
  16.                 //将结束下标设置为：中间位置-1
  17.                 endIdx = centerIdx - 1;
  18.             }
  19.             if(num==arr[centerIdx]) {
  20.                 //等于说明查找到了
  21.                 System.out.println("该元素存在于数组中，在第"+(centerIdx+1)+"位");
  22.                 return;//结束方法
  23.             }
  24.         }
  25.         //循环结束后方法还没有结束，说明没有找到该元素
  26.         System.out.println("该元素不存在于数组中");
  27.     }

三、插入排序法

  1. //int[] nums = {314,298,508,123,486,145};
  2. public static int[] injectionSort(int[] number) {
  3.         // 第一个元素作为一部分,对后面的部分进行循环
  4.         for (int j = 1; j < number.length; j++) {
  5.             //中转变量
  6.             int tmp = number[j];
  7.             //前一个数的下标
  8.             int i = j - 1;
  9.             //第一个数大于第二个数，交换位置
  10.             while (tmp < number[i]) {
  11.                 number[i + 1] = number[i];
  12.                 i--;
  13.                 if (i == -1)
  14.                     break;
  15.             }
  16.             //前一个数小于后一个数，位置不变number[j]=number[i+1]
  17.             number[i + 1] = tmp;
  18.         }
  19.         return number;
  20.     }

三、数组API使用

在java.util.Arrays的类中封装了许多方法，供操作数组使用。
注意：这些方法为Arrays的静态方法，需要通过类名Arrays来调用。
以下是一些常用的方法：

1、toString方法

以字符串的形式返回数组的内容。
注意：与Object类的toString方法区分：
1）这里为静态方法，通过类名调用；
2）Object类是成员方法，需通过创建对象来调用。

2、equals方法

比较两个数组的方式是否相等。
注意：与Object类的equals方法区分：
1）这里为静态方法，通过类名调用；
2）Object类是成员方法，需通过创建对象来调用。

3、fill方法

填充数组。

4、copyOf方法

复制数组。
注意：java.lang.System下也有一个复制数组的方法，这个方法更灵活，arraycopy。

5、sort方法

系统默认的排序方式是升序。
（1）基本数据类型：直接比较值的大小排序；
（2）引用数据类型：需要实现Comparable接口，重写comparaTo方法制定比较规则；
（3）自学Comparato。

6、binarySearch方法

二分法查找一个数是否在这个数组中，并返回索引位置。

四、可变参数

1、当使用一个方法，传入的参数的个数不固定时，可以设置可变参数，这样更加灵活。
2、传入多个参数时，多个参数之间用逗号隔开。
3、可传入数组对象。
4、定义语法：
public 返回值类型 方法名（参数类型…参数名）{功能代码}
具体调用该方法时：方法名（数组名） || 方法名（值1，值2，值3…）；
5、实质：传入的多个参数，被放进一个数组中，方法需要实现的功能通过遍历数组来实现。

五、StringBuilder和StringBuffer

字符串对象有三种：String类 \ StringBuilder类 \StringBuffer类。

1、String类

（1）String是不可变字符串。
（2）String对象存放的字符串内容是不可变的，底层的char是用final修饰的。在作相关操作的时候，只能产生新的字符串，不能在原字符串上修改。

2、StringBuilder类

（1）StringBuilder是可变字符串。线程不安全，效率高，使用较多。
（2）StringBuilder存放的字符串内容是可变的，在作相关操作的时候是在原字符串上修改，因此可以节约处理时间和存储空间。
（3）StringBuilder的常用API使用（和String类大同小异）
1）append():追加
2）delete():删除
3）insert():插入
4）reverse()：倒序
5）toString():转成String对象。
也可以用StringBuilder sb = new StringBuilder(需要转化的String对象);
6）replace():替换字符串内容
7）charAt():取出字符

3、 StringBuffer类

（1）StringBuffer是可变字符串。线程安全，效率低，使用较少。
（2）StringBuffer存放的字符串内容是可变的，在作相关操作的时候是在原字符串上修改，因此可以节约处理时间和存储空间。