精华内容
下载资源
问答
  • 队列接口的offer(E e)方法在不违反容量限制的情况下可以立即将指定的元素插入此队列。此方法优于add()方法,因为在容器的容量已满时,此方法不会引发异常,因为它会返回false。用法:boolean offer(E e)参数:此方法...

    队列接口的offer(E e)方法在不违反容量限制的情况下可以立即将指定的元素插入此队列。此方法优于add()方法,因为在容器的容量已满时,此方法不会引发异常,因为它会返回false。

    用法:

    boolean offer(E e)

    参数:此方法接受强制参数e,该参数是要插入队列中的元素。

    返回:成功插入时此方法返回true,否则返回false。

    异常:该函数引发四个异常,如下所述:

    ClassCastException:当要输入的元素的类阻止将其添加到此容器中时:

    IllegalArgumentException:当元素的某些属性阻止将其添加到队列中时:

    NullPointerException:当要插入的元素作为null传递并且Queue的接口不允许使用null元素时。

    以下示例程序旨在说明offer()队列方法:

    程序1:借助LinkedBlockingDeque。

    // Java Program Demonstrate offer()

    // method of Queue

    import java.util.*;

    import java.util.concurrent.LinkedBlockingQueue;

    public class GFG {

    public static void main(String[] args)

    throws IllegalStateException

    {

    // create object of Queue

    Queue Q

    = new LinkedBlockingQueue(3);

    if (Q.offer(10))

    System.out.println("The Queue is not full"

    + " and 10 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(15))

    System.out.println("The Queue is not full"

    + " and 15 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(25))

    System.out.println("The Queue is not full"

    + " and 25 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(20))

    System.out.println("The Queue is not full"

    + " and 20 is inserted");

    else

    System.out.println("The Queue is full");

    // before removing print Queue

    System.out.println("Queue:" + Q);

    }

    }

    输出:

    The Queue is not full and 10 is inserted

    The Queue is not full and 15 is inserted

    The Queue is not full and 25 is inserted

    The Queue is full

    Queue:[10, 15, 25]

    程序2:借助ConcurrentLinkedDeque。

    // Java Program Demonstrate offer()

    // method of Queue

    import java.util.*;

    import java.util.concurrent.ConcurrentLinkedDeque;

    public class GFG {

    public static void main(String[] args)

    throws IllegalStateException

    {

    // create object of Queue

    Queue Q

    = new ConcurrentLinkedDeque();

    if (Q.offer(10))

    System.out.println("The Queue is not full"

    + " and 10 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(15))

    System.out.println("The Queue is not full"

    + " and 15 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(25))

    System.out.println("The Queue is not full"

    + " and 25 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(20))

    System.out.println("The Queue is not full"

    + " and 20 is inserted");

    else

    System.out.println("The Queue is full");

    // before removing print Queue

    System.out.println("Queue:" + Q);

    }

    }

    输出:

    The Queue is not full and 10 is inserted

    The Queue is not full and 15 is inserted

    The Queue is not full and 25 is inserted

    The Queue is not full and 20 is inserted

    Queue:[10, 15, 25, 20]

    程序3:借助ArrayDeque。

    // Java Program Demonstrate offer()

    // method of Queue

    import java.util.*;

    public class GFG {

    public static void main(String[] args)

    throws IllegalStateException

    {

    // create object of Queue

    Queue Q

    = new ArrayDeque(6);

    if (Q.offer(10))

    System.out.println("The Queue is not full"

    + " and 10 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(15))

    System.out.println("The Queue is not full"

    + " and 15 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(25))

    System.out.println("The Queue is not full"

    + " and 25 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(20))

    System.out.println("The Queue is not full"

    + " and 20 is inserted");

    else

    System.out.println("The Queue is full");

    // before removing print Queue

    System.out.println("Queue:" + Q);

    }

    }

    输出:

    The Queue is not full and 10 is inserted

    The Queue is not full and 15 is inserted

    The Queue is not full and 25 is inserted

    The Queue is not full and 20 is inserted

    Queue:[10, 15, 25, 20]

    程序4:借助LinkedList。

    // Java Program Demonstrate offer()

    // method of Queue

    import java.util.*;

    public class GFG {

    public static void main(String[] args)

    throws IllegalStateException

    {

    // create object of Queue

    Queue Q

    = new LinkedList();

    if (Q.offer(10))

    System.out.println("The Queue is not full"

    + " and 10 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(15))

    System.out.println("The Queue is not full"

    + " and 15 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(25))

    System.out.println("The Queue is not full"

    + " and 25 is inserted");

    else

    System.out.println("The Queue is full");

    if (Q.offer(20))

    System.out.println("The Queue is not full"

    + " and 20 is inserted");

    else

    System.out.println("The Queue is full");

    // before removing print Queue

    System.out.println("Queue:" + Q);

    }

    }

    输出:

    The Queue is not full and 10 is inserted

    The Queue is not full and 15 is inserted

    The Queue is not full and 25 is inserted

    The Queue is not full and 20 is inserted

    Queue:[10, 15, 25, 20]

    以下示例程序旨在说明此方法引发的异常:

    程序5:显示NullPointerException。

    // Java Program Demonstrate offer()

    // method of Queue when Null is passed

    import java.util.*;

    import java.util.concurrent.LinkedBlockingQueue;

    public class GFG {

    public static void main(String[] args)

    throws NullPointerException

    {

    // create object of Queue

    Queue Q

    = new LinkedBlockingQueue();

    // Add numbers to end of Deque

    Q.offer(7855642);

    Q.offer(35658786);

    Q.offer(5278367);

    try {

    // when null is inserted

    Q.offer(null);

    }

    catch (Exception e) {

    System.out.println("Exception:" + e);

    }

    }

    }

    输出:

    Exception:java.lang.NullPointerException

    注意:其他两个异常是内部的,它们是由编译器引起的,因此无法在代码中显示。

    展开全文
  • Can anyone give me an example of a Queue where the add and offer methods are different?According to the Collection doc, the add method will often seek to ensure that an element exists within the Colle...

    Can anyone give me an example of a Queue where the add and offer methods are different?

    According to the Collection doc, the add method will often seek to ensure that an element exists within the Collection rather than adding duplicates. So my question is, what is the difference between the add and offer methods?

    Is it that the offer method will add duplicates regardless? (I doubt that it is because if a Collection should only have distinct elements this would circumvent that).

    EDIT:

    In a PriorityQueue the add and offer methods are the same method (see my answer below). Can anyone give me an example of a class where the add and offer methods are different?

    解决方案

    I guess the difference is in the contract, that when element can not be added to collection the add method throws an exception and offer doesn't.

    If a collection refuses to add a

    particular element for any reason

    other than that it already contains

    the element, it must throw an

    exception (rather than returning

    false). This preserves the invariant

    that a collection always contains the

    specified element after this call

    returns.

    Inserts the specified element into

    this queue, if possible. When using

    queues that may impose insertion

    restrictions (for example capacity

    bounds), method offer is generally

    preferable to method

    Collection.add(E), which can fail to

    insert an element only by throwing an

    exception.

    展开全文
  • queue.offer(new int[]{0,0}); while(queue.size()!=0){ int[] cur=queue.poll(); for (int i = 0; i ; i++) { int newx=direction[i][0]+cur[0]; int newy=direction[i][1]+cur[1]; if(newx>=m||newx||newy>=n||...
    class Solution {
        // 方块必须连着,不能跨界存在
        // 广度优先遍历,空间复杂度O(mn),时间复杂度:考虑所有方块都可以进入,则O(mn)
        public int movingCount(int m, int n, int k) {
            if(k==0){
                return 1;
            }
            int res=1;
            boolean[][] mark=new boolean[m][n];
            mark[0][0]=true;
            int[][] direction=new int[][]{{0,1},{1,0}};
            Queue<int[]> queue=new LinkedList<>();
            queue.offer(new int[]{0,0});
            while(queue.size()!=0){
                int[] cur=queue.poll();
                for (int i = 0; i < 2; i++) {
                    int newx=direction[i][0]+cur[0];
                    int newy=direction[i][1]+cur[1];
                    if(newx>=m||newx<0||newy>=n||newy<0||mark[newx][newy]||get(newx)+get(newy)>k){
                        continue;
                    }
                    res++;
                    mark[newx][newy]=true;
                    queue.offer(new int[]{newx,newy});
                }
            }
            return res;    
        }
    
        public int get(int target){
            int res=0;
            while(target!=0){
                res+=target%10;
                target=target/10;
            }
            return res;
        }
    }

     

    展开全文
  • 19.华为笔试题整理

    千次阅读 2021-10-24 14:24:30
    i 旅行 public int Travel (int N, int V, int[] A, Point[] list) { //初始化优先队列 {费用,城市索引} PriorityQueue queue=new PriorityQueue( //按照城市费用升序,如果相等就按照索引升序 (如有多个花费一样的...

    1.两数之和

     数组可以有重复元素,所以与力扣的第一题稍微有点不同

     public int[] twoSum(int[] numbers, int target) {
            int n = numbers.length;
            HashMap<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < n; i++) {
                int realTarget = target - numbers[i];
                if (map.containsKey(realTarget)&&map.get(realTarget)!=i) {
                    return new int[]{map.get(realTarget)+1,i+1};
                }else map.put(numbers[i], i);
            }
            throw  new IllegalArgumentException("No solution");
        }

    2.顺时针旋转矩阵 

    处理用一个新的数组进行处理之外,该题的空间复杂度可以缩减到O1但是需要逐层处理,因为每次交换会掩盖掉之前的数字

     public int[][] rotateMatrix(int[][] mat, int n) {
           //一层一层的进行交换,从最外层开始进行交换
            int rotateTimes=n/2;
            int i=0,low=0,high=n-1;
            while (i++<rotateTimes){
                for (int j = 0; j < high - low; j++) {
                    //用1 4 13 15交换来举例
                    int temp=mat[low][low+j];//记录1的值
                    mat[low][low+j]=mat[high-j][low];//13换到1的位置
                    mat[high-j][low]=mat[high][high-j];//16换到13的位置
                    mat[high][high-j]=mat[low+j][high];//4换到16的位置
                    mat[low+j][high]=temp;//1换到4的位置
                }
                low+=1;//往内层循环走,最低层+1
                high-=1;//最高层-1
            }
            return mat;
        }

    合并字符串

     public String WordsMerge (String[] Words) {
            StringBuilder sb= new StringBuilder("");
            for (String word : Words) {
                sb.append(word);
            }
            int n=sb.length();
            char last=sb.charAt(0);
            for (int i = 1; i <n ; i++) {
                if(sb.charAt(i)==last){
                    //左闭右开区间
                    sb.replace(i-1,i+1,"  ");
                    last=' ';
                }
                last=sb.charAt(i);
            }
            //清除所有的"  "
            return sb.toString().trim();
        }

    旅行

    public int Travel (int N, int V, int[] A, Point[] list) {
            //初始化优先队列 {费用,城市索引}
            PriorityQueue<int[]> queue=new PriorityQueue<>(
                    //按照城市费用升序,如果相等就按照索引升序 (如有多个花费一样的则首先去编号小的城市)
                    (o1,o2)->o1[0]==o2[0]?o1[1]-o2[1]:o1[0]-o2[0]);
    
            //初始化入度数组、后置城市数组
            int[] Indeg=new int[N];
            int[][] limit=new int[N][N];
    
            //给后置城市数组和入度数组赋值
            for(Point p:list){
                limit[p.x-1][p.y-1]=1;
                Indeg[p.y-1]++;
            }
    
            //如果入度为0,则表示可以访问,加入到队列
            for(int i=0;i<N;i++){
                if(Indeg[i]==0){
                    queue.offer(new int[]{A[i],i});
                }
            }
    
            //记录最多可去城市数目
            int cnt=0;
            while(!queue.isEmpty()){
                int[] city=queue.poll();//取出最小的数
                int cost=city[0];//费用
                int id=city[1];//索引
                //如果剩余花费不够,则直接跳出循环
                if(V<cost) break;
                //费用够,减去当前费用
                V-=cost;
                cnt++;//可以去的城市数量增加
                
               
                for(int j=0;j<N;j++){
                    //存在后置城市
                    if(limit[id][j]==1){
                        //后置城市的入度减一
                        Indeg[j]--;
                        //如果入度为0,则加入到队列
                        if(Indeg[j]==0){
                            queue.offer(new int[]{A[j],j});
                        }
                    }
                }
            }
    
            return cnt;
        }

    枪打出头鸟

    暴力解法: 

    public long solve(int n, int[] a) {
            //当前位置的荒唐度
            int[] dp = new int[n];
            //base
            dp[0] = 0;
            for (int i = 1; i < n; i++) {
                for (int j = i-1; j >=0; j--) {
                    if (a[i] < a[j] ) {
                        dp[i]=j+1;
                        break;
                    }
                }
            }
            //注意整形溢出问题
            long res=0;
            for (int i : dp) {
                res+=i;
            }
            return res;
        }

    栈解法:

     //如果前置元素比后置元素小,那么往后的元素肯定会击中后置元素,于是前置小的元素就没用了
    //,这也是可以利用栈来解决的原因
        public long solve(int n, int[] a) {
            long ans = 0;
            Stack<Integer> stack = new Stack<>();
            for (int i = 0; i < n; i++) {
                //如果栈不为空并且栈中的数据小于当前数据(说明打不到),栈中的元素一直弹出
                while (!stack.empty() && a[i] >= a[stack.peek()]) stack.pop();
                //如果到这里栈不为空的话说明有能被枪打到的元素 其值为索引+1
                if (!stack.empty()) ans += stack.peek() + 1;
                //无论如何都把当前元素索引放进栈中
                stack.push(i);
            }
            return ans;
        }

    翻转链表

     public ListNode ReverseList(ListNode head) {
            if (head == null) return null;
            if (head.next == null) return head;
            ListNode pre=null;
            ListNode cur=head;
            ListNode nex;
            while (cur!=null){
                //保留后续节点
                nex= cur.next;
                //指向前置节点
                cur.next=pre;
                //前置节点后移
                pre=cur;
                //当前节点后移
                cur=nex;
            }
            return pre;
        }

    k个一组进行翻转

    •  正常翻转步骤并且对k进行计数
    • 当前节点为null的时候,恢复链表(再翻转,传入的是Prev节点)
    • head.next递归调用
    public ListNode reverseKGroup (ListNode head, int k) {
            ListNode prev = null,curr = head;
            ListNode next;
            int times = k;
            while (times-- > 0){
                //经过k次以内的循环,已经超过了链表的长度
                if(curr == null){
                    //将当前翻转过的链表进行还原 
                    //对于1->2->3->4->5 k=3来说
                    //当遍历到curr==null的时候 prev=5 此时的链表情况为 3->2->1--->(5->4->null)
                    //restore后3->2->1->4->5
                    return restore(prev);
                }
                //在k次之内进行链表的翻转
                next= curr.next;
                curr.next = prev;
                prev = curr;
                curr = next;
            }
            //头结点(现在是尾节点)的下一个节点为翻转链表后的头节点 1->2->3->4 2->1->4->3
            head.next = reverseKGroup(curr, k);
            return prev;
        }
    
        private ListNode restore(ListNode head){    //不足k个时再反转还原
            ListNode prev = null,curr = head;
            ListNode next;
            while (curr != null){
                next=curr.next;
                curr.next = prev;
                prev = curr;
                curr = next;
            }
            return prev;
        }

    未排序数组最长连续子数组长度 

        public int maxlenEqualK(int[] arr, int k) {
            if (arr == null || arr.length == 0) return 0;
            int n = arr.length;
            HashMap<Integer, Integer> map = new HashMap<>();//记录每一个和以及出现的位置
            map.put(0, -1);//初始化
            int res = 0;
            int sum = 0;
            for (int i = 0; i < n; i++) {
                sum += arr[i];
                //如果满足条件就比较当前最大值
                if (map.containsKey(sum - k)) res = Math.max(res, i - map.get(sum - k));
                //没有当前和就将其放入哈希表,因为是按照顺序遍历的,后面如果出现同样的和可以直接舍弃
                if (!map.containsKey(sum)) map.put(sum, i);
            }
            return res;
        }

    字符串出现次数的TopK问题

     侧重于对哈希表进行排序处理

        public String[][] topKstrings (String[] strings, int k) {
            HashMap<String, Integer> map = new HashMap<>();
            for (int i = 0; i < strings.length; i++) {
                map.put(strings[i],map.getOrDefault(strings[i],0)+1);
            }
            //使用list对HashMap进行排序
            ArrayList<Map.Entry<String, Integer>> list = new ArrayList<>();
            list.addAll(map.entrySet());
            //指定排序规则
            Collections.sort(list,(m1,m2)->{
                //出现的次数相等按照字符集升序(要选择小的那个),否则按照出现次数降序
                return m1.getValue()==m2.getValue()?m1.getKey().compareTo(m2.getKey()):m2.getValue()-m1.getValue();
            });
            if(k>strings.length)k=strings.length;
            String[][] ans=new String[k][2];
            for (int i = 0; i <k ; i++) {
                ans[i][0]=list.get(i).getKey();
                ans[i][1]=list.get(i).getValue().toString();
            }
            return ans;
        }

    计算机算数

     堆可以处理大部分需要重新排列结果和原数据集的题目

     //由于计算机只能计算一次,所以每次取两个最小的值进行计算
        public long solve (int n, int c, int[] a) {
            long res=0;
            PriorityQueue<Integer> pq=new PriorityQueue<>();
            for (int i : a) {
                pq.offer(i);
            }
            while (pq.size()!=1){
                int x=pq.poll();
                int y=pq.poll();
                int xy=x+y;
                res+=xy;
                pq.offer(xy);
            }
            return c*res;
        }

    寻找第k大的数字

    构造一个大顶堆 

    public int findKth(int[] a, int n, int K) {
            PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer integer, Integer t1) {
                    return t1.compareTo(integer);
                }
            });
            for (int i = 0; i < n; i++) {
                priorityQueue.offer(a[i]);
            }
            //k先--再比对是否为0
            while (--K!=0){
                priorityQueue.poll();
            }
            return priorityQueue.peek();
        }

    加密完全二叉树

    long res=0;
        public long tree1 (int[] a) {
            if(a==null||a.length==0)return 0;
            TreeNode root = build(a, 1);
            getSum(root);
            return res;
        }
    
        private TreeNode build(int[]a,int index){
            if(index>a.length)return null;
            TreeNode treeNode = new TreeNode(a[index-1]);
            //二叉树性质,左节点等于父节点位置*2 注意不能使用(索引+1)*2,如果从0开始
            //(0+1)*2导致下一个访问的索引为2
            treeNode.left=build(a,index*2);
            treeNode.right=build(a,index*2+1);
            return treeNode;
        }
        private void getSum(TreeNode root){
            if(root==null)return;
            if(root.left!=null)res+=root.val^root.left.val;
            if(root.right!=null)res+=root.val^root.right.val;
            getSum(root.left);
            getSum(root.right);
        }

    也可以不构造二叉树直接使用数组:

     public long tree1 (int[] a) {
            //初始化结果变量
            long res=0L;
            int n=a.length;
            //根据数组访问树中所有节点
            for(int i=1;2*i<=n;i++){
                //左子节点对应编号
                int l=2*i;
                //右子节点对应编号
                int r=2*i+1;
                //计算异或和
                if(l<=n){
                    res+=a[i-1]^a[l-1];
                }
                if(r<=n){
                    res+=a[i-1]^a[r-1];
                }
            }
            return res;
        }

    二叉树的个数

    其实是对1000000007取模

    前置知识:两数乘积的模等于两数模的乘积,由于其中序遍历单调递增,所以它是一个搜索二叉树

    左节点只能放比自己小的,右节点只能放比自己大的

    当节点为i的时候,左子树的节点个数为i-1右子树为n-i个节点,知道这个条件就可以使用动态规划来做

     public int numberOfTree(int n) {
            //初始化dp数组
            long[] dp = new long[n + 1];
            //没有节点和只有一个节点的情况
            dp[0] = 1;
            dp[1] = 1;
            for (int i = 2; i <= n; i++) {
                //找到每一个节点(从1到i的每一个数对应一个节点)为根的情况,并进行累加
                //左子树的数量为j-1,右子树的数量为i-j
                for (int j = 1; j <= i; j++) {
                    dp[i] = (dp[i] + dp[j - 1] * dp[i - j]) % mod;
                }
            }
            return (int) dp[n];
        }

    寻找重复的数

    public int search (int n, int[] a) {
            //让数组中的元素和1-n进行异或操作
            int res=0;
            for (int i = 1; i <= n; i++) {
                res^=i;
                System.out.println(res);
                res^=a[i-1];
                System.out.println(res);
            }
            //最后一个元素还没有进行异或
            int last=a[n];
            System.out.println(res^last);
            return res^last;
        }

    交换字符串

     要保证交换后字典序大,只需保证交换之后大的字符在前面就行了

    public int turn (String s, int k) {
            int n=s.length();
            int res=0;
            //分为k组
            for(int i=0;i<k;i++){
                //临时计数数组
                int[] cnt=new int[26];
                for(int j=i;j<n;j+=k){
                    //当前字符对应下标
                    int index=s.charAt(j)-'a';
                    for(int id=0;id<index;id++){
                        //如果有小于当前字符的情况,则加上对应次数
                        res+=cnt[id];
                    }
                    //当前字符计数加一
                    cnt[index]++;
                }
            }
            return res;
        }

    青蛙跳台阶-一次跳一层或者两层,问跳到n层有多少方法

     public int jumpFloor(int target) {
            if(target==1||target==2)return target;
    
            //跳上n级台阶的跳法
            int[] dp = new int[target+1];
            dp[1]=1;
            dp[2]=2;
            for (int i = 3; i < dp.length; i++) {
                dp[i]=dp[i-1]+dp[i-2];
            }
            return dp[target];
        }

    计算器--加减乘和括号

     public int calculate(String s) {
            //使用list来存储字符串
            List<Character> list = new ArrayList<>();
            for (int i = 0; i < s.length(); i++) {
                list.add(s.charAt(i));
            }
            return helper(list);
        }
    
        private int helper(List<Character> s) {
            Stack<Integer> stack = new Stack<>();
            // 记录 num 前的符号,初始化为 +
            char sign = '+';
            int num = 0, res = 0;
            while (s.size() > 0) {
                //不断的移除获取到第一个元素(其实就和遍历一样)
                char c = s.remove(0);
                //数字累加
                if (Character.isDigit(c)) {
                    num = 10 * num + (c - '0');
                }
                //遇到前括号递归,我们需要先算出括号的结果,括号包含的算式我们认为是一个数字就行了
                if (c == '(') num = helper(s);
                if ((!Character.isDigit(c) && c != ' ') || s.size() == 0) {
                    //这里查看的其实是上一个符号,因为num也是遍历到当前符号的上一个数
                    switch (sign) {
                        //加减法直接把数字带着符号push进去,等着最后计算
                        case '+':
                            stack.push(num);
                            break;
                        case '-':
                            stack.push(-num);
                            break;
                         //遇到乘除法就直接拿出上一个数来运算   
                        case '*':
                            stack.push(stack.pop()*num);
                            break;
                        case '/':
                            stack.push(stack.peek()/num);
                            break;
                    }
                    //更新符号为当前符号,数字清零
                    sign=c;
                    num=0;
                }
                if(c==')')break;//遇到右括号递归结束
            }
            //计算所有栈里的值
            while (!stack.isEmpty()){
                res+=stack.pop();
            }
            return res;
        }
    展开全文
  • 下面来看下SynchronousQueue源码 offer(E e)和take()源码 public boolean offer(E e) { if (e == null) throw new NullPointerException(); return transferer.transfer(e, true, 0) != null; } public E take() ...
  • 当队列满时,即队列中元素的个数等于队列的容量时,再插入元素,add方法将抛异常IllegalStateException,offer方法返回false. 验证如下 验证offer ... queue.offer(1); queue.offer(1); queue.offer(1);
  • Java并发 - Queue

    2021-08-22 12:58:21
    Queue继承Collection接口,Stack继承Vector容器类,最顶层接口也是Collection。在Java中容器分为Collection和Map两大类。 Collection家族中除了常见的List、Set,现在又新增一个Queue、Stack。 public interface ...
  • 消费者: package com.dk.learndemo.queue; import java.util.Random; import java.util.concurrent.BlockingQueue; ... * @date: 2021/3/29 3:34 下午 ...public class Consumer implements Runnable { ... queue;
  • Java 实例 - 队列(Queue)用法队列是一种特殊的线性表,它只允许在表的前端进行删除操作,而在表的后端进行插入操作。LinkedList类实现了Queue接口,因此我们可以把LinkedList当成Queue来用。以下实例演示了队列...
  • j++) { if (matrix[i][j] == 0) { queue.offer(new int[] {i, j}); } else { matrix[i][j] = -1; } } } int[] dx = new int[] {-1, 1, 0, 0}; int[] dy = new int[] {0, 0, -1, 1}; while (!queue.isEmpty()) { int...
  • 【Java 集合框架】PriorityQueue 优先级队列的使用

    多人点赞 热门讨论 2021-11-08 16:15:08
    我们知道,Queue是一个先进先出(FIFO)的队列。 在很多应用中,我们通常需要按照优先情况对待处理对象进行处理,比如首先处理优先级最高的对象,然后处理次高的对象。最简单的一个例子就是,在手机上玩游戏时,如果...
  • Java Queue的使用

    2021-02-27 20:37:33
    Queue 实现一个先进先出的队列获取队列长度:size()添加元素到队尾:boolean add(E e) /boolean offer(E e)获取队列头部元素并删除:E remove() / E poll()获取队列头部元素但不删除:E element() / E peek()当添加...
  • queue.offer(root); //在初始化树时就层序遍历到第一个没有左或右子树的节点,即为待插入位置的父节点,在队列头部 while (queue.peek().left != null && queue.peek().right != null) { TreeNode node = queue....
  • 1. 接口定义 ...后一种形式的插入操作是专门为使用容量设限的 Queue 实现而设计的;在大多数实现中,插入操作不会失败。 - 抛出异常 返回特殊值 插入 add(e) offer(e) 提取/移除 remove()
  • Java Queue 详解

    2021-03-08 21:23:41
    背景Java queue接口是JDK1.5后才出现的集合, 只要目的是提供一个有优先级顺序的集合操作。 除了包括一些基本的集合操作之外,queue还提供额外的插入, 删除和获取元素的操作。 这三种操作都提供了两种方法, 一种是...
  • //都能添加元素 offer更健壮友好 区别:当队列慢 add会抛出异常 offer返回false 更健壮友好 //queue.add(1); queue.offer(1); queue.offer(2); queue.offer(3); //取出元素份两种: 只获取头元素不取出 区别:当...
  • /* 集合 boolean offer(E e) 入队操作 当我们实现了LinkedLiset,那么add 和 offer都是一样的,offer底层就是 add 但是,Queure可不是只有一个实现类 别的实现类offer 底层可不一定是add */ queue.offer("one");...
  • /** * 优先级队列是使用平衡二叉堆表示的: 节点queue[n]的两个孩子分别为 * queue[2*n+1] 和 queue[2*(n+1)]. 队列的优先级是由比较器或者 * 元素的自然排序决定的, 对于堆中的任意元素n,其后代d满足:n* 如果堆...
  • 队列的offer,poll,addAll方法: 定义队列:Queue<Node>...添加值进队列:queue.offer(root); 弹出值:Nodenode=queue.poll(); 将孩子节点的所有值都添加:queue.addAll(node.children); ...
  • Java-Queue总结

    2021-02-26 16:45:12
    import java.util.Queue;import java.util.concurrent.ConcurrentLinkedQueue;//底层链表实现 队列,先进先出public class Test_03_ConcurrentLinkedQueue {public static void main(String[] ...
  • Queue 中 add() 和 offer() 区别
  • 队列(queue)是一个典型的先进先出(FIFO)的容器。即从容器的一端放入事物,从另一端取出,并且事物放入容器的顺序与取出的顺序是相同的。相同点:都是返回第一个元素,并在队列中删除返回的对象。不同点:remove() ,...
  • 1、boolean add(E e)向队列尾中添加一个元素,成功返回true,失败返回falseadd 在队列满时会抛出IllegalStateException: Queue full异常2、boolean offer(E e)向队列尾中添加一个元素,成功返回true,失败返回...
  • java.util.Queue用法

    2021-02-27 17:54:13
    Queue使用时要尽量避免Collection的add()和remove()方法,而是要使用offer()来加入元素,使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否,add()和remove()方法在失败的时候会抛出异常。 如果...
  • BlockingQueue简介BlockingQueue:不是新的东西,父接口java.util.Queue当队列为空时,从队列中获取元素将阻塞。当队列为满时,从队列中添加元素将阻塞。因为是队列,所以我们理应想到先进先出。BlockingQueue常用...
  • 队列(Queue)

    2021-02-12 15:37:37
    在“队列”(Queue)这种数据结构中,数据项是先进先出(FIFO:first in first out)。队列的容量可以有限,也可以是无限的。一、基于数组的Queue实现一般情况下,对于Queue而言,最核心的操作是:插入队列(enqueue)、...
  • Queue使用时要尽量避免Collection的add()和remove()方法,而是要使用offer()来加入元素,使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否,add()和remove()方法在失败的时候会抛出异常。 如果...
  • // offer方法向队列中添加元素,返回布尔值 queue.offer("a"); queue.offer("b"); queue.offer("c"); queue.offer("d"); queue.offer("e"); } // poll方法移除队列首个元素并返回,若队列为空,返回null @Test ...
  • 一、阻塞队列 什么是阻塞队列? 阻塞队列(BlockingQueue)是一个支持两个附加操作的队列,这两个附加的操作是:在队列为空时,获取元素的线程会等待队列...offer(anObject):表示如果可能的话,将anObject加到Bloc
  • 概述LinkedBlockingQueue的put,add和offer这三个方法功能很相似,都是往队列尾部添加一个元素。既然都是同样的功能,为啥要有有三个方法呢?这三个方法的区别在于:put方法添加元素,如果队列已满,会阻塞直到有空间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,147
精华内容 28,858
关键字:

queue.offer