package collections.testcollection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import collections.collection.Course;

/**
 * 集合框架分两大类：List和Map，此类是测试：List（主要实现类是ArraryList）
 * 
 * 当前类测试【List】的方法有：
 * 
 * 一、测试添加方法、数组转列表方法，获取下标方法
 * -1.add(E e) :将指定的元素追加到此列表的末尾（可选操作）。 
 * -2.list.indexOf(obj):获取当前元素的下标：返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。 
 * -3.add(int index, E element) :将指定的元素插入此列表中的指定位置（可选操作）。
 * -4.Arrays.asList(obj):将参数obj（数组），转换为列表
 * -5.addAll(Collection<? extends E> c) :按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。 
 * -6.addAll(int index, Collection<? extends E> c) :将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。  
 *  
 * 二、删除
 * -7.remove(int index) :删除该列表中指定位置的元素。
 *       removerAll  :从此列表中删除包含在指定集合中的所有元素
 *       retainAll(Collection<?> c) 仅保留此列表中包含在指定集合中的元素
 * -8.boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）（可选操作）。  
 * -9.boolean removeAll(Collection<?> c) :从此列表中删除包含在指定集合中的所有元素（可选操作）。  
 * -10.clear():从此列表中删除所有元素（可选操作）。  
 * 
 * 三、查询--遍历集合
 * -11.for循环
 * -12.foreach循环
 * -13.iterator() 以正确的顺序返回该列表中的元素的迭代器。 
 *   此外还有get(index)按下标查询等简单方法
 * 
 * 
 * 四、各种判断方法是否存在?有个问题，重写equals方法?
 * -14.boolean contains(Object o)：如果此集合包含指定的元素，则返回true 。
 * -15.boolean containsAll(Collection<?> c)：如果此集合包含指定 集合中的所有元素，则返回true。
 * 
 * 五、修改
 * -16.set(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素。 
 * 
 * 六、排序
 * sort
 * 其他的方法
 * -17.replaceAll(UnaryOperator<E> operator) :将该列表的每个元素替换为将该运算符（operator）应用于该元素的结果。 
 * 
 */
public class TestList {
    
    // 类属性--待选课程集合,此属性的类型是Coure（本身即是一个类）
    public List<Course> coursesToSelect ;//使用泛型
    
    // 利用构造器来初始化couresToSelect,ArrayList是List的实现类，因为List是接口，接口不能被实例化
    public TestList(){
        this.coursesToSelect = new ArrayList<Course>();//注意泛型
    }
    
    /**
     * 基础的数据
     */
    public void newData(){
        Course c1 = new Course("1", "课程一");
        Course c2 = new Course("2", "课程二");
        Course c3 = new Course("3", "课程三");
        Course c4 = new Course("4", "课程四");
        Course c5 = new Course("5", "课程五");
        Course c6 = new Course("6", "课程六");
        coursesToSelect.add(c1);
        coursesToSelect.add(c2);
        coursesToSelect.add(c3);
        coursesToSelect.add(c4);
        coursesToSelect.add(c5);
    }
    
