328 ' ''' 329 ' ''' This method runs in linear time. 330 ' '''

331 ' '''  the list whose elements are to be reversed.  332 ' '''  if the specified list or 333 ' '''         its list-iterator does not support the set operation.  334 ''JAVA TO VB CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: 335 ' Public  Sub reverse(Of T1)(  list As List(Of T1)) 336 '            Dim size As Integer = list.Count 337 '            If size < REVERSE_THRESHOLD OrElse TypeOf list Is RandomAccess Then 338 ' Dim i As Integer=0 339 ' Dim mid As Integer=size>>1 340 ' Dim j As Integer=size-1 341 ' Do While i> 1 354 '                Do While i 364 '        ''' Randomly permutes the specified list using a default source of 365 '        ''' randomness.  All permutations occur with approximately equal 366 '        ''' likelihood. 367 '        ''' 368 '        '''

The hedge "approximately" is used in the foregoing description because 369 '        ''' default source of randomness is only approximately an unbiased source 370 '        ''' of independently chosen bits. If it were a perfect source of randomly 371 '        ''' chosen bits, then the algorithm would choose permutations with perfect 372 '        ''' uniformity. 373 '        ''' 374 '        '''

This implementation traverses the list backwards, from the last 375 '        ''' element up to the second, repeatedly swapping a randomly selected element 376 '        ''' into the "current position".  Elements are randomly selected from the 377 '        ''' portion of the list that runs from the first element to the current 378 '        ''' position, inclusive. 379 '        ''' 380 '        '''

This method runs in linear time.  If the specified list does not 381 '        ''' implement the  interface and is large, this 382 '        ''' implementation dumps the specified list into an array before shuffling 383 '        ''' it, and dumps the shuffled array back into the list.  This avoids the 384 '        ''' quadratic behavior that would result from shuffling a "sequential 385 '        ''' access" list in place. 386 '        '''  387 '        '''  the list to be shuffled.  388 '        '''  if the specified list or 389 '        '''         its list-iterator does not support the set operation.  390 '        Public  Sub shuffle(Of T1)(  list As List(Of T1)) 391 ' Dim rnd As Random = r 392 ' If rnd Is Nothing Then 393 ' rnd = New Random 394 ' r = rnd 395 ' End If 396 ' shuffle(list, rnd) 397 ' End Sub 398 399 ' Private  r As Random 400 401 ' '''

402 ' ''' Randomly permute the specified list using the specified source of 403 ' ''' randomness.  All permutations occur with equal likelihood 404 ' ''' assuming that the source of randomness is fair.

405 ' ''' 406 ' ''' This implementation traverses the list backwards, from the last element 407 ' ''' up to the second, repeatedly swapping a randomly selected element into 408 ' ''' the "current position".  Elements are randomly selected from the 409 ' ''' portion of the list that runs from the first element to the current 410 ' ''' position, inclusive.

411 ' ''' 412 ' ''' This method runs in linear time.  If the specified list does not 413 ' ''' implement the  interface and is large, this 414 ' ''' implementation dumps the specified list into an array before shuffling 415 ' ''' it, and dumps the shuffled array back into the list.  This avoids the 416 ' ''' quadratic behavior that would result from shuffling a "sequential 417 ' ''' access" list in place. 418 ' '''

419 ' '''  the list to be shuffled.  420 ' '''  the source of randomness to use to shuffle the list.  421 ' '''  if the specified list or its 422 ' '''         list-iterator does not support the set operation.  423 ''JAVA TO VB CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: 424 ' Public  Sub shuffle(Of T1)(  list As List(Of T1),   rnd As Random) 425 ' Dim size As Integer = list.size() 426 ' If size < SHUFFLE_THRESHOLD OrElse TypeOf list Is RandomAccess Then 427 ' For i As Integer = size To 2 Step -1 428 ' swap(list, i-1, rnd.Next(i)) 429 ' Next i 430 ' Else 431 ' Dim arr As Object() = list.ToArray() 432 433 ' ' Shuffle array 434 ' For i As Integer = size To 2 Step -1 435 ' swap(arr, i-1, rnd.Next(i)) 436 ' Next i 437 438 ' ' Dump array back into list 439 ' ' instead of using a raw type here, it's possible to capture 440 ' ' the wildcard but it will require a call to a supplementary 441 ' ' private method 442 ' Dim it As ListIterator = list.GetEnumerator() 443 ' For i As Integer = 0 To arr.Length - 1 444 ' it.next() 445 ' it.set(arr(i)) 446 ' Next i 447 ' End If 448 ' End Sub 449 450 '        '''  451 '        ''' Replaces all of the elements of the specified list with the specified 452 '        ''' element.

