做業_java基礎第九天_多線程、自動拆裝箱

1.蜜蜂和熊的生產消費關係，熊在蜂蜜滿10斤吃掉。蜜蜂一次生產一斤蜂蜜，且蜜蜂生成一斤蜂蜜花費的時間是10ms。

  十隻蜜蜂和兩隻熊。

2.取出兩個字符串中最大的公共子串。

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

4.完成8中基本數據類包裝類的練習，完成自動拆裝箱操做。

------------------------------做業1---------------------------------------

package 做業一;

//1.密封盒熊的生產消費關係，想在密封滿10斤的時候吃掉。密封一次生產一斤密封，且生產一斤蜂蜜花費的時間是10s

//十隻蜜蜂，2只熊

//注意：生產了一個流程不動了，不必定是死鎖了，不要忘記是寫在循環條件裏面

public class App {

public static void main(String[] args) {

Box box =new Box();

Bee bee1=new Bee(box,"b-1");

Bee bee2=new Bee(box,"b-2");

Bee bee3=new Bee(box,"b-3");

Bee bee4=new Bee(box,"b-4");

Bee bee5=new Bee(box,"b-5");

Bee bee6=new Bee(box,"b-6");

Bee bee7=new Bee(box,"b-7");

Bee bee8=new Bee(box,"b-8");

Bee bee9=new Bee(box,"b-9");

Bee bee10=new Bee(box,"b-10");

Bear bear1=new Bear(box,"熊大");

Bear bear2=new Bear(box,"熊二");

bee1.start();

bee2.start();

bee3.start();

bee4.start();

bee5.start();

bee6.start();

bee7.start();

bee8.start();

bee9.start();

bee10.start();

bear1.start();

bear2.start();

}

}

--------

package 做業一;

public class Bear extends Thread {

private Box box;//持有蜜罐---私有的，但這裏box和前面蜜蜂裏面定義的有關係麼？

public static String name="yyy";

//構造代碼塊

{

System.out.println("sss");

}

//構造函數

public Bear(Box box,String name){

super();

this.box=box;

this.name=name;

}

//run函數

public void run(){

while(true){

synchronized (box) {

if(box.capacity==Box.MAX){

int tmp=box.capacity;

box.capacity=0;

System.out.println(name+":吃掉了"+tmp);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO 自動生成的 catch 塊

e.printStackTrace();

}

box.notifyAll();

}

else{

try {

box.wait();//沒有滿的話等待

} catch (InterruptedException e) {

// TODO 自動生成的 catch 塊

e.printStackTrace();

}

}

}

}

}

}

-------

package 做業一;

//同步代碼塊比同步方法容易理解一些

//蜜蜂

//蜜蜂和熊的生產消費關係，熊在蜂蜜滿30斤吃掉。蜜蜂一次生產一斤，且一斤花費10秒（次要）

public class Bee extends Thread {//蜜蜂是線程

int i=0;

private int bag=0;//蜜蜂本身的小袋子

private static final int BAG_MAX=20;//袋子的最大容量

private static final int ONCE=5;//生產5斤能夠放入蜜罐，是放5斤仍是放多少的話還要取決於蜜罐的可用容量，本身袋子的量

private static final int TIME=10;//生產一斤花費的時間10s

private Box box;//蜜罐子的參數接收組進來，----取建立一個蜜罐

private String name;

//構造

public Bee(Box box, String name) {

super();

this.box = box;

this.name = name;

}

//run函數

public void run(){

while(true){

if(bag>=5){

//若是不足5，箱蜜罐放蜂蜜

synchronized (box) {//---在這裏運行的條件是bag>=5--生產5斤能夠放入蜜罐，是放5斤仍是放多少的話還要取決於蜜罐的可用容量，本身袋子的量

//取出當前蜜罐容量boox.capcity

int cap=box.capacity;//capacity是屬性

//蜜罐已滿

if(cap>=Box.MAX){

box.notifyAll();//通知熊吃蜜

}

else{//未滿，算蜜罐剩餘空間

int remain=Box.MAX-cap;

//蜜蜂帶

if(bag>=remain){

box.capacity=Box.MAX;

bag=bag-remain;

System.out.println(name+"添加了"+remain+",name.bag="+bag+",蜜蜂有"+box.capacity);

box.notifyAll();//通知熊來吃

}

else{//小於remain

box.capacity=box.capacity+bag;

System.out.println(name+"添加了"+bag+",name.bag="+bag+",蜜蜂有"+box.capacity);

bag=0;

}

}

}

}

else{//對應if(bag>=5)那裏-----bag<5的狀況

bag++;

System.out.println(name+".bag="+bag);

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO 自動生成的 catch 塊

e.printStackTrace();

}

}

}

}

}

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

package 做業一;

//蜜罐子

public class Box {

public static final int MAX=30;//最大容量30

public int capacity=0;//當前容量

}

【--------------------------------做業2-------------------------------------------】

package 做業2;

//ctrl+shift+o自動導包

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

//取出兩個字符串中最大的公共子串---------就是兩個字符串裏面連續字符相同最多的部分

//思路

