mt_Day9:Collection list系列

集合

Collection接口：List Set两系列

public class CollectionDemo1 {
    public static void main(String[] args) {
        //1.List系列 有序 可重复 有索引
        Collection list=new ArrayList();
        list.add("Java");
        list.add("MySQL");
        list.add("Mybatis");
        list.add(23);
        list.add('A');
        list.add(true);
        System.out.println(list);//[Java, MySQL, Mybatis, 23, A, true]

        //2.Set系列 无序 不重复 五索引
        Collection list2=new HashSet();
        list2.add("Java");
        list2.add("MySQL");
        list2.add("Mybatis");
        list2.add(23);
        list2.add('A');
        list2.add(true);
        System.out.println(list2);//[Java, A, MySQL, 23, Mybatis, true]
    }
}

Collection常用API

public class test1 {
    public static void main(String[] args) {
        //HashSet:添加的元素 无序 不重复 无索引
        Collection<String> list= new HashSet<>();
        //1.添加元素，添加成功返回true
        list.add("Java");
        list.add("MySQL");
        list.add("HTML");
        list.add("你好");
        list.add("Java");
        list.add("Java");
        System.out.println(list);

        //2.清空集合元素
//        list.clear();
//        System.out.println(list);

        //3.判断集合是否为空，空则返回true
        System.out.println(list.isEmpty());

        //4.集合大小
        System.out.println(list.size());

        //5.判断集合是否包含某个元素
        System.out.println(list.contains("Java"));

        //6.删除元素，如果有重复，默认删除第一个
        list.remove("你好");//返回true
        System.out.println(list);

        //7.把集合转成数组
        Object[] arr= list.toArray();
        System.out.println(arr[0]);

        //8.把c2的元素导入c1
        Collection<String> c1=new ArrayList<>();
        Collection<String> c2=new ArrayList<>();
        c1.add("张三");
        c1.add("李四");
        c2.add("1011");
        c2.add("1012");
        c1.addAll(c2);
        System.out.println(c1);//[张三, 李四, 1011, 1012]
    }
}

Collection集合遍历

迭代器

只能遍历集合

public class CollectionDemo1 {
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<>();
        list.add("小王");
        list.add("王五");
        list.add("李四");
        list.add("张三");
        System.out.println(list);
        //1.得到当前集合的迭代器对象
        Iterator<String> it= list.iterator();
        
        //2.while循环遍历
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

Foreach/增强for循环

即可遍历集合，也可遍历数组

public class CollectionDemo2 {
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("阿伟");
        System.out.println(list);

        //1.增强for遍历集合
        for(String name:list){
            System.out.println(name);
        }

        //2.增强for遍历数组
        double[] scores={90.5,60.2,80.5,96.0};
        for (double score : scores) {
            System.out.println(score);
        }
    }
}

Lambda表达式

public class CollectionDemo3 {
    public static void main(String[] args) {
        Collection<String> list=new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("阿伟");
        System.out.println(list);
        
/*        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        //简化
        list.forEach(s-> System.out.println(s));
    }
}

List

独有方法

public class ListDemo1 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("cat");
        list.add("cat");
        list.add("fish");
        list.add("dog");
        System.out.println(list);

        //1.按索引位置加入元素
        list.add(2,"tiger");
        System.out.println(list);

        //2.根据索引删除元素
        list.remove(0);//返回删除的String
        System.out.println(list);

        //3.根据索引取元素
        System.out.println(list.get(3));

        //4.修改索引位置元素
        System.out.println(list.set(1, "dogs"));//返回被修改的元素
        System.out.println(list);
    }
}

list遍历

public class ListDemo2 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("dog");
        list.add("dog");
        list.add("mouse");
        list.add("cat");
        System.out.println(list);

        //1.for循环遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        //2.迭代器
        Iterator<String> it= list.listIterator();
        while(it.hasNext()){
            String ele=it.next();
            System.out.println(ele);
        }

        //3.foreach 增强for循环
        for (String ele : list) {
            System.out.println(ele);
        }

        //4.Lambda表达式简化
        list.forEach(s-> System.out.println(s));
    }
}

ArrayList底层原理

• ArrayList底层基于数组实现：根据索引定位元素块，增删需要元素的位移操作
• 第一次创建集合，并添加第一个元素时，在底层创建一个长度默认为10的数组，size记录下一个要插入的位置与当前长度，超过10，容量扩大1.5倍，并迁移数据

LinkedList集合底层原理

• 底层数据结构是双链表，查询慢，首位操作速度极快，所以多了很多首尾操作的特有API

public class ListDemo3 {
    public static void main(String[] args) {
        //1.Linklist实现栈
        LinkedList<String> stack=new LinkedList<>();//不用List<String> stack是因为多态不能用子类的独有方法
        //压栈
        stack.addFirst("一号");
        stack.addFirst("二号");
        stack.push("三号");//push（）中的内容其实就是addFirst（）
        System.out.println(stack);//[三号, 二号, 一号]
        //出栈
        System.out.println(stack.removeFirst());//三号
        System.out.println(stack.removeFirst());//二号
        System.out.println(stack.pop());//一号 pop()中的内容其实就是removeFirst()
        System.out.println(stack);//[]

        //2.LinkList实现队列
        LinkedList<String> queue=new LinkedList<>();
        //入队
        queue.addLast("一号");
        queue.addLast("二号");
        queue.addLast("三号");
        System.out.println(queue);//[一号, 二号, 三号]

        //出队
        System.out.println(queue.removeFirst());//一号
        System.out.println(queue.removeFirst());//二号
        System.out.println(queue.removeFirst());//三号
        System.out.println(queue);//[]
    }
}

遍历删除

public class test1 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("Java");
        list.add("HTML");
        list.add("MySQL");
        list.add("Java");
        list.add("Java");
        System.out.println(list);//[Java, HTML, MySQL, Java, Java]

        //删除所有"Java"信息
        //1.迭代器遍历删除
        Iterator<String> it=list.iterator();
        while (it.hasNext()){
            String ele=it.next();
            if(ele.equals("Java")){
                //list.remove(ele);//删除后剩下元素前移，有风险，报错
                it.remove();//删除当前元素，但计数-1，it不会后移
            }
        }
        System.out.println(list);//[HTML, MySQL]

        //2.foreach遍历删除（出bug）
        /*for (String ele : list) {
            if (ele.equals("Java")) {
                //list.remove(ele);//报错，同上,所以不用此方法遍历删除
            }
        }
        System.out.println(list);*/

        //3.lambda表达式（出bug）
        /*list.forEach(s->{
            if(s.equals("Java")){
                list.remove("Java");//内部原理也是foreach，边遍历边删除，报错
            }
        });*/

        //4.for循环
        for (int i = list.size()-1; i >=0; i--) {
            if(list.get(i).equals("Java")){
                list.remove(i);
            }
        }
        System.out.println(list);//[HTML, MySQL]
    }
}

