面向对象核心编程---Day 02

一、集合

（一）概述

        概述：也是一个类似于数组的统一存储和管理数据的容器，集合只能存储引用数据类型，不能存储基本数据类型，就类似于对象数组

（二）优势

        1、可扩展性：底层会自动增长，不用我们自行扩展

        2、集合中存储了大量用于操作集合的方法

        3、集合存储的是引用数据类型，以及对象；利于我们面向对象的思想

        4、不带泛型的集合可以存储任何数据类型

（三）集合体系

        1、分类： ·

     （1）单列集合：每一个元素都是一个单独的个体，就类似于数组一样

     （2）双列集合：每一个操作都针对一对数据进行，以一对数据为单位

        2、体系结构

     （1）单列集合

     （2）双列集合

 

二、Collection接口

（一）概述

        1、 Collection ，接口名；含义：收集、集合

        2、单列集合的顶层接口，定义了所有单列集合共有的方法

        3、接口不能创建对象，需要子实现类类创建对象调用方法：接口 Collection 的引用，指向实现类ArrayList对象

        4、常用方法：

     （1） add (Object obj) ：将 obj 元素添加到集合中

     （2） remove (Object o) ：将指定元素从集合中删除

     （3） clear () ：移出此集合中所有的元素

     （4） isEmpty () ：判断集合是否为空

     （5） contains (Object o) ：判断集合中是否包含指定元素

     （6） size () ：返回集合的个数

import java.util.ArrayList;
import java.util.Collection;
public class Demo01_Collection {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        //(1) add(Object obj):将obj元素添加到集合中
        list.add("qwe");
        list.add(234);
        list.add('Q');
        list.add("^&*");
        list.add("qwe");
        System.out.println(list);
        //(2) remove(Object 0):将指定元素从集合中删除
        list.remove('Q');
        System.out.println(list);
        //(3) clear(): 移出此集合中所有的元素
        list.clear();
        //(4) isEmpty!(): 判断集合是否空
        System.out.println(list.isEmpty());
        //(5) contains(Object 0):判断集合中是否包含指定元素
        System.out.println(list.contains(234));
        //(6) size(): 返回集合的个数
        System.out.println(list.size());
    }
}

（二）第一种遍历

        1、 toArray () ：将集合中的元素添加到一个数组并返回

        2、调用此方法，将集合元素存储在数组中，再对数组进行遍历

import java.util.ArrayList;
import java.util.Collection;
public class Demo02_ToArray {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        //(1) add(Object obj):将obj元素添加到集合中
        list.add("qwe");
        list.add(234);
        list.add('Q');
        list.add("^&*");
        list.add("qwe");
        Object[] arr = list.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

（三）第二种遍历：迭代器

        1、迭代器：专门用于将集合中的元素，一个到另一个迭代的对象

        2、迭代器的获取： iterator () ，集合通过调用方法获取迭代器对象

        3、迭代器的使用

     （1） hasNext () ：判断是否有下一个可以迭代的元素，如果有返回 true

     （2） next () ：获取集合中的下一个元素

     （3） remove () ：删除集合中迭代器正在迭代的这个元素

        4、注意

     （1） hasNext () ：每次只能判断下一个元素是否存在

     （2） next () ：每次只能获取一个元素并且将迭代器向下一个元素移动一个位置

     （3）调用一次 hasNext 方法只能调用一次 next 方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo03_Iterator {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add(new Person("张三", 23));
        coll.add(new Person("李四", 24));
        coll.add(new Person("王五", 25));
        //coll.add(new Person("赵六", 26));
        //1、获取迭代器对象
        Iterator it = coll.iterator();
        //2.判断还有没有下一个元素
        while (it.hasNext()) {
            //3、获取下一个元素
            Object next = it.next();
            //4、向下转型，执行子类特有的方法
            Person p = (Person) next;
            System.out.println(p.getName() + "..." + p.getAge());
            // 禁止书写 当调用一次hasNext方法的时候，只能调用一次next()方法
            // System.out.println(((Person) it.next()).getName() + "..." +((Person) it.next()).getAge());
        }
    }
}

三、List接口

（一）概述

        1、是 Collection 的子接口

        2、特点：

     （1）有序：元素存储顺序和读取顺序一致

     （2）可重复：允许存储重复的元素

        3、常用方法：

     （1） add (int index, E element) ：将指定元素插入到集合的指定位置

     （2） remove (int index) ：删除指定索引上的元素

     （3） set (int index, E element) ：用指定元素替换指定索引上的元素

     （4） get (int index) ：返回指定索引上的元素

（二）第三种遍历

        1、针对 List 集合特有的遍历方式， Collection 中不一定能使用， Set 中肯定不能使用

        2、可以通过 size 方法获取集合的长度，进而就可以得到集合的索引范围，再配个 get 方法获取指定索引上的元素，就能获取到每一个索引上对应的元素

