Java中的Deque addFirst（）方法及其示例-yiteyi-C++库

这个 addFirst（E） 方法 Deque接口如果有空格，则将参数中传递的元素插入Deque的前面。如果Deque容量受限，并且没有空间可供插入，则返回 非法国家例外 .成功插入后，函数返回true。

null

语法：

void addFirst(E e)

参数： 此方法接受一个强制参数 E 这是要插入到Deque前面的元素。

返回： 此方法在成功插入时返回true。

例外情况： 该函数引发四个异常，如下所述：

类别例外 ：当要输入的元素的类阻止它添加到此容器时。
非法国家例外 ：当容器的容量已满且插入完成时。
非法数据异常 ：当元素的某些属性阻止将其添加到Deque时。
空指针异常 ：当要插入的元素作为null传递，并且Deque的接口不允许null元素时。

下面的程序举例说明 addFirst（） 设计方法：

项目1： 借助于链表 .

                     // Java Program Demonstrate addFirst()                   
                     // method of Deque                   
                     import                               java.util.*;                   
                             
                     public                               class                               GFG {                   
                                         public                               static                               void                               main(String[] args)                   
                                         throws                               IllegalStateException                   
                                         {                   
                             
                                         // create object of De1ue                   
                                         Deque<Integer> DQ                   
                                         =                               new                               LinkedList<Integer>();                   
                             
                                         // Add numbers to end of Deque                   
                                         DQ.addFirst(                               7855642                               );                   
                                         DQ.addFirst(                               35658786                               );                   
                                         DQ.addFirst(                               5278367                               );                   
                                         DQ.addFirst(                               74381793                               );                   
                             
                                         // print Deque                   
                                         System.out.println(                               "Deque: "                               + DQ);                   
                                         }                   
                     }                   

输出：

Deque: [74381793, 5278367, 35658786, 7855642]

项目2： 借助于 ArrayDeque .

                     // Java Program Demonstrate addFirst()                   
                     // method of Deque                   
                     import                               java.util.*;                   
                             
                     public                               class                               GFG {                   
                                         public                               static                               void                               main(String[] args)                   
                                         throws                               IllegalStateException                   
                                         {                   
                             
                                         // create object of De1ue                   
                                         Deque<Integer> DQ                   
                                         =                               new                               ArrayDeque<Integer>();                   
                             
                                         // Add numbers to end of Deque                   
                                         DQ.addFirst(                               7855642                               );                   
                                         DQ.addFirst(                               35658786                               );                   
                                         DQ.addFirst(                               5278367                               );                   
                                         DQ.addFirst(                               74381793                               );                   
                             
                                         // print Deque                   
                                         System.out.println(                               "Deque: "                               + DQ);                   
                                         }                   
                     }                   

输出：

Deque: [74381793, 5278367, 35658786, 7855642]

方案3： 借助于 ConcurrentLinkedEque .

                     // Java Program Demonstrate addFirst()                   
                     // method of Deque                   
                     import                               java.util.*;                   
                     import                               java.util.concurrent.ConcurrentLinkedDeque;                   
                     public                               class                               GFG {                   
                                         public                               static                               void                               main(String[] args)                   
                                         throws                               IllegalStateException                   
                                         {                   
                             
                                         // create object of De1ue                   
                                         Deque<Integer> DQ                   
                                         =                               new                               ConcurrentLinkedDeque<Integer>();                   
                             
                                         // Add numbers to end of Deque                   
                                         DQ.addFirst(                               7855642                               );                   
                                         DQ.addFirst(                               35658786                               );                   
                                         DQ.addFirst(                               5278367                               );                   
                                         DQ.addFirst(                               74381793                               );                   
                             
                                         // print Deque                   
                                         System.out.println(                               "Deque: "                               + DQ);                   
                                         }                   
                     }                   

输出：

Deque: [74381793, 5278367, 35658786, 7855642]

