队列集合的手势是怎么样的？求大神帮助_百度知道
队列集合的手势是怎么样的？求大神帮助
，手势是怎么样的，成横队集合的时侯？急盼答复！？成纵队集合的时候，手势是怎么样的啊请问在队列上
提问者采纳
┕━━━━━━━━━━━
你把手比成着样就好了!
其他类似问题
为您推荐：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁java中的 队列
- ITeye技术网站
博客分类：
java中的队列 集合 映射
从计算机的角度看，数据是所有能被输入到计算机中的，且能被计算机处理的符号的集合。它是计算机操作对象的统称。数据结构是指数据与数据之间的联系，可以看做是数据与数据之间存在某种关系的集合，数据结构包括一下几个方面：
（1）：数据元素之间的逻辑关系，即数据的逻辑结构。
（2）：数据元素在计算机中的存储方式，即数据的存储结构。
（3）：施加在数据上的任何操作，在计算机中我们统称为运算（即数据的运算）（数据的运算包括：检索，插入，删除，更新，排序等）。
我们现在讲的队列，集合，映射是数据的常用的简单的存储结构。
1队列 （以ArrayList为例）：它的特点是：线性的，有序的，长度可变的，有下表，可重复存放元素。画图板的保存可以用队列。有三种遍历方式。它的常用的方法add（添加元素），size（列表的长度）、isEmpty（判断是否为空）、get（有下表得到元素）、set(替换某位置上的元素（两个参数）)、iterator （迭代器）和 contains（是否包含某个元素）。
2集合 （以HashSet为例）：它的特点是;无序的，长度可变的，不可重复，无下表。由于他的不可重复性我们可以去掉某一队列中重复的元素。有两种遍历方式。他的常用方法add（添加元素），size（列表的长度）、isEmpty（判断是否为空），iterator （迭代器）contains（是否包含某个元素）。
例题：我们要将一个无序数组，去掉重复的元素后，排序。
思路：我们创建一个集合，然后我们把数组的元素放入到集合中，然后在取出集合中的元素，放入到一个数组，此时数组即为无重复的数组。然后再排序。
package netjava.txc.
public class MyTest {
//定义一个数组
int a[]=new int[10];
// 程序入口
public static void main(String args[]){
//创建对象
MyTest txc = new MyTest();
int a[]= txc.createa(21);
for(int i=0;i&a.i++){
System.out.print(a[i]+"\t");
int b[]=new int[a.length];
System.out.println();
b=txc.quchong(a);
System.out.println();
int c[]=new int[b.length];
c=txc.sort(b);
for(int i=0;i&c.i++){
System.out.print(c[i]+"\t");
public int[] createa(int len){
//定义一个数组
int a[]=new int[len];
for(int i=0;i&a.i++){
//创建随机对象
java.util.Random an=new java.util.Random();
int txc=an.nextInt(20);
public int [] quchong(int a[]){
//把数组 放入到 集合 中
java.util.HashSet&Integer& setn=new java.util.HashSet&Integer&();
for(int i=0;i&a.i++){
setn.add(a[i]);
//遍历 先得到迭代器
java.util.Iterator&Integer& iter =setn.iterator();
int d []=new int[setn.size()];
while(iter.hasNext()){
d[i]=iter.next();
// System.out.print("&&"+d[i]+"\t");
* 排序的 方法
* @param a 要传入的 参数
* @return 返回一个数组
public int[] sort(int a[]){
//排序 用冒泡
for(int i=0;i&a.i++){
for(int j=i+1;j&a.j++){
if(a[i]&a[j]){
int temp=a[i];
a[i]=a[j];
3 映射（以HashMap为例）：它的特点是：首先是一个K &---&V ,K是一个Set集合（不可重复，无序的），每一个K都对应一个K，如果加入相同的键值时，则会替换已经存在的键值队。containsKey(Object key)判断该映射是否包含对应的键值。containsValue(Object value) 判断该映射是否包含 由键 映射得到的值。get(Object key) 返回该值（由键 映射得到的值）。isEmpty()判断是否为空，
put(K key, V value)加入一对键值。size()键值的对数。场景：在学校中一个学号对应一个学生及他的相关信息，在一个国家中一个身份证对应一个公民及他的相关信息。
例题：统计一个数组中每一个元素的次数。
思路：遍历数组，对他的每一个元素我们用 映射的containsKey(Object key)，如果存在该元素我们取出该元素在映射的值 并加以放到映射中，如果不存在我们将value 赋值1，加到映射中。
&!--EndFragment--&
package netjava.txc.
import java.util.HashM
public class MinTest {
//定义一个数组
int a[]=new int[10];
// 程序入口
public static void main(String args[]){
//创建对象
MyTest txc = new MyTest();
int a[]= txc.createa(21);
for(int i=0;i&a.i++){
// System.out.print(a[i]+"\t");
System.out.println();
//创建 对象
MinTest min=new MinTest();
HashMap&Integer, Integer& map= min.time(a);
// java.util.HashMap&Integer, Integer& maps= new java.util.HashMap&Integer, Integer&();
//得到 k的集合
java.util.Set&Integer& se= map.keySet();
//得到迭代器
java.util.Iterator&Integer& iter =se.iterator();
while(iter.hasNext()){
//取出 一个 k
int num =iter.next();
//取出相应的 v
int v =map.get(num);
System.out.println(num+"\t"+v);
public int[] createa(int len){
//定义一个数组
int a[]=new int[len];
for(int i=0;i&a.i++){
//创建随机对象
java.util.Random an=new java.util.Random();
int txc=an.nextInt(20);
public HashMap&Integer, Integer& time(int a[]){
HashMap&Integer, Integer& map =new HashMap&Integer, Integer&();
for(int i=0;i&a.i++){
if(map.containsKey(a[i])){
int v=map.get(a[1])+1;
map.put(a[i], v);
map.put(a[i],1);
&!--EndFragment--&
xichao1929
浏览: 14373 次
来自: 广州
这么麻烦为什么不用maven插件?
我看过Effective Java的关于equal的内容，他里 ...
工作几年后，更应该回到这些基本知识上来重新思考，这样的收获能记 ...
这些才是最基础的东西！基础不扎实是无法写出优雅高效的代码Java基础（2）
在开发中，有时候我们会遇到这样的需求：对一个集合操作，提前为集合指定最大大小，在我们不断向集合中添加数据的时候，当数据内容超过最大值的时候，自动将最先入队的元素移除队列。实现方法很简单，代码如下package com.test.
import java.util.C
import java.util.I
import java.util.LinkedL
import java.util.Q
* 实现一个固定长度的集合队列
* @author SHANHY()
* @param &E&
public class LimitQueue&E& implements Queue&E& {
* 队列长度，实例化类的时候指定
Queue&E& queue = new LinkedList&E&();
public LimitQueue(int limit){
this.limit =
public boolean offer(E e){
if(queue.size() &= limit){
//如果超出长度,入队时,先出队
queue.poll();
return queue.offer(e);
public E poll() {
return queue.poll();
* 获取队列
* @author SHANHY
public Queue&E& getQueue(){
* 获取限制大小
* @author SHANHY
public int getLimit(){
public boolean add(E e) {
return queue.add(e);
public E element() {
return queue.element();
public E peek() {
return queue.peek();
public boolean isEmpty() {
return queue.size() == 0 ? true :
public int size() {
return queue.size();
public E remove() {
return queue.remove();
public boolean addAll(Collection&? extends E& c) {
return queue.addAll(c);
public void clear() {
queue.clear();
public boolean contains(Object o) {
return queue.contains(o);
public boolean containsAll(Collection&?& c) {
return queue.containsAll(c);
public Iterator&E& iterator() {
return queue.iterator();
public boolean remove(Object o) {
return queue.remove(o);
public boolean removeAll(Collection&?& c) {
return queue.removeAll(c);
public boolean retainAll(Collection&?& c) {
return queue.retainAll(c);
public Object[] toArray() {
return queue.toArray();
public &T& T[] toArray(T[] a) {
return queue.toArray(a);
package com.test.
* @author SHANHY()
public class TestQueue {
public static void main(String[] args) {
LimitQueue&String& list = new LimitQueue&String&(4);
list.offer(&SHANHY&);
System.out.println(list.size());
list.offer(&SHANHY&);
System.out.println(list.size());
list.offer(&SHANHY&);
System.out.println(list.size());
list.offer(&SHANHY&);
System.out.println(list.size());
list.offer(&SHANHY&);
System.out.println(list.size());
list.offer(&SHANHY&);
System.out.println(list.size());
list.offer(&SHANHY&);
System.out.println(list.size());
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：600886次
积分：7707
积分：7707
排名：第1395名
原创：180篇
转载：36篇
译文：10篇
评论：294条
(17)(17)(10)(13)(21)(12)(5)(1)(9)(4)(6)(8)(2)(3)(2)(5)(2)(6)(4)(2)(1)(2)(1)(2)(1)(7)(14)(7)(5)(3)(1)(2)(19)(9)(3)java中LinkedList集合类实现栈和队列_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
java中LinkedList集合类实现栈和队列
上传于||文档简介
&&j​a​v​a​中​L​i​n​k​e​d​L​i​s​t​集​合​类​实​现​栈​和​队​列
阅读已结束，如果下载本文需要使用
想免费下载本文？
下载文档到电脑，查找使用更方便
还剩6页未读，继续阅读
你可能喜欢