大數(shù)據(jù)第九天內(nèi)容

筆記部分：

創(chuàng)建線程方式

-----------------

1.Thread

2.Runnable{public void run();}

class Man extends Person implements Runnable{

public void run(){

...

}

}

new Car().start();

new Thread(new Man()).start();

eclipse

---------------

alt + ///代碼輔助

alt + 上箭頭//向上移動(dòng)一行

alt + 下箭頭//向上移動(dòng)一行

alt + shift + 上箭頭        //向上復(fù)制一行

alt + shift + 下箭頭        //向下復(fù)制一行

ctrl + D//刪除一行

String

-----------------

1. ==     //判斷是否是同一對(duì)象。判斷對(duì)象的內(nèi)存地址。

2. equals     //是判斷兩個(gè)對(duì)象內(nèi)容是否相同。

split(String reg);     //按照指定的字符串進(jìn)行拆分，返回值數(shù)組。

substring(int start);        //取子串操作，指定起始索引之后的所有字符

substring(int start,int end);//取子串操作，指定起始索引和結(jié)束索引之間的全部字符，

     //包含起始索引，不含結(jié)尾索引。[a,b)屬于半開半閉區(qū)間。

byteByte     //包裝類

shortShort

intInteger

longLong

floatFloat

douleDouble

booleanBoolean

charCharacter

byte b = 127 ;

Byte b = new Byte(127);

StringBuffer  

字符串緩沖區(qū)

StringBuffer是字符串變量，它的對(duì)象是可以擴(kuò)充和修改的。

append方法可以追加字符串，字符，對(duì)象等

和String相比：當(dāng)String方法執(zhí)行Sting=String+i等情況時(shí)，實(shí)際上String對(duì)象是不可改變對(duì)象，因此不斷地在創(chuàng)建對(duì)象，并字符串池中也不斷增加，原來對(duì)像再被回收，String執(zhí)行效率低。

StringBuffer中的方法是被synchronized修飾的，是同步的，線程安全的，同一時(shí)間只有一個(gè)對(duì)像可以執(zhí)行，鎖是執(zhí)行時(shí)的當(dāng)前StringBuffer對(duì)象

StringBuilder沒有被synchronized修飾的，非同步的

性能不一致，StringBuilder在每次訪問的時(shí)候不需要判斷對(duì)像鎖是否被占用，性能更好效率更高。

作業(yè)部分：

1.蜜蜂和熊的生產(chǎn)消費(fèi)關(guān)系，熊在蜂蜜滿10斤吃掉。蜜蜂一次生產(chǎn)一斤蜂蜜，且蜜蜂生成一斤蜂蜜花費(fèi)的時(shí)間是10s。

十只蜜蜂和兩只熊。

代碼：

package com.work.ten;

class Bear extends Thread{
	
	private FengMi fengmi;
	
	private String bearname;
	
	
	public Bear(FengMi fengmi,String  bearname){
		
		this.fengmi=fengmi;
		
		this.bearname=bearname;
		
	}
	
	public void run(){
		

		
		while(true){
			
		synchronized(fengmi){
		
		if (fengmi.getFengmiWeight()<10) {
			
		try {
		
		fengmi.wait();
			
		}
		catch (Exception e){
			
		}
			
		}
		
		else if(fengmi.getFengmiWeight()>=10&&fengmi.getFengmiWeight()%10==0){
			
			    
				fengmi.ChiFemgmi();
		
				System.out.println("10 斤蜂蜜被"+bearname+"吃掉，剩余"+fengmi.getFengmiWeight()+"斤蜂蜜");
		
			try{
		
				fengmi.notifyAll();
				
			}
			
			catch(Exception e){
				
				
			}	
				
		}
		
		
		}
		
		yield();
	
	}
	
}

}


class FengMi {
	
	private static int fengmiWeight=0; //蜜罐中蜂蜜數(shù)量
	
	private  final int fengmiWeightMax=20; //蜜罐中蜂蜜數(shù)量上限

	public  int getFengmiWeight() {
		return fengmiWeight;
	}


	public int getFengmiWeightMax() {
		return fengmiWeightMax;
	}
	

	public void CreateFemgmi() { //生產(chǎn)蜂蜜
		this.fengmiWeight += 1;
	}
	
	public void ChiFemgmi() { //吃蜂蜜
		this.fengmiWeight -=10;
	}
	
}



class Bee extends Thread{
	
	private FengMi fengmi;
	
	private String  beename;
	
	
	public Bee(FengMi fengmi,String beename){
		
		this.fengmi=fengmi;
		
		this.beename=beename;
		
	}
	
