AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

PinnedHeaderListView实现删除

2016-04-29 1560
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

项目中用到四个List集合展示一个页面,并且每个页面都会有一个标题栏.找了半天资料决定用PinnedHeaderListView开源项目.最后需求又来了,需要一个删除的功能,又去网上找资料,发现没有实现删除的demo,于是自己把PinnedHeaderListView源码分析了下,其实也就一个类.下面我贴上代码,希望后面的朋友少走弯路.


PinnedHeaderListView   实现滚动,重绘,添加回调函数

  1. import android.content.Context;  
  2. import android.graphics.Canvas;  
  3. import android.util.AttributeSet;  
  4. import android.view.View;  
  5. import android.view.ViewGroup;  
  6. import android.widget.*;  
  7. import android.widget.AbsListView.OnScrollListener;  
  8.   
  9. public class PinnedHeaderListView extends ListView implements OnScrollListener{  
  10.   
  11.     private OnScrollListener mOnScrollListener;  
  12.   
  13.     public static interface PinnedSectionedHeaderAdapter {  
  14.         public boolean isSectionHeader(int position);  
  15.   
  16.         public int getSectionForPosition(int position);  
  17.   
  18.         public View getSectionHeaderView(int section, View convertView, ViewGroup parent);  
  19.   
  20.         public int getSectionHeaderViewType(int section);  
  21.   
  22.         public int getCount();  
  23.   
  24.     }  
  25.   
  26.     private PinnedSectionedHeaderAdapter mAdapter;  
  27.     private View mCurrentHeader;  
  28.     private int mCurrentHeaderViewType = 0;  
  29.     private float mHeaderOffset;  
  30.     private boolean mShouldPin = true;  
  31.     private int mCurrentSection = 0;  
  32.     private int mWidthMode;  
  33.     private int mHeightMode;  
  34.   
  35.     public PinnedHeaderListView(Context context) {  
  36.         super(context);  
  37.         super.setOnScrollListener(this);  
  38.     }  
  39.   
  40.     public PinnedHeaderListView(Context context, AttributeSet attrs) {  
  41.         super(context, attrs);  
  42.         super.setOnScrollListener(this);  
  43.     }  
  44.   
  45.     public PinnedHeaderListView(Context context, AttributeSet attrs, int defStyle) {  
  46.         super(context, attrs, defStyle);  
  47.         super.setOnScrollListener(this);  
  48.     }  
  49.   
  50.     public void setPinHeaders(boolean shouldPin) {  
  51.         mShouldPin = shouldPin;  
  52.     }  
  53.   
  54.     @Override  
  55.     public void setAdapter(ListAdapter adapter) {  
  56.         mCurrentHeader = null;  
  57.         mAdapter = (PinnedSectionedHeaderAdapter) adapter;  
  58.         super.setAdapter(adapter);  
  59.     }  
  60.   
  61.     @Override  
  62.     public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {  
  63.         if (mOnScrollListener != null) {  
  64.             mOnScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);  
  65.         }  
  66.   
  67.         if (mAdapter == null || mAdapter.getCount() == 0 || !mShouldPin || (firstVisibleItem < getHeaderViewsCount())) {  
  68.             mCurrentHeader = null;  
  69.             mHeaderOffset = 0.0f;  
  70.             for (int i = firstVisibleItem; i < firstVisibleItem + visibleItemCount; i++) {  
  71.                 View header = getChildAt(i);  
  72.                 if (header != null) {  
  73.                     header.setVisibility(VISIBLE);  
  74.                 }  
  75.             }  
  76.             return;  
  77.         }  
  78.   
  79.         firstVisibleItem -= getHeaderViewsCount();  
  80.   
  81.         int section = mAdapter.getSectionForPosition(firstVisibleItem);  
  82.         int viewType = mAdapter.getSectionHeaderViewType(section);  
  83.         mCurrentHeader = getSectionHeaderView(section, mCurrentHeaderViewType != viewType ? null : mCurrentHeader);  
  84.         ensurePinnedHeaderLayout(mCurrentHeader);  
  85.         mCurrentHeaderViewType = viewType;  
  86.   
  87.         mHeaderOffset = 0.0f;  
  88.   
  89.         for (int i = firstVisibleItem; i < firstVisibleItem + visibleItemCount; i++) {  
  90.             if (mAdapter.isSectionHeader(i)) {  
  91.                 View header = getChildAt(i - firstVisibleItem);  
  92.                 float headerTop = header.getTop();  
  93.                 float pinnedHeaderHeight = mCurrentHeader.getMeasuredHeight();  
  94.                 header.setVisibility(VISIBLE);  
  95.                 if (pinnedHeaderHeight >= headerTop && headerTop > 0) {  
  96.                     mHeaderOffset = headerTop - header.getHeight();  
  97.                 } else if (headerTop <= 0) {  
  98.                     header.setVisibility(INVISIBLE);  
  99.                 }  
  100.             }  
  101.         }  
  102.   
  103.         invalidate();  
  104.     }  
  105.   
  106.     @Override  
  107.     public void onScrollStateChanged(AbsListView view, int scrollState) {  
  108.         if (mOnScrollListener != null) {  
  109.             mOnScrollListener.onScrollStateChanged(view, scrollState);  
  110.         }  
  111.     }  
  112.   
  113.     private View getSectionHeaderView(int section, View oldView) {  
  114.         boolean shouldLayout = section != mCurrentSection || oldView == null;  
  115.   
  116.         View view = mAdapter.getSectionHeaderView(section, oldView, this);  
  117.         if (shouldLayout) {  
  118.             // a new section, thus a new header. We should lay it out again  
  119.             ensurePinnedHeaderLayout(view);  
  120.             mCurrentSection = section;  
  121.         }  
  122.         return view;  
  123.     }  
  124.   
  125.     private void ensurePinnedHeaderLayout(View header) {  
  126.         if (header.isLayoutRequested()) {  
  127.             int widthSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth(), mWidthMode);  
  128.               
  129.             int heightSpec;  
  130.             ViewGroup.LayoutParams layoutParams = header.getLayoutParams();  
  131.             if (layoutParams != null && layoutParams.height > 0) {  
  132.                 heightSpec = MeasureSpec.makeMeasureSpec(layoutParams.height, MeasureSpec.EXACTLY);  
  133.             } else {  
  134.                 heightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);  
  135.             }  
  136.             header.measure(widthSpec, heightSpec);  
  137.             header.layout(0, 0, header.getMeasuredWidth(), header.getMeasuredHeight());  
  138.         }  
  139.     }  
  140.   
  141.     @Override  
  142.     protected void dispatchDraw(Canvas canvas) {  
  143.         super.dispatchDraw(canvas);  
  144.         if (mAdapter == null || !mShouldPin || mCurrentHeader == null)  
  145.             return;  
  146.         int saveCount = canvas.save();  
  147.         canvas.translate(0, mHeaderOffset);  
  148.         canvas.clipRect(0, 0, getWidth(), mCurrentHeader.getMeasuredHeight()); // needed  
  149.         // for  
  150.         // <  
  151.         // HONEYCOMB  
  152.         mCurrentHeader.draw(canvas);  
  153.         canvas.restoreToCount(saveCount);  
  154.     }  
  155.   
  156.     @Override  
  157.     public void setOnScrollListener(OnScrollListener l) {  
  158.         mOnScrollListener = l;  
  159.     }  
  160.   
  161.     @Override  
  162.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  163.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
  164.   
  165.         mWidthMode = MeasureSpec.getMode(widthMeasureSpec);  
  166.         mHeightMode = MeasureSpec.getMode(heightMeasureSpec);  
  167.     }  
  168.   
  169.     public void setOnItemClickListener(PinnedHeaderListView.OnItemClickListener listener) {  
  170.         super.setOnItemClickListener(listener);  
  171.     }  
  172.   
  173.     public static abstract class OnItemClickListener implements AdapterView.OnItemClickListener {  
  174.         @Override  
  175.         public void onItemClick(AdapterView<?> adapterView, View view, int rawPosition, long id) {  
  176.             SectionedBaseAdapter adapter;  
  177.             if (adapterView.getAdapter().getClass().equals(HeaderViewListAdapter.class)) {  
  178.                 HeaderViewListAdapter wrapperAdapter = (HeaderViewListAdapter) adapterView.getAdapter();  
  179.                 adapter = (SectionedBaseAdapter) wrapperAdapter.getWrappedAdapter();  
  180.             } else {  
  181.                 adapter = (SectionedBaseAdapter) adapterView.getAdapter();  
  182.             }  
  183.             int section = adapter.getSectionForPosition(rawPosition);  
  184.             int position = adapter.getPositionInSectionForPosition(rawPosition);  
  185.   
  186.             if (position == -1) {  
  187.                 onSectionClick(adapterView, view, section, id);  
  188.             } else {  
  189.                 onItemClick(adapterView, view, section, position, id);  
  190.             }  
  191.         }  
  192.   
  193.         public abstract void onItemClick(AdapterView<?> adapterView, View view, int section, int position, long id);  
  194.   
  195.         public abstract void onSectionClick(AdapterView<?> adapterView, View view, int section, long id);  
  196.   
  197.     }  
  198. }  