//1.把字符串"abcd"變成a,ab,abc,abcd放進集合裏面---另一個字符串「bcde」變成b,bc,bcd,bcde放進集合裏面---//對應str1,str2包含的全部字符串

//3.而後遍歷比較集合裏面的每一個字符串，相同的字符串加入到相同的集合列表裏面--對應方法//包含相同的字符串那裏

//4.而後遍歷集合每一個元素的長度，取出長度最長的----對應//最大的公共子串那裏

//不過這個也有缺陷，如"abcdfff";"bcdefff";bcd和fff的長度都是同樣的，打出來確實bcd

public class LongestCommentString2 {

public static void main(String[] args) {

String str1 = "abcdfff";//"beijinggg1111ch@angpingshahe";

        String str2 = "bcdefff";//"beijinggggg@shahe";

        //char Str2[] = {'b', 'e', 'i','j'......};//效果其實就是這樣

        //調用下面的方法

        String comment = getLongestCommentString(str1, str2);

        System.out.println(comment);

        

//        測試

        List<String> str1Sub = new ArrayList<String>();

//        System.out.println(str1.substring(1, 2));

        

        for (int i = 0; i <= str1.length(); i++) {

            for (int j = i; j <= str1.length(); j++) {

//                System.out.println(str1.substring(i, j));

                str1Sub.add(str1.substring(i, j));

            }

        }

        

        //普通型遍歷集合

//        System.out.println("-------------------");

//        for(int i=0;i<str1Sub.size();i++){

//        System.out.print(str1Sub.get(i));

//        }

        

}

private static String getLongestCommentString(String str1, String str2) {

List<String> str1Sub = new ArrayList<String>();

        List<String> str2Sub = new ArrayList<String>();

        List<String> listSame = new ArrayList<String>();

        //str1包含的全部字符串

        for (int i = 0; i <= str1.length(); i++) {//str1仍是字符串

            for (int j = i; j <= str1.length(); j++) {

                str1Sub.add(str1.substring(i, j));

                //str1Sub.add(e)向列表str1Sub的尾部追加指定的元素

                

                //字符串String.substring方法

//                public String substring(int beginIndex,

//                        int endIndex)返回一個新字符串，它是此字符串的一個子字符串。

//                該子字符串從指定的 beginIndex 處開始，一直到索引 endIndex - 1 處的字符。所以，該子字符串的長度爲 endIndex-beginIndex。

            }

        }

        //str2包含的全部字符串

        for (int i = 0; i <= str2.length(); i++) {

            for (int j = i; j <= str2.length(); j++) {

                str2Sub.add(str2.substring(i, j));

            }

        }

        //包含相同的字符串

        for (int i = 0; i < str1Sub.size(); i++) {

            for (int j = 0; j < str2Sub.size(); j++) {

                if (str1Sub.get(i).equals(str2Sub.get(j))) {

                    listSame.add(str1Sub.get(i));

                }

            }

        }

        //最大的公共子串

        int maxId = 0;

        int maxValue = 0;

        for (int i = 0; i < listSame.size(); i++) {

            if (listSame.get(i).length() > maxValue) {

                maxId = i;

                maxValue = listSame.get(i).length();

            }

        }

        return listSame.get(maxId);

}

}

【--------------------------------做業3-------------------------------------------】

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

答：性能不一致，StringBuilder在每次訪問的時候不須要判斷對象鎖是否被佔用，性能更好效率更高。

【--------------------------------做業4-------------------------------------------】

package 做業2;

//完成8種基本數據類包裝類的練習，完成自動拆裝箱操做。

//答：

public class autoUpUi4{

public static void main(String[] args) {

// byte類型的自動裝箱與拆箱

        Byte b1 = 1;//對應的包裝類，自動拆箱

        Byte b3 =new Byte("11");

//        參數：

//        s - 要轉換成 Byte 的 String 

        System.out.println(b3);

        byte b2 = b1;

        System.out.println("Byte " + (b1 == b2));

        // Short類型的自動裝箱與拆箱

        Short s1 = 1;

        short s2 = s1;

        System.out.println("Short " + (s1 == s2));

        // Integer類型的自動裝箱與拆箱

        Integer int1 = 1;

        Integer int3=new Integer(3);

        int int2 = int1;

        System.out.println("Integer " + (int1 == int2));

        // Long類型的自動裝箱與拆箱

        Long long1 = 1L;

        Long long3=new Long(2);

        System.out.println(long3+"--------");

        long long2 = long1;

        System.out.println("Long " + (long1 == long2));

        // Float類型的自動裝箱與拆箱

        Float f1 = 3.1415f;

        float f2 = f1;

        System.out.println("Float " + (f1 == f2));

        // Double類型的自動裝箱與拆箱

        Double d1 = 3.1415d;

        double d2 = d1;

        System.out.println("Double " + (d1 == d2));

        // 字符類型的自動裝箱與拆箱

        Character c1 = 'a';

        char c2 = c1;

        System.out.println("Character" + (c1 == c2));

        // Boolean類型的自動裝箱與拆箱

        Boolean bool1 = false;

        Boolean bool3=new Boolean(false);

        bool3=new Boolean("false");

        boolean bool2 = bool1;

        System.out.println("Boolean " + (bool1 == bool2));

}

}