453 '        ''' 454 '        ''' This method runs in linear time. 455 '        '''

456 '        ''' @param   the class of the objects in the list  457 '        '''  the list to be filled with the specified element.  458 '        '''  The element with which to fill the specified list.  459 '        '''  if the specified list or its 460 '        '''         list-iterator does not support the set operation.  461 '        'JAVA TO VB CONVERTER TODO TASK: There is no .NET equivalent to the Java 'super' constraint: 462 '        Public  Sub fill(Of T, T1)(  list As List(Of T1),   obj As T) 463 '            Dim size As Integer = list.Count 464 465 '            If size < FILL_THRESHOLD OrElse TypeOf list Is RandomAccess Then 466 '                For i As Integer = 0 To size - 1 467 '                    list(i) = obj 468 '                Next 469 '            Else 470 ''JAVA TO VB CONVERTER TODO TASK: There is no .NET equivalent to the Java 'super' constraint: 471 ''JAVA TO VB CONVERTER TODO TASK: Java wildcard generics are not converted to .NET: 472 ' Dim itr As ListIterator(Of ?) = list.GetEnumerator() 473 '                For i As Integer = 0 To size - 1 474 '                    itr.next() 475 '                    itr.set(obj) 476 '                Next 477 '            End If 478 ' End Sub 479 480 '        '''  481 '        ''' Rotates the elements in the specified list by the specified distance. 482 '        ''' After calling this method, the element at index i will be 483 '        ''' the element previously at index (i - distance) mod 484 '        ''' list.size(), for all values of i between 0 485 '        ''' and list.size()-1, inclusive.  (This method has no effect on 486 '        ''' the size of the list.) 487 '        ''' 488 '        '''

For example, suppose list comprises [t, a, n, k, s]. 489 '        ''' After invoking Collections.rotate(list, 1) (or 490 '        ''' Collections.rotate(list, -4)), list will comprise 491 '        ''' [s, t, a, n, k]. 492 '        ''' 493 '        '''

Note that this method can usefully be applied to sublists to 494 '        ''' move one or more elements within a list while preserving the 495 '        ''' order of the remaining elements.  For example, the following idiom 496 '        ''' moves the element at index j forward to position 497 '        ''' k (which must be greater than or equal to j): 498 '        '''

499  '        '''     Collections.rotate(list.subList(j, k+1), -1);
500  '        '''
501 '        ''' To make this concrete, suppose list comprises 502 '        ''' [a, b, c, d, e].  To move the element at index 1 503 '        ''' (b) forward two positions, perform the following invocation: 504 '        '''
505  '        '''     Collections.rotate(l.subList(1, 4), -1);
506  '        '''
507 '        ''' The resulting list is [a, c, d, b, e]. 508 '        ''' 509 '        '''

To move more than one element forward, increase the absolute value 510 '        ''' of the rotation distance.  To move elements backward, use a positive 511 '        ''' shift distance. 512 '        ''' 513 '        '''

If the specified list is small or implements the {@link 514 '        ''' RandomAccess} interface, this implementation exchanges the first 515 '        ''' element into the location it should go, and then repeatedly exchanges 516 '        ''' the displaced element into the location it should go until a displaced 517 '        ''' element is swapped into the first element.  If necessary, the process 518 '        ''' is repeated on the second and successive elements, until the rotation 519 '        ''' is complete.  If the specified list is large and doesn't implement the 520 '        ''' RandomAccess interface, this implementation breaks the 521 '        ''' list into two sublist views around index -distance mod size. 522 '        ''' Then the  method is invoked on each sublist view, 523 '        ''' and finally it is invoked on the entire list.  For a more complete 524 '        ''' description of both algorithms, see Section 2.3 of Jon Bentley's 525 '        ''' Programming Pearls (Addison-Wesley, 1986). 526 '        '''

