Collection

//for的形式：
for（int i=0;i<arr.size();i++）{...}

//foreach的形式： 
for（int　i：arr）{...}

//iterator的形式：
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); ...}

//  keySet
Map map = new HashMap();
map.put("key1","lisi1");
map.put("key2","lisi2");
map.put("key3","lisi3");
map.put("key4","lisi4"); 
//先获取map集合的所有键的set集合，keyset（）
Iterator it = map.keySet().iterator();
 //获取迭代器
while(it.hasNext()){
Object key = it.next();
System.out.println(map.get(key));
}
// using entrySet
Iterator it = map.entrySet().iterator();
while(it.hasNext()){
Entry e =(Entry) it.next();
System.out.println("键"+e.getKey () + "的值为" + e.getValue());
}

//System.out.println(arraylist.add("x"));  【增】  尾部插入元素x
//System.out.println(arraylist.add(2,x));   下标为2的地方插入元素x  todo

//System.out.println(arraylist);    打印数组个各元素
//System.out.println(arraylist.size());   计算数组大小， 这个是size，不是length
//System.out.println(arraylist.isEmpty());  用于检查此Arraylist是"空"还是"非空"

//System.out.println(arraylist.remove(2))；【删】 按位置删除，只删除一个元素，从左往右
//System.out.println(arrayList.remove(x));     按值删除，需要遍历整个数组

//boolean ret=arraylist.contains("x");    【查】
//System.out.println("查找到的元素为"+ret);    从前往后遍历，找不到返回-1
//int index=arraylist.indexOf("x");
//System.out.println("查找到的元素的位置为"+index);  第一次出现元素的位置

//String num=arrayList.get(0);    【改】   // todo, 这里出现比较多问题，get和set 修改值
//System.out.println("0号元素为"+num);   获取0号元素
//arrayList.set(0,"php");
//System.out.println("修改后的元素为"+arrayList);   将0号元素修改为php

//for(int i=0;i<=arraylist.size;i++) {        【访问数组下标遍历】
//    System.out.println(arrayList.get(i));   通过下标进行遍历访问数组
//}

//Iterator<String> iterator=arrayList.iterator();  【迭代器遍历】
//while(iterator.hasNext()) {
//  String e =iterator.next();
//    System.out.println("通过迭代器遍历元素"+e);
//   }  由于数组有顺序，所以可以使用访问下标进行遍历，使用迭代器可以遍历图，树

 boolean    add(E e) //如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
 boolean    addAll(Collection<? extends E> c) //如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
 void    　　clear() //移除此 set 中的所有元素（可选操作）。
 boolean    contains(Object o) //如果 set 包含指定的元素，则返回 true。
 boolean    containsAll(Collection<?> c) //如果此 set 包含指定 collection 的所有元素，则返回 true。
 boolean    equals(Object o) //比较指定对象与此 set 的相等性。
 int    　　 hashCode() //返回 set 的哈希码值。
 boolean    isEmpty() //如果 set 不包含元素，则返回 true。
 Iterator<E>    iterator() //返回在此 set 中的元素上进行迭代的迭代器。
 boolean    remove(Object o) //如果 set 中存在指定的元素，则将其移除（可选操作）。
 boolean    removeAll(Collection<?> c) //移除 set 中那些包含在指定 collection 中的元素（可选操作）。
 boolean    retainAll(Collection<?> c) //仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
 int    　　 size() //返回 set 中的元素数（其容量）。
 Object[]   toArray() //返回一个包含 set 中所有元素的数组。
<T> T[]    toArray(T[] a) //返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

char[] a= {'j','c','e','o'};   Arrays.sort(a); 
//自定义排序规则
Character[] a= {'j','c','e','o'};  
Arrays.sort(a, new Comparator<Character>() {  
    public int compare(Character n1,Character n2)  
    {  
        return n1-n2;   // 这里如果返回1， 则颠倒位置， 
    }  
}); 

