集合（上）（List的学习）

一.
算法介绍（栈、队列、数组、链表、Hash、树）
1.栈：先进后出，存储元素（A,B,C）（压栈），并取出（弹栈），
队列：先进先出，横向队列，存入取出
2.数组：查询快，增删慢(创建一个数组int[] arr = {11,13,45,67,34},
需求一：在45号元素后面增加一个元素23
（因为数组长度不够，要重新创建一个数组，在3这个索引处添加一个元素）
需求二：删除元素45（直接将45所以对应的索引删除）
需求三：我要获取45这个元素（直接用45这个元素所对应的索引去获取他）

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

数组的特点：查询慢，增删快
需求1：查询元素45，需要一个一个从头遍历
需求2：删除45这个元素，（1.保存45这个元素所保存的地址值 2.
断开链子 3.将第一个步骤中取得到的地址值赋值给45的下一个元素））
分为：单向链表：数据+下一个元素的地址
双向链表 ：数据+下一个元素的地址+上一个元素的地址
单向循环链表 ：最后一个元素存储的地址是第一个元素的地址值
双向循环链表：存储的是两个地址，最后一个元素所存储的两个地址分别是上一个元素的地址和第一个元素的地址

hash:一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，
变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，
不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的信息压缩到
某一固定长度的消息摘要的函数

三.集合概念
3.1
案例：写一个学生数组，提出需求，根据需求分析数组和集合的区别
* 需求：存储5个学生对象，并输出学生对象的数据信息。
*
* 分析：
* A:定义学生类(name,age)
* B:定义学生数组，用于存储学生对象
* C:创建学生对象，给学生对象的成员变量赋值
* D:把创建好的学生对象添加到数组中
* E:遍历数组。

public class StudentDemo {
    public static void main(String[] args) {

         * 需求：德云社又添加了几个新徒弟
         * 如果还想给德云社的数组中添加新徒弟的话，因为数组长度不可变，所以我们必须创建新的数组重新添加
         */
        //2.创建学生对象
        Student s1 = new Student("岳云鹏", 33);
        Student s2 = new Student("孙越", 35);
        Student s3 = new Student("郭老师", 45);
        Student s4 = new Student("谦哥", 50);

        //创建一个新徒弟
        Student s5 = new Student("陈洁", 23);

        //3.创建学生数组
        Student[] ts = new Student[4];

        //4.将创建的学生对象存储到数组中
        ts[0] = s1;
        ts[1] = s2;
        ts[2] = s3;
        ts[3] = s4;

        //遍历学生数组
        for (int i = 0; i < ts.length; i++) {
            System.out.println(ts[i].getName()+"  "+ts[i].getAge());
        }


    }

}

1.集合和数组的区别
数组：
1.长度固定
2.可以存储基本类型，也可以存储引用类型 （如果见到int类型的数据，那会是因为数据进行了自动装箱）
3.存储元素类型一致
集合：
1.长度可变
2.只可以存储引用类型
3.可以存储多种类型

3.2
* 为什么出现集合类？
* 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，我们就需要对这多个对象进行存储。
* 而目前为止我们学习过的可以存储多个元素的东西是数组，但是呢，数组长度固定，不能适应变化的需求，所以，Java就提供了集合类供我们使用。

四.
4.1
* Java提供了集合类供我们使用，而我们的需求可能是这样的：
* 我要求我的元素是有序的，
* 我要求我的元素是无序的，
* 我要求我的元素是唯一的，
* 我要求我的元素是可以重复的。
* 为了满足不同的需求，Java就提供了不同的集合类。
* 而这些集合类由于数据结构不同，才可以满足这些条件的。
* 数据结构：存储元素的方式。
* 而无论这些集合的结构是什么样子的，都是要装水的，所以，他们应该有共性的内容。
* 通过不断的向上提取，最终会形成一个集合的继承体系图。

4.2
java API 集合类图介绍
Collction体系结构图
Collection
List
ArrayList
Vector
LinkedList
Set
HashSet
TreeSet

集合部分：
1.Collection
1.1
是集合的顶层结构，定义了集合的共性功能。
可以存储对象，这些对象也被称为元素。
1.2（学习方法）
* 成员方法：(看到E先把它理解为Object，其实是一种泛型)
* A:添加功能
* boolean add(Object obj):往集合中添加一个元素
* boolean addAll(Collection c):往集合中添加多个元素
* B:删除功能
* void clear():清空所有元素
* boolean remove(Object o):从集合中删除一个元素
* boolean removeAll(Collection c):从集合中删除另一个集合的元素
* C:判断功能
* boolean contains(Object o):判断集合中是否包含指定的元素
* boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素
* boolean isEmpty():判断集合是否为空。
D:交集功能
* boolean retainAll(Collection c)
* E:迭代器(集合特有的遍历方式)
* Iterator iterator()
重点：Iterator的使用
A:使用步骤
B:迭代器原理
* F:长度功能
* int size():返回集合中元素的个数
*
* 混淆点： 面试题：
* 数组有length()吗?字符串有length()吗?集合有length()吗?
数组的length 是一种属性，String的length是一种方法
集合中没有length，但是有size
G:集合转数组
Object[]toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合

import java.util.ArrayList;
public class CollectionDemo {
public static void main(String[] args) {
//创建集合
//Collection c = new Collection();
Collection<Comparable> c = new ArrayList<Comparable>();


public class CollectionDemo {
public static void main(String[] args) {
//创建集合
//Collection c = new Collection();
Collection<Comparable> c = new ArrayList<Comparable>();
//boolean add(Object obj):往集合中添加一个元素
c.add("hello");
c.add("world");
c.add("java");
c.add(100);//集合中只能添加引用类型的数据，但是在这里为什么可以添加int类型的数据100呢？在这里进行了自动装箱

//boolean all(Collection c):往集合中添加多个元素
        Collection<String> c1 = new ArrayList<String>();
        c1.add("章子怡");
        c1.add("郭德纲");
        c.addAll(c1);

        //void clear():清空所有元素
        //c.clear();

        //boolean remove(Object o):从集合中删除一个元素
//      boolean remove = c.remove("sfdgdfg");
//      System.out.println(remove);

        //boolean removeAll(Collection c):从集合中删除另一个集合的元素,只要删除一个元素就代表删除成功
//      Collection<String> c2 = new ArrayList<String>();
//      c2.add("hello");
//      c2.add("sdfdsf");
//      boolean removeAll = c.removeAll(c2);
//      System.out.println(removeAll);


        //boolean contains(Object o):判断集合中是否包含指定的元素
//      boolean contains = c.contains("sdfcds");
//      System.out.println(contains);

        //boolean containsAll(Collection c):判断集合中是否包含另一个集合的元素,包含的所有元素才叫全部包含
//      Collection<String> c2 = new ArrayList<String>();
//      c2.add("hello");
//      c2.add("sfsdfsdf");
//      boolean containsAll = c.containsAll(c2);
//      System.out.println(containsAll);

        //boolean isEmpty():判断集合是否为空。
//      c.clear();
//      boolean empty = c.isEmpty();
//      System.out.println(empty);


        //boolean retainAll(Collection c):求出交集元素，并且将没有交集的元素删除
//      Collection c2 = new ArrayList();
//      c2.add("hello");
//      c2.add("sfsdfsdf");
//      boolean retainAll = c.retainAll(c2);
//      System.out.println(retainAll);

        //int size():返回集合中元素的个数
        System.out.println(c.size());

        System.out.println("---------------");
        //怎么遍历集合呢？
        //先将集合转成数组
        Object[] objects = c.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
    }

}

• 练习：
  1.3
• 需求：往集合中添加三个字符串，并遍历。
• A:创建集合对象
• B:创建字符串对象
• C:把字符串对象添加到集合对象中
• D:遍历集合
• 
  
  • Object[] toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合。

Object[] objects = c.toArray();
        for (int i = 0; i < objects.length; i


++) {
            System.out.println(objects[i]);
        }

 * 
 * 练习：
 *      在集合中存储3个学生对象，并遍历,拿出每一个学生对象的属性。
public class Student {
    private String name;
    private int age;


    //alt+shift+s自动生成
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    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;
    }



}
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        /**
         * 在集合中存储3个学生对象，并遍历,拿出每一个学生对象的属性。
         * 1.创建学生对象
         * 2.创建集合
         * 3.将学生对象添加到集合中
         * 4.遍历集合
         */
        //1.创建学生对象
        Student s1 = new Student("郭德纲", 50);
        Student s2 = new Student("于谦", 50);
        Student s3 = new Student("岳云鹏", 50);
        Student s4 = new Student("孙越", 50);
        Student s5 = new Student("候震", 50);

        //2.创建集合
        Collection c =  new ArrayList();

        //3.将学生对象添加到集合中
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);

        //4.遍历集合
        //将集合转换为数组
        Object[] objects = c.toArray();
        for (int i = 0; i < objects.length; i++) {
            Student s = (Student)objects[i];//在这里必须进行强制类型转换
            System.out.println(s.getAge()+"  "+s.getName());
        }

    }

}