SectionedBaseAdapter    

  1. import android.util.SparseArray;  
  2. import android.view.View;  
  3. import android.view.ViewGroup;  
  4. import android.widget.BaseAdapter;  
  5. import za.co.immedia.pinnedheaderlistview.PinnedHeaderListView.PinnedSectionedHeaderAdapter;  
  6.   
  7. public abstract class SectionedBaseAdapter extends BaseAdapter implements PinnedSectionedHeaderAdapter {  
  8.     private static int HEADER_VIEW_TYPE = 0;  
  9.     private static int ITEM_VIEW_TYPE = 0;  
  10.   
  11.     /** 
  12.      * Holds the calculated values of @{link getPositionInSectionForPosition} 
  13.      */  
  14.     private SparseArray<Integer> mSectionPositionCache;  
  15.     /** 
  16.      * Holds the calculated values of @{link getSectionForPosition} 
  17.      */  
  18.     private SparseArray<Integer> mSectionCache;  
  19.     /** 
  20.      * Holds the calculated values of @{link getCountForSection} 
  21.      */  
  22.     private SparseArray<Integer> mSectionCountCache;  
  23.   
  24.     /** 
  25.      * Caches the item count 
  26.      */  
  27.     private int mCount;  
  28.     /** 
  29.      * Caches the section count 
  30.      */  
  31.     private int mSectionCount;  
  32.   
  33.     public SectionedBaseAdapter() {  
  34.         super();  
  35.         mSectionCache = new SparseArray<Integer>();  
  36.         mSectionPositionCache = new SparseArray<Integer>();  
  37.         mSectionCountCache = new SparseArray<Integer>();  
  38.         mCount = -1;  
  39.         mSectionCount = -1;  
  40.     }  
  41.   
  42.     @Override  
  43.     public void notifyDataSetChanged() {  
  44.         mSectionCache.clear();  
  45.         mSectionPositionCache.clear();  
  46.         mSectionCountCache.clear();  
  47.         mCount = -1;  
  48.         mSectionCount = -1;  
  49.         super.notifyDataSetChanged();  
  50.     }  
  51.   
  52.     @Override  
  53.     public void notifyDataSetInvalidated() {  
  54.         mSectionCache.clear();  
  55.         mSectionPositionCache.clear();  
  56.         mSectionCountCache.clear();  
  57.         mCount = -1;  
  58.         mSectionCount = -1;  
  59.         super.notifyDataSetInvalidated();  
  60.     }  
  61.   
  62.     @Override  
  63.     public final int getCount() {  
  64.         if (mCount >= 0) {  
  65.             return mCount;  
  66.         }  
  67.         int count = 0;  
  68.         for (int i = 0; i < internalGetSectionCount(); i++) {  
  69.             count += internalGetCountForSection(i);  
  70.             count++; // for the header view  
  71.         }  
  72.         mCount = count;  
  73.         return count;  
  74.     }  
  75.   
  76.     @Override  
  77.     public final Object getItem(int position) {  
  78.         return getItem(getSectionForPosition(position), getPositionInSectionForPosition(position));  
  79.     }  
  80.   
  81.     @Override  
  82.     public final long getItemId(int position) {  
  83.         return getItemId(getSectionForPosition(position), getPositionInSectionForPosition(position));  
  84.     }  
  85.   
  86.     @Override  
  87.     public final View getView(int position, View convertView, ViewGroup parent) {  
  88.         if (isSectionHeader(position)) {  
  89.             return getSectionHeaderView(getSectionForPosition(position), convertView, parent);  
  90.         }  
  91.         return getItemView(getSectionForPosition(position), getPositionInSectionForPosition(position), convertView, parent);  
  92.     }  
  93.   
  94.     @Override  
  95.     public final int getItemViewType(int position) {  
  96.         if (isSectionHeader(position)) {  
  97.             return getItemViewTypeCount() + getSectionHeaderViewType(getSectionForPosition(position));  
  98.         }  
  99.         return getItemViewType(getSectionForPosition(position), getPositionInSectionForPosition(position));  
  100.     }  
  101.   
  102.     @Override  
  103.     public final int getViewTypeCount() {  
  104.         return getItemViewTypeCount() + getSectionHeaderViewTypeCount();  
  105.     }  
  106.   
  107.     public final int getSectionForPosition(int position) {  
  108.         // first try to retrieve values from cache  
  109.         Integer cachedSection = mSectionCache.get(position);  
  110.         if (cachedSection != null) {  
  111.             return cachedSection;  
  112.         }  
  113.         int sectionStart = 0;  
  114.         for (int i = 0; i < internalGetSectionCount(); i++) {  
  115.             int sectionCount = internalGetCountForSection(i);  
  116.             int sectionEnd = sectionStart + sectionCount + 1;  
  117.             if (position >= sectionStart && position < sectionEnd) {  
  118.                 mSectionCache.put(position, i);  
  119.                 return i;  
  120.             }  
  121.             sectionStart = sectionEnd;  
  122.         }  
  123.         return 0;  
  124.     }  
  125.   
  126.     public int getPositionInSectionForPosition(int position) {  
  127.         // first try to retrieve values from cache  
  128.         Integer cachedPosition = mSectionPositionCache.get(position);  
  129.         if (cachedPosition != null) {  
  130.             return cachedPosition;  
  131.         }  
  132.         int sectionStart = 0;  
  133.         for (int i = 0; i < internalGetSectionCount(); i++) {  
  134.             int sectionCount = internalGetCountForSection(i);  
  135.             int sectionEnd = sectionStart + sectionCount + 1;  
  136.             if (position >= sectionStart && position < sectionEnd) {  
  137.                 int positionInSection = position - sectionStart - 1;  
  138.                 mSectionPositionCache.put(position, positionInSection);  
  139.                 return positionInSection;  
  140.             }  
  141.             sectionStart = sectionEnd;  
  142.         }  
  143.         return 0;  
  144.     }  
  145.   
  146.     public final boolean isSectionHeader(int position) {  
  147.         int sectionStart = 0;  
  148.         for (int i = 0; i < internalGetSectionCount(); i++) {  
  149.             if (position == sectionStart) {  
  150.                 return true;  
  151.             } else if (position < sectionStart) {  
  152.                 return false;  
  153.             }  
  154.             sectionStart += internalGetCountForSection(i) + 1;  
  155.         }  
  156.         return false;  
  157.     }  
  158.   
  159.     public int getItemViewType(int section, int position) {  
  160.         return ITEM_VIEW_TYPE;  
  161.     }  
  162.   
  163.     public int getItemViewTypeCount() {  
  164.         return 1;  
  165.     }  
  166.   
  167.     public int getSectionHeaderViewType(int section) {  
  168.         return HEADER_VIEW_TYPE;  
  169.     }  
  170.   
  171.     public int getSectionHeaderViewTypeCount() {  
  172.         return 1;  
  173.     }  
  174.   
  175.     public abstract Object getItem(int section, int position);  
  176.   
  177.     public abstract long getItemId(int section, int position);  
  178.   
  179.     public abstract int getSectionCount();  
  180.   
  181.     public abstract int getCountForSection(int section);  
  182.   
  183.     public abstract View getItemView(int section, int position, View convertView, ViewGroup parent);  
  184.   
  185.     public abstract View getSectionHeaderView(int section, View convertView, ViewGroup parent);  
  186.   
  187.     private int internalGetCountForSection(int section) {  
  188.         Integer cachedSectionCount = mSectionCountCache.get(section);  
  189.         if (cachedSectionCount != null) {  
  190.             return cachedSectionCount;  
  191.         }  
  192.         int sectionCount = getCountForSection(section);  
  193.         mSectionCountCache.put(section, sectionCount);  
  194.         return sectionCount;  
  195.     }  
  196.   
  197.     private int internalGetSectionCount() {  
  198.         if (mSectionCount >= 0) {  
  199.             return mSectionCount;  
  200.         }  
  201.         mSectionCount = getSectionCount();  
  202.         return mSectionCount;  
  203.     }  
  204.   
  205. }  