	public void run(){
		
		int i=1;
		
		while(true){
			
		synchronized(fengmi){
			
		if(fengmi.getFengmiWeight()<fengmi.getFengmiWeightMax()){
			
			
			if(fengmi.getFengmiWeight()==0){
				
				try{

					fengmi.CreateFemgmi();
					
					System.out.println("蜂蜜采集好了,目前一共"+fengmi.getFengmiWeight()+"斤蜂蜜");
				
					fengmi.notifyAll();
				
					Thread.sleep(10);
					
					System.out.println("經(jīng)過10ms,蜜蜂休息好了");
								
				}

				catch(Exception e){
					
				}
				
			}
			
			else {
				
				if (fengmi.getFengmiWeight()%10==0){
					
					try{

						fengmi.CreateFemgmi();
						
						System.out.println("蜂蜜采集好了,目前一共"+fengmi.getFengmiWeight()+"斤蜂蜜");
					
						fengmi.notifyAll();
					
						Thread.sleep(10);
						
						System.out.println("經(jīng)過10ms,蜜蜂休息好了");
					
									
					}

					catch(Exception e){
						
					}
				
					}
				
				else {
					
					try{

						fengmi.CreateFemgmi();
						
						if(fengmi.getFengmiWeight()%10==0){
							
							System.out.println("蜂蜜采集好了,目前一共"+fengmi.getFengmiWeight()+"斤蜂蜜,熊可以來采了");
						}
						
						else  System.out.println("蜂蜜采集好了,目前一共"+fengmi.getFengmiWeight()+"斤蜂蜜");
					
						fengmi.notifyAll();
					
						Thread.sleep(10);
						
						System.out.println("經(jīng)過10ms,蜜蜂休息好了");
									
					}

					catch(Exception e){
						
					}
					
				}
					
					
				}
			}
				

			
		else {
			
			System.out.println("蜂蜜滿了");
			
			try{			
			
			fengmi.wait();
			
			}
			catch(Exception e){
				
			}
			
			}	
			
		}
		
		i++;
		
		yield();
		
		
		
		}
	
	}
	
}




class 	BeeBearModel2{
	
	public static void main(String[] args){
		
		
		FengMi fengmi=new FengMi();
			
		Bear bear1=new Bear(fengmi,"Bear1");	
		
		
		Bee bee1=new Bee(fengmi,"Bee1");	
		
		Bee bee2=new Bee(fengmi,"Bee2");	

		bear1.start();
		
		
		bee1.start();

		bee2.start();
	}
	
	
}

作業(yè)1運(yùn)行結(jié)果（部分）：

蜂蜜采集好了,目前一共18斤蜂蜜

經(jīng)過10ms,蜜蜂休息好了

蜂蜜采集好了,目前一共19斤蜂蜜

經(jīng)過10ms,蜜蜂休息好了

蜂蜜采集好了,目前一共20斤蜂蜜,熊可以來采了

經(jīng)過10ms,蜜蜂休息好了

10 斤蜂蜜被Bear1吃掉，剩余10斤蜂蜜

蜂蜜采集好了,目前一共11斤蜂蜜

經(jīng)過10ms,蜜蜂休息好了

蜂蜜采集好了,目前一共12斤蜂蜜

經(jīng)過10ms,蜜蜂休息好了

蜂蜜采集好了,目前一共13斤蜂蜜

經(jīng)過10ms,蜜蜂休息好了

作業(yè)2

取出兩個(gè)字符串中最大的公共子串。

package com.work.nine;

public class Find {
	
	private String checkString1;
	
	private String checkString2;

	public String getCheckString1() {
		return checkString1;
	}

	public void setCheckString1(String checkString1) {
		this.checkString1 = checkString1;
	}

	public String getCheckString2() {
		return checkString2;
	}

	public void setCheckString2(String checkString2) {
		this.checkString2 = checkString2;
	}
	
	public Find(String checkString1,String checkString2){
		
		this.checkString1=checkString1;
		
		this.checkString2=checkString2;
	}
	
	
	public String FindMaxPublicString(boolean result){
		
		if(checkString1==null||checkString2==null) return "";
		
		else{
			
			String temp=this.checkString2;
		
		
		if(result){
			
			temp=temp.toLowerCase();
			
			String String1Lower=this.checkString1.toLowerCase();
			
			String String2Lower=this.checkString2.toLowerCase();
			
			if(String1Lower.equals(String2Lower)) return this.checkString1;
			
			else{
					
					while(!String1Lower.contains(temp)){
						
						temp=temp.substring(0, temp.length()-1);
					}
					
					return temp;
					
				}
			
		}
		
 
		
		else{
			
			if(this.checkString1.equals(this.checkString2)) return this.checkString1;
			
			
			else{
					
					while(!this.checkString1.contains(temp)){
						
						temp=temp.substring(0, temp.length()-1);
					}
					
					return temp;
					
				}
			
		}
		
		}
	

	
}
	
}