1.4
* 迭代器：（分别创建String对象，Student对象添加集合遍历练习）
* Iterator iterator()
* Object next():返回迭代的下一个元素,并移动指向的位置
* boolean hasNext():判断是否有元素
*
* NoSuchElementException:没有这样的元素异常。
* 原因是：你已经获取到元素的末尾了，你还要继续获取元素，已经没有了，所以就报错了。
* 解决方案：你不要再拿了。我哪知道什么就不拿了啊?怎么办呢?就应该在拿之前判断一下是否有元素。
*
* 迭代器遍历集合：
* 迭代器是依赖于集合而存在的。所以，要想得到迭代器对象，必须先有集合对象。
*
* 迭代步骤：
* A:通过集合对象获取到迭代器对象
* B:通过迭代器对象的hasNext()方法判断是否有元素
* C:通过迭代器对象的next()方法获取元素

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

 public class Dog {
    private String name;
    private int age;
    private String type;
    public Dog(String name, int age, String type) {
        super();
        this.name = name;
        this.age = age;
        this.type = type;
    }
    public Dog() {
        super();
        // TODO Auto-generated constructor stub
    }
    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 String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }


}
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class DogTest {
    public static void main(String[] args) {
        /**
         * 练习：创建狗对象（带参数），存储到集合，用迭代器进行遍历并打印对象的属性数据
         * 1.创建dog对象
         * 2.创建集合
         * 3.将dog对象添加到集合
         * 4.获取迭代器对象
         * 5.调用方法进行遍历
         */



//1.创建dog对象
        Dog d1 = new Dog("小黑", 1, "藏獒");
        Dog d2 = new Dog("小黄", 1, "金毛");
        Dog d3 = new Dog("小白", 2, "萨摩耶");

        //2.创建集合
        Collection c = new ArrayList();

        //3.将dog对象添加到集合
        c.add(d1);
        c.add(d2);
        c.add(d3);

        //4.获取迭代器对象,该集合对应的迭代器对象
        Iterator it = c.iterator();

        // 5.调用方法进行遍历
        while (it.hasNext()) {
            Dog d = (Dog) it.next();
            System.out.println(d.getName()+"  "+d.getAge()+"  "+d.getType());
        }

    }

}

