冒泡排序、选择排序、二分查找、单例模式、生产消费者模型

一、冒泡排序

import java.util.Arrays;
public class Bubble {
    public static void main(String[] args) {
        int[]a= {-1,-99,20,11-3,188,21};
        int tem1;
        for(int i=0;i

二、选择排序

package testdemo;

import java.util.Arrays;

public class Selected {

    public static void main(String[] args) {            
        int[] arr = {12,1,23,53,-99,17,0,888};
        int max=0;
        int index=0;        
        for(int i=0;i

三、二分查找

package testdemo;

public class Banary {

    public static void main(String[] args) {
        //首先得是一个有序数组！！！
        int [] a= {1,2,3,4,5,6,7,8,9};
        //所要索引得数据
        int key=6;  
        
        //返回所要查找的数据的对应数组索引
        int search = binSearch(a,key);
        System.out.println(search);
    }
        
    public static int binSearch(int []arr,int key) {        
        //数组的长度
        int len=arr.length;
        //高位（最后一位）索引
        int high=len-1;
        //低位索引（0）
        int low=0;      
        //如果高位索引等于小于低位索引跳出寻呼
        while(low<=high) {
            //二分从这儿开始定义中间位索引
            int mid=(high-low)/2+low;
            //如果中间位的数值等于所要索引的数据的值则返回中间位索引
            if(arr[mid]==key) {
                return mid;
            //如果中间位的值小于所要索引的数据 的值，则低位索引切换为中间位索引+1（索引从0开始）
            }else if(arr[mid]

四、单例模式

• 优点：节省静态方法区中的内存，使用时效率高。
• 缺点：相对静态来讲，效率还是要低一些。

设计要点

• 私有化构造方法
• 自己创建对象并记录住
• 保证整个变量的安全

• 懒汉式：线程不安全，解决方法

//懒汉式   饱汉式 
public class MyTool {

    private static MyTool myTool = null;
    //私有话构造方法, 让使用者无法new对象
    //这样使用者就没有办法创建多个对象了
    private MyTool(){}
    //提供一个静态方法, 使用者调用这个方法可以获取对象
    //这样,我们就可以控制创建的对象了
    public static MyTool getInstance(){
        //第一次访问时,发现变量中没有记录对象, 就新建对象
        //如果已经创建过对象,就直接返回
        if(myTool==null){
            myTool = new MyTool();
        }
        
        return myTool; 
    }
    
}

饿汉式：线程安全

//饿汉式
public class MyTool2 {

    private static MyTool2 myTool = new MyTool2();
    //私有话构造方法, 让使用者无法new对象
    //这样使用者就没有办法创建多个对象了
    private MyTool2(){}
    //提供一个静态方法, 使用者调用这个方法可以获取对象
    //这样,我们就可以控制创建的对象了
    public static MyTool2 getInstance(){
        
        return myTool; 
    }
    
}

饿汉式2：

//饿汉式
public class MyTool3 {
    public static final MyTool3 MY_TOOL = new MyTool3();
    //私有话构造方法, 让使用者无法new对象
    //这样使用者就没有办法创建多个对象了
    private MyTool3(){}
}

五、生产消费者模型

• 生产者线：母鸡，如果容器中没有空位（装满鸡蛋）则母鸡线程进入等待，只要容器中有空位则唤醒母鸡线程，生产鸡蛋。同时只要容器中有鸡蛋就要唤醒消费者线程。

• 消费者线程：吃货，如果容器中的没有对象（没有鸡蛋size()=0）则吃货线程进入等待，只要容器中有鸡蛋吃货线程就持续运行，同时只要容器中有空位就应该唤醒母鸡线程进行生产

• 容器：唯一的，有容量限制的，公用的资源。

• 注意事项：sychronized（）锁的是公用对象即list，也可以锁个大招。但是不能锁this。 线程等待与唤醒方法应该由锁对象进行调用。

package testdemo;

import java.util.LinkedList;

/**
 * 
 * @author 86183
 *
 */
class Egg{
    private int eggId;

    public Egg() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Egg(int eggId) {
        super();
        this.eggId = eggId;
    }

    public int getEggId() {
        return eggId;
    }

    public void setEggId(int eggId) {
        this.eggId = eggId;
    }

    @Override
    public String toString() {
        return "Egg [eggId=" + eggId + "]";
    }
}
/**
 * 生产者线程
 * @author 86183
 *
 */
class Hen implements Runnable{
    private int iCounter=1;
    //公共容器
    private LinkedList list;
    
    //由外部传入
    public Hen(LinkedList list) {
        this.list=list;
    }


    @Override
    public void run() {
        while(true) {
            
            //一次执行需要保证不可分割的原子性操作
            synchronized(list) {
                if(list.size()==10) {
                        try {
                            list.wait();
                        } catch (InterruptedException e1) {
                            // TODO Auto-generated catch block
                            e1.printStackTrace();
                        }
                    }
                //如果容器没有满则母鸡下蛋母鸡生产一个鸡蛋          
                Egg e = new Egg(iCounter);
                iCounter++;
                //将鸡蛋放入容器中
                list.push(e);
                System.out.println(Thread.currentThread().getName()+"生产了"+e);           
                //只要篮子里鸡蛋不为0就要唤醒吃货线程
                list.notify();                      
            }   
        }
    }   
}

/**
 * 消费者线程
 * @author 86183
 *
 */
class Consumer implements Runnable{
    //公共容器
    private LinkedList  list;
    
    public Consumer(LinkedList  list) {
        this.list=list;
    }

    @Override
    public void run() {
        
        while(true) {           
            synchronized(list) {        
                if(list.size()==0) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }//如果容器部位空吃货一直吃
                    //吃货吃了一个鸡蛋
                    Egg egg = list.pop();
                    System.out.println(Thread.currentThread().getName()+"吃了"+egg);          
                    list.notify();
            }
        }       
    }
    
}


public class CustoemrProducerModel {
    public static void main(String[] args) {
        LinkedList list=new LinkedList<>();

        Hen hen = new Hen(list);
        Consumer consumer = new Consumer(list);
        
        Thread t1 = new Thread(hen, "母鸡");
        Thread t2 = new Thread(consumer, "吃货");
        
        
        t1.start();
        t2.start();
    }
}