    /**
     * 方便查看集合
     */
    public void testForeach(){
        for (Course course : coursesToSelect) {
            System.out.println(course.getName());
        }
    }
    /**
     * 一、测试添加方法、数组转列表方法，获取下标方法
     */
    public void testAdd(){
        // 通过实例化课程类（Course），新建课程对象，以便放入集合coursesToSelect中
        Course c1 = new Course("1", "课程一");
        Course c2 = new Course("2", "课程二");
        
        //1.add(E e) :将指定的元素追加到此列表的末尾（可选操作）。 
        coursesToSelect.add(c1);
        System.out.print("添加了课程：");
        System.out.print(coursesToSelect.get(0).getId()+":"+coursesToSelect.get(0).getName());
        // 结果--添加了课程：1:课程一
        System.out.println();
        
        //2.获取当前元素的下标：list.indexOf(obj)
        System.out.println("此时课程一的下标为："+coursesToSelect.indexOf(c1));
        // 结果--此时课程一的下标为：0
        System.out.println("现在查询一个不存在的对象的下标，返回值为："+coursesToSelect.indexOf("dd"));
        // 结果--现在查询一个不存在的对象的下标，返回值为：-1
        System.out.println();
        
        //3.add(int index, E element) 将指定的元素插入此列表中的指定位置（可选操作）。 
        coursesToSelect.add(0, c2);
        System.out.print("添加了课程：");
        System.out.print(coursesToSelect.get(0).getId()+":"+coursesToSelect.get(0).getName());
        // 结果--添加了课程：2:课程二
        System.out.println("--此时课程一的下标为："+coursesToSelect.indexOf(c1));
        // 结果--此时课程一的下标为：1
        System.out.println();
        
        /*
         * 4.Arrays.asList(obj):将参数obj（数组），转换为列表
         * 5.addAll(Collection<? extends E> c)
         * 6.addAll(int index, Collection<? extends E> c) 
         */
        
        // 新建数组---为方法4、5和6做准备
        Course[] courses = {new Course("3", "课程三"),new Course("4", "课程四")};
        Course[] courses2 = {new Course("5", "课程五"),new Course("6", "课程六")};
        
        //4.Arrays.asList(obj):将参数obj（数组），转换为列表
        List<Course> arrayToList = Arrays.asList(courses);//此时arrayToList是作为集合代替了数组courses
        List<Course> arrayToList2 = Arrays.asList(courses2);//此时arrayToList是作为集合代替了数组courses
        System.out.println();
        
        //5.addAll(Collection<? extends E> c)
        coursesToSelect.addAll(arrayToList);
        System.out.println("新添加了"+coursesToSelect.get(2).getName()+"和"+coursesToSelect.get(3).getName());
        // 新添加了课程三和课程四
        System.out.println();
        
        //6.addAll(int index, Collection<? extends E> c) 
        coursesToSelect.addAll(0,arrayToList2);
        System.out.println("此时下标为0和1的课程："+coursesToSelect.get(0).getName()+"和"+coursesToSelect.get(1).getName());
        // 此时下标为0和1的课程：课程五和课程六
    }
    
    /**
     * 二、测试删除方法  
     */
    public void testDelete(){
        
        //7.remove(int index) :删除该列表中指定位置的元素
        System.out.println("删除前共有："+coursesToSelect.size()+"个元素，下标为0的是"+coursesToSelect.get(0).getName());
        coursesToSelect.remove(0);
        System.out.println("删除下标为0的元素后，共有"+coursesToSelect.size()+"个元素下标为0的是"+coursesToSelect.get(0).getName());
        System.out.println();
        
        //8.boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在)
        //获取index=0的对象
        Course obj = coursesToSelect.get(0);
        System.out.println("调用boolean remove(Object o)前，下标0"+coursesToSelect.get(0).getName());
        System.out.println("从列表中删除指定元素的第一个出现（如果存在）:"+coursesToSelect.remove(obj));
        System.out.println("调用boolean remove(Object o)后，下标0"+coursesToSelect.get(0).getName());
        System.out.println();
        
        //9.boolean removeAll(Collection<?> c) :从此列表中删除包含在指定集合中的所有元素

        Course[] courses = {new Course("3", "课程三"),new Course("4", "课程四")};
        List<Course> arrayToList2 = Arrays.asList(courses);//此时arrayToList是作为集合代替了数组courses
        System.out.println(arrayToList2.size());
        System.out.println(coursesToSelect.removeAll(arrayToList2));
        System.out.println(coursesToSelect.size());
        System.out.println(arrayToList2.size());
        System.out.println();
        
        //10.clear():从此列表中删除所有元素
        System.out.println("此时集合courseToSelect的长度为:"+coursesToSelect.size());
        coursesToSelect.clear();
        System.out.println("调用clear()方法后此时集合courseToSelect的长度为:"+coursesToSelect.size());
        
    }

