collection集合——List(ArrayList、LinkList、Vector)、Set(HashSet、TreeSet)

一、集合

特点

            1.        长度可以发生改变

            2.        只能存储对象

            3.        可以存储多种类型对象

与数组区别

数组	集合
长度 : 长度 固定	可变
存储元素: 基本类型/引用类型	引用类型
元素类型的一致性: 必须一致	可以不一致

3.常用集合的分类：
Collection 接口的接口 对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
│—————-├ ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
│—————-└ Vector 接口实现类 数组， 同步， 线程安全
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口： 仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组）存储元素
│————————└ LinkedHashSet 链表维护元素的插入次序
└ —————-TreeSet 底层实现为二叉树，元素排好序

二、collecton集合基本功能

A:添加功能

1. boolean add(Object obj):向集合中添加一个元素
2. boolean addAll(Collection c)：向集合中添加一个集合的元素。

System.out.println("~~~~~~~~~~~添加功能~~~~~~~~~~");
		list.add("增加一个元素");
		List<String> b = new ArrayList<String>();
		b.add("B集合的第一个元素");
		b.add("b集合中第二个元素");
		list.addAll(b);  //将B集合元素添加到A集合中
输出：

B:删除功能

1. void clear()：删除集合中的所有元素。
2. boolean remove(Object obj)：从集合中删除指定的元素
3. boolean removeAll(Collection c):从集合中删除一个指定的集合元素。

System.out.println("~~~~~~~~~~~删除功能~~~~~~~~~~");
		b.clear();  //删除b集合中的的所有元素	
		boolean t = list.remove("年后");  //从list集合中删除指定  （元素/索引（所在元素））第一次出现（索引小的）
		System.out.println("删除  年后  元素："+ t);
		boolean ts = list.removeAll(b);  //从list集合中删除b集合中的元素
		System.out.println(ts);
		
		//输出：
		~~~~~~~~~~~删除功能~~~~~~~~~~
删除  年后  元素：true
false

C:判断功能

1. boolean isEmpty()：判断集合是否为空。
2. boolean contains(Object obj)：判断集合中是否存在指定的元素。
3. boolean containsAll(Collection c)：判断集合中是否存在指定的一个集合中的元素。

System.out.println("~~~~~~~~~~~~判断功能~~~~~~~~~~");
		boolean t1 = list.isEmpty();
		System.out.println("list集合是否为空：" + t1);
		boolean t2 = list.contains("年后");
		System.out.println("list中是否包含  年后  元素：" + t2);
		System.out.println("年后所在索引：" + list.indexOf("年后"));
		List<String> c = new ArrayList<String>();
		c.add("c集合的第一个元素");
		c.add("c集合中第二个元素");
		list.add("c集合的第一个元素");
		boolean t3 = list.containsAll(c);
		System.out.println("list是否包含c集合中的元素：" + t3);//list包含c集合中的所有元素即为true
输出：
~~~~~~~~~~~~判断功能~~~~~~~~~~
list集合是否为空：false
list中是否包含  年后  元素：true
年后所在索引：2
list是否包含c集合中的元素：false

D:遍历功能

1. Iterator iterator():就是用来获取集合中每一个元素。

Iterator<String> its = list.iterator();
		boolean t4 = its.hasNext();  //判断是否还有下一个元素
		System.out.println(t4);
		String x = its.next();   //返回上个元素 ，指向上个元素和下一个元素的中位置
		System.out.println(x);
输出：
~~~~~~~~~~~~遍历功能~~~~~~~~~~~
true
nice

E:长度功能

1. int size():获取集合中的元素个数

System.out.println("~~~~~~~~~~~~~长度~~~~~~~~~~~~");
		System.out.println(list.size());

F:交集功能

boolean retainAll(Collection c):判断两个集合中是否有相同的元素。

System.out.println("~~~~~~~~~~~~~交集功能~~~~~~~~~~~~");
		System.out.println("list和c集合中是否具有相同元素：" + list.retainAll(c));

G:把集合转换成数组

Object[] toArray():把集合变成数组。

System.out.println("~~~~~~~~~~~~~集合变数组~~~~~~~~~~~~");
		Object[] arrays = list.toArray();
		for (Object a : arrays){
			System.out.println(a);
			System.out.println(a instanceof String);
		}

三、3种遍历方式

public static void main(String[] args) {
		
		//1、有序、可以重复
		List<String> list = new ArrayList<String>();
		list.add("年后");
		list.add("nice");
		list.add("asas");
		list.add("年后");		
		//2、遍历：使用for循环
		System.out.println("~~~~~~~~~~~~遍历：使用for循环~~~~~~~~~~~~");
		for(int i=0; i<list.size(); i++){
			System.out.println(i + ": " + list.get(i));
			
		}
		//2、遍历：使用迭代
		System.out.println("~~~~~~~~~~~~~~~遍历：使用迭代~~~~~~~~~~~~~~~~~~");
		Iterator<String> it = list.iterator();
		while (it.hasNext()){
			String t = it.next();
			System.out.println(t);
		}
		//3、遍历： 使用for-each
		System.out.println("~~~~~~~~~~~~~遍历： 使用for-each~~~~~~~~~~~~~");
		for (String l : list){
			System.out.println(l);
		}

	}

