车羊有关问题（Car and Goats prob...- 运用ExpandableListView - 2011.08.30（二）——— java BlockingQueue ExecutorService

当前位置: 编程技术>移动开发

本页文章导读:

▪车羊有关问题（Car and Goats problem）车羊问题（Car and Goats problem）车羊问题（Car and Goats problem） (2008-08-05 05:48:40) 转载标签：情感车羊问题（Car and Goats problem）又叫蒙提霍尔问题(Monty Hall Problem)或三门问题。这.........

▪ 运用ExpandableListView 使用ExpandableListView 效果图 Group右边的图标是Android系统自动加上的默认图标 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orient.........

▪ 2011.08.30（二）——— java BlockingQueue ExecutorService 2011.08.30（2）——— java BlockingQueue ExecutorService 2011.08.30（2）——— java BlockingQueue ExecutorService参考：http://www.iteye.com/topic/366591http://topic.csdn.net/u/20091226/16/b1337a92-a4a2-463e-a04e-7226e5fa78d2.html并.........

[1]车羊有关问题（Car and Goats problem）

来源: 互联网发布时间: 2014-02-18

车羊问题（Car and Goats problem）

车羊问题（Car and Goats problem） (2008-08-05 05:48:40)

转载

标签：情感

车羊问题（Car and Goats problem）又叫蒙提霍尔问题(Monty Hall Problem)或三门问题。这个问题来源于美国电视娱乐节目Let’s Make a Deal,问题的名字则来自该节目的主持人蒙提·霍尔(Monty Hall)。

问题是这样的：参赛者会看见三扇关闭了的门，其中一扇的后面有一辆汽车，选中后面有车的那扇门就可以赢得该汽车，而另外两扇门后面则各藏有一只山羊。当参赛者选定了一扇门，但未去开启它的时候，节目主持人会开启剩下两扇门的其中一扇，露出其中一只山羊。主持人其后会问参赛者要不要换另一扇仍然关上的门。

明确的限制条件如下：
　　参赛者在三扇门中挑选一扇。他并不知道里面有什么
　　主持人知道每扇门后面有什么
　　主持人必须开启剩下的其中一扇门,并且必须提供换门的机会
　　主持人永远都会挑一扇有山羊的门
　　如果参赛者挑了一扇有山羊的门,主持人必须挑另一扇有山羊的门
　　如果参赛者挑了一扇有汽车的门,主持人随机在另外两扇门中挑一扇有山羊的门
　　参赛者会被问是否保持他的原来选择,还是转而选择剩下的那一道

那么换与不换，哪种策略答对的机率高呢。我们会觉得无论改变答案与否，答对的概率都是相同的1/2，除去主持人选出的那道门，剩下的两道门里，一道藏着羊，一道藏着车，问题不过是从3选1变成2选1，改变答案能改变答对的几率么?但事实上，如果换门的话，选中的机率会从1/3升为2/3。

Savant在 Parade Magazine对这一问题的解答是应该换，因为换了之后有2/3的概率赢得车，不换的话概率只有1/3，这个答案简洁而精致，却让所有人觉得荒唐。展开来看，按这位高智商的观点，参赛者选定正确的门的概率是1/3，主持人为他排除一个错误答案后，如果他不换答案，概率维持不变，还是1/3，如果换答案，作为对立事件，概率升为2/3。文章发表之后，有大约一万Parada杂志的读者，其中包括一千人左右有PhD学位，写信给杂志社，说他们错了，并在之后引起的广泛的争论。

得出1/2的原因是把一个问题拆成两个独立的问题，刚开始是三选一，主持人去掉一个门以后，变成二选一。

[2] 运用ExpandableListView

来源: 互联网发布时间: 2014-02-18

使用ExpandableListView

效果图

Group右边的图标是Android系统自动加上的默认图标

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
    <ExpandableListView android:id="@+id/expandable_list_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />
</LinearLayout>

package com.improve;
import android.app.Activity;
import android.os.Bundle;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.BaseExpandableListAdapter;
import android.widget.ExpandableListView;
import android.widget.ExpandableListView.OnChildClickListener;
import android.widget.ExpandableListView.OnGroupCollapseListener;
import android.widget.ExpandableListView.OnGroupExpandListener;
import android.widget.Toast;
import android.widget.ExpandableListView.OnGroupClickListener;
import android.widget.TextView;

/**
 * ExpandableListView只能是两级层次
 * @author Davee
 */
public class ExpandableListViewDemo extends Activity {
    private List<String> groupData;
    private List<List<String>> childrenData;
    private void loadData() {
        groupData = new ArrayList<String>();
        groupData.add("Group 1");
        groupData.add("Group 2");
        groupData.add("Group 3");

        childrenData = new ArrayList<List<String>>();
        List<String> sub1 = new ArrayList<String>();
        sub1.add("G1 Item 1");
        sub1.add("G1 Item 2");
        childrenData.add(sub1);
        List<String> sub2 = new ArrayList<String>();
        sub2.add("G2 Item 1");
        sub2.add("G2 Item 2");
        sub2.add("G2 Item 3");
        sub2.add("G2 Item 4");
        childrenData.add(sub2);
        List<String> sub3 = new ArrayList<String>();
        sub3.add("G3 Item 1");
        sub3.add("G3 Item 2");
        sub3.add("G3 Item 3");
        sub3.add("G3 Item 4");
        sub3.add("G3 Item 5");
        childrenData.add(sub3);
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.expandable_list_view);
        
        loadData();
        