527 '        '''  the list to be rotated.  528 '        '''  the distance to rotate the list.  There are no 529 '        '''        constraints on this value; it may be zero, negative, or 530 '        '''        greater than list.size().  531 '        '''  if the specified list or 532 '        '''         its list-iterator does not support the set operation. 533 '        ''' @since 1.4  534 '        Public  Sub rotate(Of T1)(  list As List(Of T1),   distance As Integer) 535 ' If TypeOf list Is RandomAccess OrElse list.size() < ROTATE_THRESHOLD Then 536 ' rotate1(list, distance) 537 ' Else 538 ' rotate2(list, distance) 539 ' End If 540 ' End Sub 541 542 ' Private  Sub rotate1(Of T)(  list As List(Of T),   distance As Integer) 543 ' Dim size As Integer = list.size() 544 ' If size = 0 Then Return 545 ' distance = distance Mod size 546 ' If distance < 0 Then distance += size 547 ' If distance = 0 Then Return 548 549 ' Dim cycleStart As Integer = 0 550 ' Dim nMoved As Integer = 0 551 ' Do While nMoved <> size 552 ' Dim displaced As T = list.get(cycleStart) 553 ' Dim i As Integer = cycleStart 554 ' Do 555 ' i += distance 556 ' If i >= size Then i -= size 557 ' displaced = list.set(i, displaced) 558 ' nMoved += 1 559 ' Loop While i <> cycleStart 560 ' cycleStart += 1 561 ' Loop 562 ' End Sub 563 564 ' Private  Sub rotate2(Of T1)(  list As List(Of T1),   distance As Integer) 565 ' Dim size As Integer = list.size() 566 ' If size = 0 Then Return 567 ' Dim mid As Integer = -distance Mod size 568 ' If mid < 0 Then mid += size 569 ' If mid = 0 Then Return 570 571 ' reverse(list.subList(0, mid)) 572 ' reverse(list.subList(mid, size)) 573 ' reverse(list) 574 ' End Sub 575 576 ' '''  577 ' ''' Replaces all occurrences of one specified value in a list with another. 578 ' ''' More formally, replaces with newVal each element e 579 ' ''' in list such that 580 ' ''' (oldVal==null ? e==null : oldVal.equals(e)). 581 ' ''' (This method has no effect on the size of the list.) 582 ' '''  583 ' ''' @param   the class of the objects in the list  584 ' '''  the list in which replacement is to occur.  585 ' '''  the old value to be replaced.  586 ' '''  the new value with which oldVal is to be 587 ' '''        replaced.  588 ' '''  true if list contained one or more elements 589 ' '''         e such that 590 ' '''         (oldVal==null ?  e==null : oldVal.equals(e)) 591 ' '''  if the specified list or 592 ' '''         its list-iterator does not support the set operation. 593 ' ''' @since  1.4  594 ' Public  Function replaceAll(Of T)(  list As List(Of T),   oldVal As T,   newVal As T) As Boolean 595 ' Dim result As Boolean = False 596 ' Dim size As Integer = list.size() 597 ' If size < REPLACEALL_THRESHOLD OrElse TypeOf list Is RandomAccess Then 598 ' If oldVal Is Nothing Then 599 ' For i As Integer = 0 To size - 1 600 ' If list.get(i) Is Nothing Then 601 ' list.set(i, newVal) 602 ' result = True 603 ' End If 604 ' Next i 605 ' Else 606 ' For i As Integer = 0 To size - 1 607 ' If oldVal.Equals(list.get(i)) Then 608 ' list.set(i, newVal) 609 ' result = True 610 ' End If 611 ' Next i 612 ' End If 613 ' Else 614 ' Dim itr As ListIterator(Of T)=list.GetEnumerator() 615 ' If oldVal Is Nothing Then 616 ' For i As Integer = 0 To size - 1 617 ' If itr.next() Is Nothing Then 618 ' itr.set(newVal) 619 ' result = True 620 ' End If 621 ' Next i 622 ' Else 623 ' For i As Integer = 0 To size - 1 624 ' If oldVal.Equals(itr.next()) Then 625 ' itr.set(newVal) 626 ' result = True 627 ' End If 628 ' Next i 629 ' End If 630 ' End If 631 ' Return result 632 ' End Function 633 634 ' '''  635 ' ''' Returns the starting position of the first occurrence of the specified 636 ' ''' target list within the specified source list, or -1 if there is no 637 ' ''' such occurrence.  More formally, returns the lowest index i 638 ' ''' such that {@code source.subList(i, i+target.size()).equals(target)}, 639 ' ''' or -1 if there is no such index.  (Returns -1 if 640 ' ''' {@code target.size() > source.size()}) 641 ' ''' 642 ' '''

