Code666 (代码贴、代码片段)

[Java] java 随机队列 →→→→→进入此内容的聊天室

来自 , 2020-10-29, 写在 Java, 查看 187 次.
URL http://www.code666.cn/view/b4d8c3b4
  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Iterator;
  4. import java.util.LinkedList;
  5. import java.util.NoSuchElementException;
  6. import java.util.Queue;
  7. import java.util.Random;
  8.  
  9. public class RandomQueue<E> implements Queue<E> {
  10.         static int Squads = 32;
  11.         static int wid = 8;
  12.         @SuppressWarnings("unchecked")
  13.         LinkedList<E>[][] bulk = new LinkedList[wid][wid];
  14.         Random r;
  15.         int count = 0;
  16.  
  17.         @Override
  18.         public int size() {
  19.                 return count;
  20.         }
  21.  
  22.         public RandomQueue() {
  23.                 r = new Random(System.currentTimeMillis());
  24.                 for (int i = 0; i < wid; ++i) {
  25.                         for (int j = 0; j < wid; ++j) {
  26.                                 bulk[i][j] = new LinkedList<E>();
  27.                         }
  28.                 }
  29.         }
  30.  
  31.         @Override
  32.         public boolean isEmpty() {
  33.                 return count > 0 ? false : true;
  34.         }
  35.  
  36.         @Override
  37.         public boolean contains(Object o) {
  38.                 for (int i = 0; i < wid; ++i) {
  39.                         for (int j = 0; j < wid; ++j) {
  40.                                 if (bulk[i][j].contains(o)) {
  41.                                         return true;
  42.                                 }
  43.                         }
  44.                 }
  45.                 return false;
  46.         }
  47.  
  48.         @Override
  49.         public Iterator<E> iterator() {
  50.                 ArrayList<E> list = new ArrayList<E>();
  51.                 for (int i = 0; i < wid; ++i) {
  52.                         for (int j = 0; j < wid; ++j) {
  53.                                 bulk[i][j].toArray();
  54.                                 list.addAll(bulk[i][j]);
  55.                         }
  56.                 }
  57.                 return list.iterator();
  58.         }
  59.  
  60.         @Override
  61.         public Object[] toArray() {
  62.                 ArrayList<E> list = new ArrayList<E>();
  63.                 for (int i = 0; i < wid; ++i) {
  64.                         for (int j = 0; j < wid; ++j) {
  65.                                 bulk[i][j].toArray();
  66.                                 list.addAll(bulk[i][j]);
  67.                         }
  68.                 }
  69.                 return list.toArray();
  70.         }
  71.  
  72.         @Override
  73.         public <T> T[] toArray(T[] a) {
  74.                 ArrayList<E> list = new ArrayList<E>();
  75.                 for (int i = 0; i < wid; ++i) {
  76.                         for (int j = 0; j < wid; ++j) {
  77.                                 bulk[i][j].toArray();
  78.                                 list.addAll(bulk[i][j]);
  79.                         }
  80.                 }
  81.                 return list.toArray(a);
  82.         }
  83.  
  84.         @Override
  85.         public boolean remove(Object o) {
  86.                 for (int i = 0; i < wid; ++i) {
  87.                         for (int j = 0; j < wid; ++j) {
  88.                                 if (bulk[i][j].contains(o)) {
  89.                                         return bulk[i][j].remove(o);
  90.                                 }
  91.                         }
  92.                 }
  93.                 return false;
  94.         }
  95.  
  96.         @Override
  97.         public boolean containsAll(Collection<?> c) {
  98.                 ArrayList<E> list = new ArrayList<E>();
  99.                 for (int i = 0; i < wid; ++i) {
  100.                         for (int j = 0; j < wid; ++j) {
  101.                                 bulk[i][j].toArray();
  102.                                 list.addAll(bulk[i][j]);
  103.                         }
  104.                 }
  105.                 return list.containsAll(c);
  106.         }
  107.  
  108.         @Override
  109.         public boolean addAll(Collection<? extends E> c) {
  110.                 int i = r.nextInt(wid);
  111.                 int j = r.nextInt(wid);
  112.                 return bulk[i][j].addAll(c);
  113.         }
  114.  
  115.         @Override
  116.         public boolean removeAll(Collection<?> c) {
  117.                 for (int i = 0; i < wid; ++i) {
  118.                         for (int j = 0; j < wid; ++j) {
  119.                                 bulk[i][j].removeAll(c);
  120.                         }
  121.                 }
  122.                 return true;
  123.         }
  124.  
  125.         @Override
  126.         public boolean retainAll(Collection<?> c) {
  127.                 for (int i = 0; i < wid; ++i) {
  128.                         for (int j = 0; j < wid; ++j) {
  129.                                 bulk[i][j].retainAll(c);
  130.                         }
  131.                 }
  132.                 return true;
  133.         }
  134.  
  135.         @Override
  136.         public void clear() {
  137.                 for (int i = 0; i < wid; ++i) {
  138.                         for (int j = 0; j < wid; ++j) {
  139.                                 bulk[i][j].clear();
  140.                         }
  141.                 }
  142.         }
  143.  
  144.         @Override
  145.         public boolean add(E e) {
  146.                 int i = r.nextInt(wid);
  147.                 int j = r.nextInt(wid);
  148.                 return bulk[i][j].add(e);
  149.         }
  150.  
  151.         @Override
  152.         public boolean offer(E e) {
  153.                 return add(e);
  154.         }
  155.  
  156.         @Override
  157.         public E remove() {
  158.                 int i = r.nextInt(wid);
  159.                 int j = r.nextInt(wid);
  160.                 for (int k = i; k < wid; ++k) {
  161.                         for (int l = j; l < wid; ++l) {
  162.                                 if (bulk[k][l].isEmpty()) {
  163.                                         continue;
  164.                                 }
  165.                                 return bulk[k][l].remove();
  166.                         }
  167.                 }
  168.                 for (int k = 0; k < i; ++k) {
  169.                         for (int l = 0; l < j; ++l) {
  170.                                 if (bulk[k][l].isEmpty()) {
  171.                                         continue;
  172.                                 }
  173.                                 return bulk[k][l].remove();
  174.                         }
  175.                 }
  176.                 throw new NoSuchElementException();
  177.         }
  178.  
  179.         @Override
  180.         public E poll() {
  181.                 int i = r.nextInt(wid);
  182.                 int j = r.nextInt(wid);
  183.                 try {
  184.                         for (int k = i; k < wid; ++k) {
  185.                                 for (int l = j; l < wid; ++l) {
  186.                                         if (bulk[k][l].isEmpty()) {
  187.                                                 continue;
  188.                                         }
  189.                                         return bulk[k][l].remove();
  190.                                 }
  191.                         }
  192.                         for (int k = 0; k < i; ++k) {
  193.                                 for (int l = 0; l < j; ++l) {
  194.                                         if (bulk[k][l].isEmpty()) {
  195.                                                 continue;
  196.                                         }
  197.                                         return bulk[k][l].remove();
  198.                                 }
  199.                         }
  200.                 } catch (NoSuchElementException e) {
  201.                         return null;
  202.                 }
  203.                 return null;
  204.         }
  205.  
  206.         @Override
  207.         public E element() {
  208.                 int i = r.nextInt(wid);
  209.                 int j = r.nextInt(wid);
  210.                 for (int k = i; k < wid; ++k) {
  211.                         for (int l = j; l < wid; ++l) {
  212.                                 if (bulk[k][l].isEmpty()) {
  213.                                         continue;
  214.                                 }
  215.                                 return bulk[k][l].getFirst();
  216.                         }
  217.                 }
  218.                 for (int k = 0; k < i; ++k) {
  219.                         for (int l = 0; l < j; ++l) {
  220.                                 if (bulk[k][l].isEmpty()) {
  221.                                         continue;
  222.                                 }
  223.                                 return bulk[k][l].getFirst();
  224.                         }
  225.                 }
  226.                 throw new NoSuchElementException();
  227.         }
  228.  
  229.         @Override
  230.         public E peek() {
  231.                 int i = r.nextInt(wid);
  232.                 int j = r.nextInt(wid);
  233.                 try {
  234.                         for (int k = i; k < wid; ++k) {
  235.                                 for (int l = j; l < wid; ++l) {
  236.                                         if (bulk[k][l].isEmpty()) {
  237.                                                 continue;
  238.                                         }
  239.                                         return bulk[k][l].getFirst();
  240.                                 }
  241.                         }
  242.                         for (int k = 0; k < i; ++k) {
  243.                                 for (int l = 0; l < j; ++l) {
  244.                                         if (bulk[k][l].isEmpty()) {
  245.                                                 continue;
  246.                                         }
  247.                                         return bulk[k][l].getFirst();
  248.                                 }
  249.                         }
  250.                 } catch (NoSuchElementException e) {
  251.                         return null;
  252.                 }
  253.                 return null;
  254.         }
  255.  
  256. }
  257.  
  258. //java/1313

回复 "java 随机队列"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666