泛型以及ArrayList类

本文主要内容：
1.ArrayList与LinkList区别
2.泛型的基本使用
3.自动装箱与拆箱
4.ArrayList类
5.杨辉三角
1.ArrayList 和 LinkedList 的区别是什么？
ArrayList是封装的数组，LinkList是封装的链表，ArrayList可以支持随机访问，时间复杂度为1，LinkList的时间复杂度为n，且性能高。
2.泛型的基本使用：
泛型时编译期间的魔法，类的字节码中没有泛型，运行期间也没有。

• 诞生的意义
  顺序表本身是一种抽象数据类型，保存的数据不只是int类型。如果没有泛型的支持，我们必须为每一种要保存的数据类型定义一个顺序表。为了解决类似顺序表的结构，支持通用类型元素的类型。为了解决这个问题：
  第一阶段：Object是所有类的基类
  元素类型：Object类类型的引用，Object引用可以指向任意类的对象
  第二阶段：新的问题
  无法在编译期间快速找到一些问题，可能会出现运行时异常：ClassCastException

    ArrayList list = new ArrayList();
    list.add(new Person());
    String o = (String)list.get(0);//（错误）运行期间会抛异常

为了让错误尽可能在编译期间出现,引入泛型：

    ArrayList<Person> list = new ArrayList<>();
    list.add(new Person());
    String o = (String)list.get(0);//编译时报错

• 泛型类的使用
  （1）如何使用泛型类
  new ArrayList<String[类型变量的实参]>{}

1)嵌套
 ArrayList<ArrayList<String>> q;
 Set<Map.Entry<String,String>>[Map.Entey<String,String>是键值对]
2)类型推导
ArrayList<String> a = new ArrayList<String>();[可推导]
3）多类型参数
Map<String,Integer> grade;

（2）自己定义泛型类
class ArrayList<类型变量形参>{}
3.自动装箱与自动拆箱[编译期间的魔法]
（1）自动装箱

class ArrayList<E>{
    E[] array; //Object[] array
    int size
}

顺序表中的里面的元素为int，怎么办？引出包装类

int i = 10; 
Integer i1  = i;//装箱
Integer i2 = new Integer(i);//装箱

基本数据类型的包装类：大多数将首字母大写。特殊：char（Character）、int（Integer）
（2）自动拆箱

Integer i = new Integer(10);//装箱
int j = i;//拆箱
int m = i.intValue();//拆箱

4.List接口

（1）ArrayList的构造方法
ArrayList() ：构造一个初始容量为十的空列表。
ArrayList(Collection<? extends E> c) ：构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
ArrayList(int initialCapacity) ：构造具有指定初始容量的空列表。
（2）ArrayList的重要方法
add(E e) ：将指定的元素追加到此列表的末尾。
void add(int index, E element) ：在此列表中的指定位置插入指定的元素。
addAll(Collection<? extends E> c) ：按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
void clear() ：从列表中删除所有元素。
contains(Object o) ：如果此列表包含指定的元素，则返回 true 。
ensureCapacity(int minCapacity) ：如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。
get(int index) ：返回此列表中指定位置的元素。
int indexOf(Object o) ：返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
isEmpty() ：如果此列表不包含元素，则返回 true 。
代码实现：

public class Test1 {
     private static class Person{
        private String name;
        private int age;
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add("Java");
        list.add("C++");
        list.add(2,1);
        System.out.println(list);
        Person person = new Person("小明",20);
        list.add(person);
        for(Object o:list){
            System.out.println(o);
        }
        System.out.println(list.contains("Java"));
        Object o = list.get(2);
        System.out.println(o);
        list.clear();
        System.out.println(list.isEmpty());
    }
}
//运行结果：
[Java, C++, 1]
Java
C++
1
Person{name='小明', age=20}
true
1
true

5.杨辉三角

public class Test2 {
    //打印杨辉三角
    public static List<List<Integer>> generate (int numRows){
         List<List<Integer>> list = new ArrayList<>(numRows);
         //list是一种引用，List类型的接口引用，list逻辑上是一个线性表，其元素类型为List<Integer>
        for(int i = 0;i<numRows;i++){
            List<Integer> arrayList = new ArrayList<>(i+1);
            list.add(arrayList);
            if(i == 0){
                arrayList.add(1);
            }else if(i == 1){
                arrayList.add(1);
                arrayList.add(1);
            } else {
                List<Integer> num = list.get(i);
                num.add(1);
                for(int j = 1;j < i;j++){
                    num.add(list.get(i-1).get(j-1)+list.get(i-1).get(j));
                }
                num.add(1);
            }
        }
        return list;
    }
    public static List<List<Integer>> generate1 (int numRows) {
         List<List<Integer>> list = new ArrayList<>(numRows);
         for(int i = 0;i< numRows ;i++){
             List<Integer> arrayList = new ArrayList<>(i+1);
             list.add(arrayList);
             arrayList.add(1);
             for(int j = 1;j < i;j++){
                 arrayList.add(list.get(i-1).get(j-1)+list.get(i-1).get(j));
             }
             if(i != 0) {
                 arrayList.add(1);
             }
         }
         return list;
    }
    public static void main(String[] args) {
        List<List<Integer>> lists = generate(5);
        System.out.println(lists);
        List<List<Integer>> lists1 = generate1(5);
        System.out.println(lists1);
      }
}
//运行结果：
[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]
[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]]

6.链表