1 /* 2 3 dsh-collect Collection and map utility classes. 4 Copyright (c) 2008-2013 held jointly by the individual authors. 5 6 This library is free software; you can redistribute it and/or modify it 7 under the terms of the GNU Lesser General Public License as published 8 by the Free Software Foundation; either version 3 of the License, or (at 9 your option) any later version. 10 11 This library is distributed in the hope that it will be useful, but WITHOUT 12 ANY WARRANTY; with out even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 14 License for more details. 15 16 You should have received a copy of the GNU Lesser General Public License 17 along with this library; if not, write to the Free Software Foundation, 18 Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 19 20 > http://www.fsf.org/licensing/licenses/lgpl.html 21 > http://www.opensource.org/licenses/lgpl-license.php 22 23 */ 24 package org.dishevelled.collect; 25 26 import java.util.Collection; 27 import java.util.Collections; 28 import java.util.Comparator; 29 import java.util.HashSet; 30 import java.util.Iterator; 31 import java.util.NavigableSet; 32 import java.util.Set; 33 import java.util.SortedSet; 34 import java.util.TreeSet; 35 36 import java.util.concurrent.ConcurrentSkipListSet; 37 import java.util.concurrent.CopyOnWriteArraySet; 38 39 import com.google.common.collect.ImmutableSet; 40 import com.google.common.collect.ImmutableSortedSet; 41 42 import org.cliffc.high_scale_lib.NonBlockingHashSet; 43 44 /** 45 * Static utility methods for Sets. 46 * 47 * @author Michael Heuer 48 * @version $Revision$ $Date$ 49 */ 50 public final class Sets 51 { 52 53 /** 54 * Private no-arg constructor. 55 */ 56 private Sets() 57 { 58 // empty 59 } 60 61 62 /** 63 * Create and return a new empty set. Delegates to <code>Collections.emptySet()</code>. 64 * 65 * @param <T> element type 66 * @return a new empty set 67 */ 68 public static <T> Set<T> emptySet() 69 { 70 return Collections.<T>emptySet(); 71 } 72 73 // 74 // asXxx methods, which accept elements as parameters 75 76 /** 77 * Create and return a set containing the unique elements in <code>elements</code>. 78 * 79 * @param <T> element type 80 * @param elements variable number of elements to be added to the 81 * returned set 82 * @return a set containing the unique elements in <code>elements</code> 83 */ 84 public static <T> Set<T> asSet(final T... elements) 85 { 86 // TODO: check null? 87 Set<T> set = createSet(elements.length); 88 for (T t : elements) 89 { 90 set.add(t); 91 } 92 return set; 93 } 94 95 /** 96 * Create and return a set containing the unique elements returned by the 97 * specified iterator. 98 * 99 * @param <T> element type 100 * @param iterator iterator, must not be null 101 * @return a set containing the unique elements returned by the specified iterator 102 */ 103 public static <T> Set<T> asSet(final Iterator<? extends T> iterator) 104 { 105 if (iterator == null) 106 { 107 throw new IllegalArgumentException("iterator must not be null"); 108 } 109 Set<T> set = createSet(); 110 while (iterator.hasNext()) 111 { 112 set.add(iterator.next()); 113 } 114 return set; 115 } 116 117 /** 118 * Create and return a set containing the unique elements returned by the 119 * specified iterable. 120 * 121 * @param <T> element type 122 * @param iterable iterable, must not be null 123 * @return a set containing the unique elements returned by the specified iterable 124 */ 125 public static <T> Set<T> asSet(final Iterable<? extends T> iterable) 126 { 127 if (iterable == null) 128 { 129 throw new IllegalArgumentException("iterable must not be null"); 130 } 131 Set<T> set = createSet(); 132 for (T t : iterable) 133 { 134 set.add(t); 135 } 136 return set; 137 } 138 139 /** 140 * Create and return a sorted set containing the unique elements in <code>elements</code> 141 * sorted in their natural order. 142 * 143 * @param <T> element type 144 * @param elements variable number of elements to be added to the 145 * returned sorted set 146 * @return a sorted set containing the unique elements in <code>elements</code> 147 * sorted in their natural order 148 */ 149 public static <T> SortedSet<T> asSortedSet(final T... elements) 150 { 151 SortedSet<T> sortedSet = createSortedSet(); 152 for (T t : elements) 153 { 154 sortedSet.add(t); 155 } 156 return sortedSet; 157 } 158 159 /** 160 * Create and return a sorted set containing the unique elements returned by the 161 * specified iterator sorted in their natural order. 162 * 163 * @param <T> element type 164 * @param iterator iterator, must not be null 165 * @return a sorted set containing the unique elements returned by the specified iterator 166 * sorted in their natural order 167 */ 168 public static <T> SortedSet<T> asSortedSet(final Iterator<? extends T> iterator) 169 { 170 if (iterator == null) 171 { 172 throw new IllegalArgumentException("iterator must not be null"); 173 } 174 SortedSet<T> sortedSet = createSortedSet(); 175 while (iterator.hasNext()) 176 { 177 sortedSet.add(iterator.next()); 178 } 179 return sortedSet; 180 } 181 182 /** 183 * Create and return a sorted set containing the unique elements returned by the 184 * specified iterable sorted in their natural order. 185 * 186 * @param <T> element type 187 * @param iterable iterable, must not be null 188 * @return a sorted set containing the unique elements returned by the specified iterable 189 * sorted in their natural order 190 */ 191 public static <T> SortedSet<T> asSortedSet(final Iterable<? extends T> iterable) 192 { 193 if (iterable == null) 194 { 195 throw new IllegalArgumentException("iterable must not be null"); 196 } 197 SortedSet<T> sortedSet = createSortedSet(); 198 for (T t : iterable) 199 { 200 sortedSet.add(t); 201 } 202 return sortedSet; 203 } 204 205 /** 206 * Create and return a sorted set containing the unique elements returned by the 207 * specified iterator sorted according to the specified comparator. 208 * 209 * @param <T> element type 210 * @param iterator iterator, must not be null 211 * @param comparator comparator to be used to sort the returned sorted set 212 * @return a sorted set containing the unique elements returned by the specified iterator 213 * sorted according to the specified comparator 214 */ 215 public static <T> SortedSet<T> asSortedSet(final Iterator<? extends T> iterator, 216 final Comparator<? super T> comparator) 217 { 218 if (iterator == null) 219 { 220 throw new IllegalArgumentException("iterator must not be null"); 221 } 222 SortedSet<T> sortedSet = createSortedSet(comparator); 223 while (iterator.hasNext()) 224 { 225 sortedSet.add(iterator.next()); 226 } 227 return sortedSet; 228 } 229 230 /** 231 * Create and return a sorted set containing the unique elements returned by the 232 * specified iterable sorted according to the specified comparator. 233 * 234 * @param <T> element type 235 * @param iterable iterable, must not be null 236 * @param comparator comparator to be used to sort the returned sorted set 237 * @return a sorted set containing the unique elements returned by the specified iterable 238 * sorted according to the specified comparator 239 */ 240 public static <T> SortedSet<T> asSortedSet(final Iterable<? extends T> iterable, 241 final Comparator<? super T> comparator) 242 { 243 if (iterable == null) 244 { 245 throw new IllegalArgumentException("iterable must not be null"); 246 } 247 SortedSet<T> sortedSet = createSortedSet(comparator); 248 for (T t : iterable) 249 { 250 sortedSet.add(t); 251 } 252 return sortedSet; 253 } 254 255 /** 256 * Create and return an immutable set containing the unique elements in <code>elements</code>. 257 * The returned immutable set is a high-performance, immutable <code>Set</code> with reliable 258 * iteration order. 259 * 260 * @param <T> element type 261 * @param elements variable number of elements to be added to the 262 * returned immutable set 263 * @return an immutable set containing the unique elements in <code>elements</code> 264 */ 265 public static <T> Set<T> asImmutableSet(final T... elements) 266 { 267 return ImmutableSet.copyOf(elements); 268 } 269 270 /** 271 * Create and return an immutable set containing the unique elements returned by the 272 * specified iterator. The returned immutable set is a high-performance, immutable <code>Set</code> 273 * with reliable iteration order. 274 * 275 * @param <T> element type 276 * @param iterator iterator, must not be null 277 * @return an immutable set containing the unique elements returned by the specified iterator 278 */ 279 public static <T> Set<T> asImmutableSet(final Iterator<? extends T> iterator) 280 { 281 if (iterator == null) 282 { 283 throw new IllegalArgumentException("iterator must not be null"); 284 } 285 return ImmutableSet.copyOf(iterator); 286 } 287 288 /** 289 * Create and return an immutable set containing the unique elements returned by the 290 * specified iterable. The returned immutable set is a high-performance, immutable <code>Set</code> 291 * with reliable iteration order. 292 * 293 * @param <T> element type 294 * @param iterable iterable, must not be null 295 * @return an immutable set containing the unique elements returned by the specified iterable 296 */ 297 public static <T> Set<T> asImmutableSet(final Iterable<? extends T> iterable) 298 { 299 if (iterable == null) 300 { 301 throw new IllegalArgumentException("iterable must not be null"); 302 } 303 return ImmutableSet.copyOf(iterable); 304 } 305 306 /** 307 * Create and return an immutable sorted set containing the unique elements in <code>elements</code> 308 * sorted by their natural order. The returned immutable sorted set is a high-performance, immutable 309 * <code>SortedSet</code> that stores its elements in a sorted array. 310 * 311 * @param <T> element type 312 * @param elements variable number of elements to be added to the 313 * returned immutable sorted set 314 * @return an immutable sorted set containing the unique elements in <code>elements</code> 315 * sorted by their natural order 316 */ 317 public static <T extends Comparable<? super T>> SortedSet<T> asImmutableSortedSet(final T... elements) 318 { 319 return ImmutableSortedSet.copyOf(elements); 320 } 321 322 /** 323 * Create and return an immutable sorted set containing the unique elements in the specified iterator 324 * sorted by their natural order. The returned immutable sorted set is a high-performance, immutable 325 * <code>SortedSet</code> that stores its elements in a sorted array. 326 * 327 * @param <T> element type 328 * @param iterator iterator, must not be null 329 * @return an immutable set containing the unique elements returned by the specified iterator 330 * sorted by their natural order 331 */ 332 public static <T extends Comparable<? super T>> SortedSet<T> asImmutableSortedSet(final Iterator<? extends T> iterator) 333 { 334 if (iterator == null) 335 { 336 throw new IllegalArgumentException("iterator must not be null"); 337 } 338 return ImmutableSortedSet.copyOf(iterator); 339 } 340 341 /** 342 * Create and return an immutable sorted set containing the unique elements in the specified iterable 343 * sorted by their natural order. The returned immutable sorted set is a high-performance, immutable 344 * <code>SortedSet</code> that stores its elements in a sorted array. 345 * 346 * @param <T> element type 347 * @param iterable iterable, must not be null 348 * @return an immutable set containing the unique elements returned by the specified iterable 349 * sorted by their natural order 350 */ 351 public static <T extends Comparable<? super T>> SortedSet<T> asImmutableSortedSet(final Iterable<? extends T> iterable) 352 { 353 if (iterable == null) 354 { 355 throw new IllegalArgumentException("iterable must not be null"); 356 } 357 return ImmutableSortedSet.copyOf(iterable); 358 } 359 360 /** 361 * Create and return an immutable sorted set containing the unique elements in the specified iterator 362 * sorted according to the specified comparator. The returned immutable sorted set is a high-performance, 363 * immutable <code>SortedSet</code> that stores its elements in a sorted array. 364 * 365 * @param <T> element type 366 * @param iterator iterator, must not be null 367 * @param comparator comparator to be used to sort the returned immutable sorted set 368 * @return an immutable set containing the unique elements returned by the specified iterator 369 * sorted according to the specified comparator 370 */ 371 public static <T extends Comparable<? super T>> SortedSet<T> asImmutableSortedSet(final Iterator<? extends T> iterator, 372 final Comparator<? super T> comparator) 373 { 374 if (iterator == null) 375 { 376 throw new IllegalArgumentException("iterator must not be null"); 377 } 378 if (comparator == null) 379 { 380 return asImmutableSortedSet(iterator); 381 } 382 ImmutableSortedSet.Builder<T> builder = new ImmutableSortedSet.Builder<T>(comparator); 383 builder.addAll(iterator); 384 return builder.build(); 385 } 386 387 /** 388 * Create and return an immutable sorted set containing the unique elements in the specified iterable 389 * sorted according to the specified comparator. The returned immutable sorted set is a high-performance, 390 * immutable <code>SortedSet</code> that stores its elements in a sorted array. 391 * 392 * @param <T> element type 393 * @param iterable iterable, must not be null 394 * @param comparator comparator to be used to sort the returned immutable sorted set 395 * @return an immutable set containing the unique elements returned by the specified iterable 396 * sorted according to the specified comparator 397 */ 398 public static <T extends Comparable<? super T>> SortedSet<T> asImmutableSortedSet(final Iterable<? extends T> iterable, 399 final Comparator<? super T> comparator) 400 { 401 if (iterable == null) 402 { 403 throw new IllegalArgumentException("iterable must not be null"); 404 } 405 if (comparator == null) 406 { 407 return asImmutableSortedSet(iterable); 408 } 409 ImmutableSortedSet.Builder<T> builder = new ImmutableSortedSet.Builder<T>(comparator); 410 builder.addAll(iterable); 411 return builder.build(); 412 } 413 414 // 415 // createXxx methods, which accept constructor parameters 416 417 /** 418 * Create and return a new instance of Set. 419 * 420 * @param <T> element type 421 * @return a new instance of Set 422 */ 423 public static <T> Set<T> createSet() 424 { 425 return new HashSet<T>(); 426 } 427 428 /** 429 * Create and return a new instance of Set containing the elements of the 430 * specified collection. 431 * 432 * @param <T> element type 433 * @param elements elements to be added to the returned set, must not be null 434 * @return a new instance of Set containing the elements of the specified 435 * collection 436 */ 437 public static <T> Set<T> createSet(final Collection<? extends T> elements) 438 { 439 return new HashSet<T>(elements); 440 } 441 442 /** 443 * Create and return a new instance of Set with the specified initial capacity. 444 * 445 * @param <T> element type 446 * @param initialCapacity initial capacity 447 * @return a new instance of Set with the specified initial capacity 448 */ 449 public static <T> Set<T> createSet(final int initialCapacity) 450 { 451 return new HashSet<T>(initialCapacity); 452 } 453 454 /** 455 * Create and return a new instance of Set with the specified initial capacity 456 * and load factor. 457 * 458 * @param <T> element type 459 * @param initialCapacity initial capacity 460 * @param loadFactor load factor 461 * @return a new instance of Set with the specified initial capacity and 462 * load factor 463 */ 464 public static <T> Set<T> createSet(final int initialCapacity, final float loadFactor) 465 { 466 return new HashSet<T>(initialCapacity, loadFactor); 467 } 468 469 /** 470 * Create and return a new instance of SortedSet. 471 * 472 * @param <T> element type 473 * @return a new instance of SortedSet 474 */ 475 public static <T> SortedSet<T> createSortedSet() 476 { 477 return new TreeSet<T>(); 478 } 479 480 /** 481 * Create and return a new instance of SortedSet containing the elements 482 * of the specified collection. 483 * 484 * @param <T> element type 485 * @param elements elements to be added to the returned set, must not be null 486 * @return a new instance of SortedSet containing the elements of the 487 * specified collection 488 */ 489 public static <T> SortedSet<T> createSortedSet(final Collection<? extends T> elements) 490 { 491 return new TreeSet<T>(elements); 492 } 493 494 /** 495 * Create and return a new instance of SortedSet sorted according to the specified 496 * comparator. 497 * 498 * @param <T> element type 499 * @param comparator comparator to be used to sort the returned set 500 * @return a new instance of SortedSet 501 */ 502 public static <T> SortedSet<T> createSortedSet(final Comparator<? super T> comparator) 503 { 504 return new TreeSet<T>(comparator); 505 } 506 507 /** 508 * Create and return a new instance of SortedSet containing the elements 509 * of the specified collection sorted according to the specified comparator. 510 * 511 * @param <T> element type 512 * @param elements elements to be added to the returned set, must not be null 513 * @param comparator comparator to be used to sort the returned set 514 * @return a new instance of SortedSet containing the elements of the 515 * specified collection sorted according to the specified comparator 516 */ 517 public static <T> SortedSet<T> createSortedSet(final Collection<? extends T> elements, 518 final Comparator<? super T> comparator) 519 { 520 SortedSet<T> sortedSet = createSortedSet(comparator); 521 sortedSet.addAll(elements); 522 return sortedSet; 523 } 524 525 /** 526 * Create and return a new instance of SortedSet containing the same elements 527 * in the same order as the specified sorted set. 528 * 529 * @param <T> element type 530 * @param sortedSet sorted set of elements to be added to the returned set, must not be null 531 * @return a new instance of SortedSet containing the same elements in the same 532 * order as the specified sorted set 533 */ 534 public static <T> SortedSet<T> createSortedSet(final SortedSet<T> sortedSet) 535 { 536 return new TreeSet<T>(sortedSet); 537 } 538 539 /** 540 * Create and return a new instance of NavigableSet. 541 * 542 * @param <T> element type 543 * @return a new instance of NavigableSet 544 */ 545 public static <T> NavigableSet<T> createNavigableSet() 546 { 547 return new TreeSet<T>(); 548 } 549 550 /** 551 * Create and return a new instance of NavigableSet containing the elements 552 * of the specified collection. 553 * 554 * @param <T> element type 555 * @param elements elements to be added to the returned set, must not be null 556 * @return a new instance of NavigableSet containing the elements of the 557 * specified collection 558 */ 559 public static <T> NavigableSet<T> createNavigableSet(final Collection<? extends T> elements) 560 { 561 return new TreeSet<T>(elements); 562 } 563 564 /** 565 * Create and return a new instance of NavigableSet sorted according to the specified 566 * comparator. 567 * 568 * @param <T> element type 569 * @param comparator comparator to be used to sort the returned set 570 * @return a new instance of NavigableSet sorted according to the specified comparator 571 */ 572 public static <T> NavigableSet<T> createNavigableSet(final Comparator<? super T> comparator) 573 { 574 return new TreeSet<T>(comparator); 575 } 576 577 /** 578 * Create and return a new instance of NavigableSet containing the elements 579 * of the specified collection sorted according to the specified comparator. 580 * 581 * @param <T> element type 582 * @param elements elements to be added to the returned set, must not be null 583 * @param comparator comparator to be used to sort the returned set 584 * @return a new instance of NavigableSet containing the elements of the 585 * specified collection sorted according to the specified comparator 586 */ 587 public static <T> NavigableSet<T> createNavigableSet(final Collection<? extends T> elements, 588 final Comparator<? super T> comparator) 589 { 590 NavigableSet<T> navigableSet = createNavigableSet(comparator); 591 navigableSet.addAll(elements); 592 return navigableSet; 593 } 594 595 /** 596 * Create and return a new instance of NavigableSet containing the same elements 597 * in the same order as the specified sorted set. 598 * 599 * @param <T> element type 600 * @param sortedSet sorted set of elements to be added to the returned set, must not be null 601 * @return a new instance of NavigableSet containing the same elements in the same 602 * order as the specified sorted set 603 */ 604 public static <T> NavigableSet<T> createNavigableSet(final SortedSet<T> sortedSet) 605 { 606 return new TreeSet<T>(sortedSet); 607 } 608 609 /** 610 * Create and return a new instance of ConcurrentSkipListSet. 611 * 612 * @param <T> element type 613 * @return a new instance of ConcurrentSkipListSet 614 */ 615 public static <T> ConcurrentSkipListSet<T> createConcurrentSkipListSet() 616 { 617 return new ConcurrentSkipListSet<T>(); 618 } 619 620 /** 621 * Create and return a new instance of ConcurrentSkipListSet containing the elements 622 * of the specified collection. 623 * 624 * @param <T> element type 625 * @param elements elements to be added to the returned set, must not be null 626 * @return a new instance of ConcurrentSkipListSet containing the elements of the 627 * specified collection 628 */ 629 public static <T> ConcurrentSkipListSet<T> createConcurrentSkipListSet(final Collection<? extends T> elements) 630 { 631 return new ConcurrentSkipListSet<T>(elements); 632 } 633 634 /** 635 * Create and return a new instance of ConcurrentSkipListSet sorted according to the specified 636 * comparator. 637 * 638 * @param <T> element type 639 * @param comparator comparator to be used to sort the returned set 640 * @return a new instance of ConcurrentSkipListSet 641 */ 642 public static <T> ConcurrentSkipListSet<T> createConcurrentSkipListSet(final Comparator<? super T> comparator) 643 { 644 return new ConcurrentSkipListSet<T>(comparator); 645 } 646 647 /** 648 * Create and return a new instance of ConcurrentSkipListSet containing the elements 649 * of the specified collection sorted according to the specified comparator. 650 * 651 * @param <T> element type 652 * @param elements elements to be added to the returned set, must not be null 653 * @param comparator comparator to be used to sort the returned set 654 * @return a new instance of ConcurrentSkipListSet containing the elements of the 655 * specified collection sorted according to the specified comparator 656 */ 657 public static <T> ConcurrentSkipListSet<T> createConcurrentSkipListSet(final Collection<? extends T> elements, 658 final Comparator<? super T> comparator) 659 { 660 ConcurrentSkipListSet<T> set = createConcurrentSkipListSet(comparator); 661 set.addAll(elements); 662 return set; 663 } 664 665 /** 666 * Create and return a new instance of ConcurrentSkipListSet containing the same elements 667 * in the same order as the specified sorted set. 668 * 669 * @param <T> element type 670 * @param sortedSet sorted set of elements to be added to the returned set, must not be null 671 * @return a new instance of ConcurrentSkipListSet containing the same elements in the same 672 * order as the specified sorted set 673 */ 674 public static <T> ConcurrentSkipListSet<T> createConcurrentSkipListSet(final SortedSet<T> sortedSet) 675 { 676 return new ConcurrentSkipListSet<T>(sortedSet); 677 } 678 679 /** 680 * Create and return a new instance of CopyOnWriteArraySet. 681 * 682 * @param <T> element type 683 * @return a new instance of CopyOnWriteArraySet 684 */ 685 public static <T> CopyOnWriteArraySet<T> createCopyOnWriteArraySet() 686 { 687 return new CopyOnWriteArraySet<T>(); 688 } 689 690 /** 691 * Create and return a new instance of CopyOnWriteArraySet containing the elements 692 * of the specified collection. 693 * 694 * @param <T> element type 695 * @param elements elements to be added to the returned set, must not be null 696 * @return a new instance of CopyOnWriteArraySet containing the elements of the 697 * specified collection 698 */ 699 public static <T> CopyOnWriteArraySet<T> createCopyOnWriteArraySet(final Collection<? extends T> elements) 700 { 701 return new CopyOnWriteArraySet<T>(elements); 702 } 703 704 /** 705 * Create and return a new non-blocking implementation of Set. 706 * 707 * @param <T> element type 708 * @return a new non-blocking implementation of Set 709 */ 710 public static <T> Set<T> createNonBlockingSet() 711 { 712 return new NonBlockingHashSet<T>(); 713 } 714 715 /** 716 * Create and return a new non-blocking implementation of Set containing the elements 717 * of the specified collection. 718 * 719 * @param <T> element type 720 * @param elements elements to be added to the returned set, must not be null 721 * @return a new non-blocking implementation of Set containing the elements of the 722 * specified collection 723 */ 724 public static <T> Set<T> createNonBlockingSet(final Collection<? extends T> elements) 725 { 726 Set<T> set = createNonBlockingSet(); 727 set.addAll(elements); 728 return set; 729 } 730 731 // 732 // view or wrapper methods, which accept sets or sorted sets as parameters 733 734 /** 735 * Create and return an unmodifiable view of the specified set. Query operations on the 736 * returned set "read through" to the specified set, and attempts to modify the returned set, 737 * whether direct or via its iterator, result in an <code>UnsupportedOperationException</code>. 738 * 739 * @param <T> element type 740 * @param set set to view, must not be null 741 * @return an unmodifiable view of the specified set 742 */ 743 public static <T> Set<T> unmodifiableSet(final Set<? extends T> set) 744 { 745 return Collections.unmodifiableSet(set); 746 } 747 748 /** 749 * Create and return an unmodifiable view of the specified sorted set. Query operations 750 * on the returned sorted set "read through" to the specified sorted set. Attempts to modify 751 * the returned sorted set, whether direct, via its iterator, or via its <code>subSet</code>, 752 * <code>headSet</code>, or <code>tailSet</code> views, result in an 753 * <code>UnsupportedOperationException</code>. 754 * 755 * @param <T> element type 756 * @param sortedSet sorted set to view, must not be null 757 * @return an unmodifiable view of the specified sorted set 758 */ 759 public static <T> SortedSet<T> unmodifiableSortedSet(final SortedSet<T> sortedSet) 760 { 761 return Collections.unmodifiableSortedSet(sortedSet); 762 } 763 764 /** 765 * Create and return an immutable set containing the elements in the specified set, in order. 766 * The returned immutable set is a high-performance, immutable <code>Set</code> 767 * with reliable iteration order. 768 * 769 * @param <T> element type 770 * @param set set to copy, must not be null 771 * @return an immutable set containing the elements in the specified set, in order 772 */ 773 public static <T> Set<T> immutableSet(final Set<? extends T> set) 774 { 775 return ImmutableSet.copyOf(set); 776 } 777 778 /** 779 * Create and return an immutable sorted set containing the elements in the specified 780 * sorted set, sorted by the same comparator. 781 * 782 * @param <T> element type 783 * @param sortedSet sorted set to copy, must not be null 784 * @return an immutable sorted set containing the elements in the specified sorted set, 785 * sorted by the same comparator 786 */ 787 public static <T> SortedSet<T> immutableSortedSet(final SortedSet<T> sortedSet) 788 { 789 return ImmutableSortedSet.copyOfSorted(sortedSet); 790 } 791 }