package com.work.nine;

class MaxPublicStringDemo{
	
	
	public static void main(String[] args){
		
		Find find1=new Find("ABCDEFG","");
		
		Find find2=new Find("ABCDEFG","ABCDEFG");
		
		Find find3=new Find("ABCDEFG","HIGKLMN");
		
		Find find4=new Find("ABCDEFG","AB");
		
		Find find5=new Find("ABCDEFG","ab");
		
		Find find11=new Find("ABCDEFG","AABBCCD");
		
		System.out.println("最大的公共子串為"+find1.FindMaxPublicString(false));
		
		System.out.println("最大的公共子串為"+find2.FindMaxPublicString(false));
		
		System.out.println("最大的公共子串為"+find3.FindMaxPublicString(false));
		
		System.out.println("最大的公共子串為"+find4.FindMaxPublicString(false));
		
		System.out.println("最大的公共子串為"+find5.FindMaxPublicString(false));
		
		System.out.println("最大的公共子串為"+find11.FindMaxPublicString(false));
		
		System.out.println("--------------------------------------------");
		
		
		Find find6=new Find("ABCDEFG","");
		
		Find find7=new Find("ABCDEFG","ABCDEFG");
		
		Find find8=new Find("ABCDEFG","AACCEEG");
		
		Find find9=new Find("ABCDEFG","AB");
		
		Find find10=new Find("ABCDEFG","abcdefg");
		
		System.out.println("最大的公共子串為"+find6.FindMaxPublicString(true));
		
		System.out.println("最大的公共子串為"+find7.FindMaxPublicString(true));
		
		System.out.println("最大的公共子串為"+find8.FindMaxPublicString(true));
		
		System.out.println("最大的公共子串為"+find9.FindMaxPublicString(true));
		
		System.out.println("最大的公共子串為"+find10.FindMaxPublicString(true));
		
	}
	
}

結(jié)果：

最大的公共子串為

最大的公共子串為ABCDEFG

最大的公共子串為

最大的公共子串為AB

最大的公共子串為

最大的公共子串為A

--------------------------------------------

最大的公共子串為

最大的公共子串為ABCDEFG

最大的公共子串為a

最大的公共子串為ab

最大的公共子串為ABCDEFG

作業(yè)3

StringBuffer是線程安全的，StringBuilder不是線程安全。單線程訪問情況下，性能是否一致？

性能不一致，StringBuilder在每次訪問的時(shí)候不需要判斷對(duì)像鎖是否被占用，性能更好效率更高。

作業(yè)4

完成8種基本數(shù)據(jù)類包裝類的練習(xí)，完成自動(dòng)拆裝箱操作。

package com.work.nine;

public class chaizhuang {

	public static void main(String[] args){
		
		// byte類型的自動(dòng)裝箱與拆箱
        Byte b1 = 1;
        byte b2 = b1;
        System.out.println("Byte " + (b1 == b2));

        // Short類型的自動(dòng)裝箱與拆箱
        Short s1 = 1;
        short s2 = s1;
        System.out.println("Short " + (s1 == s2));

        // Integer類型的自動(dòng)裝箱與拆箱
        Integer int1 = 1;
        int int2 = int1;
        System.out.println("Integer " + (int1 == int2));

        // Long類型的自動(dòng)裝箱與拆箱
        Long long1 = 1L;
        long long2 = long1;
        System.out.println("Long " + (long1 == long2));

        // Float類型的自動(dòng)裝箱與拆箱
        Float f1 = 3.1415f;
        float f2 = f1;
        System.out.println("Float " + (f1 == f2));

        // Double類型的自動(dòng)裝箱與拆箱
        Double d1 = 3.1415d;
        double d2 = d1;
        System.out.println("Double " + (d1 == d2));

        // 字符類型的自動(dòng)裝箱與拆箱
        Character c1 = 'a';
        char c2 = c1;
        System.out.println("Character" + (c1 == c2));

        // Boolean類型的自動(dòng)裝箱與拆箱
        Boolean bool1 = false;
        boolean bool2 = bool1;
        System.out.println("Boolean " + (bool1 == bool2));
		
		
	}
	
}