JavaSE重要知识点回顾（四）——基础语法篇

JavaSE重要知识点回顾（四）——基础语法篇

1.冒泡排序
冒泡排序规则，比较相邻的两个元素之间的大小，如果第一个比第二个大就交换他们，把最大的移动到最右边
使用java代码实现冒泡排序：

/***
 * 冒泡排序
 */
public class MapPao {
    public static void main(String[] args) {
        int[] arrrys = {25,69,13,59};
        /**
         * 观察上面的图可知，4个数需要循环三次。
         * 第1次循环4个数，比较3次
         * 第2次循环了3个数，比较了2次
         * 第3次循环2个数，比较了1次
         *
         */
        for (int i = arrrys.length - 1 ; i > 0 ; i--){

            for (int j = 0 ; j < i ; j++){
                if (arrrys[j] > arrrys[j+1]){
                        //交互数组的常用方式，找一个新的容器
                        int c =  0;
                        c = arrrys[j+1];
                        arrrys[j+1] = arrrys[j];
                        arrrys[j] = c;
                }
            }
        }
        for (int i = 0 ; i < arrrys.length ; i++){
            System.out.print(arrrys[i] + "  ");//13  25  59  69
        }

    }

}

2.选择排序
选择排序就是在一堆数中，找到最大（最小）的那个数，然后用这个数和第一个元素交换位置选择排序每一次交换位置都是有意义的

代码实现：

/***
 * 选择排序
 */
public class XuanZePaiXun {
    public static void main(String[] args) {
        int[] arrays = {3,1,6,2,5};
        //遍历数组，找出最小的元素和第一个元素交换位置
        for (int i = 0 ; i < arrays.length - 1 ; i++){
            //每一次比较后，需要交换的最左边下标从0开始一直在变化
            //此时的i正好是最左边元素的下标
            int min = i;
            for (int j = i + 1 ; j < arrays.length ; j++){
                //假设第一个元素是最小的，和后面的元素依次比较，找到最小的和最左变得元素交换位置
                if(arrays[j] < arrays[min]){
                    //此时最小的元素就下标就变成了j
                    min = j;
                }
            }
            //把最小的元素和最左边的元素交换位置
            int c = arrays[i];
            arrays[i] = arrays[min];
            arrays[min] = c;
        }

        for (int a : arrays){
            System.out.print(a + " ");//1 2 3 5 6 
        }
    }
}

选择排序和冒泡排序一定要弄清楚，这是面试中最基础的算法题。

3.二分法查找
二分法查找是在已经排序的基础之上进行的，比如：
代码实现;

public class ErFenFa {
    public static void main(String[] args) {
        int[] ars = {23,56,89,100,111,222,235,500,600};

        int result = erfenfa(ars,600);
        System.out.println(result == -1 ? "该元素不存在" : "该元素的下标为" + result);
    }

    /***
     *
     * @param ars 被查找的数组（这个数组必须是已经完成排序的）
     * @param dest 需要查找的元素
     * @return
     */
    private static int erfenfa(int[] ars, int dest) {
        //开始元素下标
        int begin = 0;
        //结束元素下标
        int end = ars.length - 1;

        while (begin <= end){
            //中间元素下标
            int mid = (begin + end) / 2;
            if(ars[mid] == dest){
                return mid;
            }else if (ars[mid] > dest){
                //目标元素在中间元素的左边
                //结束下标发生改变
                end = mid - 1;
            }else if (ars[mid] < dest){
                //目标元素在中间元素的右边
                //开始下标发生改变
                begin = mid + 1;
            }
        }

        return -1;
    }

}

以上算法在java中都有已经封好的方法，建议查看源码。

====================================================

java中的常用类

1.String类
String类是被final修饰的，所以String类不能被继承。
String类在java中的作用是创建字符串，字符串一旦创建就不可变。
当你创建了一个String对象后，你对String对象的修改并不是修改了原有的String对象，而是创建了一个全新的String对象。
创建String对象的两种方式
第一种：new String（）；使用new的方式会在堆内存中创建一个String对象，然后去字符串常量池中找该字符串，一定会有，因为字符串在编译阶段就已经在字符串常量池中创建好了。

第二种：使用" "。直接使用 " " 不会在堆内存中创建String对象，在编译阶段字符串在字符串常量池中创建。然后直接把字符串在字符串常量池中的内存地址返回给引用。
字符串常量池：
字符串常量池在方法区中，在类加载的时候就创建了字符串对象，用一次双引号就会在字符串常量池中创建一个字符串对象。如果使用new的形式创建字符串对象，那么引用会指向堆内存中的String对象，而堆内存中的String对象会保存方法区中字符串常量池中String类型变量的内存地址。

String s1 = new String(“hello”);
String s2 = new String(“hello”);

以上两句话共创建3个对像，在字符串常量池中创建了一个“hello”的字符串对象。在堆内存中创建了两个String类型的对象，一个对象指向引用s1，另一个指向引用s2。

String类中的常用方法
String类中有很多方法，以下是最常用的方法。


注意：String是不可变对象，所以不能创建进行大量的字符串拼操作，会造成内存溢出，给垃圾回收带来巨大的工作量。需要进行字符串拼接的话请使用StringBuffer和StringBulider。

StringBuffer和StringBuilder
StringBuffer:StringBuffer叫做字符串缓冲区，他的工作原理是，StringBuffer会预先申请一块内存空间，他的底层是byte类型的数组，初始化容量是16，这块内存空间用于存放字符串序列，如果字符串序列满了，他会自动改变缓存区的大小，容纳更多的字符串序列。StringBuffer是可变对象，append（）是追加字符串的方法。
StringBuffer其实就是可变的字符串对象，需要进行字符串拼接时，他把原来的字符串改为拼接后的，他的默认大小只有16，建议创建StringBuffer时，手动初始化一个大一点的空间。

StringBuilder和StringBuffer工作原理完全一致，唯一的区别是
StringBuffer是线程安全的，StringBuilder是非线程安全的。

下期接着常用类回顾，谢谢。