2.List
(1)List集合的元素有序(存储和取出顺序一致),元素可重复
(2)List的特有功能：
A:添加功能
void add(int index,Object obj):在指定的位置添加元素
B:删除功能
Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
C:获取功能
get(int index) 返回列表中指定位置的元素。
D:替换功能
Object set(int index,Object obj）
(3)案例：
A:List存储字符串并遍历(迭代器,普通for)
B:List存储自定义对象并遍历(迭代器,普通for）
(4).List的倒序与洗牌
List中元素顺序可以被洗牌Collections.shuffle(list)
List中元素顺序可以被倒序Collections.reverse(list)
Collections.sort(list)对List元素排序（字母数字分别进行测试）

 * 2.List
    (1)List集合的元素有序(存储和取出顺序一致),元素可重复

    (2)List的特有功能：
        A:添加功能
        void add(int index,Object obj):在指定的位置添加元素
        B:删除功能
        Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
        C:获取功能
        get(int index) 返回列表中指定位置的元素。
        D:替换功能
        Object set(int index,Object obj)
 *
 */


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //创建List集合,List集合特点：元素的存入和取出的顺序一致
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");


        //void add(int index,Object obj):在指定的位置添加元素
        //list.add(1, "php");

        //Object remove(int index):通过指定的索引删除元素，并把删除的元素返回
        //Object remove = list.remove(1);
        //System.out.println(remove);


        //get(int index) 返回列表中指定位置的元素。
//      Object object = list.get(0);
//      System.out.println(object);
//      Object object2 = list.get(1);
//      System.out.println(object2);
//      Object object3 = list.get(2);
//      System.out.println(object3);
        //list集合的特有的便利方式，通过get（int index）,和size()方法，可以通过普通for循环去遍历list集合
        /*
        for(int i=0;i<list.size();i++){
            Object object = list.get(i);
            String str = (String)object;
            System.out.println(str);
        }*/


        //Object set(int index,Object obj),将指定的索引处的元素替换成指定元素，并且将原来的老的元素返回
        String set = list.set(2, "c++");
        System.out.println(set);



        System.out.println("---------------");
        //遍历集合
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }

}

