Collections工具类的使用

创建实体类

public class News implements Comparable {
    private int id;  //新闻编号
    private String title;  //新闻标题

    @Override
    public String toString() {
        return "新闻 [编号=" + id + ", 标题=" + title + "]";
    }

    public News() { //无参构造
        super();
    }
    public News(int id, String title) { //带参构造
        super();
        this.id = id;
        this.title = title;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }

    //重写 排序的规则    升序
    @Override
    public int compareTo(Object o) {
          News news=(News) o;
          if (news.getId()==this.id) {
            return 0;
         }else if (news.getId()<this.id) {
            return 1;  // 降序  return -1;
        }else {
            return -1; // 降序  return 1;
        }
    }
}

创建测试类

public class CollectionsTest {

    public static void main(String[] args) {
        /*
         * 操作集合的工具类Collections
         */
        //创建一个集合
        List<String> list=new ArrayList<String>();
        list.add("b");
        list.add("d");
        list.add("c");
        list.add("a");
        System.out.println("没有排序====》"+list);  //插入时候的顺序
        //对集合进行随机排序
        Collections.shuffle(list);
        //开奖号码   136  顺序必须对      631不对
        System.out.println("随机排序====》"+list);
        //按照字母的升序排列
        Collections.sort(list);
        System.out.println("升序====》"+list);
        //降序  也是必须在升序之后
        Collections.reverse(list);
        System.out.println("降序====》"+list);
        //查询 "b"在集合中的位置  必须先升序 排列之后再查询
        Collections.sort(list);
        System.out.println(Collections.binarySearch(list, "a"));
        System.out.println("****************************");
        List<News> news=new ArrayList<News>();  //想实现对象的排序
        news.add(new News(3, "新闻3"));
        news.add(new News(1, "新闻1"));
        news.add(new News(4, "新闻4"));
        news.add(new News(2, "新闻2"));
        for (News news2 : news) {
            System.out.println(news2);
        }
        /*
         * 如果News没有重写Comparable接口中的compareTo（）是编译报错的！
         * 我们必须重写compareTo（） 定义规则
         */
        Collections.sort(news);
        System.out.println("对象排序之后.........");
        for (News news2 : news) {
            System.out.println(news2);
        }
    }

    @Test
    public  void  test1(){
        //通过String类中的split（）把字符串转换成字符串数组
        String[] str1="a b c d d d".split(" ");
        //把数组转换成集合
        List<String> asList = Arrays.asList(str1);
        System.out.println(asList);
        String[] str2="c d".split(" ");
        List<String> asList2= Arrays.asList(str2);
        //最后一次出现的位置
        System.out.println(Collections.lastIndexOfSubList(asList, asList2));
        //首次出现的位置
        System.out.println(Collections.indexOfSubList(asList, asList2));
    }

    @Test
    public  void  test2(){
        String[] str1="a b c d e f".split(" ");
        //把数组转换成集合
        List<String> list = Arrays.asList(str1);
        System.out.println(list);
        //集合中的元素向后移distance个位置，之后被覆盖的元素循环前移
        Collections.rotate(list, 2);
        System.out.println(list);
    }
}

排序

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("x");
        list.add("z");
        list.add("a");
        list.add("e");
        list.add("b");
        System.out.println("默认插入数据时候的顺序===》" + list);
        /*// 逆序
        Collections.reverse(list);
        System.out.println("Collections.reverse时候的顺序===》" + list);
        // 排序 升序
        Collections.sort(list);
        System.out.println("Collections.sort时候的顺序===》" + list);
        // 随机排序
        Collections.shuffle(list);
        System.out.println("Collections.shuffle时候的顺序===》" + list);
        System.out.println(Collections.binarySearch(list, "z"));*/

        List<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("e");
        list2.add("b");
        System.out.println("list2默认插入数据时候的顺序===》" + list2);
        // 查询list2在list中出现的位置
        // 以整体作为比较System.out.println(Collections.indexOfSubList(list, list2));
        // 集合中的元素向后移参数2个位置，之后被覆盖的元素循环到集合的前面
        Collections.rotate(list2, 3);
        System.out.println(list2);
    }

map遍历的效率比较

@Test
public  void  test(){
       Map<String, Object> map=new HashMap<String, Object>();
        for (int i = 0; i <1000000; i++) {
            map.put("key"+i, "value"+i);
        }
       //获取当前毫秒数
       Long a= System.currentTimeMillis();
       //遍历map   首先获取所有key的集合
       Set<String> set = map.keySet();
       for (String key : set) {
        map.get(key); //根据key取得value
       }
       //获取当前毫秒数
       Long b= System.currentTimeMillis();
      System.out.println("使用keySet遍历的时间是："+(b-a));

      //使用entry遍历     效率最高的
      Set<Entry<String, Object>> entrySet = map.entrySet();
      for (Entry<String, Object> entry : entrySet) {
         entry.getValue();
      }
      //获取当前毫秒数
       Long c= System.currentTimeMillis();
       System.out.println("使用entrySet遍历的时间是："+(c-b));
}

汉字的排序

public class ListTest {

    public static void main(String[] args) {
     //实现都汉字的排序   传入一个语言环境
        Comparator<Object> collator=Collator.getInstance(Locale.CHINA);
        ArrayList<String> list=new ArrayList<String>();
        list.add("你好");
        list.add("好");
        list.add("啊");
        list.add("它好");
        //工具类
        Collections.sort(list, collator);
        for (String string : list) {
            System.out.println(string);
        }
    }
}