TestSectionedAdapter  适配器

  1. import java.util.ArrayList;  
  2. import java.util.HashMap;  
  3. import java.util.List;  
  4. import java.util.Map;  
  5.   
  6. import za.co.immedia.pinnedheaderlistview.SectionedBaseAdapter;  
  7. import android.content.Context;  
  8. import android.view.LayoutInflater;  
  9. import android.view.View;  
  10. import android.view.View.OnClickListener;  
  11. import android.view.ViewGroup;  
  12. import android.widget.LinearLayout;  
  13. import android.widget.RelativeLayout;  
  14. import android.widget.TextView;  
  15.   
  16. public class TestSectionedAdapter extends SectionedBaseAdapter{  
  17.     private List<String> titles;//所有标题  
  18.     private Map<String,List<SWWSafearea>> mMap;//根据首字母存放数据  
  19.       
  20.     public TestSectionedAdapter(){  
  21.         List<SWWSafearea> localWifi=new ArrayList<SWWSafearea>();  
  22.         for(int i=1;i<=10;i++){  
  23.             localWifi.add(new SWWSafearea(i,"10"+i));  
  24.         }  
  25.           
  26.         List<SWWSafearea> localGeography=new ArrayList<SWWSafearea>();  
  27.         for(int i=4;i<=15;i++){  
  28.             localGeography.add(new SWWSafearea(i,"10"+i,i));  
  29.         }  
  30.           
  31.         List<SWWSafearea> serverWifi=new ArrayList<SWWSafearea>();  
  32. //      for(int i=7;i<=9;i++){  
  33. //          serverWifi.add(new SWWSafearea(i,"10"+i));  
  34. //      }  
  35.           
  36.         List<SWWSafearea> serverGeography=new ArrayList<SWWSafearea>();  
  37.         for(int i=30;i<=60;i++){  
  38.             serverGeography.add(new SWWSafearea(i,"10"+i,i));  
  39.         }  
  40.           
  41.         titles=new ArrayList<String>();  
  42.         titles.add("1");  
  43.         titles.add("2");  
  44.         titles.add("3");  
  45.         titles.add("4");  
  46.           
  47.         mMap = new HashMap<String, List<SWWSafearea>>();  
  48.         mMap.put(titles.get(0),localWifi);  
  49.         mMap.put(titles.get(1),localGeography);  
  50.         mMap.put(titles.get(2),serverWifi);  
  51.         mMap.put(titles.get(3),serverGeography);  
  52.     }  
  53.   
  54.     @Override  
  55.     public Object getItem(int section, int position) {  
  56.         return mMap.get(titles.get(section)).get(position);  
  57.     }  
  58.   
  59.     @Override  
  60.     public long getItemId(int section, int position) {  
  61.         return 0;  
  62.     }  
  63.   
  64.     @Override  
  65.     public int getSectionCount() {//一共显示多少行标题栏  
  66.         return titles.size();  
  67.     }  
  68.   
  69.     //每列显示的行数  
  70.     @Override  
  71.     public int getCountForSection(int section) {  
  72.         return mMap.get(titles.get(section)).size();  
  73.     }  
  74.   
  75.     @Override  
  76.     public View getItemView(final int section,final int position, View convertView, ViewGroup parent) {  
  77.         ViewHolder holder=null;  
  78.         if (null==convertView) {  
  79.             holder=new ViewHolder();  
  80.             LayoutInflater inflator = (LayoutInflater) parent.getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
  81.             convertView=(LinearLayout)inflator.inflate(R.layout.list_item, null);  
  82.             holder.name=(TextView) convertView.findViewById(R.id.name);  
  83.             holder.radius=(TextView) convertView.findViewById(R.id.radius);  
  84.             holder.safeareaItem=(RelativeLayout) convertView.findViewById(R.id.safearea_item);  
  85.             convertView.setTag(holder);  
  86.         }else{  
  87.             holder=(ViewHolder) convertView.getTag();  
  88.         }  
  89.         SWWSafearea sf=mMap.get(titles.get(section)).get(position);  
  90.         if(section==0||section==2){  
  91.             holder.name.setText(sf.name);  
  92.             holder.radius.setText("");  
  93.         }else{  
  94.             holder.name.setText(sf.name);  
  95.             holder.radius.setText(""+sf.radius);  
  96.         }  
  97.         holder.safeareaItem.setOnClickListener(new OnClickListener() {  
  98.             @Override  
  99.             public void onClick(View v) {  
  100.                 mMap.get(titles.get(section)).remove(position);  
  101.                 notifyDataSetChanged();  
  102.             }  
  103.         });  
  104.         return convertView;  
  105.     }  
  106.       
  107.     private class ViewHolder{  
  108.         TextView name,radius;  
  109.         RelativeLayout safeareaItem;  
  110.     }  
  111.   
  112.     @Override  
  113.     public View getSectionHeaderView(int section, View convertView, ViewGroup parent) {  
  114.         LinearLayout layout = null;  
  115.         if (convertView == null) {  
  116.             LayoutInflater inflator = (LayoutInflater) parent.getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
  117.             layout = (LinearLayout) inflator.inflate(R.layout.header_item, null);  
  118.         } else {  
  119.             layout = (LinearLayout) convertView;  
  120.         }  
  121.           
  122.         TextView textView=((TextView) layout.findViewById(R.id.textItem));  
  123.         if(mMap.get(titles.get(section)).size()>0){  
  124.             textView.setVisibility(View.VISIBLE);  
  125.             textView.setText(titles.get(section));  
  126.         }else{  
  127.             textView.setVisibility(View.GONE);  
  128.         }  
  129.         return layout;  
  130.     }  
  131.       
  132.       
  133.   
  134.     //实体类  
  135.     private class SWWSafearea{  
  136.         public int id;  
  137.         public String name;  
  138.         public int radius;  
  139.         public SWWSafearea(int id, String name, int radius) {  
  140.             super();  
  141.             this.id = id;  
  142.             this.name = name;  
  143.             this.radius = radius;  
  144.         }  
  145.           
  146.         public SWWSafearea(int id, String name) {  
  147.             super();  
  148.             this.id = id;  
  149.             this.name = name;  
  150.         }  
  151.     }  
  152. }  

