集合和泛型的应用

   

内容：
    ArrayList
    Vector
    LinkedList
    泛型(Generic)
    可变参数
    增强for循环

ArrayList存储字符串并遍历
    
    A:案例演示:    ArrayList存储字符串并遍历
            迭代器
            普通for

public class ListDemo {

	public static void main(String[] args) {

		List list = new ArrayList();
		
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(0,10);
	//迭代器
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		list.remove(0);
		System.out.println(list);
		
		System.out.println(list.get(list.size()-1));
		
	}

}

ArrayList存储自定义对象并遍历

    A:案例演示:    ArrayList存储自定义对象并遍历
            迭代器
            普通for

Vector的特有功能

    A:Vector类概述:    Vector 类可以实现可增长的对象数组 , Vector 是同步的。 
    B:Vector类特有功能
        public void addElement(E obj)
        public E elementAt(int index)
        public Enumeration elements()
  

LinkedList的特有功能

    A:LinkedList类概述:  List 接口的链接列表实现 , 此实现不是同步的
    B:LinkedList类特有功能
        public void addFirst(E e)及addLast(E e)
        public E getFirst()及getLast()
        public E removeFirst()及public E removeLast()
    C:案例演示    
        LinkedList的特有功能演示
        

去除ArrayList中重复字符串元素方式

    A:案例演示
        需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
        思路：创建新集合方式

 

ArrayList<String> list = new ArrayList<>();
        list.add("林黛玉");
        list.add("史湘云");
        list.add("王熙凤");
        list.add("薛宝钗");
        list.add("林黛玉");
        list.add("史湘云");
        list.add("王熙凤");
        list.add("薛宝钗");
        list.add("林黛玉");
        list.add("史湘云");
        list.add("王熙凤");
        list.add("薛宝钗");
        System.out.println(list);
        //思路：创建一个新的集合
        ArrayList<String> list1 = new ArrayList<>();
        for(int i=0;i<list.size();i++){
            //获取旧集合的元素，添加到新集合，遇到重复元素不要添加到新集合
            String ele = list.get(i);
            if(!list1.contains(ele)){
                list1.add(ele);
            }
        }

        System.out.println(list1);

    }
}

 

泛型概述和基本使用

    A:泛型概述:是一种把类型明确的工作
    推迟到创建对象
    或者调用方法的时候才去明确的特殊的类型。
    参数化类型，把类型当作参数一样的传递。
    B:泛型的格式    :    <数据类型>    这里的数据类型只能是引用数据类型
    C:泛型好处
        (1): 把运行时期的问题提前到了编译期间
        (2): 避免了强制类型转换
        (3):优化了程序设计，解决了黄色警告线
        注意：泛型只在编译期有效  但在运行期就擦除了
    D:泛型基本使用

    
泛型的由来

 
        ObjectTool
        泛型的由来:通过Object转型问题引入
        早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
        也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

(泛型类的概述及使用)

    A:泛型类概述:            把泛型定义在类上
    B:定义格式:    public class 类名<泛型类型1,…>
    C:注意事项:        泛型类型必须是引用类型
    D:案例演示:        泛型类的使用
    /**
 * 泛型的应用之泛型类: 就是把泛型定义在类上
 * 格式:        public class 类名<数据类型 , ....> {}
 */
public class ObjectTools<K> {
    
    private K k ;

    public K getK() {
        return k;
    }

    public void setK(K k) {
        this.k = k;
    }

}

泛型方法的概述和使用

    A:泛型方法概述:    把泛型定义在方法上
    B:定义格式:        public <泛型类型> 返回类型 方法名(泛型类型 变量名)
    C:案例演示:        泛型方法的使用
    public class Phone {
    
    /**
     * 泛型方法
     */
    public <E> void show(E e){
        System.out.println(e);
    }
}

泛型接口的概述和使用

    A:泛型接口概述:    把泛型定义在接口上
    B:定义格式:        public interface 接口名<泛型类型>
    C:案例演示:        泛型接口的使用
    public interface Inter<T> {
    
    public abstract void show(T t) ;

}
/**
 * 泛型接口的子类:    第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了
 */
//public class InterImpl implements Inter<String> {
//
//    @Override
//    public void show(String t) {
//        System.out.println(t);
//    }
//
//}

/**
 * 泛型接口的子类: 第二种情况: 就是在定义子类的时候我们还不知道到底使用神马数据类型.这个时候我们就需要将这个子类也定义
 * 成泛型
 */
public class InterImpl<T> implements Inter<T>  {

    @Override
    public void show(T t) {
        System.out.println(t);
    }

}

泛型高级之通配符

    A:泛型通配符<?>:        任意类型，如果没有明确，那么就是Object以及任意的Java类了
    B:? extends E:            向下限定，E及其子类
    C:? super E:            向上限定，E及其父类
    D:案例演示:            泛型高级之通配符的基本使用
        /**
         * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
         */
        Collection<Object> col1 = new ArrayList<Object>() ;
        Collection<Object> col2 = new ArrayList<Animal>() ;//报错

        // ? 表示任意的数据类型
        Collection<?> col5 = new ArrayList<Object>() ;
        Collection<?> col6 = new ArrayList<Animal>() ;

        // ? extends E : 向下限定    , ? 表示的是E或者E的子类
//        Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
        Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
        Collection<? extends Animal> col11 = new ArrayList<Dog>() ;

        // ? super E:  向上限定 , ? 表示的是E或者E的父类
        Collection<? super Animal> col13 = new ArrayList<Object>() ;
        Collection<? super Animal> col14 = new ArrayList<Animal>() ;
//        Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错
    
增强for的概述和使用

    A:增强for概述
        简化数组和Collection集合的遍历
    B:格式：
        for(元素数据类型 变量 : 数组或者Collection集合) {
            使用变量即可，该变量就是元素
        }

    D:好处和注意事项
        简化遍历
        注意事项：增强for的目标要判断是否为null

 

 

可变参数的概述和使用

    A:可变参数概述:    定义方法的时候不知道该定义多少个参数
    B:格式:            修饰符 返回值类型 方法名(数据类型…  变量名){}
    C:注意事项：
        a:    这里的变量其实是一个数组
        b:    如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

        // 可变参数
    public static int add(int... a){
        
        // 定义一个累加变量
        int sum = 0 ;
        
        for(int s : a ){
            sum += s ;
        }
        
        return sum;
    }

Arrays工具类的asList()方法的使用

  Arrays工具类的asList(T... t)方法的使用:        将数组转换成集合
        注意事项:    得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)
                只能获取元素(get)

集合嵌套之ArrayList嵌套ArrayList
    
    A:需求：
        我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
        但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。    
        而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
        集合嵌套之ArrayList嵌套ArrayList

思路:

        // 定义大的集合
        ArrayList<ArrayList<Student>> allClassList = new  ArrayList<ArrayList<Student>>() ;
        
        // 创建每一个班的集合
        ArrayList<Student> jcClassList = new  ArrayList<Student>() ;