案例练习：
* 需求：用List集合存储3个汽车对象，然后遍历。
*
* 汽车：Car
* 成员变量：String brand,int price,String color
* 构造方法：无参，带参
* 成员方法：getXxx()/setXxx()
*
* 注意事项：
* A:忘写main方法。
* B:导入包的问题，集合操作的时候，导入包基本上都是在java.util下
* C:大家针对我们的命名规范有些忘记了，需要回来再看一下
* 类，接口等名称是首字母大写
* 变量或者方法名首字母小写

public class Car {
    private String brand;
    private int price;
    private String color;
    public Car(String brand, int price, String color) {
        super();
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    public Car() {
        super();
        // TODO Auto-generated constructor stub
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }



}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CarDemo {
    public static void main(String[] args) {
        //创建汽车对象
        Car c1 = new Car("兰博基尼", 4000000, "黑色");
        Car c2 = new Car("玛莎拉蒂", 1000000, "黑色");
        Car c3 = new Car("特斯拉", 1000000, "黑色");

        //创建集合
        List list = new ArrayList();

        //给集合中添加元素
        list.add(c1);
        list.add(c2);
        list.add(c3);

        //迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            Car c = (Car)obj;
            System.out.println(c.getBrand()+"  "+c.getColor()+"  "+c.getPrice());
        }

        System.out.println("----------------");

        //普通for循环
        for (int i = 0; i < list.size(); i++) {
            Car car = (Car)list.get(i);
            System.out.println(car.getBrand()+"  "+car.getColor()+"  "+car.getPrice());
        }

        System.out.println("----------------");
        //增强for循环
        for(Object obj:list){
            Car car2 = (Car)obj;
            System.out.println(car2.getBrand()+" "+car2.getColor()+"  "+car2.getPrice());
        }

    }

}

3.ArrayList
案例1：存储字符串并遍历
案例2：存储自定义对象并遍历