import java.util.ArrayList;
import java.util.List;
public class Demo04_PrintList {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qwe");
        list.add(234);
        list.add('Q');
        list.add("^&*");
        list.add("qwe");
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }
}

（三）并发修改异常

        1、 ConcurrentModificationException

                     并发           修改         异常

        2、出现原因：在使用迭代器进行遍历的时候，通过集合对象操作集合

        3、避免方式：

     （1）集合遍历，集合操作

     （2）迭代器遍历，迭代器操作

        4、 listIterator () ： List 集合特有迭代器，操作和以前一样，只不过提供了更多的操作集合的方法

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo05 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qwe");
        list.add("asd");
        list.add("zxc");
        list.add(234);
        list.add(789);
        list.add("fgh");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            //list.add("666");
            if ("zxc".equals(next)) {
                it.remove();
            }
            System.out.print(next + " ");
        }
        System.out.println();
        System.out.print(list + " ");
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo06_ListIt {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qwe");
        list.add("asd");
        list.add("zxc");
        list.add(234);
        list.add(789);
        list.add("fgh");
        ListIterator li = list.listIterator();
        while (li.hasNext()) {
            Object next = li.next();
            if ("asd".equals(next)) {
                li.add(666);
            }
            System.out.println(next);
        }
        System.out.println(list);
    }
}

四、基本数据类型包装类

（一）概述

        1、基本数据类型有八种

        2、集合中只能存储引用数据类型，不能存储基本数据类型，如果需要将基本数据类型存储在集合中，就需要对基本数据类型进行封装

        3、详述

基本数据类型	byte	short	int	long	float	double	char	boolean
包装类	Byte	Short	Integer	Long	Float	Double	Character	Boolean

（二）自动拆装箱机制

public class Demo07_Integer {
    public static void main(String[] args) {
        Integer num1 = 10;//自动装箱
        int num2 = num1;//自动拆箱
        num1 = num1 + 10;//自动拆箱 进行运算 自动装箱
    }
}

五、List的实现类

（一）概述

        1、 List 是一个接口，无法直接创建对象，所以根据它的实现类不同，具有不同的特点

        2、 ArrayList ：数组实现，顺序存储

        3、 Vector ：数组实现，顺序存储

        4、 LinkedList ：链表实现，节点存储

（二）ArrayList

        1、概述

        1、是 List 的实现类

        2、存储方式：

     （1）数组实现，顺序存储

     （2）增删慢，查询快；增删慢是因为有索引，增加或者删除一个元素之后，索引需要重新排列，比较慢；查询快：是因为有索引，可以直接找到对应索引的元素

     （3）通过物理内存结构实现位置关系，来表达逻辑上的相邻

        2、练习

        生成6个 1-33 之间的随机数，不能重复，存储在集合中，并遍历打印；使用 ArrayList 集合

import java.util.ArrayList;
import java.util.Random;
public class Demo08_Exercise {
    /**
    * 生成6个1-33之间的随机数，不能重复，存储在集合中，并遍历打印；使用ArrayList集合
    */
    public static void main(String[] args) {
        //创建随机数
        Random ran = new Random();
        //创建集合存储数据
        ArrayList<Integer> list = new ArrayList<>();
        //29 13 16 10 19 23
        while (list.size() < 6) {
            int num = ran.nextInt(33) + 1;
            if (!list.contains(num)) {
                list.add(num);
            }
        }
        System.out.println(list);
    }
    private static void test(Random ran, ArrayList list) {
        for (int i = 0; i < 6; i++) {
            int num = ran.nextInt(33) + 1;
            //System.out.println(num);
            //存值
            list.add(num);
            //去重
            for (int j = 0; j < i; j++) {
                //System.out.println("i = " + i + " j = " + j);
                if (num == (Integer) list.get(j)) {
                    list.remove(i);
                    i--;
                    break;
                }
            }
        }
        System.out.println(list);
    }
}

（三）LinkedList

        1、 List 接口的实现类

        2、存储方式：

     （1）节点实现，链式存储

     （2）不是通过物理结构实现的相邻关系，是通过逻辑结构实现的相邻

     （3）每一个节点，存储了元素以及相邻节点的地址值，通过地址值实现前后的相邻关系

 

         3、特点

     （1）查询慢：需要根据前面的节点获取下一个节点的地址，前面所有的节点都需要过一遍，节点越多，查询速度越慢

     （2）增删快：增加或者删除一个元素，只需要断开相邻节点的连接，在相邻节点中添加新的地址值即可

        4、特有方法

     （1） addFirst (E e) ：将指定元素插入到列表头部

     （2） addLast (E e) ：将指定元素插入到列表尾部

     （3） getFirst () ：获取头部元素

     （4） getLast () ：获取尾部元素

     （5） removeFirst () ：删除头部元素并返回

     （6） removeLast () ：删除尾部元素并返回