        ExpandableListView expandableListView = (ExpandableListView)findViewById(R.id.expandable_list_view);
        expandableListView.setAdapter(new ExpandableAdapter());
        expandableListView.setOnGroupClickListener(new OnGroupClickListener() {
            @Override
            public boolean onGroupClick(ExpandableListView parent, View clickedView, int groupPosition, long groupId) {
                showMessage("点击Group: " + ((TextView)clickedView).getText());
                return false;//返回true表示此事件在此被处理了
            }
        });
        expandableListView.setOnChildClickListener(new OnChildClickListener() {
            @Override
            public boolean onChildClick(ExpandableListView expandablelistview,
                    View clickedView, int groupPosition, int childPosition, long childId) {
                showMessage("点击Child: " + ((TextView)clickedView).getText());
                return false;//返回true表示此事件在此被处理了
            }
        });
        expandableListView.setOnGroupCollapseListener(new OnGroupCollapseListener() {
            @Override
            public void onGroupCollapse(int groupPosition) {
                showMessage("合拢Group: " + (groupPosition + 1));
            }
        });
        expandableListView.setOnGroupExpandListener(new OnGroupExpandListener() {
            @Override
            public void onGroupExpand(int groupPosition) {
                showMessage("展开Group: " + (groupPosition + 1));
            }
        });
    }
    
    private class ExpandableAdapter extends BaseExpandableListAdapter {

        @Override
        public Object getChild(int groupPosition, int childPosition) {
            return childrenData.get(groupPosition).get(childPosition);
        }

        @Override
        public long getChildId(int groupPosition, int childPosition) {
            return 0;
        }

        @Override
        public View getChildView(int groupPosition, int childPosition, boolean isLastChild, View convertView, ViewGroup parent) {
            TextView text = null;
            if (convertView != null) {
                text = (TextView)convertView;
                text.setText(childrenData.get(groupPosition).get(childPosition));
            } else {
                text = createView(childrenData.get(groupPosition).get(childPosition));
            }
            return text;
        }

        @Override
        public int getChildrenCount(int groupPosition) {
            return childrenData.get(groupPosition).size();
        }

        @Override
        public Object getGroup(int groupPosition) {
            return groupData.get(groupPosition);
        }

        @Override
        public int getGroupCount() {
            return groupData.size();
        }

        @Override
        public long getGroupId(int groupPosition) {
            return 0;
        }

        @Override
        public View getGroupView(int groupPosition, boolean isExpanded, View convertView, ViewGroup parent) {
            TextView text = null;
            if (convertView != null) {
                text = (TextView)convertView;
                text.setText(groupData.get(groupPosition));
            } else {
                text = createView(groupData.get(groupPosition));
            }
            return text;
        }

        @Override
        public boolean hasStableIds() {
            return false;
        }

        @Override
        public boolean isChildSelectable(int groupPosition, int childPosition) {
            return false;
        }
        
        private TextView createView(String content) {
            AbsListView.LayoutParams layoutParams = new AbsListView.LayoutParams(  
                    ViewGroup.LayoutParams.FILL_PARENT, 38);  
            TextView text = new TextView(ExpandableListViewDemo.this);  
            text.setLayoutParams(layoutParams);  
            text.setGravity(Gravity.CENTER_VERTICAL | Gravity.LEFT);  
            text.setPadding(40, 0, 0, 0);  
            text.setText(content);
            return text;
        }
    }
    
    private void showMessage(String message) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
    }
}

在上面效果图中，图标是系统自动加上的，也可以定义自己的图标

效果图

增加drawable文件

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_expanded="true" android:drawable="@drawable/narrow_expand" />
    <item android:drawable="@drawable/narrow_unexpand" />
</selector>

修改布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">
    <ExpandableListView android:id="@+id/expandable_list_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:groupIndicator="@drawable/group_icon_selector" />
</LinearLayout>

1 楼昔雪似花 2011-12-08

2 楼昔雪似花 2011-12-08

昔雪似花写道

[3] 2011.08.30（二）——— java BlockingQueue ExecutorService

来源: 互联网发布时间: 2014-02-18

2011.08.30（2）——— java BlockingQueue ExecutorService
2011.08.30（2）——— java BlockingQueue ExecutorService
参考：http://www.iteye.com/topic/366591
http://topic.csdn.net/u/20091226/16/b1337a92-a4a2-463e-a04e-7226e5fa78d2.html

并发库中的BlockingQueue是一个比较好玩的类，顾名思义，就是阻塞队列。该类主要提供了两个方法put()和take()，前者将一个对象放到队列尾部，如果队列已经满了，就等待直到有空闲节点；后者从head取一个对象，如果没有对象，就等待直到有可取的对象。

package com.lp;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;


public class MyBlockingQueue extends Thread{
	public static BlockingQueue<String> queue=new LinkedBlockingQueue<String>(3);
	private int index;
	public MyBlockingQueue(int i){
		this.index=i;
	}

	public void run(){
		try{
			queue.put(String.valueOf(this.index));
			System.out.println("put {"+this.index+"} into queue!");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	public static void main(String args[]){
		ExecutorService service=Executors.newCachedThreadPool();
		for( int i=0; i<10; i++){
			service.submit(new MyBlockingQueue(i));
		}
		Thread thread = new Thread(){
			public void run(){
				try{
					while(true){
						Thread.sleep((int)(Math.random()*1000));
						if(MyBlockingQueue.queue.isEmpty()) break;
						String str=MyBlockingQueue.queue.take();
						System.out.println("take {" + str+"} out of queue!");
					}
				}catch(Exception e){
					e.printStackTrace();
				}
			}
		};
		service.submit(thread);
		service.shutdown();
	}
	
}