泛型

自定义泛型类

• 模拟ArrayList集合自定义一个集合MyArrayList集合，完成添加和删除的功能

package com.xuexi.d7_genericity;

import java.util.ArrayList;

public class MyArrayList<E> {
    private ArrayList list=new ArrayList<>();
    //添加元素
    public void add(E e){
        list.add(e);
    }
    //删除元素
    public void remove(E e){
        list.remove(e);
    }

    @Override
    public String toString() {
        return list.toString();
    }
}

package com.xuexi.d7_genericity;

public class test {
    public static void main(String[] args) {
        MyArrayList<String> list=new MyArrayList<>();
        list.add("Java");
        list.add("Java");
        list.add("Java");
        list.add("Java");
        list.add("HTML");
        list.remove("Java");
        System.out.println(list);
    }
}

自定义泛型方法

• 给任何一个类型的数组，都能返回它的内容。即实现ArrayList.toString(数组)的功能

public class test {
    public static void main(String[] args) {
        String[] names={"张三","李四","王五"};
        printArray(names);

        Integer[] ages={20,19,24};
        printArray(ages);
    }

    public static <T> void printArray(T[] arr){
        StringBuilder sb=new StringBuilder("[");
        if(arr!=null){
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i!=arr.length-1?",":"");
            }
        }else{
            System.out.println(arr);
        }
        sb.append("]");
        System.out.println(sb);
    }
}

自定义泛型接口

public interface Data <E>{
    //对Students类和Teachers类进行操作
    //void add(Students students);//此方法只能作用Students类，通用性差,改用泛型接口
    void add(E e);
    void delete(int id);
    void update(E e);
    E queryById(int id);
}

public class TeacherData implements Data<Teachers>{
    @Override
    public void add(Teachers teachers) {
        
    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Teachers teachers) {

    }

    @Override
    public Teachers queryById(int id) {
        return null;
    }
}

• 泛型接口作用：约束实现类，实现类可以在实现接口时，传入自己的操作的数据类型，这样重写的方法将都是针对该类型的操作

泛型通配符、上下限

import java.util.ArrayList;

public class test {
    public static void main(String[] args) {
        ArrayList<BENZ> benzs=new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);

        ArrayList<BMW> bmws=new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(benzs);
    }

    /*public static void go1(ArrayList<Cars> cars){
    //BMW和BENS都继承了Cars，但ArrayList<BMW>和ArrayList<BENZ>与ArrayList<Cars>没有关系
    //不能直接传入benzs和bmws
    }*/
    public static void go(ArrayList<? extends Cars> cars){
    //通配符：？ 
    //？extends Cars:?必须是Cars或其子类 泛型上限
    //？super Cars:?必须是Cars或其父类 泛型下限
    }
}

class Dog{

}
class BENZ extends Cars{

}

class BMW extends Cars{

}
//父类
class Cars{

}