day16集合

需求：

集合框架(去除ArrayList中重复字符串元素方式)(掌握)

    ArrayList去除集合中字符串的重复值(字符串的内容相同)
    * 思路：创建新集合方式

            public static void main(String[] args) {
                ArrayList list = new ArrayList();
                list.add("a");
                list.add("a");
                list.add("b");
                list.add("c");
                list.add("c");
                list.add("c");
                
                System.out.println(list);
                ArrayList newList = getSingle(list);
                System.out.println(newList);
            }
        
            /*
             * 去除重复
             * 1,返回ArrayList
             * 2,参数列表ArrayList
             */
            public static ArrayList getSingle(ArrayList list) {
                ArrayList newList = new ArrayList();            //创建一个新集合
                Iterator it = list.iterator();                    //获取迭代器
                while(it.hasNext()) {                            //判断老集合中是否有元素
                    String temp = (String)it.next();            //将每一个元素临时记录住
                    if(!newList.contains(temp)) {                //如果新集合中不包含该元素
                        newList.add(temp);                        //将该元素添加到新集合中
                    }
                }
                return newList;                                    //将新集合返回
            }

集合框架(去除ArrayList中重复自定义对象元素)(掌握)

去除ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
重写equals()方法的

public class Person {
    private String name;
    private int age;
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public boolean equals(Object obj) {
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
    
}

因为Contains 方法中依赖的是equals方法，而在自定义的new 出来的每个地址都不一样，所有要复写equals方法。  getSingle方法代码同上

集合框架(LinkedList的特有功能)(掌握)
* B:LinkedList类特有功能
    * public void addFirst(E e)及addLast(E e)
    * public E getFirst()及getLast()
    * public E removeFirst()及public E removeLast()
    * public E get(int index);

###16.04_集合框架(栈和队列数据结构)(掌握)
* 栈 先进后出
* 队列 先进先出

根据此。我们可以做一个(用LinkedList模拟栈数据结构的集合并测试）

public class Stack {
    private LinkedList list = new LinkedList();
    
    /*
     * 模拟进栈方法
     */
    public void in(Object obj) {
        list.addLast(obj);
    }
    
    /*
     * 模拟出栈
     */
    public Object out() {
        return list.removeLast();
    }
    
    /*
     * 模拟栈结构是否为空
     */
    
    public boolean isEmpty() {
        return list.isEmpty();
    }
}

测试

public static void main(String[] args) {
        //demo1();
        Stack s = new Stack();
        s.in("a");                                //进栈
        s.in("b");
        s.in("c");
        s.in("d");
        
        while(!s.isEmpty()) {                    //判断栈结构是否为空
            System.out.println(s.out());        //弹栈
        }
    }    

结果：d
c
b
a

16.06_集合框架(泛型概述和基本使用)(掌握)
* A:泛型概述
* B:泛型好处
    * 提高安全性(将运行期的错误转换到编译期)
    * 省去强转的麻烦
* C:泛型基本使用
    * <>中放的必须是引用数据类型
* D:泛型使用注意事项
    * 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

ArrayList<Person> list = new ArrayList<Person>();
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        
        Iterator<Person> it = list.iterator();
        while(it.hasNext()) {         
            Person p = it.next();            //不用转型了
            System.out.println(p.getName() + "..." + p.getAge())

存储一个字符串并且遍历

    ArrayList<String> list = new ArrayList<>();            //创建集合对象
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        
        Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }

###16.09_集合框架(泛型类的概述及使用)(了解)
* A:泛型类概述<T>
    * 把泛型定义在类上
* B:定义格式
    * public class 类名<泛型类型1,…>
* C:注意事项    
    * 泛型类型必须是引用类型
* D:案例演示
    * 泛型类的使用

泛型类

public class Tool<Q> { //泛型方法
    private Q q;

    public Q getObj() {
        return q;
    }

    public void setObj(Q q) {
        this.q = q;
    }
    //泛型方法
    public<T> void show(T t) {                //方法泛型最好与类的泛型一致
        System.out.println(t);                //如果不一致,需要在方法上声明该泛型
    }
    
    public static<W> void print(W w) {        //静态方法必须声明自己的泛型
        System.out.println(w);
    }
    
}

实现

public static void main(String[] args) {
        Tool<String> t = new Tool<>();
        t.show(true);   //打印出来就是show

Tool<Student> tt = new Tool<>();                    //创建工具类对象
        tt.setObj(new Student("张三",23));

Student s=tt.getQ();
System.out.println(s.getName()+" "+s.getAge());

集合框架(泛型接口的概述和使用)(了解)
* A:泛型接口概述
    * 把泛型定义在接口上
* B:定义格式    
    * public interface 接口名<泛型类型>
* C:案例演示
    * 泛型接口的使用

定义一个泛型接口

public interface InfoDemo<T>{
    public T getVar();  //都是抽象方法
    
}

一个类来实现它

public class InfoDemoImp implements InfoDemo<String> {
private String var;
public InfoDemoImp(String var){
this.setVar(var);    
}
public void setVar(String var){
    this.var=var;
}
    @Override
    public String getVar() {
        // TODO Auto-generated method stub
        return this.var;
    }
}
    }

//找一个类来测试一下

    public static void main(String[] args) {
        // TODO Auto-generated method stub
InfoDemo w=new InfoDemoImp("liguo");
System.out.println("内容是"+w.getVar());
    }
结果是：liguo

集合框架(泛型高级之通配符)
* A:泛型通配符<?>
    * 任意类型，如果没有明确，那么就是Object以及任意的Java类了
* B:? extends E
    * 向下限定，E及其子类
* C:? super E
    * 向上限定，E及其父类

    public static void main(String[] args) {
        // TODO Auto-generated method stub
ArrayList<Person> l1=new ArrayList<>();
l1.add(new Person("这哪个房",11));
l1.add(new Person("什么",12));
ArrayList<Student> l2=new ArrayList<>();
l2.add(new Student("liguo",15));
l2.add(new Student("liziqi",16));
l1.addAll(l2);
System.out.println(l1);
因为Person 是student 的父类，所以才可以添加

数组转换集合或者集合转数组

public static void demo1(){  //数组转换成集合
        Integer[] ar={5,6,52,96};
        List<Integer> l=Arrays.asList(ar);  //包装类型
        System.out.println(l);
    }
    public static void demo2(){   
        String[] arr={"liy","lifnag"};
        List<String> li = Arrays.asList(arr);
        System.out.println(li);
    }

    public static void demo3() {
        int[] ii = { 5, 6, 8, 74 };
        List<int[]> fo = Arrays.asList(ii);  //看这个泛型类型就不一样了。
        System.out.println(fo);
    }

需求

    /**
     * * A:案例演示
     * 集合嵌套之ArrayList嵌套ArrayList
     * 案例:
     * 我们学科,学科又分为若个班级
     * 整个学科一个大集合
     * 若干个班级分为每一个小集合
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
ArrayList<ArrayList<Person>> a=new ArrayList<>();
ArrayList<Person> first=new ArrayList<>();
first.add(new Person("杨幂", 30));
first.add(new Person("李冰冰", 33));
first.add(new Person("范冰冰", 20));
ArrayList<Person> second=new ArrayList<>();
second.add(new Person("黄晓明", 31));
second.add(new Person("赵薇", 33));
second.add(new Person("陈坤", 32));

//将班级添加到学科集合中
a.add(first);
a.add(second);
//遍历学科集合
for(ArrayList<Person> f:a){
    for(Person p:f){
        System.out.println(p);
    }
}


    }

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

集合框架(三种迭代的能否删除)(掌握)
* 普通for循环,可以删除,但是索引要--
* 迭代器,可以删除,但是必须使用迭代器自身的remove方法,否则会出现并发修改异常
* 增强for循环不能删除

/**
     * * A:增强for概述
            * 简化数组和Collection集合的遍历
        * B:格式：
        *
                for(元素数据类型 变量 : 数组或者Collection集合) {
                    使用变量即可，该变量就是元素
                }
        * C:案例演示
            * 数组，集合存储元素用增强for遍历
        * D:好处
            * 简化遍历
        增强for循环底层依赖的是迭代器(Iterator)
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        //1,普通for循环删除,索引要--
    /*    for(int i=0;i<list.size();i++){
            if("b".equals(list.get(i))){
                list.remove(i--);      //这个可以的
            }
        }
        
    }*/
        //2,迭代器删除
                /*Iterator<String> it = list.iterator();
                while(it.hasNext()) {
                    if("b".equals(it.next())) {
                        //list.remove("b");                            //不能用集合的删除方法,因为迭代过程中如果集合修改会出现并发修改异常
                        it.remove();   //这个可以的
                    }
                }*/
        

        //3,增强for循环,增强for循环不能删除,只能遍历
        for(String s:list){
            if("b".equals(s)){
                list.remove("b");
            }
        }
        
    System.out.println(list);
    
}