JAVA语言集合框架collection接口

package com.tedu.cn;

import org.junit.Test;

import java.util.*;

/**
 * 测试collection接口中与All相关方法
 * 泛型类型是引用数据类型，不能是基本数据类型，首选泛型集合
 */
public class CollectionAll {
    /**
     * 1、测试集合中与All相关方法
     */
    @Test
    public void testAll(){
        Collection<String> c1 = new ArrayList<String>();
        c1.add("梅花3");
        c1.add("黑桃2");
        c1.add("大王");
        c1.add("红桃k");
        Collection<String> c2 =new ArrayList<String>();
        c2.add("小王");
        c2.add("黑桃2");
        c2.addAll(c1);//向c2中拼接c1   addAll
        //结论：两个集合拼接，不会创建新集合，直接修改c2集合对象的数组
        System.out.println(c2);
        //判断集合中是否包含王炸：同时包含大小王
        //先将要判断的元素放入一个集合，再对两个集合进行比较
        Collection<String> c = new ArrayList<String>();
        c.add("大王");
        c.add("小王");
        System.out.println(c2.containsAll(c)?"有王炸":"没有王炸");
        //containsAll判断当前集合是否包含给定集合
        System.out.println(c.isEmpty());  //isEmpty判断集合是否为空，不为空返回false
        System.out.println("我手里有"+c.size()+"张牌");
        c.clear();  //清空当前集合
        System.out.println(c +"没有元素，已经清空");
        System.out.println(c.isEmpty());//为空返回true
    }


    @Test
    /**
     * 2、求两个集合的交集和差集
     * 其实都是从集合中批量删除元素，都会修改原集合
     * 只不过retainAll方法删除不同元素
     * removeAll删除两个集合相同的元素
     */
    public void batchRemove(){
        Collection<String> mine = new ArrayList<String>();
        mine.add("擎天柱");
        mine.add("大黄蜂");
        mine.add("救护车");
        System.out.println("我们家有"+mine);
        Collection<String> your = new ArrayList<String>();
        your.add("擎天柱");
        your.add("大黄蜂");
        your.add("蜘蛛侠");
        your.add("威震天");
        System.out.println("你们家有"+your);

//        mine.retainAll(your);
//        System.out.println("我们都有"+mine);
        //原来Mine里面的救护车被自动删除了，找不回来了
        //结论：求交集时  调用对象和参数对象的顺序不影响结果

//        mine.removeAll(your);
//        System.out.println("我有"+mine+"，别人没有");
        your.removeAll(mine);
        System.out.println("别人有"+your+"，我没有");
        //结论：求差集时，调用对象与参数对象位置顺序有关
        //谁调用removeAll方法，就会保留谁中的差集元素
        //作为参数的集合 仅仅用来做比较
    }


    /**
     * 3、迭代器
     * 迭代器用于遍历集合的元素，获取迭代器可以使用collection定义的方法
     * 测试集合对象的迭代器
     */
    @Test
    public void teatIterator(){
        //4张100元钱，有一张假的
        Collection<String> money = new ArrayList<String>();
        money.add("100");
        money.add("100");
        money.add("假100");
        money.add("100");
        System.out.println(money);
        //1、只要遍历集合，就要属于迭代器
        //2、只要使用迭代器，就得从集合对象得的iterator方法获得
        Iterator<String> i = money.iterator();
        //迭代器固定套路：While循环：条件 是否有下一个元素，循环体：使用next方法
        //向后移动一个位置，并去除新元素进行炒作
        int sum = 0;
        while (i.hasNext()){ //hasnext 判断是否具有下一个位置
            //迭代器的起始位置在第一个元素之前
            //结论：必须先调用next方法到下一个位置，再处理
            String s = i.next();
            if(s.equals("100")){
                sum+=Integer.parseInt(s);// 将字符串转换成数累加到sum
            }else{
                System.out.println("发现假币");
                i.remove();  //迭代器的remove的方法,默认删除当前假币，
                // 只能使用迭代器调用方法，利用集合对象调用会出差错
                //迭代器的删除会向后退一个位置，二集合对象的删除不会，所以会漏掉下一个
                System.out.println(money);
            }
        }
        System.out.println("一共有"+sum+"元");
    }

