Java学习笔记（十）--集合 List集合

数据结构栈，队列，数组和链表的各自特点

栈：先进后出
队列：先进先出
数组：查询快，增删慢
链表：查询慢，增删快

链表：通过一个链子把多个结点（元素）连接起来。数据和地址组成一个元素。结点本身必须有一个地址值（就是下一个元素的地址）。

链表的分类：
-单向链表：数据加下一个元素的地址
-双向链表：数据+上一个元素地址+下一个元素地址
-单向循环链表：最后一个元素存储的地址是第一个元素的地址值。
-双向链表：存储的是两个地址，最后一个元素存储的分别是上一个元素的地址和第一个元素的地址。

---

集合概念

数组：
1.长度固定
2.可以存储基本类型，也可以存储引用类型
3.存储元素类型一致

集合：
1.长度可变
2.只能存储引用类型
3.可以存储多种类型

数组和集合的区别：数组不适应变化的需求,所以Java就提供了集合类供我们使用。

集合的继承体系图

---

集合

Collection
1.Collection是一个接口，是集合的顶层结构，定义了集合的共性功能。可以存储对象，这些对象也被称为元素。
2.成员方法：
-添加功能：

boolean add(Object obj) //往集合中添加一个元素
boolean addAll(Collection c) //往集合中添加多个元素，其实就是往集合中添加另一个集合

-删除功能：

void clear() //清空所有元素
boolean remove(Object obj) //从集合中删除一个元素
boolean removeAll(Collection c) //从集合中删除另一个集合的元素

-判断功能：

boolean contains(Object obj) //判断集合中是否包含指定的元素
boolean containsAll(Collection c) //判断集合中是否包含另一个集合的元素
boolean isEmpty() //判断集合是否为空

-交集功能

boolean retainAll(Collection c) 

-长度功能

int size() //返回集合中元素的个数

3.迭代器：集合特有的遍历方式
步骤：
（1）通过集合对象获取迭代器对象

Iterator iterator()

（2）通过迭代器对象的hasNext()方法判断是否有元素

boolean hasNext()

（3）通过迭代器对象的next()方法获取元素

Object next()

需求：创建狗对象（带参数），存储到集合，用迭代器进行遍历并打印对象的属性数据。

public class DogTest {
    public static void main(String[] args) {
        /**
         * 1.创建dog对象
         * 2.创建集合
         * 3.将dog对象添加到集合
         * 4.获取迭代器对象
         * 5.调用方法进行遍历
         */
        //创建Dog对象
        Dog d1 = new Dog("小黄",1);
        Dog d2 = new Dog("小白",2);
        Dog d3 = new Dog("小黑",3);
        //创建集合
        Collection c = new ArrayList();
        //将Dog对象添加到集合中
        c.add(d1);
        c.add(d2);
        c.add(d3);
        //获取迭代器对象
        Iterator it = c.iterator();
        //遍历
        while (it.hasNext()) {
            Dog d = (Dog)it.next();
            System.out.println(d.getName()+"  "+d.getAge());
        }
    }

}

运行结果：

List
1.List集合的元素有序（存储和取出的顺序一致），元素可重复。
2.List特有功能：
-添加功能：

void add(int index,Object obj) //在指定的位置添加元素

-删除功能：

Object remove(int index) //通过指定的索引删除元素，并把删除的元素返回

-获取功能：

get(int index) //返回列表中指定位置的元素

-替换功能：

Object set(int index,Object obj)

-List的倒序与洗牌：

Collections.shuffle(list) //List中元素顺序可以被洗牌
Collections.reverse(list) //List中元素顺序可以被倒序

-排序：

Collections.sort(list) //对List元素排序
//如果是字母，按照a-z排序
//如果是数字，按照0-1排序

需求：用List集合存储3个汽车对象，然后遍历。

public class CarDemo {
    public static void main(String[] args) {
        //创建汽车类对象
        Car c1 = new Car("品牌1",1000000);
        Car c2 = new Car("品牌2",2000000);
        Car c3 = new Car("品牌3",3000000);
        //创建集合
        List list = new ArrayList();
        //把汽车类对象添加到集合中
        list.add(c1);
        list.add(c2);
        list.add(c3);
        //迭代器遍历
        Iterator it = list.iterator();
        while(it.hasNext()){
            Car c = (Car)it.next();
            System.out.println(c.getBrand()+"  "+c.getPrice());
        }
        System.out.println("----------------------");
        //for循环遍历
        for (int i = 0; i < list.size(); i++) {
            Car c = (Car)list.get(i);
            System.out.println(c.getBrand()+"  "+c.getPrice());
        }
        System.out.println("----------------------");
        //增强for循环
        for (Object obj : list) {
            Car c = (Car)obj;
            System.out.println(c.getBrand()+"  "+c.getPrice());
        }
    }

}

运行结果：

ArrayList
特点：底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。

LinkedList
特点：底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

LinkedList特有功能：

public void addFirst(E e)
public void addLast(E e)

public E getFirst()
public E getLast()

public E removeFirst()
public E removeLast()

---

泛型入门

1.泛型：是一种把明确数据类型的工作推迟到创建对象获取调用方法时才去明确数据类型的特殊数据类型。
2.格式：<数据类型>
这里的数据类型只能是引用类型，如果看到基本类型，其实是采用了自动装箱。
3.好处：
（1）把运行时期的问题提前到了编译时期
（2）避免了强制类型转换
（3）优化程序设计，解决了黄色警告线问题
4.泛型的概述：
（1）泛型类：泛型定义在类上
（2）泛型方法：泛型定义在方法上
（3）泛型接口：泛型定义在接口上