Java集合总结

集合总结

泛型:

泛型存在的意义:

我们知道集合可以存储多种数据类型的元素,这个特点是集合的好处，同时也是集合的弊端。假设我们使用集合存储了多种数据类型的元素，那么后期我们需要对这些数据进行操作的时候，我们就需要遍历集合，获取每一个元素，然后判断当前这个元素的数据类型是什么，针对不同的数据类型，我们需要做不同的处理,比较麻烦.为简化集合的使用,Jdk1.5以后就提供了一种安全机制，就是泛型。使用泛型来限定我们集合中可以存储数据的元素类型。

泛型的概念:

泛型是JDK1.5后提供的新特性,是一种参数化类型.主要是将我们需要使用的类型进行参数化,提供了编译时安全检测机制. 类似方法定义上的形式参数,定义时我们并不知道其具体值,调用方法时才知道. 泛型也类似,在定义时不知道具体的数据类型,在使用时才知道.

泛型的定义及定义位置：

   定义格式:     <标识符1 , 标识符2, ....>
   定义位置：     类，方法， 接口

泛型的好处:

①将运行期的错误提前到编译期;
②避免强制类型转换

泛型通配符:

 泛型通配符：？  表示的意思是不确定的类型
？extends E ： 向上限定，表示的是E或者E的子类
？super E ：向下限定，表示的是E或者E的父类 

泛型通配符常见的使用场景:

在方法上定义了一个集合类型，不明确集合类型中所存储的数据的元素类型，此时我们就需要去使用泛型通配符.
目的：就是为了提高方法的灵活性.
例如:

// 后期在调用method方法的时候需要传递一个Collection的子类对象，而这个子类对象中的元素的数据类型可以是Number或者Number的子类
public static void method(Collection<? extends Number> collection) {
方法体....
}

集合

集合的体系结构

Collection集合的常见方法(增/删/改/查):

boolean add(E e);										 // 添加元素
boolean remove(Object o);								 // 从集合中移除指定的元素
default boolean removeIf(Predicate<? super E> filter);	// 根据指定的条件从集合中删除元素
void clear();											 // 清空集合中的元素
boolean contains(Object o);								// 判断集合中是否存在指定的元素
boolean isEmpty()										// 判断集合是否为空
int size()						                       // 集合的长度，也就是集合中元素的个数

//根据指定的条件从集合中删除元素方法演示:
//需求:删除集合中长度为3的元素
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);    //仅有test一个抽象方法
    }
//removeIf(Predicate<? super E> filter),该方法需要一个Predicate类型的参数,Predicate为一个函数式接口,所以在使用removeIf方法时可传入Predicate接口的匿名内部类或者Lambdab表达式
代码如下:
Collection<String> list = new ArrayList<>();   //多态形式创建一个Collection集合
            list.add("aaa");                    //boolean add(E e);添加元素
            list.add("abc");
            list.add("ccc");
            list.add("edfg");
            list.add("2222");
            list.add("王二麻子");
            //1.匿名内部类:
            list.removeIf(new Predicate<String>() {
                @Override
                public boolean test(String s) {
                    return s.length()==3;   //删除长度为3的元素
                }
            });
            //2.Lambda表达式:
             list.removeIf(s ->s.length()==3);   
            System.out.println(list);
            
以上两种方式的运行结果:[edfg, 2222, 王二麻子]

Collection是接口,用多态形式创建对象:

举例:
// Collection后面<>中使用了String这个数据类型，表示的含义就是用来限定我们这个集合对象中只能存储String类型的元素
Collection<String> collection = new ArrayList<>();

Collection集合的遍历操作:

1.迭代器. //Collection集合特有

//1.获取迭代器对象:
Iterator<E> iterator();		// Collection集合中提供的方法，用来获取迭代器，<>中定义的元素类型就是集合中存储的元素类型
//2.调用迭代器对象方法来获取元素
E next();				// 用来获取元素的
boolean hasNext();	// 判断集合中是否存在下一个元素

2.增强for循环. //jdk1.5以后提供的一个新的语法，主要是用来遍历Collection集合和数组的。

//增强for循环格式:
for(元素数据类型 变量名 : 要遍历的数组或者集合的名称) {
	操作变量
}
//温馨提示:IDAE中可快捷自动生成增强fo格式:      要遍历的数组或者集合的名称.for

3.forEach方法

//forEach方法
list.forEach(Consumer<? super T> action){ }          //forEach方法,需要传入Consumer类型的参数,如上,是个函数式接口.可通过Lambda表达式来传入参数.

Collection集合练习

/**
 * 需求：使用Collection集合来存储学生对象并进行遍历
 * 分析：
 * 1、	创建一个Collection集合对象
 * 2、	创建一个学生类(Student --- > 姓名 ， 年龄)
 * 3、	创建学生对象
 * 4、	把学生对象添加到集合中
 * 5、	对集合进行遍历获取每一个学生对象，然后将学生对象的信息打印到控制台
 * a)	使用迭代器进行遍历
 * b)	使用增强for循环进行遍历
 */
 学生类：
 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 +
                '}';
    }
}

测试类：
public class CollectionTest1 {
    public static void main(String[] args) {
        Collection<Student> list=new ArrayList<>();
        Student stu1=new Student("hanhan",23);
        Student stu2=new Student("xiaoming",28);
        Student stu3=new Student("dalang",33);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        //使用迭代器进行遍历
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("*****************************************");
        //使用增强for循环进行遍历
        for (Student student : list) {
            System.out.println(student);
        }
        System.out.println("*****************************************");
        //forEach 方法
        list.forEach(student -> System.out.println(student));
    }
}

List集合特点

1.元素是有序的(存入和取出顺序一致); 2.元素可以重复; 3.每个元素都存在索引值

List集合特有方法

void add(int index,E element)				// 在此集合中的指定位置插入指定的元素
E remove(int index)							// 删除指定索引处的元素，返回被删除的元素
E set(int index,E element)					// 修改指定索引处的元素，返回被修改的元素
E get(int index)							// 返回指定索引处的元素

List集合下常见的类ArraryList/LinkdeList…

ArrayList集合源码