|
1
7
8 package java.util;
9
10
55
56 public abstract class AbstractList<E> extends AbstractCollection  <E> implements List <E> {
57
61 protected AbstractList() {
62 }
63
64
88 public boolean add(E o) {
89 add(size(), o);
90 return true;
91 }
92
93
102 abstract public E get(int index);
103
104
125
126 public E set(int index, E element) {
127 throw new UnsupportedOperationException ();
128 }
129
130
150 public void add(int index, E element) {
151 throw new UnsupportedOperationException ();
152 }
153
154
171 public E remove(int index) {
172 throw new UnsupportedOperationException ();
173 }
174
175
176
178
194 public int indexOf(Object o) {
195 ListIterator <E> e = listIterator();
196 if (o==null) {
197 while (e.hasNext())
198 if (e.next()==null)
199 return e.previousIndex();
200 } else {
201 while (e.hasNext())
202 if (o.equals(e.next()))
203 return e.previousIndex();
204 }
205 return -1;
206 }
207
208
225 public int lastIndexOf(Object o) {
226 ListIterator <E> e = listIterator(size());
227 if (o==null) {
228 while (e.hasPrevious())
229 if (e.previous()==null)
230 return e.nextIndex();
231 } else {
232 while (e.hasPrevious())
233 if (o.equals(e.previous()))
234 return e.nextIndex();
235 }
236 return -1;
237 }
238
239
240
242
257 public void clear() {
258 removeRange(0, size());
259 }
260
261
302 public boolean addAll(int index, Collection <? extends E> c) {
303 boolean modified = false;
304 Iterator <? extends E> e = c.iterator();
305 while (e.hasNext()) {
306 add(index++, e.next());
307 modified = true;
308 }
309 return modified;
310 }
311
312
313
315
336 public Iterator <E> iterator() {
337 return new Itr();
338 }
339
340
348 public ListIterator <E> listIterator() {
349 return listIterator(0);
350 }
351
352
388 public ListIterator <E> listIterator(final int index) {
389 if (index<0 || index>size())
390 throw new IndexOutOfBoundsException ("Index: "+index);
391
392 return new ListItr(index);
393 }
394
395 private class Itr implements Iterator <E> {
396
399 int cursor = 0;
400
401
406 int lastRet = -1;
407
408
413 int expectedModCount = modCount;
414
415 public boolean hasNext() {
416 return cursor != size();
417 }
418
419 public E next() {
420 checkForComodification();
421 try {
422 E next = get(cursor);
423 lastRet = cursor++;
424 return next;
425 } catch(IndexOutOfBoundsException e) {
426 checkForComodification();
427 throw new NoSuchElementException ();
428 }
429 }
430
431 public void remove() {
432 if (lastRet == -1)
433 throw new IllegalStateException ();
434 checkForComodification();
435
436 try {
437 AbstractList.this.remove(lastRet);
438 if (lastRet < cursor)
439 cursor--;
440 lastRet = -1;
441 expectedModCount = modCount;
442 } catch(IndexOutOfBoundsException e) {
443 throw new ConcurrentModificationException ();
444 }
445 }
446
447 final void checkForComodification() {
448 if (modCount != expectedModCount)
449 throw new ConcurrentModificationException ();
450 }
451 }
452
453 private class ListItr extends Itr implements ListIterator <E> {
454 ListItr(int index) {
455 cursor = index;
456 }
457
458 public boolean hasPrevious() {
459 return cursor != 0;
460 }
461
462 public E previous() {
463 checkForComodification();
464 try {
465 int i = cursor - 1;
466 E previous = get(i);
467 lastRet = cursor = i;
468 return previous;
469 } catch(IndexOutOfBoundsException e) {
470 checkForComodification();
471 throw new NoSuchElementException ();
472 }
473 }
474
475 public int nextIndex() {
476 return cursor;
477 }
478
479 public int previousIndex() {
480 return cursor-1;
481 }
482
483 public void set(E o) {
484 if (lastRet == -1)
485 throw new IllegalStateException ();
486 checkForComodification();
487
488 try {
489 AbstractList.this.set(lastRet, o);
490 expectedModCount = modCount;
491 } catch(IndexOutOfBoundsException e) {
492 throw new ConcurrentModificationException ();
493 }
494 }
495
496 public void add(E o) {
497 checkForComodification();
498
499 try {
500 AbstractList.this.add(cursor++, o);
501 lastRet = -1;
502 expectedModCount = modCount;
503 } catch(IndexOutOfBoundsException e) {
504 throw new ConcurrentModificationException ();
505 }
506 }
507 }
508
509
569 public List <E> subList(int fromIndex, int toIndex) {
570 return (this instanceof RandomAccess ?
571 new RandomAccessSubList<E>(this, fromIndex, toIndex) :
572 new SubList<E>(this, fromIndex, toIndex));
573 }
574
575
577
599 public boolean equals(Object o) {
600 if (o == this)
601 return true;
602 if (!(o instanceof List ))
603 return false;
604
605 ListIterator <E> e1 = listIterator();
606 ListIterator e2 = ((List ) o).listIterator();
607 while(e1.hasNext() && e2.hasNext()) {
608 E o1 = e1.next();
609 Object o2 = e2.next();
610 if (!(o1==null ? o2==null : o1.equals(o2)))
611 return false;
612 }
613 return !(e1.hasNext() || e2.hasNext());
614 }
615
616
625 public int hashCode() {
626 int hashCode = 1;
627 Iterator <E> i = iterator();
628 while (i.hasNext()) {
629 E obj = i.next();
630 hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
631 }
632 return hashCode;
633 }
634
635
658 protected void removeRange(int fromIndex, int toIndex) {
659 ListIterator <E> it = listIterator(fromIndex);
660 for (int i=0, n=toIndex-fromIndex; i<n; i++) {
661 it.next();
662 it.remove();
663 }
664 }
665
666
692 protected transient int modCount = 0;
693 }
694
695 class SubList<E> extends AbstractList <E> {
696 private AbstractList <E> l;
697 private int offset;
698 private int size;
699 private int expectedModCount;
700
701 SubList(AbstractList <E> list, int fromIndex, int toIndex) {
702 if (fromIndex < 0)
703 throw new IndexOutOfBoundsException ("fromIndex = " + fromIndex);
704 if (toIndex > list.size())
705 throw new IndexOutOfBoundsException ("toIndex = " + toIndex);
706 if (fromIndex > toIndex)
707 throw new IllegalArgumentException ("fromIndex(" + fromIndex +
708 ") > toIndex(" + toIndex + ")");
709 l = list;
710 offset = fromIndex;
711 size = toIndex - fromIndex;
712 expectedModCount = l.modCount;
713 }
714
715 public E set(int index, E element) {
716 rangeCheck(index);
717 checkForComodification();
718 return l.set(index+offset, element);
719 }
720
721 public E get(int index) {
722 rangeCheck(index);
723 checkForComodification();
724 return l.get(index+offset);
725 }
726
727 public int size() {
728 checkForComodification();
729 return size;
730 }
731
732 public void add(int index, E element) {
733 if (index<0 || index>size)
734 throw new IndexOutOfBoundsException ();
735 checkForComodification();
736 l.add(index+offset, element);
737 expectedModCount = l.modCount;
738 size++;
739 modCount++;
740 }
741
742 public E remove(int index) {
743 rangeCheck(index);
744 checkForComodification();
745 E result = l.remove(index+offset);
746 expectedModCount = l.modCount;
747 size--;
748 modCount++;
749 return result;
750 }
751
752 protected void removeRange(int fromIndex, int toIndex) {
753 checkForComodification();
754 l.removeRange(fromIndex+offset, toIndex+offset);
755 expectedModCount = l.modCount;
756 size -= (toIndex-fromIndex);
757 modCount++;
758 }
759
760 public boolean addAll(Collection <? extends E> c) {
761 return addAll(size, c);
762 }
763
764 public boolean addAll(int index, Collection <? extends E> c) {
765 if (index<0 || index>size)
766 throw new IndexOutOfBoundsException (
767 "Index: "+index+", Size: "+size);
768 int cSize = c.size();
769 if (cSize==0)
770 return false;
771
772 checkForComodification();
773 l.addAll(offset+index, c);
774 expectedModCount = l.modCount;
775 size += cSize;
776 modCount++;
777 return true;
778 }
779
780 public Iterator <E> iterator() {
781 return listIterator();
782 }
783
784 public ListIterator <E> listIterator(final int index) {
785 checkForComodification();
786 if (index<0 || index>size)
787 throw new IndexOutOfBoundsException (
788 "Index: "+index+", Size: "+size);
789
790 return new ListIterator <E>() {
791 private ListIterator <E> i = l.listIterator(index+offset);
792
793 public boolean hasNext() {
794 return nextIndex() < size;
795 }
796
797 public E next() {
798 if (hasNext())
799 return i.next();
800 else
801 throw new NoSuchElementException ();
802 }
803
804 public boolean hasPrevious() {
805 return previousIndex() >= 0;
806 }
807
808 public E previous() {
809 if (hasPrevious())
810 return i.previous();
811 else
812 throw new NoSuchElementException ();
813 }
814
815 public int nextIndex() {
816 return i.nextIndex() - offset;
817 }
818
819 public int previousIndex() {
820 return i.previousIndex() - offset;
821 }
822
823 public void remove() {
824 i.remove();
825 expectedModCount = l.modCount;
826 size--;
827 modCount++;
828 }
829
830 public void set(E o) {
831 i.set(o);
832 }
833
834 public void add(E o) {
835 i.add(o);
836 expectedModCount = l.modCount;
837 size++;
838 modCount++;
839 }
840 };
841 }
842
843 public List <E> subList(int fromIndex, int toIndex) {
844 return new SubList<E>(this, fromIndex, toIndex);
845 }
846
847 private void rangeCheck(int index) {
848 if (index<0 || index>=size)
849 throw new IndexOutOfBoundsException ("Index: "+index+
850 ",Size: "+size);
851 }
852
853 private void checkForComodification() {
854 if (l.modCount != expectedModCount)
855 throw new ConcurrentModificationException ();
856 }
857 }
858
859 class RandomAccessSubList<E> extends SubList<E> implements RandomAccess {
860 RandomAccessSubList(AbstractList <E> list, int fromIndex, int toIndex) {
861 super(list, fromIndex, toIndex);
862 }
863
864 public List <E> subList(int fromIndex, int toIndex) {
865 return new RandomAccessSubList<E>(this, fromIndex, toIndex);
866 }
867 }
868 |
Popular Tags |
Java API By Example, From Geeks To Geeks.