集合， 数组，Comparable，Comparator

//-Cell继承 Comparable-------------------------------------------------
package day0811;

public class Cell implements Comparable<Cell>{
    int x;
    int y;
    public Cell(int x, int y) {
        this.x = x;
        this.y = y;
    }
    @Override
    public boolean equals(Object obj) {
        if(obj==null){
            return false;
        }
        if(obj==this){
            return true;
        }
        if(obj instanceof Cell){
            Cell c = (Cell)obj;
            return c.x==this.x && c.y==this.y;
        }

        return false;
    }
    @Override
    public String toString() {
        return "("+x+","+y+")";
    }
    /**
     * 比较大小的方法
     * 返回值不不关注具体的值，只关注取值范围
     * 返回值<0：当前对象比给定对象小
     * 返回值=0：两个对象相等
     * 返回值>0：当前对象比给定对象大
     */
    @Override
    public int compareTo(Cell o) {
        return this.y - o.y;
    }



}
//-集合的contains（）方法-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;
/**
 * 集合：List，可重复，有序
 * Set 不可重复（一般无序，但也有有序的）
 */
public class CollectionDemo {

    public static void main(String[] args) {
        Collection<Cell> c = new ArrayList<Cell>();

        Cell c3 = new Cell(3,4);
        c.add(new Cell(1,2));
        c.add(new Cell(2,3));
        c.add(c3);

        Cell c4 = new Cell(3,4);
        System.out.println(c3.equals(c4));//true
        /**
         * 是否包含给定元素，主要看equals方法
         * equals比较为true的，即为包含
         */
        System.out.println(c.contains(c4));//true

    }

}

//-集合的addAll（）、containsAll（）方法-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo0 {

    public static void main(String[] args) {
        Collection<String> c1 = new ArrayList<String>();

        c1.add("a");
        c1.add("b");
        c1.add("c");

        Collection<String> c2 = new ArrayList<String>();
        c2.add("one");
        c2.add("two");

        //批量把另一集合加过来
        c1.addAll(c2);
        System.out.println(c1);//结果：[a, b, c, one, two]

        Collection<String> c3 = new ArrayList<String>();
        c3.add("a");
        c3.add("one");
        //c1是否包含c3所有的元素
        System.out.println(c1.containsAll(c3));//true
    }

}

//-集合的remove（）方法-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo1 {

    public static void main(String[] args) {
        Collection<Cell> c = new ArrayList<Cell>();
        c.add(new Cell(1,2));
        c.add(new Cell(2,3));
        c.add(new Cell(3,4));
        c.add(new Cell(1,2));

        Cell cell = new Cell(1,2);
        //Collection的remove()方法把比较equals是true的元素删除
        //并且只删除第一个内容一样的元素
        c.remove(cell);
        System.out.println(c);//[(2,3), (3,4), (1,2)]

    }

}

//-集合的循环方法 （Iterator ）-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo2 {

    public static void main(String[] args) {
        // 集合的迭代
        //用HashSet也可 ： Collection c = new HashSet();
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        /**
         * Iterator是个接口
         * 问，取，删（删不是必须）
         */
        Iterator it = c.iterator();
        //hasNext询问迭代器是否还有元素
        while(it.hasNext()){
            Object obj = it.next();
            String str = (String)obj;
            System.out.println(str);
        }

    }

}

//-集合中元素数量size()，以及是否不含元素isEmpty()-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo3 {

    public static void main(String[] args) {
        Collection<Cell> c = new ArrayList<Cell>();
        int s = c.size();//集合中元素数量
        System.out.println(s);
        System.out.println(c.isEmpty());//集合不含任何元素则为true

        c.add(new Cell(1,2));
        c.add(new Cell(3,4));
        System.out.println(c.size());
        System.out.println(c.isEmpty());

        c.clear();//清空集合中的元素
        System.out.println(c.size());
        System.out.println(c.isEmpty());

    }

}

//-Iterator 删除集合元素  it.remove()-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo4 {

    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("#");
        c.add("C");
        c.add("java");
        c.add("#");

        Iterator it = c.iterator();
        while(it.hasNext()){
            String str = (String)it.next();
            if("#".equals(str)){
                it.remove();//删除元素
            }
        }
        System.out.println(c);//[C, java]

    }

}

//-集合支持泛型，集合的高级for循环，以及Iterator循环-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * 所有集合都支持泛型，集合中的泛型用来定义集合的元素类型
 */
public class CollectionDemo6 {

    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("a");
        c.add("b");
        c.add("c");