MainActivity  

  1. import android.app.Activity;  
  2. import android.os.Bundle;  
  3. import android.view.Menu;  
  4. import za.co.immedia.pinnedheaderlistview.PinnedHeaderListView;  
  5.   
  6. public class MainActivity extends Activity {  
  7.   
  8.     @Override  
  9.     public void onCreate(Bundle savedInstanceState) {  
  10.         super.onCreate(savedInstanceState);  
  11.         setContentView(R.layout.activity_main);  
  12.         PinnedHeaderListView listView = (PinnedHeaderListView) findViewById(R.id.pinnedListView);  
  13.           
  14.         TestSectionedAdapter sectionedAdapter = new TestSectionedAdapter();  
  15.         listView.setAdapter(sectionedAdapter);  
  16.     }  
  17.   
  18.     @Override  
  19.     public boolean onCreateOptionsMenu(Menu menu) {  
  20.         getMenuInflater().inflate(R.menu.activity_main, menu);  
  21.         return true;  
  22.     }  
  23. }  

效果图如下:



推荐下自己创建的android QQ群:202928390   欢迎大家的加入.

文章标签：
前端开发
ansen_666
目录
相关文章
像教授
删除服务
像教授
1013 0
嗯哼9925
|
关系型数据库 Shell PostgreSQL
Slony-I的删除：
嗯哼9925
966 0
晴栀~
评论删除出现ｂｕｇ
评论删除出现ｂｕｇ
晴栀~
81 0
pensir
删除确认
或 删除 或 删除
pensir
782 0
小趴菜111.
|
10月前
视频删除
视频删除
小趴菜111.
100 0
yangyi_dba
|
SQL
如何删除大表中的数据
通常我们认为truncate和drop都是ddl语句,都会释放表占用的空间,且不可回退;而他们的之间的区别在于我们平时忽略的reuse/drop storage子句.
yangyi_dba
731 0
技术小美
|
Linux
创建与删除
技术小美
931 0
Iric
|
OLTP 数据库
数据的删除与修改
数据的删除与修改
Iric
209 0
bisal
|
SQL 移动开发
【求助】从大表中删除小表中存在的记录问题
A表：30万，主键ID B表：300万，主键ID 从B表中删除ID=A表ID的记录。 DELETE FROM B WHERE EXISTS (SELECT 1 FROM (SELECT ID FROM (SELECT T.
bisal
741 0
余二五
快速删除小文件和删除日志
余二五
1033 0

热门文章

最新文章

  • 1
    信用算力基于 RocketMQ 实现金融级数据服务的实践
  • 2
    git 报错 RPC failed; curl 18 transfer closed with outstanding read data remaining
  • 3
    如何在chrome上开启WebGL功能和判断目前浏览器是否支持
  • 4
    阿里云全面支持IPv6！一文揽尽4位大咖精彩演讲
  • 5
    OAuth 及 移动端鉴权调研
  • 6
    YARN中的CPU资源隔离-CGroups
  • 7
    南理工计算机学院研究生课程的评价和反思（研一上）
  • 8
    我的实用设计模式 - Simple Factory和Reflection
  • 9
    再提一下Linux系统中的MD5校验
  • 10
    checkpoint性能测试
  • 1
    有偿创建 CosyVoice2-0.5B 大模型
    47
  • 2
    《深度揭秘：分布式技术如何赋能AI与鸿蒙系统集成的性能飞跃》
    30
  • 3
    《深度解析：人工智能与鸿蒙系统集成中的版本管理与迭代升级》
    37
  • 4
    《探索AI与鸿蒙融合的开源宝藏：这些框架你不能错过》
    26
  • 5
    《鸿蒙系统下AI模型训练加速：时间成本的深度剖析与优化策略》
    22
  • 6
    《深度剖析：鸿蒙系统下智能NPC与游戏剧情的深度融合》
    26
  • 7
    2025年国内工单系统推荐：技术架构、场景适配与行业实践
    29
  • 8
    JVM实战—2.JVM内存设置与对象分配流转
    28
  • 9
    2025年AI客服机器人推荐：核心能力与实际场景应用分析
    32
  • 10
    从第十批算法备案通过名单中分析算法的属地占比、行业及应用情况
    33

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    获取百炼API-KEY