Java基础——ArrayList、Vector、LinkedList 、泛型

1.ArrayList的遍历

除了迭代器和普通for循环可以遍历ArrayList外，JDK1.8新增的一个方法也能遍历集合；
void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 。

自定义Student对象

package com.xawl.demo;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类（存储自定义对象并遍历）

package com.xawl.demo;

import java.util.ArrayList;
import java.util.function.Consumer;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("张三",23));
        list.add(new Student("李四",24));
        list.add(new Student("王五",25));
        list.add(new Student("赵六",26));
        list.forEach(new Consumer() {
            @Override
            public void accept(Object stu) {
                System.out.println(stu);
            }
        });
    }
}

2.Vector的特有功能

Vector类概述:	Vector 类可以实现可增长的对象数组 , Vector 是同步的。 
Vector类特有功能:
	public void addElement(E obj)    添加指定的组件到这个向量的结束，增加其大小由一个。 
	public E elementAt(int index)  返回指定索引处的组件
	public Enumeration elements()  返回此向量的组件的枚举
	 E firstElement()  返回此向量的第一个组件（位于索引 0) 处的项）。   
      E lastElement()  返回此向量的最后一个组件。 
      void insertElementAt(E obj, int index)  将指定对象作为此向量中的组件插入到指定的 index 处。 

3.LinkedList的特有功能

LinkedList类概述:  List 接口的链接列表实现 , 此实现不是同步的.
LinkedList类特有功能
	public void addFirst(E e)及addLast(E e)  向集合中第一个位置和最后一个位置添加元素
	public E getFirst()及getLast() 获取集合中第一个或者最后一个元素
	public E removeFirst()及public E removeLast()删除集合中第一个和最后一个元素

4.ArrayList的案例

注意：String中重写了equals方法，如果比较对象中没有重写equals()方法，需要重写过后进行比较
ArrayList去除集合中字符串的重复值（删除重复元素）

package com.xawl.demo;
import java.util.ArrayList;
/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test2 {
    public static void main(String[] args) {
        //ArrayList去除集合中字符串的重复值(字符串的内容相同)
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("dddddd");
        list.add("bbb");
        list.add("ddd");
        list.add("eee");
        list.add("eee");
        for (int i = 0; i < list.size()-1; i++) {
            for (int j = i+1; j < list.size(); j++) {
                if (list.get(i).equals(list.get(j))){
                    list.remove(list.get(j));
                    j--;//可以防止跳过某一个元素
                }
            }
        }
        System.out.println(list);
    }
}

ArrayList去除集合中字符串的重复值（创建新集合）

package com.xawl.demo;

import java.util.ArrayList;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        ArrayList list2=new ArrayList();//创建新集合保存旧集合中未重复元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("dddddd");
        list.add("bbb");
        list.add("ddd");
        list.add("eee");
        list.add("eee");
        for (int i = 0; i < list.size(); i++) {
            if (!list2.contains(list.get(i))){
                list2.add(list.get(i));
            }
        }
        System.out.println(list2);
    }
}

5.泛型概述和基本使用

泛型概述:是一种把类型明确的工作
推迟到创建对象
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。

泛型的格式 : <数据类型> 这里的数据类型只能是引用数据类型.
泛型好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效 但在运行期就擦除了

ArrayList存储自定义对象并遍历泛型版
—Student类仍采用上面的代码

package com.xawl.demo2;
import java.util.ArrayList;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("张三",23));
        list.add(new Student("李四",24));
        list.add(new Student("王五",25));
        list.add(new Student("赵六",26));
        for (Student student : list) {
            System.out.println(student.getName()+"==="+student.getAge());
        }
    }
}

泛型的由来:通过Object转型问题引入
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

6.泛型类、泛型方法、泛型接口

泛型类

泛型类概述:	        把泛型定义在类上
定义格式:		public class 类名<泛型类型1,…>
注意事项:		泛型类型必须是引用类型
案例演示:		泛型类的使用

泛型方法

泛型方法概述:	把泛型定义在方法上
定义格式:		public <泛型类型> 返回类型 方法名(泛型类型 变量名)

泛型接口

泛型接口概述:	把泛型定义在接口上
定义格式:		public interface 接口名<泛型类型>

7.泛型的通配符

泛型通配符<?>:		任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E:			向下限定，E及其子类
? super E:			向上限定，E及其父类
泛型高级之通配符的基本使用
	/**
	 * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
	 */
	Collection<Object> col1 = new ArrayList<Object>() ;
	Collection<Object> col2 = new ArrayList<Animal>() ;//报错

	// ? 表示任意的数据类型
	Collection<?> col5 = new ArrayList<Object>() ;
	Collection<?> col6 = new ArrayList<Animal>() ;

// ? extends E : 向下限定	, ? 表示的是E或者E的子类
	//	Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
		Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
		Collection<? extends Animal> col11 = new ArrayList<Dog>() ;


// ? super E:  向上限定 , ? 表示的是E或者E的父类
   //Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错
	Collection<? super Animal> col13 = new ArrayList<Object>() ;
	Collection<? super Animal> col14 = new ArrayList<Animal>() ;

8.增强for

增强for：简化数组和Collection集合的遍历

格式：
	for(元素数据类型 变量 : 数组或者Collection集合) {
		使用变量即可，该变量就是元素
	}

简化遍历
	注意事项：增强for的目标要判断是否为null
	注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常

9.可变参数

可变参数概述:	定义方法的时候不知道该定义多少个参数。
格式:      修饰符 返回值类型 方法名(数据类型…  变量名){}
注意事项：
	a:	这里的变量其实是一个数组
	b:	如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

	// 可变参数
public static int add(int... a){
	// 定义一个累加变量
	int sum = 0 ;
	for(int s : a ){
		sum += s ;
	}
	return sum;
}

10.其他

静态导入语法

import static java.lang.Math.random; 直接导入到静态方法
import static java.lang.Math.*; 可以使用统配符把Math类下的所有静态方法都导入


使用时可以不用写类名，直接调用方法即可
random();

Arrays工具类的asList()方法的使用
Arrays工具类的asList(T… t)方法的使用: 将数组转换成集合

注意事项:	得到的集合长度是不可变的 ,不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)
			只能获取元素(get)

集合嵌套之ArrayList嵌套ArrayList

我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
	但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。	
	而我现在有多个ArrayList<Student>。

package com.xawl.demo2;

import java.util.ArrayList;

/**
 * @Author:liger
 * @Description:爱学Java
 */
public class Test2 {
    public static void main(String[] args) {
    //定义一个集合存储第一个班的信息
        ArrayList<Student> student1 = new ArrayList<>();
        student1.add(new Student("张飞",30));
        student1.add(new Student("关羽",50));
        student1.add(new Student("刘备",60));
        //定义另一个集合存储第二个班的信息
        ArrayList<Student> student2 = new ArrayList<>();
        student2.add(new Student("杨过",30));
        student2.add(new Student("小龙女",50));
        student2.add(new Student("郭靖",60));
        //定义一个大的集合存储前两个集合的信息的
        ArrayList<ArrayList<Student>> students = new ArrayList<>();
        students.add(student1);
        students.add(student2);
        //双层for循环遍历集合中学生的信息
        for (ArrayList<Student> student : students) {
            for (Student student3 : student) {
                System.out.println(student3.getName() + "===" + student3.getAge());
            }
        }
    }
}