• 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);
        
    }

  • 相关阅读:
    Nginx log日志参数详解
    sea.js模块加载工具
    sea.js模块加载工具
    Airbnb React/JSX 编码规范
    4.2 react patterns(转)
    4.1 react 代码规范
    3.5 compose redux sages
    3.3 理解 Redux 中间件(转)
    3.4 redux 异步
    3.1 开始使用 redux
  • 原文地址:https://www.cnblogs.com/lixiaowei395659729/p/6921207.html
Copyright © 2020-2023  润新知