public int[][] reconstructQueue(int[][] people) {
    Arrays.sort(people, new Comparator<int[]>() {
        public int compare(int[] person1, int[] person2) {
            if (person1[0] != person2[0]) {
                return person2[0] - person1[0];  // 按照递减的顺序进行排列  #二维排序
            } else {
                return person1[1] - person2[1];   //按照递增顺序进行排列
            }
        }
    });
    List<int[]> ans = new ArrayList<int[]>();
    //进行插入操作，满足相应的顺序关系
    for (int[] person : people) {
        ans.add(person[1], person);
    }
    // 这一步需要会写
    return ans.toArray(new int[ans.size()][]);
}

String[] array = { "1", "2", "3" };
List<String> list = null;
// ------ 方法一： for循环
list = Arrays.asList(array);
// List 转变为数组
array = list.toArray(new String[0]);
list.toArray(new int[0][]);
Arrays.toString(int[ ] array); //会以字符串的形式返回数组的全部值而无需手动遍历，一般用于打印数组.

ArrayList<Character> list=new ArrayList<Character>();  
for(int i=0;i<a.length;i++)  
{  
    list.add(a[i]);  
}  
Collections.sort(list,new Comparator<Character>() {  
    public int compare(Character c1,Character c2)  
    {  
        if(c1>c2)  
            return -1;  
        else if(c1<c2) return 1;  
        else return 0;  
    }  
});

public class Employee implements Comparable<Employee> {  
    private int id;  
    private String name;  
    private int age;  
    public Employee(int id, String name, int age) { //利用构造方法初始化各个域  
        this.id = id;  
        this.name = name;  
        this.age = age;  
    }  
    @Override  
    public int compareTo(Employee o) {              //利用编号实现对象间的比较  
        if (id > o.id) {  
            return 1;  
        } else if (id < o.id) {  
            return -1;  
        }  
        return 0;  
    }  
    @Override  
    public String toString() {                      //重写toString()方法  
        StringBuilder sb = new StringBuilder();  
        sb.append("员工的编号：" + id + "，");  
        sb.append("员工的姓名：" + name + "\t，");  
        sb.append("员工的年龄：" + age);  
        return sb.toString();  
    }  
}  

package com.ldd.second.shuzu;
 
import java.util.TreeMap;
/**
 * @author liudongdong19
 * @description TreeMap 介绍
 *  Map接口派生了一个SortedMap子接口，SortedMap有一个TreeMap实现类。
 *  TreeMap是基于红黑树对TreeMap中所有key进行排序，从而保证TreeMap中所有key-value对处于有序状态。TreeMap也有两种排序方式：
 *  自然排序：TreeMap的所有key必须实现Comparable接口，而且所有key应该是同一个类的对象，否则将会抛出ClassCastException异常。
 *  定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口。
 * */
public class MyTreeMap implements Comparable  {
    int count;
    public MyTreeMap(int count)
    {
        this.count = count;
    }
    public String toString()
    {
        return "MytreeMap [count:" + count + "]";
    }
    // 根据count来判断两个对象是否相等。
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj != null && obj.getClass() ==MyTreeMap.class)
        {
            MyTreeMap myTreeMap = (MyTreeMap)obj;
            return myTreeMap.count == this.count;
        }
        return false;
    }
    // 根据count属性值来判断两个对象的大小。
    public int compareTo(Object obj)
    {
        MyTreeMap myTreeMap = (MyTreeMap) obj;
        return count > myTreeMap.count ? 1 :
                count < myTreeMap.count ? -1 : 0;
    }
}
class TreeMapTest
{
    public static void main(String[] args)
    {
        TreeMap tm = new TreeMap();
        tm.put(new MyTreeMap(3) , "兰花");
        tm.put(new MyTreeMap(-5) , "龟背竹");
        tm.put(new MyTreeMap(9) , "紫罗兰");
        System.out.println(tm);
        // 返回该TreeMap的第一个Entry对象
        System.out.println(tm.firstEntry());
 
    }
}

public static void main(String[] args){
        ArrayList<Integer> intList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        System.out.println(intList);
        Collections.rotate(intList, 1);
        System.out.println(intList);
}
运行结果:[1, 2, 3, 4, 5]
        [5, 1, 2, 3, 4]