4.LinkedList
案例1：存储字符串并遍历
案例2：存储自定义对象并遍历
* LinkedList特有功能:
* public void addFirst(E e)
* public void addLast(E e)
*
* public E getFirst()
* public E getLast()
*
* public E removeFirst()
* public E removeLast()

import java.util.LinkedList;
import java.util.List;

/**
 * 4.LinkedList
        案例1：存储字符串并遍历
        案例2：存储自定义对象并遍历
 * LinkedList特有功能:
 *      public void addFirst(E e)
 *      public void addLast(E e)
 *      
 *      public E getFirst()
 *      public E getLast()
 *      
 *      public E removeFirst()
 *      public E removeLast()
 *
 */


public class LinkedListDemo {
    public static void main(String[] args) {
        //创建一个LinkedList的集合
        LinkedList list = new LinkedList();
        list.add("hello");
        list.add("world");
        list.add("java");

        // *        public void addFirst(E e)
        // *        public void addLast(E e)
        //需求：在hello前面加上一个元素“c++”
        list.addFirst("c++");
        list.addLast("js");


//       *      public E getFirst()
//       *      public E getLast()
//      Object first = list.getFirst();
//      Object last = list.getLast();
//      System.out.println(first);
//      System.out.println(last);


//       *      public E removeFirst()
//       *      public E removeLast()
        Object removeFirst = list.removeFirst();
        Object removeLast = list.removeLast();
        System.out.println(removeFirst);
        System.out.println(removeLast);



        System.out.println("---------------");
        //遍历集合
        for(Object obj:list){
            System.out.println(obj);
        }

    }

}

8.ArrayList与LinkedList的相同点与不同点
相同点：有顺序的，元素可以重复
(1)ArrayList特点:
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
(2)LinkedList特点:
底层数据结构是链表,查询慢,增删快
线程不安全,效率高

9.List的遍历（必须掌握）
1.for（普通for）
2.Iterator(迭代器)
3.foreach（增强for）

10.泛型入门
引入：
案例：创建集合存储字符串，存储integer类型数据，遍历的时候强制转换
与String数组进行对比，引入泛型

泛型(掌握)：如果不加反型，我们只有在程序运行的时候发现他的错误，这样很不安全
(1)是一种把明确数据类型的工作推迟到创建对象或者调用方法的时候才去明确类型的特殊类型
(2)格式：
<数据类型>
默认情况下，是Object类型。
这里数据类型只能是引用类型。如果你看到写基本类型也行，其实这里使用了自动装箱。
(3)好处：
A:把运行时期问题提前到了编译时期
B:避免了强制类型转换
C:优化程序设计，解决了黄色警告线问题
(4)在哪里用?
一般来说就是在集合中用的多。
看API,如果类或者接口或者方法出现了<>说明这里就有泛型拓展
(5)泛型的概述
A:泛型类（把泛型定义在类上）
B:泛型方法（把泛型定义在方法上）
C:泛型接口（泛型定义在接口上）
(6)泛型通配符

public class GenericDemo<E> {    //泛型存在于类中
    //创建一个方法
    public void show(E e){
        System.out.println(e);
    }

}
public class Test {
    public static void main(String[] args) {
        GenericDemo<String> gd = new GenericDemo<String>();
        gd.show("hello");
    }

}



public class GenericDemo<E> {    //泛型存在于方法中

    public void show(E e){
        System.out.println(e);
    }

    //创建一个方法，将泛型加载方法上
    public<BMW> void method(BMW bmw){
        System.out.println(bmw);
    }

}
public class Test {
    public static void main(String[] args) {
        GenericDemo<String> gd = new GenericDemo<String>();
        gd.show("hello");
        gd.method("hello");
        gd.method(100);
        gd.method('a');

    }

}



public interface Inter<E> {   //泛型存在于接口中在接口的实现类实现它时 ，他就已经明确

}
public class InterImpl<E> implements Inter<E> {

}