JAVA-10-算法、集合、Collection、List等、泛型入门

一.　算法介绍（栈、队列、数组、链表、Hash、树）
　　（1）栈：先进后出
　　（2）队列：先进先出，横向队列，存入取出
　　（3）数组：查询快，增删慢
　　（４）链表：通过一个链子把多个结点（元素）连接起来，由数据和地址组成的一个元素，节点本身必须有一个地址值（就是下一个元素的地址值）。　　特点：查询慢，增删快。
　　链表分类：
　　　　单向链表：数据+下一个元素的地址
　　　　双向链表 ：数据+下一个元素的地址+上一个元素的地址
　　　　单向循环链表 ：最后一个元素存储的地址是第一个元素的地址值
　　　　双向循环链表：存储的是两个地址，最后一个元素所存储的两个地址分别是上一个元素的地址和第一个元素的地址
　　（5）hash:一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的信息压缩到某一固定长度的消息摘要的函数。（在JAVA-11有讲解）
　　（6）二叉树：（在JAVA-11有讲解）
面试题要点：数据结构：存储数据的方式 问题：常见数据结构的优缺点？

二.　集合概念
2.1　：由于数组不适应长度变化的需求,所有Java就提供了集合类供我们使用。
　　数组特点：
　　　　1.长度固定
　　　　2.可以存储基本类型，也可以存储引用类型
　　　　3.存储元素类型一致
　　集合特点：
　　　　1.长度可变
　　　　2.只可以存储引用类型
　　　　3.可以存储多种类型
2.2　为什么出现集合类？
　　面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，我们就需要对这多个对象进行存储。而目前为止我们学习过的可以存储多个元素的东西是数组，但是呢，数组长度固定，不能适应变化的需求，所以，Java就提供了集合类供我们使用。

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

3.2　java API 集合类的继承体系图介绍
　　

四.　开发中常类介绍
String,　Math,　Scanner,　List,　ArrayList,　等等
集合部分：
1.Collection
　　1.1　简单介绍这个接口
　　　　是集合的顶层结构，定义了集合的共性功能。
　　　　可以存储对象，这些对象也被称为元素。
　　1.2　成员方法：(API 看到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()
　　　　F:长度功能
　　　　　　int size():返回集合中元素的个数
面试题：数组有length()吗?字符串有length()吗?集合有length()吗?
　　　　G:集合转数组
　　　　　　Object[]toArray():把集合转成数组，然后遍历数组，其实就相当于遍历了集合。(一般不用)
　　1.3　迭代器（重点）：
　　　　Iterator iterator()
　　　　Object next():返回迭代的下一个元素,并移动指向的位置
　　　　boolean hasNext():判断是否有元素
　　　　NoSuchElementException:没有这样的元素异常。原因是：你已经获取到元素的末尾了，你还要继续获取元素，已经没有了，所以就报错了。
　　解决方案：在拿之前判断一下是否有元素。
　　迭代器遍历集合：
　　　　迭代器是依赖于集合而存在的。所以，要想得到迭代器对象，必须先有集合对象。
　　迭代步骤：
　　　　A:通过集合对象获取到迭代器对象
　　　　B:通过迭代器对象的hasNext()方法判断是否有元素
　　　　C:通过迭代器对象的next()方法获取元素
　　1.４　练习：创建狗对象（带参数），存储到集合，用迭代器和进行遍历并打印对象的属性数据

package com.edu_05;
//创建Dog类
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;
    }
}

package com.edu_05;
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());
        }
        System.out.println("----------------");
        for (Object obj : c) {
            Dog d = (Dog)obj;
            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)
　　(３)　List的倒序与洗牌
　　　　List中元素顺序可以被洗牌Collections.shuffle(list)
　　　　List中元素顺序可以被倒序Collections.reverse(list)
　　　　Collections.sort(list)对List元素排序（字母数字分别进行测试）
　　(4)　List的遍历（掌握）
　　　　1.for（普通for）
　　　　2.Iterator(迭代器)
　　　　3.foreach（增强for）
3.　ArrayList
　　　　基本用法和List相同
4.　LinkedList
　　　　LinkedList特有功能:
　　　　　　public void addFirst(E e)
　　　　　　public void addLast(E e)
　　　　　　public E getFirst()
　　　　　　public E getLast()
　　　　　　public E removeFirst()
　　　　　　public E removeLast()
５.　ArrayList与LinkedList的相同点与不同点 （面试题）**
　　相同点：有顺序的，元素可以重复
　　　　(1)ArrayList特点:
　　　　　　底层数据结构是数组,查询快,增删慢
　　　　　　线程不安全,效率高
　　　　(2)LinkedList特点:
　　　　　　底层数据结构是链表,查询慢,增删快
　　　　　　线程不安全,效率高

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