        //高级for循环，遍历集合中元素
        for(String str: c){
            System.out.println(str);
        }

        //Iterator也可定义泛型
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

    }

}

//-List的替换下标元素set,插入指定位置元素add(),删除指定位置上的元素remove------
package day0811;

import java.util.ArrayList;
import java.util.List;

public class ListDemo {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
        //List可以通过下表遍历集合
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        /**
         * T set (int index, T t)
         * 替换给定下标的元素
         */
        System.out.println(list);//[one, two, three]
        String old = list.set(1, "2");
        System.out.println(list);//[one, 2, three]
        System.out.println("被替换的元素："+old);//被替换的元素：two

        /**
         * void add(int index ,T t）
         * 插入元素，原位置以及后续的元素向后移动
         */
        list.add(1, "22");
        System.out.println(list);//[one, 22, 2, three]

        /**
         * E remove(int index)
         * 删除指定位置上的元素
         */
        String str1 = list.remove(1);
        System.out.println(list);//[one, 2, three]
        System.out.println("被删的元素："+str1);//被删的元素：22

    }

}

//-List的子集-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.List;

public class ListDemo1 {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list);//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

        /**
         * 获取当前集合的子集
         * List subList(int start, int end)
         * (参数含头不含尾)
         */
        List<Integer> subList = list.subList(3, 8);
        System.out.println(subList);//[3, 4, 5, 6, 7]
        /**
         * 子集的元素全部乘以10
         */
        for(int i=0;i<subList.size();i++){
            subList.set(i, subList.get(i)*10);
        }
        System.out.println(subList);//[30, 40, 50, 60, 70]
        //修改子集的任何元素都会影响原集合
        System.out.println(list);//[0, 1, 2, 30, 40, 50, 60, 70, 8, 9]
    }

}
//-数组转成List-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ToListDemo {

    public static void main(String[] args) {
        String[] array = {"1","2","3","4","5","6","7"};
        List<String> list = Arrays.asList(array);
        System.out.println(list);//[1, 2, 3, 4, 5, 6, 7]

        //list.add("8");//出错，不可添加新元素，因为list是只读的

        //创建新的list2，可以增删改
        List<String> list2 = new ArrayList<String>(list);
        list2.add("8");
        System.out.println(list2);//[1, 2, 3, 4, 5, 6, 7, 8]
    }

}

//-集合转为数组-------------------------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 集合转为数组
 * Collection定义了2个方法
 * Object[] toArray()
 *<T>T[] toArray(T[] array)
 */
public class ListDemo2 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");

        //不常用
        //Object[] array = c.toArray();

        /**
         * 常用，new String[0]不够长就自动创建同类型的数组
         * 若长度够，则使用给定的数组
         */
        String[] array = c.toArray(new String[0]);
        for(String str : array){
            System.out.println(str);
        }
    }

}

//-集合排序Collections.sort(list)---------------------------------
package day0811;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class SortCollectionDemo {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        Random r = new Random();
        for(int i=0;i<10;i++){
            list.add(r.nextInt(100));
        }
        /**
         * Collections：集合的工具类，可以对list集合排序
         */
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }

}


//--集合排序 Collections Comparable-----------------------------------
**package day0811;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortCollectionDemo1 {

    public static void main(String[] args) {
        List<Cell> list = new ArrayList<Cell>();
        list.add(new Cell(4,5));
        list.add(new Cell(1,7));
        list.add(new Cell(1,2));
        list.add(new Cell(3,3));
        /**
         * 使用Collections的sort方法进行排序的集合
         * 要求元素必须实现Comparable接口
         * 只有实现了该接口才认为是可比较的元素
         */
        Collections.sort(list);//Cell里实现了Comparable接口
        System.out.println(list);//[(1,2), (3,3), (4,5), (1,7)]
    }

}
**
//--集合排序，Collections.sort(list, c)；新建Comparator------------------
package day0811;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortCollectionDemo3 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("小泽老师");
        list.add("张三");
        list.add("a");
        list.add("范老师");
        list.add("苍#null");
        System.out.println(list);

        Comparator<String> c = new MyComparator();
        /**
         * 重载的sort方法，根据给定的比较器将给定的集合元素比较大小后进行排序
         */
        Collections.sort(list, c);
        System.out.println(list);

    }
}
//自定义比较器
class MyComparator implements Comparator<String>{
    /**
     * 自定义比较字符串规则：字符串字符多的大
     */
    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length();
    }

}