This implementation uses the "brute force" technique of scanning 643 ' ''' over the source list, looking for a match with the target at each 644 ' ''' location in turn. 645 ' '''

646 ' '''  the list in which to search for the first occurrence 647 ' '''        of target.  648 ' '''  the list to search for as a subList of source.  649 ' '''  the starting position of the first occurrence of the specified 650 ' '''         target list within the specified source list, or -1 if there 651 ' '''         is no such occurrence. 652 ' ''' @since  1.4  653 ' Public  Function indexOfSubList(Of T1, T2)(  source As List(Of T1),   target As List(Of T2)) As Integer 654 ' Dim sourceSize As Integer = source.size() 655 ' Dim targetSize As Integer = target.size() 656 ' Dim maxCandidate As Integer = sourceSize - targetSize 657 658 ' If sourceSize < INDEXOFSUBLIST_THRESHOLD OrElse (TypeOf source Is RandomAccess AndAlso TypeOf target Is RandomAccess) Then 659 ' nextCand: 660 ' For candidate As Integer = 0 To maxCandidate 661 ' Dim i As Integer=0 662 ' Dim j As Integer=candidate 663 ' Do While i 693 ' ''' Returns the starting position of the last occurrence of the specified 694 ' ''' target list within the specified source list, or -1 if there is no such 695 ' ''' occurrence.  More formally, returns the highest index i 696 ' ''' such that {@code source.subList(i, i+target.size()).equals(target)}, 697 ' ''' or -1 if there is no such index.  (Returns -1 if 698 ' ''' {@code target.size() > source.size()}) 699 ' ''' 700 ' '''

This implementation uses the "brute force" technique of iterating 701 ' ''' over the source list, looking for a match with the target at each 702 ' ''' location in turn. 703 ' '''  704 ' '''  the list in which to search for the last occurrence 705 ' '''        of target.  706 ' '''  the list to search for as a subList of source.  707 ' '''  the starting position of the last occurrence of the specified 708 ' '''         target list within the specified source list, or -1 if there 709 ' '''         is no such occurrence. 710 ' ''' @since  1.4  711 ' Public  Function lastIndexOfSubList(Of T1, T2)(  source As List(Of T1),   target As List(Of T2)) As Integer 712 ' Dim sourceSize As Integer = source.size() 713 ' Dim targetSize As Integer = target.size() 714 ' Dim maxCandidate As Integer = sourceSize - targetSize 715 716 ' If sourceSize < INDEXOFSUBLIST_THRESHOLD OrElse TypeOf source Is RandomAccess Then ' Index access version 717 ' nextCand: 718 ' For candidate As Integer = maxCandidate To 0 Step -1 719 ' Dim i As Integer=0 720 ' Dim j As Integer=candidate 721 ' Do While i 0 Then 739 ' ' Back up source iterator to next candidate 740 ' For j As Integer = 0 To i+1 741 ' si.previous() 742 ' Next j 743 ' End If 744 ' GoTo nextCand 745 ' End If 746 ' Next i 747 ' Return candidate 748 ' Next candidate 749 ' End If 750 ' Return -1 ' No candidate matched the target 751 ' End Function 752 753 End Module 754 755 End Namespace