【JAVA】Collections类的其他方法

Collections类还有其他的方法，这里我们值列举几个常用的方法：

//反转
Collections.reverse(s);

//随机打乱
Collections.shuffle(s);

//交换
Collections.swap(s, 2, 5);

//旋转
Collections.rotate(s, 3);

//判断两个集合有没有交集
Collections.disjoint();

package 归并排序;

import edu.xalead.Student;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 测试Collections
 */
public class CollectionTest {

    @Test
    public void test1() {
List<String> list=new ArrayList<>();

        public final class String
                implements java.io.Serializable, Comparable<java.lang.String>, CharSequence {
            /** The value is used for character storage. */
        这里有一个要求，即要能够是先比较大小的规范。
        而字符串类是final的，所以这里就阻止了继承。
        但是String类里头实现了Comparable接口，
        所以这里我们就不用再去写Comparable接口了。

        可是，如果接口我们自己没有实现的话，
        我们就需要实现Comparator接口。
        而我们可以用Lambda表达式
        List<edu.xalead.Student> list = new ArrayList<>();
        //Lambda表达式
        Collections.sort(list, (o1, o2) -> {
            if (o1 instanceof edu.xalead.Student && o2 instanceof edu.xalead.Student) {
                edu.xalead.Student s1 = (edu.xalead.Student) o1;
                edu.xalead.Student s2 = (Student) o2;
                if (s1.getId() < s2.getId()) {
                    return -1;
                } else if (s1.getId() > s2.getId()) {
                    return 1;
                }
                return 0;
            }
            throw new RuntimeException("类型不匹配");
        });
    }

    @Test
    public void test2() {
        List<Integer> s = new ArrayList<>();
        s.add(20);
        s.add(30);
        s.add(40);
        s.add(21);
        s.add(76);
        s.add(34);
        s.add(56);
        System.out.println("输入："+s);

        //反转
        Collections.reverse(s);
        System.out.println("反转："+s);

        //排序
        Collections.sort(s);
        System.out.println("排序："+s);

        //随机打乱
        Collections.shuffle(s);
        System.out.println("随机打乱："+s);

        //交换
        Collections.swap(s, 2, 5);
        System.out.println("交换第三个和第六个元素："+s);

        //旋转
        Collections.rotate(s, 3);
        System.out.println("旋转（从第二个元素往后的元素依次排到第一个元素前面）："+s);

        //Collections还有个Arrays类，
        //它是用来操作数组的。
        //而Collections主要是操作集合的。

        //判断两个集合有没有交集
        //Collections.disjoint();

        //要继承Comparable，因为是二分查找，需要先排序。
        //Collections.binarySearch();
    }
}
//LinkedHasSet,LinkedHasMap
//存的时候用哈希表存，排的时候用链表排。

输入：[20, 30, 40, 21, 76, 34, 56]
反转：[56, 34, 76, 21, 40, 30, 20]
排序：[20, 21, 30, 34, 40, 56, 76]
随机打乱：[21, 76, 56, 30, 20, 40, 34]
交换第三个和第六个元素：[21, 76, 40, 30, 20, 56, 34]
旋转（从第二个元素往后的元素依次排到第一个元素前面）：[20, 56, 34, 21, 76, 40, 30]