    /**
     * 三、遍历集合
     */
    public void testErgodic(){  
        // 添加数据
        newData();
        
        //11.普通for循环
        
        System.out.println();
        System.out.println("普通for循环遍历集合");
        for (int i = 0; i < coursesToSelect.size(); i++) {
            
            System.out.println("  " + coursesToSelect.get(i).getId()+" : "+coursesToSelect.get(i).getName());
        }

        System.out.println();
        //12.foreach循环
        System.out.println("foreach循环");
        for (Course course : coursesToSelect) {
            System.out.println(course.getId()+" : "+course.getName());
        }
        System.out.println();
        
        //iterator() 以正确的顺序返回该列表中的元素的迭代器。 
        System.out.println("iterator()迭代器遍历集合");
        //第一步:创建迭代器对象
        Iterator it = coursesToSelect.iterator();
        //第二步：通过循环迭代  
        //hasNext():判断是否存在下一个元素  
        while(it.hasNext()){
            Course obj = (Course) it.next();
            System.out.println(obj.getName());
        }
        
    }
        
    /**
     * 四、判断方法（是否包含等方法）-有疑问。contains返回true和false
     */
    public void testBoolean(){
        newData();
        //14.boolean contains(Object o)：如果此集合包含指定的元素，则返回true 
        // 判断一个对象是否在容器中
        // 判断标准： 是否是同一个对象，而不是name是否相同
        Course newc6 = new Course("6", "课程一");
        Course newc7 = new Course("3", "课程单独二");
        System.out.println(coursesToSelect.contains(newc6));
        System.out.println(coursesToSelect.contains(newc7));
        // ？直接调用contains方法会依次比较内容，有相同的就返回true，因为此时每个对象里面有两个小对象定义的属性相同，？所有有一个相同就true？
        // ？自己定义的元素，应该重写equals()方法！这里和预想有误
        
        //15.boolean containsAll(Collection<?> c)
        List<Course> testList = new ArrayList<Course>();
        Course newc8 = new Course("1", "课程一");
        Course newc9 = new Course("3", "课程三");
        coursesToSelect.add(newc8);
        coursesToSelect.add(newc9);
        testList.add(newc8);
        testList.add(newc9);
        System.out.println(coursesToSelect.contains(testList));//数值相同，但是对象不同，所以也是返回false
        testForeach();
    }
    
    /**
     * 五、修改
     */
    public void testSet(){
        newData();
        //set(int index, E element)
        Course c6 = new Course("6", "课程六");
        coursesToSelect.set(0, c6);
        testForeach();//修改了第一个课程
    }
    
    /**
     * 17..replaceAll(UnaryOperator<E> operator) :将该列表的每个元素替换为将该运算符（operator）应用于该元素的结果。 
     */
    public void testReplaceAll(){
        
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println("一开始list："+list);
        // replaceAll是Collections的方法
        Collections.replaceAll(list, 1, 111);
        System.out.println(list);
    }
    
    /**
     * sort
     */
    public void testSort(){
        List<Integer> nums = new ArrayList<Integer>();  
        nums.add(3);  
        nums.add(5);  
        nums.add(1);  
        nums.add(0);  
        System.out.println(nums);  
        Collections.sort(nums);  
        System.out.println(nums);
    }



    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TestList testList = new TestList();
        System.out.println("-----------调用方法testAdd()-----------");
//      testList.testAdd();
        System.out.println();
        
        System.out.println("-----------调用方法testDelete()-----------");
//      testList.testDelete();
        System.out.println();
        
        System.out.println("-----------调用方法testErgodic()-----------");
//      testList.testErgodic();
        System.out.println();
        
        System.out.println("-----------调用testBoolean()");
//      testList.testBoolean();
        System.out.println();
        
        System.out.println("-----------调用testSet()");
//      testList.testSet();
        System.out.println();
        
        System.out.println("-----------调用testReplaceAll()");
//      testList.testReplaceAll();
        System.out.println();
        
        System.out.println("-----------调用testSort()");
        testList.testSort();
        System.out.println();
    }

}