package com.oracle.Test;

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

/*
 * 问题: 你们怎么理解集合这个词.
 * 答: 通常指容器.用来装载n个数据.
 * 
 * 问题: 集合中能放的元素类型
 * 答: Java设计人员.设计Java中的集合时.是希望这个集合可以放下所有类型的数据.
 * Java中有一个类是所有类的父类.Object.按照继承和多态的理念.放Object可以代表
 * 所有类型的数据.那么放入没有问题.但是再取出时要由大转小.需要强转.那么这就会
 * 遇到一个问题.ClassCastException(类型转换异常.)这个异常是在引用数据类型
 * 大转小时.很容易产生的.如果想避免这个问题.需要使用instanceof 或者对象.getClass
 * ==类.class 来验证数据类型是否匹配.(判断对象属不属于某个类型)
 * 
 * JDK在1.5的时候借鉴C++中模版这一概念在Java中引入了泛型.
 * 
 * 问题:什么是泛型
 * 答: 简单说就是类型参数化.要求一个容器中保存的数据类型是一致的.写法是
 * 容器<T>  T代表这个容器要保存的数据类型.
 * 
 * 总结:Java中的所有括号
 * 1. {  } 代表各种作用域. 类体 方法体 循环体 判断体 
 *             静态域    代码块
 * 2. (  ) 遇到小括号代表方法.
 * 3. [  ] 数组
 * 4. <  > 泛型
 * 
 * 泛型可以写成泛型类 : 在类名后<T>  T语法上可以被其它
 *             英文替换.我们习惯都使用T
 * 泛型可以写泛型变量
 *             T t;  是跟随泛型类的
 * 泛型可以写泛型方法.有两个地方可以写泛型
 *         1.参数  也是和泛型类挂钩的.
 *         2.返回值 
 * 
 *     public <T>void method(){
 *     }
 *     
 * 
 * 泛型的使用注意点:
 *     1.泛型的尖括号内只支持引用数据类型.如果想放
 *         源生数据类型,需要使用对应的包装类.
 * 
 *     2.不推荐使用泛型类.C++中模版是可以被继承的.但是
 * Java中泛型是可擦除的.即在父类中设计了泛型.子类在继承时
 * 如果没有显示的提供泛型.父类的泛型可以被不继承.如果
 * 一定要使用泛型类那么在遇到继承时要在子类中提供一个构造
 * 方法(带有泛型的).强制要求子类继承父类的泛型.
 * 目前泛型依然可以使用的是泛型方法.  
 * 
 * 
 * 集合:
 *     1.集合是可变长度,因此在声明时不需要像数组那样指明长度
 *     2.集合产看长度用的size()方法.获取的是集合中元素的个数.
 * 
 * 补充:
 * 1.接口和接口之间只有继承关系.因为实现一个接口要把接口中所有
 * 抽象内容具体化.而接口本身只能提供声明.
 * 
 * 2.接口可以继承多个接口.而class(类)只能单继承.所以Java被叫做
 * 单继承,多实现.
 * 
 * 3.接口是对外的.所有接口中不可以有私有内容.
 * 
 * 
 * 
 * 
 */
public class Test {
    //Ctrl + Shift + T  Open Type
    
    
    public static void main(String[] args) {
        
        /*
         * SRP  职责单一  方法
         * LSP  里氏替换   继承
         * OCP  开闭原则  抽象类
         * DIP  迪米特方法则 .依赖倒置原则  - 面向接口编程
         * ISP  接口职责单一 
         * 
         * 这里的警告是因为Collection接口上有泛型..编译器会
         * 检查类型因此.因此需要提供
         * 
         * 在JDK1.8之前使用泛型时前后两边都要写
         * 在JDK1.8以后可以省略后面的泛型.
         * 
         *
         */
        Collection<String/*只要是引用数据类型都行*/> list = new ArrayList<String>();
        
        //--注意size是方法
        System.out.println(list.size());    //0
        
        System.out.println(list.isEmpty());  //true
        
        /*
         *通过add方法向集合中添加元素.当集合因为调用该方法
         *而发生改变时会返回true.其它情况返回false
         */
        System.out.println(list.add("Hello")+" 变化1");
            //list =    list.add("World");   这是错误的，因为 list.add("World")的返回值是boolean型
        System.out.println(list.add("World")+" 变化2");    
        //list.add("World");
        //--以下代码是否会产生死循环.是否会产生异常.会产生什么异常.
        /*for(int i = 0 ;i < list.size() ;i ++){
            list.add(i+"");
        }*/    //  不是死循环，但会产生异常  int类型最大值是会产生异常
        
        //--判断是否包含指定的对象.参数是对象.
        System.out.println(list.contains("Hello")+"包含指定对象1");
        System.out.println(list.contains("World")+"包含指定对象2");
        
        //--需要注意的是.这里的返回值是Object[] 不可以转变成
        //--其它类型..如果转换会产生ClassCastException
        Object[] array = list.toArray();
        
        for (Object object : array) {
            System.out.println (object+" ");
        }                              //输出         Hello World         
        System.out.println(list.remove("World") );            //输出    true
        System.out.println(list.size());                //输出   1
        
        Collection<String> other = new ArrayList<>();
        other.add("World");
        //--不会覆盖之前的..ArrayList是允许有重复元素的.
        other.add("Hello");
        other.add("!");
        
        list.addAll(other);
        
        System.out.println(list.size());   //输出   4
        
        for (String string : list) {
            System.out.println(string);
        }
        
        list.remove("!");
        list.add("ABC");
        list.add("DEF");
        list.add("!");
        
        
        /*
         * list : Hello World Hello !
         * other : World Hello !
         * 
         * 判断是否包含全部元素.这个比较和顺序无关.
         * 
         */
        System.out.println(list.containsAll(other));   //输出   true
        
    }
    
    //-- 自己写判断包含全部的原型
    public static boolean isContainsAll(Collection c1,Collection c2){
        boolean result = true;
        //--1.参数检查
        //--2.确定谁大谁下
        if(c1.size() >= c2.size()){
            //--2.对第一个集合进行遍历
            for (Object obj : c2) {
                //--将每一个元素在c2中判断是否包含
                if(c1.contains(obj)){
                    result = true;
                    continue;
                }else{
                    result = false;
                    break;
                }
            }
        }
        return result;
    }
    
    
    
    /** 
     * 想把c2中的内容都加到c1中.
     * @param c1
     * @param c2
     */
    public void addAll(Collection<String> c1,Collection<String> c2){        
        //--1.检查参数        
        //--2.遍历C2.利用迭代器对集合进行遍历.
        Iterator<String> iter = c2.iterator();
        //--3.利用迭代器中已有API来判断是否有下一个元素
        while(iter.hasNext()){    //hasNext()  如果仍有元素可以迭代则返回true，其他返回false.
            //--4.通过迭代器取值
            String temp = iter.next();//--返回值的类型会根据泛型自动改变      next() 返回迭代的下一个元素
            c1.add(temp);
        }
    }
    
}