方案4： 借助于 LinkedBlockingDeque .

                     // Java Program Demonstrate addFirst()                   
                     // method of Deque                   
                     import                               java.util.*;                   
                     import                               java.util.concurrent.LinkedBlockingDeque;                   
                     public                               class                               GFG {                   
                                         public                               static                               void                               main(String[] args)                   
                                         throws                               IllegalStateException                   
                                         {                   
                             
                                         // create object of De1ue                   
                                         Deque<Integer> DQ                   
                                         =                               new                               LinkedBlockingDeque<Integer>();                   
                             
                                         // Add numbers to end of Deque                   
                                         DQ.addFirst(                               7855642                               );                   
                                         DQ.addFirst(                               35658786                               );                   
                                         DQ.addFirst(                               5278367                               );                   
                                         DQ.addFirst(                               74381793                               );                   
                             
                                         // print Deque                   
                                         System.out.println(                               "Deque: "                               + DQ);                   
                                         }                   
                     }                   

输出：

Deque: [74381793, 5278367, 35658786, 7855642]

下面的程序举例说明 addFirst（）方法引发的异常 :

方案5： 展示 空指针异常 .

                       /// Java Program Demonstrate addFirst()                     
                       // method of DeQue when Null is passed                     
                       import                                  java.util.*;                     
                       import                                  java.util.concurrent.LinkedBlockingDeque;                     
                                
                       public                                  class                                  GFG {                     
                                             public                                  static                                  void                                  main(String[] args)                     
                                             throws                                  IllegalStateException                     
                                             {                     
                                
                                             // create object of DeQue                     
                                             Deque<Integer> DQ                     
                                             =                                  new                                  LinkedBlockingDeque<Integer>();                     
                                
                                             // Add numbers to end of DeQue                     
                                             DQ.addFirst(                                  7855642                                  );                     
                                             DQ.addFirst(                                  35658786                                  );                     
                                             DQ.addFirst(                                  5278367                                  );                     
                                             // when null is inserted                     
                                             DQ.addFirst(                                  null                                  );                     
                                
                                             // before removing print DeQue                     
                                             System.out.println(                                  "DeQue: "                                  + DQ);                     
                                             }                     
                       }                     

输出：

Exception in thread "main" java.lang.NullPointerException
    at java.util.concurrent.LinkedBlockingDeque.offerFirst(LinkedBlockingDeque.java:342)
    at java.util.concurrent.LinkedBlockingDeque.addFirst(LinkedBlockingDeque.java:325)
    at GFG.main(GFG.java:20)

项目6： 展示 非法国家例外 .

                       // Java Program Demonstrate addFirst()                     
                       // method of Deque when capacity is full                     
                       import                                  java.util.*;                     
                       import                                  java.util.concurrent.LinkedBlockingDeque;                     
                                
                       public                                  class                                  GFG {                     
                                             public                                  static                                  void                                  main(String[] args)                     
                                             throws                                  IllegalStateException                     
                                             {                     
                                
                                             // create object of Deque                     
                                             Deque<Integer> DQ                     
                                             =                                  new                                  LinkedBlockingDeque<Integer>(                                  3                                  );                     
                                
                                             // Add numbers to end of Deque                     
                                             DQ.addFirst(                                  7855642                                  );                     
                                             DQ.addFirst(                                  35658786                                  );                     
                                             DQ.addFirst(                                  5278367                                  );                     
                                
                                             // when capacity is full                     
                                             DQ.addFirst(                                  10                                  );                     
                                
                                             // before removing print Deque                     
                                             System.out.println(                                  "Deque: "                                  + DQ);                     
                                             }                     
                       }                     

输出：

Exception in thread "main" java.lang.IllegalStateException: Deque full
    at java.util.concurrent.LinkedBlockingDeque.addFirst(LinkedBlockingDeque.java:326)
    at GFG.main(GFG.java:21)

注：另外两个异常是内部异常，由编译器引起，因此无法在编译器中显示。

参考： https://docs.oracle.com/javase/8/docs/api/java/util/Deque.html#addFirst-E-

文章版权归作者所有，未经允许请勿转载。

THE END

Java