Day12Java基础学习笔记

集合/集合框架（List）

数组和集合的区别

数组长度固定的，一旦定义，就无法改变
集合长度可变
数组中可以粗出基本数据类型，也可以是对象（实际上是对象的引用
集合只能存储对象的引用）

Java集合体系：分为Collection和Map两种体系

Collection接口

Collection有两个派生出来的接口：Set、List

Set：特点是：元素无序，不可重复
List：特点是：元素有序，可以重复

Collection接口的常用抽象方法

boolean add(Object o):向集合中添加一个元素，如果添加成功，则返回true，否则返回false
boolean addAll（Collection c）：把另一个集合中的所有元素添加到当前集合中，如果添加成功，则返回true，否则返回false
void clear（）：清除集合里所有元素，将集合长度变为0
boolean contains（Object o）：返回集合里是否包含指定元素
boolean containAll（Collection c）：返回集合里是否包含集合c里包含的所有元素
boolean isEmpty（）：返回当前集合是否为空
Iterator iterator（）：返回一个Iterator对象，用于遍历集合里的元素
boolean remove（Object o）：删除集合中指定的元素c，当集合中包含一个或者多个元素c时，该方法只删除第一个符合条件的元素，陈宫删除返回true
boolean removeAll（Collection c）：从集合中删除集合c中包含的素有元素，相当于用当前集合减去集合c，如果删除了一个或者一个以上的元素，该方法返回true
int size（）：返回集合中元素个数
Object[] toArray（）：将集合转换成一个数组，转换后的数组时Object类型

迭代器Iterator实现集合遍历

Iterator也是集合框架中的成员，但是他不能用来盛庄元素，只能用来遍历（即迭代）Collection中的元素，Iterator对象那个也被成为迭代器

如果想使用Iterator迭代器，则必须有一个集合对象，没有集合对象，迭代器也就没有意义了

常用的迭代器方法

boolean hasNext（）：查看集合是否还有元素，如果集合被遍历完了，则返回false，否则返回true
Object next（）：返回集合中的下一个元素，注意放回类型是Object

boolean remove（）：将上一次返回的元素删除，删除成功返回true，否则false

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //给集合中添加元素
        c.add("hello");
        c.add(123);
        c.add("asd");
        c.add("hello");
        c.add(new Student("张三",15));
        Iterator it = c.iterator(); // 获取迭代器
        while (it.hasNext()) {
            Object obj =it.next();
            System.out.println(obj);
        }
    }
}

遍历集合的另一个方式：增强for循环

也叫foreach循环，每次循环都把数组/集合中的元素拿出来复制给一个变量，用来遍历集合和数组

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    public class CollectionDemo {
        public static void main(String[] args) {
            Collection c = new ArrayList();
            c.add("hello");
            c.add(123);
            c.add("asd");
            c.add("hello");
            c.add(new Student("张三",15));
            for (Object obj : c) {
                System.out.println(obj);
            }
        }
    }

注意！：在使用增强for遍历集合时，采用的值传递，改变循环变量的值不会影响到集合中的元素，但可以改变变量的值。

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    public class CollectionDemo {
        public static void main(String[] args) {
            Collection c = new ArrayList();
            c.add("java");
            c.add("javaee");
            c.add("javase");
            for (Object obj : c) {
                String name = (String)obj；//强转为String类型
                name = "String"+ name;//在字符串前面加上String字样
            }
            System.out.println(c);// 元素并不会改变
        }
    }

如何在遍历时删除集合中的元素

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    public class CollectionDemo {
        public static void main(String[] args) {
            Collection c = new ArrayList();
            c.add("hello");
            c.add(123);
            c.add("asd");
            c.add("hello");
            c.add(new Student("张三",15));
            Iterator it = c.iterator();
            while(it.hasNext()){
                Object obj = it.next();
                if(obj.equals(123)){  //调用Object类的equals（）方法进行是否相等比较
                    it.remove(); //这里调用Iterator的remove（）方法进行删除
                }
            }
            it = c.iterator(); //重置迭代指针，在上一轮循环中指针已指到末尾位置，重新开始遍历需要将指针重置
            while (it.hasNext()) {
                Object obj1 =it.next();
                System.out.println(obj1);
            }
        }
    }

List接口

是Collection接口的一个重要子接口，集合类中元素有序，且可重复，集合中的每个元素都有其对应的顺序索引。

List接口实现类有三种遍历方式

使用Iterator迭代器遍历集合
使用for循环中get（int index）通过索引来遍历

增强for循环

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class ListDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List al = new ArrayList();
        al.add("java");
        al.add("javaee");
        al.add("javase");
        //使用Iterator迭代器遍历集合
        Iterator it = al.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
        //增强for循环j进行遍历
        for (Object obj : al) {
            System.out.println(obj);
        }
        //使用for循环中get（int index）通过索引来遍历
        for (int i = 0; i < al.size(); i++) {
            Object obj = al.get(i);
            System.out.println(obj);
        }
    }
}

List中遍历集合时对元素进行删除：

逆序遍历删除元素

    import java.util.ArrayList;
    import java.util.List;
    public class RemoveDemo {
        public static void main(String[] args) {
            List al = new ArrayList();
            al.add("java");
            al.add("java");
            al.add("java");
            al.add("java");
            //逆序遍历删除
            for (int i = al.size()-1; i >=0; i--) {
                String str =(String)al.get(i);
                if(str.equals("java")){
                al.remove(i);
                }
            }
            System.out.println(al);
        }
    }

案例练习，验证使用contains方法时是否调用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) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    }

    import java.util.ArrayList;

    public class ArrayListDem {
        public static void main(String[] args) {
            ArrayList al = new ArrayList();
            Person p1 = new Person("p1",11);
            Person p2 = new Person("p2",12);
            Person p3 = new Person("p3",13);
            Person p4 = new Person("p4",14);
            al.add(p1);
            al.add(p2);
            al.add(p3);
            al.add(p4);
            for (Object object : al) {
                System.out.println(object);
            }
            System.out.println("----------");
            System.out.println(al.contains(p3));
        }
    }

面试题：简述List的子类特点

    ArrayList:
        底层数据结构是数组，查询快，增删慢。
        线程不安全，效率高。
    Vector:
        底层数据结构是数组，查询快，增删慢。
        线程安全，效率低。
    Vector相对ArrayList查询慢(线程安全的)
    Vector相对LinkedList增删慢(数组结构)
    LinkedList:
        底层数据结构是链表，查询慢，增删快。
        线程不安全，效率高。

    Vector和ArrayList的区别
        Vector是线程安全的,效率低
        ArrayList是线程不安全的,效率高
    共同点:都是数组实现的
    ArrayList和LinkedList的区别
        ArrayList底层是数组结果,查询和修改快
        LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
    共同点:都是线程不安全的

List有三个儿子，我们到底使用谁呢?

    查询多用ArrayList
    增删多用LinkedList
    如果都多ArrayList