四、List集合

特点： List接口下的集合元素存储有序，可以重复。

List的特有功能
          A:添加功能

              void add(int index, Object obj):在指定位置添加元素

          B:删除功能

              Object remove(int index):根据指定索引删除元素，并把删除的元素返回。

          C:修改功能

              Object set(int index, Object obj):把指定索引位置的元素修改为指定的值，返回修改前的值。

          D:获取功能

              int indexOf(Object o):返回指定元素在集合中第一次出现的索引

              Object get(int index):获取指定位置的元素

              ListIterator listIterator()：列表迭代器

          E:截取功能

              List subList(int fromIndex, int toIndex)：截取集合。

public static void main(String[] args) {
		
		//1、有序、可以重复
		List<String> list = new ArrayList<String>();
		list.add("年后");
		list.add("nice");
		list.add("asas");
		list.add("年后");
		
		System.out.println("~~~~~~~~~~~删除功能~~~~~~~~~~~");
		boolean li = list.remove("年后");//删除第一次出现的指定元素
		System.out.println(li);
		System.out.println("~~~~~~~~~~修改功能~~~~~~~~~~~");
		String str = list.set(1, "客行");//修改指定索引上的元素，返回修改前的元素
		System.out.println(str);
		System.out.println("~~~~~~~~~~~~~获取功能~~~~~~~~~~~");
		int index = list.indexOf("年后");//返回指定元素在集合中第一次出现的索引，没有则为-1
		System.out.println(index);
		String o = list.get(2);
		System.out.println(o);  //获取指定索引上的元素
		System.out.println("~~~~~~~~~~~~~截取功能~~~~~~~~~~~");
		List<String> subList = list.subList(0, 1);
		System.out.println("~~~~~~~~~~~~~遍历： 使用for-each~~~~~~~~~~~~~");
		for (String sub : subList){
			System.out.println(sub);
		}
	}	

五、Set 接口

Set接口下的元素无序，不可以重复。其下面分为HashSet和TreeSet。

（一）、HashSet接口

 HashSet
           底层数据结构是哈希表，线程不安全，效率高。

           保证唯一性依赖两个方法：hashCode()和equals()。

           顺序：

                   判断hashCode()值是否相同。

                   相同：继续走equals(),看返回值

                               如果true：就不添加到集合。

                               如果false：就添加到集合。

                   不同：就添加到集合。

1、HashSet类（散列存放）

        Java.util.HashSet类实现了Java.util.Set接口。

         l  它不允许出现重复元素；

         l  不保证集合中元素的顺序

         l  允许包含值为null的元素，但最多只能有一个null元素。

		Set<Object> set =new  HashSet<Object>();
		set.add("九霄");
		set.add("科学");
		set.add("w");
		set.add(new Integer(1));
		set.add(1);  //重复元素，未被添加
		set.add(1);  //重复元素，未被添加
		set.add("科学");  //重复元素，未被添加
		set.add(new Date());
		
		System.out.println("set大小：" +set.size());
		//1、遍历，通过迭代器
		Iterator<Object> it = set.iterator();
		while (it.hasNext()){
			Object str =  it.next();
			System.out.println(str);
		}
		set.remove("科学");
		System.out.println("删除后set集合大小："+ set.size());
		boolean ts = set.contains("九霄");
		System.out.println(ts);
		
		System.out.println("~~~~~~~~~通过 for-each 循环 ~~~~~~~~~");
		//2、遍历： 通过 for-each 循环 
		for(Object s : set){
			System.out.println(s);
		}
	
	输出：
	set大小：5
w
1
九霄
科学
Tue Apr 20 09:58:50 CST 2021
删除后set集合大小：4
true
~~~~~~~~~通过 for-each 循环 ~~~~~~~~~
w
1
九霄
Tue Apr 20 09:58:50 CST 2021	

（二)、TreeSet接口

 TreeSet
            底层数据结构是二叉树，线程不安全，效率高。

            保证元素唯一性的方法时根据返回值是否是0。

            保证排序的两种方式：

                    自然排序（元素具备比较性）：实现Comparable接口

                    比较器排序（集合具备比较性）：实现Comparator接口

tree.add("东君");
		tree.add(""); //插入空值
		tree.add("依水");
		tree.add("东君");  //重复元素不插入
		tree.add("星尘");
		//1、遍历：通过迭代器
		Iterator<String> at = tree.iterator();
		while (at.hasNext()){
			String str = at.next();
			System.out.println(str);
		}
		System.out.println("tree容量：" + tree.size());
		//1、tree集合中是否包含这个元素
		boolean t = tree.contains("依水");
		System.out.println(t);
		
		System.out.println("是否为空集合: " + tree.isEmpty());
		
		//删除一个元素
		boolean ir = tree.remove("东君");
		System.out.println("删除的元素是否存在： " + ir);
		
	输出：
	~~~~~~~~TreeSet~~~~~~~~~~

东君
依水
星尘
tree容量：4
true
是否为空集合: false
删除的元素是否存在： true

参考：文章：https://blog.csdn.net/haovip123/article/details/45423683