Collection集合的简单介绍及使用（上）

Collection集合的简单介绍及使用（上）

这是Collection集合的简单介绍及使用（下）的地址。

集合的概念：集合是对象的容器，定义了对多个对象进行操作的常用方法，可实现数组的功能。

集合与数组的区别：数组长度固定，可以存储基本类型和引用类型；集合长度不固定，只能存储引用类型。

# Collection体系集合

一、List接口与实现类

• 特点：有序、有下标、元素可以重复。
• 继承Collection接口。

（1）ArrayList

# 底层结构是数组，添加原理是数组扩容，一般情况下扩容1.5倍，查询快、增删慢。

代码示例：

public class TestArrayList {
	public static void main(String[] args) {
		//创建集合
        ArrayList arrayList=new ArrayList();
        //1添加元素
        Students s1=new Students(101,"刘德华", 20);
        Students s2=new Students(102,"郭富城", 22);
        Students s3=new Students(103,"梁朝伟", 18);
        //add是将指定的元素添加到此列表的尾部。
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        //size是返回此列表中的元素个数。
        System.out.println("元素个数:"+arrayList.size());
        for (int i = 0; i < arrayList.size(); i++) {
            //get是返回此列表中指定位置上的元素。
            System.out.println(arrayList.get(i));
        }
        //2删除元素
        //remove是移除此列表中指定位置上的元素。
        arrayList.remove(new Students(101,"刘德华", 20));
        System.out.println("删除之后:"+arrayList.size());
        //3遍历元素
        for (int i = 0; i < arrayList.size(); i++) {
            //get是返回此列表中指定位置上的元素。
            System.out.println(arrayList.get(i));
        }
        //4判断
        //contains是如果此列表中包含指定的元素，则返回 true。
        System.out.println(arrayList.contains(new Students(104,"梁朝伟", 18)));
        //isEmpty是如果此列表中没有元素，则返回 true
        System.out.println(arrayList.isEmpty());
        //5查找
        //indexOf是返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回-1。
        System.out.println(arrayList.indexOf(new Students(104,"梁朝伟", 18)));
	}
}

（2）LinkedList

# 底层结构是双向链表，增删快，查询慢。

代码示例：

public class Demo2 {
	public static void main(String[] args) {
		//创建集合
        LinkedList linkedList=new LinkedList();
        //1添加元素
        Students s1=new Students(101,"刘德华", 20);
        Students s2=new Students(102,"郭富城", 22);
        Students s3=new Students(103,"梁朝伟", 18);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println("元素个数:"+linkedList.size());
        for(int i=0;i<linkedList.size();i++) {
            System.out.println(linkedList.get(i));
        }
        //2删除
        linkedList.remove(new Students(101,"刘德华", 20));
        System.out.println("删除之后:"+linkedList.size());
        //3遍历元素
        for(int i=0;i<linkedList.size();i++) {
            System.out.println(linkedList.get(i));
        }
        //4判断
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.isEmpty());
	}
}

ArrayList和LinkedList区别：

• 线程都是不安全的。
• 使用的方法都是一样的，都可以使用4种遍历方式。
• ArrayList存储结构是数组，查找、遍历效率高。
• LinkedList存储结构是双向链表，删除、添加效率高。

（3）Vector

# 元老级别的集合，底层结构是数组，用法跟ArrayList，LinkedList一样，不过方法不一样，查询快、增删慢，线程安全。

代码示例：

public class Demo04 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        //添加
        vector.addElement("a");
        vector.addElement("b");
        vector.addElement("c");
        //遍历，其他4种遍历方式也可以使用
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            System.out.println(elements.nextElement());
        }
    }
}

（4）Stack

# 模拟堆栈的集合，特点是后进先出，用完即删，是线程安全的数组集合。

代码示例：

public class Demo05 {
    public static void main(String[] args) {
        Stack stack = new Stack();
        //添加
        stack.push("a");
        stack.push("b");
        stack.push("c");
        stack.push("d");
        System.out.println(stack.size());
        //遍历的话，使用其他4种方式也是可以的
        //stack.empty()判断stack集合是否为空
        while (!stack.empty()){
            //从最后一个元素开始，一个一个的移出来
            System.out.println(stack.pop());
        }
        System.out.println(stack.size());
    }
}
//输出结果：
//4
//d
//c
//b
//a
//0

（5）泛型

概念：

• Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
• 用来约束集合存储的数据类型，一定程度上提高了效率。
• 常见形式有泛型类、泛型接口、泛型方法。

语法：

• <T,…> T称为类型占位符，表示一种引用类型。
• <? super User> 泛型为User类或者是其父类。
• <? extends User> 泛型为User类或其子类。

优点：

• 提高代码的重用性。
• 防止类型转换异常，提高代码的安全性。

代码示例：

public class Demo01 {
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<>();
        list.add("a");	//会报错，因为泛型规定了只能添加User类的对象，不能添加其他对象
        list.add(1);	//会报错，因为泛型规定了只能添加User类的对象，不能添加其他对象
        list.add(true);	//会报错，因为泛型规定了只能添加User类的对象，不能添加其他对象
        list.add(new User("张三",18));	//添加成功，因为添加的是User类的对象
    }
}

（6）迭代器等遍历Collection集合的方式

# 迭代器只能服务于Collection集合。

# 帮助我们快速遍历集合的工具。

# 迭代器其实就是指针，先读取集合中的一个数据，读完以后又指向下一个数据。

# 迭代器只能读、不能改，效率要比for循环要高。

代码示例：下面列出了遍历集合的多种方式

public class Demo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        
        System.out.println("------1、for--------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        System.out.println("------2、foreach--------");
        for (String str:list) {
            System.out.println(str);
        }
        
        System.out.println("------3、迭代器----------");
        //获取迭代器
        Iterator<String> it = list.iterator();
        //迭代是使用循环实现，循环的终止条件：集合中没元素, hasNext()返回了false
        while (it.hasNext()){
            System.out.println(it.next());
        }
        
        System.out.println("------4、列表迭代器----------");
        //列表迭代器和Iterator的区别，ListIterator可以向前或向后遍历，添加、删除、修改元素
		ListIterator lit=list.listIterator();
		System.out.println("------使用列表迭代器从前往后-------");
		while(lit.hasNext()) {
			System.out.println(lit.nextIndex()+":"+lit.next());
		}
        System.out.println("------使用列表迭代器从后往前------");
		while(lit.hasPrevious()) {
			System.out.println(lit.previousIndex()+":"+lit.previous());
		}
        
        System.out.println("------5、JDK1.8才有的lambda表达式------");
        //item是标识符，是一个循环值
        list.forEach(item->{
            System.out.println(item);
        });
        
    }
}