Day11

集合

• 概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。

• 和数组的区别

  • 数组长度固定，集合长度不固定
  • 数组可存储基本类型和引用类型，集合只能存储引用类型

• 位置：java.util.*;

Collection体系集合

• Collection为根接口，有两个子接口
• List接口：有序、有下标、元素可重复
• Set接口：无序、无下标、元素不能重复

public class Student {
    String name;
    int 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;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        //判断是否同一个对象
        if(this == obj){
            return true;
        }
        //判断是否为空
        if(obj == null){
            return false;
        }
        //判断是否为Student类
        if(obj instanceof Student){
            Student s = (Student) obj;
            //比较属性
            if(this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        //都不是
        return false;
    }
}
--------------------------------------------
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo02 {
    public static void main(String[] args) {
        //创建对象
        Collection collection = new ArrayList();
        Student s1 = new Student("zs",20);
        Student s2 = new Student("ls",18);
        Student s3 = new Student("ww",22);

        //添加
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println("元素有"+collection.size()+"个");
        System.out.println(collection.toString());

        //删除
        //collection.remove(s3);
        collection.remove(new Student("ww",22));//需要重写equals方法
        System.out.println(collection.toString());
        System.out.println("删除后有"+collection.size()+"个");

        //清除
//        collection.clear();//清的只是集合里的内存，实践对象并未删除
//        System.out.println(collection.size());

        for (Object o : collection) {
            //Student s = (Student) o;
            System.out.println(o);
        }

        System.out.println("=====迭代器======");
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //判断
        System.out.println(collection.contains(s1));//是否包含
    }
}

List子接口

• 有序、有下标、元素可重复

• ArrayList实现类：

  • 数组结构实现，查询快、增删慢
  • 效率高、不安全

• Vector实现类：

  • 数组结构实现，查询快、增删慢
  • 效率慢、安全

• LinkedList实现类：

  • 链表结构实现，增删快、查询慢

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo01 {
    public static void main(String[] args) {
        //创建
        List list = new ArrayList();

        //添加
        list.add("1");
        list.add("2");
        list.add("3");
        System.out.println(list.size());
        System.out.println(list);

        //可以for遍历,有下标
        System.out.println("========for======");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));//get下标
        }

        //也可以增强for
        System.out.println("======增强for======");
        for (Object o : list) {
            System.out.println(o.toString());
        }

        //listIterator列表迭代器
        //可向前和向后遍历，还可以增删改
        ListIterator listIterator = list.listIterator();
        System.out.println("======从前往后========");
        while(listIterator.hasNext()){
            System.out.println(listIterator.nextIndex()+"："+listIterator.next());
        }
        System.out.println("=======从后往前========");
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previousIndex()+"："+listIterator.previous());
        }

        //判断
        System.out.println(list.contains("3"));
        //判空
        System.out.println(list.isEmpty());

        //获取下标
        System.out.println(list.indexOf("2"));

    }
}

import java.util.ArrayList;
import java.util.List;

public class Demo02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        //添加数字数据隐含了自动装箱(int=>Integer)
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        list.remove(3);//根据下标删除，而不是数字3
        //list.remove((Object) 3);//要删除3可以转成Object
        //list.remove(new Integer(3));//因为Integer里重写了equals的方法
        System.out.println(list.size());
        System.out.println(list.toString());

        //subList()返回子集合,含头不含尾
        System.out.println(list.subList(0, 3));//1,2,3

    }
}

ArrayList

• 源码分析
  • 默认容量：DEFAULT_CAPACITY=10//添加后的容量，添加前为0。每次扩容为原来的1.5倍
  • 存放元素的数组：elementData
  • 元素个数：size

import com.yjj.Student;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

//ArrayList
//* 数组结构实现，查询快、增删慢
//* 效率高、不安全
public class Demo03 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList<>();

        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",25);

        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);

        System.out.println(arrayList.size());
        System.out.println(arrayList.toString());

        arrayList.remove(new Student("王五",25));//需要重写equals
        System.out.println(arrayList.toString());

        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }

        for (Object o : arrayList) {
            Student s = (Student) o;
            System.out.println(s);
        }

        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Student s = (Student) iterator.next();
            System.out.println(s.toString());
        }

        System.out.println("=========列表迭代器逆序=========");
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasPrevious()){
            Student s = (Student) listIterator.previous();
            System.out.println(s.toString());
        }

    }
}