    /**
     * 4、增强for循环（只能用于遍历数组和集合，这是和普通for循环的区别）
     *
     */
    @Test
    public void testFor(){
        Collection<String> money = new ArrayList<String>();
        money.add("100");
        money.add("100");
        money.add("假100");
        money.add("100");
        System.out.println("该集合元素个数有"+money.size()+"个");
        int sum = 0;
        for(String a:money){
            //for(元素类型 自定义变量 ： 集合或数组){循环体}
            //新循环编译时会转换为迭代器模式（本质上是迭代器）
            if(a.equals("100")){
                sum+=Integer.parseInt(a);
            }
//            else{
//                money.remove("假100");
            //增强for 不能删除元素，强行删除会丢失元素
            // 若要删除元素，则需要自己编写迭代器，迭代器调用删除方法
//            }
        }
        System.out.println("总共有"+sum+"元");
    }



@Test
    /**
     * 5、ArrayList:数组方式存储，查找访问下标快速，删除插入慢（会移动原有元素的位置）
     * LinkedList:链式存储，查找慢（不能使用下标访问,头 和 尾），删除插入快速，
     * 不影响原有元素的位置，只需要改变链接
     */
public void testList(){
    List<String> list = new ArrayList<String>();
    List<String> linked = new LinkedList<String>();
    //结论：
    //都实现了List接口，功能完全一样
    //ArrayList在查找指定位置上更高效
    //LinkedList通过遍历节点才能找到指定位置的元素
}

/**
 * 6、测试get 和set 方法
 * set方法不是插入，是替换位置上的某元素
 */
@Test
    public void testGetSet(){
    //图书馆门前排队
//    List<String> L = new ArrayList<String>();
    //两个都是实现了List 接口，功能上完全一样
    List<String> L = new LinkedList<String>();
    //LinkedList之所以能用get set 方法，是底层模拟了一个访问下标的方法
    //利用了next，大于一半就从后边开始，小于就从前边
    L.add("学妹");
    L.add("你");
    L.add("女汉子");
    System.out.println(L);
    //女神来了,你让位给她
    L.set(1,"女神");
    System.out.println(L);
    //女汉子和学妹的位置对调
    //1、得到学妹的位置
    String xm = L.get(0);
    //2、将xm的位置替换到2
    String ns = L.set(2,xm);
    //3、将ns 的位置替换到0
    L.set(0,ns);
    System.out.println(L);
}

/**
 * 7、
 * add方法：两个参数的add重载，插入到指定位置，原位置及后续元素向后移动
 * remove 方法：删除给定位置元素并返回该删除元素
 */
@Test
    public void testAddRemove(){
    List<String> L = new ArrayList<String>();
    L.add("学妹");
    L.add("你");
    L.add("女汉子");
    System.out.println(L);
    //学霸来了，要插入学妹后面
    L.add(1,"学霸");
    System.out.println(L);
    //你决定走了
    String a = L.remove(2);  //删除指定位置元素并将其返回
    System.out.println(a+"走了");
    System.out.println(L);
    //结论：
    //ArrayList:将当前位置之后的元素向前移动一个位置，效率低
    //LinkedList:仅仅改变钱后两个元素的指向（next,prev属性），不一动任何位置，效率高
}

/**
 * 8、
 * 测试subList方法
 */
@Test
    public void testSub(){
    List<String> cards = new ArrayList<String>();
    cards.add("大王");
    cards.add("小王");
    cards.add("红桃2");
    cards.add("黑桃K");
    cards.add("梅花A");
    cards.add("方块3");
    System.out.println("我手里的牌有"+cards);
    List<String> bom = cards.subList(0,1+1); //含头不含尾，加1修正
    System.out.println("炸弹："+bom);
    //清空子集合
    bom.clear();
    System.out.println("我手里的牌有"+cards);
    //修改子集合，原集合有影响（本来就是同一个集合，修改原集合，子集合也有影响）
}

/**
 * 9、
 * 集合转换数组
 * 结论：如果数组放不下所有集合元素，会抛弃旧数组创建新数组返回新数组对象
 * //用一个变量接住返回对像
 */
@Test
public void testArr(){
    List<String> l = new ArrayList<String>();
    for (int i = 0; i <4 ; i++) {
        l.add("蛋");
    }
    //创建一个新数组   用来装集合元素
    //1、数组装得下集合元素
    System.out.println("-------数组长度大于集合元素个数的情况-------");
    String[] basket = new String[6];
     l.toArray(basket);
    System.out.println(Arrays.toString(basket));
    //2、数组装不下时，会创建新数组去容纳
    System.out.println("-------数组长度小于集合元素个数的情况-----");
    String[] basket1 = new String[2];
    String[] newBasekt = l.toArray(basket1);
    System.out.println(Arrays.toString(newBasekt));
    //3、通用做法：传入0个元素作为数组(不必关心集合元素的个数和数组的长度)
    System.out.println("------拿一个0长度的数组——————");
    String [] basket2 = new String[0];
    String[] basket3 =  l.toArray(basket2);
    System.out.println(Arrays.toString(basket3));
    //4、传入一个和集合元素个数相等的数组
    // （优化数组，不存在抛弃数组，创建新数组的情况）
    System.out.println("-------传入一个和集合元素个数相等的数组-------");
    String [] basket4 = l.toArray(new String[l.size()]) ;
    System.out.println(Arrays.toString(basket4));
}


/**
 * 10、
 * 数组转换为集合
 * 结论：转换后的集合对象和原数组对象共享同一个空间，任意一方修改都回影响对方
 * 转换后的数组不支持增加删除超炒作（若要获得这些炒作就要new 一个正牌的ArrayList对象，用addall追加进去）
 */
@Test
    public  void test2List(){
    String[] money = {"100","100","假100","100"};
    List<String> l = Arrays.asList(money);//把数组伪装成集合，部分集合方法可以使用
    System.out.println("集合对象："+l);
    for (int i = 0; i <l.size() ; i++) {
        if(!l.get(i).equals("100")){
            System.out.println("发现假币，进行修正");
            l.set(i,"100");
        }
    }
    System.out.println("集合对象："+l);
    System.out.println("数组对象（也被修改）"+Arrays.toString(money));
}

/**
 * 11、
 * contains方法用于自定义类型的比较,集合在判断元素是否包含是根据equals方法
 * 通常有必要重写equas方法，保证conatins的合理结果
 * 重写equals方法的四步骤：
 * 一、判断obj是否为null，如果为null直接返回false
 * 二、判断obj和this是否为同一个对象，如果是直接返回true
 * 三、判断obj是不是当前类型，如果不是直接返回false
 * 四、最后再进行类型转换，再自定义核心比较逻辑
 */
@Test
    public void testEquals(){
    Collection<Emp> emps = new ArrayList<Emp>();
    emps.add(new Emp("JEMS",8000));
    emps.add(new Emp("KOBE",10000));
    emps.add(new Emp("JORDN",10000));
    emps.add(new Emp("KRIV",9000));
    //返回false，需要重写equals方法后返回true
    System.out.println(emps.contains(new Emp("KOBE",10000))?"存在":"不存在");
}


/**
 * 12、
 * 排序功能的测试类
 */
@Test
    public void testSort(){
//默认排序功能的测试方法
    List<Integer> l = new ArrayList<Integer>();
    Random r = new Random(1);
    for (int i = 0; i <10 ; i++) {
        l.add(r.nextInt(100));  //随机生成10个1到100的数添加到l集合
    }
    System.out.println("-----未排序前的集合----");
    System.out.println(l); //未排序前的顺序
    Collections.sort(l);  //直接调用Collections里的排序功能
    System.out.println("-----排序后的集合----");
    System.out.println(l);//升序排序
    
}
}