排序算法和设计模式

两种基本排序算法

冒泡排序

相邻元素两两进行比较，大的往后放，第一次比较完毕后，最大值在最大索引处。循环进行，直到全部比完。

代码：

public static voidbubbleSort(int[] arr) {
                                   for(int x=0;x<arr.length-1; x++){
                                          for(inty=0; y<arr.length-1-x; y++){
                                                 if(arr[y]>arr[y+1]){
                                                        inttemp = arr[y];
                                                        arr[y]= arr[y+1];
                                                        arr[y+1]= temp;
                                                 }
                                          }
                                   }
                            }

选择排序

拿0索引处的元素和后面所有元素依次比较，小的放大0索引处。第一次比较完毕，最小值出现在最小索引处。循环进行，直到全部比完。

代码：

public static voidselectSort(int[] arr) {
                                   for(int x=0;x<arr.length-1; x++){
                                          for(inty=x+1; y<arr.length; y++){
                                                 if(arr[x]>arr[y]){
                                                        inttemp = arr[y];
                                                        arr[y]= arr[x];
                                                        arr[x]= temp;
                                                 }
                                          }
                                   }
                            }

设计模式

就是前人总结的一些经验和思想，给我们提供了从抽象到具体的方法。

 

单例设计模式

定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

要素：

1，私有的构造方法。

2，指向自己实例的私有静态引用。

3，以自己实例为返回值的静态的公有的方法。

 

注意：单例模式根据实例化对象时机的不同分为两种：一种是饿汉式单例，一种是懒汉式单例。饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；而懒汉式在调用取得实例方法的时候才会实例化对象。

 

饿汉式单例

public class Single{
    private staticSingle singlet = new Single();
 
    private Single(){
    }
 
    public staticSingle getInstance() {
    returnsingleton;
    }
}

 

懒汉式单例

public class Single2 {
    private staticSingle2 single;
 
    privateSingle2() {
 
    }
 
    public staticsynchronized Single2 getInstance() {
 
       if (single ==null) {
 
           single =new Single2();
 
           }
       returnsingle;
    }
}
 

单例模式的优点：
1，在内存中只有一个对象，节省内存空间。
2，避免频繁的创建销毁对象，可以提高性能。
3，避免对共享资源的多重占用。
4，可以全局访问。

适用场景：

由于单例模式的以上优点，所以是编程中用的比较多的一种设计模式。
1，需要频繁实例化然后销毁的对象。
2，创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3，有状态的工具类对象。
4，频繁访问数据库或文件的对象。
5，以及其他我没用过的所有要求只有一个对象的场景。

注意事项：
1，只能使用单例类提供的方法得到单例对象，不要使用反射，否则将会实例化一个新对象。
2，不要做断开单例类对象与类中静态引用的危险操作。
3，多线程使用单例使用共享资源时，要注意线程安全问题。特别是使用懒汉式时会出现线程安全问题。