JAVA基础-集合Collection

Posted 2020-12-14 不愿透露姓名的王建森

首先总结一下集合的体系：

集合 的体系：
------------| Collection 单例集合的根接口
----------------| List 如果是实现了List接口的集合类，具备的特点： 有序，可重复。
-------------------| ArrayList 底层是维护了一个Object数组实现的。 特点： 查询速度快，增删慢。
-------------------| LinkedList 底层是使用了链表数据结构实现的， 特点： 查询速度慢，增删快。
-------------------| Vector(了解即可) 底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低。

----------------| Set 如果是实现了Set接口的集合类，具备的特点： 无序，不可重复。
-------------------| HashSet 底层是使用了哈希表来支持的，特点： 存取速度快.
-------------------| TreeSet 如果元素具备自然顺序 的特性，那么就按照元素自然顺序的特性进行排序存储。

Collection

首先我们先来看一下JAVA中util包中几个集合之间的继承或实现关系：

可以看出Collection是所有集合的源头（实现接口）。

因为Colleciton是接口，所以我们不能直接实现他，只能利用子类向上转型来实现它。

Collection c = new ArrayList();

一些简单的API代码:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {
	
	public static void main(String[] args) {
		//集合 导包 全都是java.util包下的
		//无序 可重复
		//接口  向上转型特点  只能调用共有的属性和方法
		Collection c1 = new ArrayList();
		Collection c2 = new ArrayList();
		c2.add(10);
		c2.add(true);
		c2.add(33.4);
		c2.add("ddd");
		//1.添加    
		c1.add(10);
		c1.add(true);
		c1.add(33.4);
		c1.add("ddd");
		//添加集合
		c1.addAll(c2);
		System.out.println(c1);
		//2.清空全部元素
        //c1.clear();
		System.out.println(c1);
		c1.add(33.4);
		c1.add("ddd");
		//3.移除单个元素
		c1.remove("ddd");//移除里面的元素
		//c1.removeAll(c2);//移除里面的集合
		System.out.println(c1);
		//4.判断此集合是否是空元素集合
		System.out.println(c1.isEmpty());
		//5.判断此元素是否存在集合中  有返回true
		System.out.println(c1.contains(33.4));
		//c1.containsAll(c)判断集合是否存在此集合中
		//6.长度
		System.out.println("集合长度："+c1.size());
		
		//遍历  只要集合中发现了迭代器方法  都可以使用foreach （for增强） 去遍历集合
		//1.foreach遍历 for(数组或集合数据类型   起个名字 ：数组名或集合名){输出起的这个名}
		for(Object obj:c1) {
			System.out.println(obj);
		}
		System.out.println("---------------------------------------");
		//2.使用迭代器遍历集合
		//得到迭代器
		Iterator i1=c1.iterator();
		//判断游标后面有没有元素 有就返回true
		while(i1.hasNext()) {
			//返回游标下一个元素 并把游标位置移动到下一个位置
			System.out.println(i1.next());
		}
		//i1.hasNext()他返回的就是false
		System.out.println("i2------------------------------");
		//集合中有序无序 你要看他可不可以用下标访问元素
		Iterator i2=c1.iterator();
		while(i2.hasNext()) {
			//返回游标下一个元素 并把游标位置移动到下一个位置
			System.out.println(i2.next());
		}
		
	}
}

List

List和Collection相比，List是有序的集合，可以通过下标来索引。

其他的东西并不太特殊。

其中List的迭代器实现中，提供类listIterator()方法，下面总结了一下listIterator和Iterator两个迭代器不同的地方：

1. 使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。

2. ListIterator有add方法，可以向List中添加对象，而Iterator不能。

3. ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。

4. ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。

5. 都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。

下面是一些简单的API：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {

	public static void main(String[] args) {
		
		List l1=new ArrayList<>();
		//1.添加
		l1.add("ddd");
		l1.add(1);
		l1.add("gggg");
		l1.add(1);
		l1.add(1, "张三");
		System.out.println(l1);
		//2.移除
		System.out.println(l1.remove("gggg"));
		System.out.println(l1);
		//3.清空  长度 还有空集合判断  判断元素是否包含 跟collection一样的
		//4.通过下标得到元素
		System.out.println(l1.get(1));
		//5 替换
		l1.set(2, "李四");
		//6 indexof 返回此元素第一次出现的下标值 （索引值） 没有-1 lastindexof 返回最后一次出现的下标值
		System.out.println(l1.indexOf("李四"));
		//遍历  for循环  foreach  迭代器
		System.out.println("for循环--------------------");
		for (int i = 0; i <l1.size(); i++) {
			System.out.println(l1.get(i));
		}
		System.out.println("foreach---------------------");
		//foreach
		for(Object o1:l1) {
			System.out.println(o1);
		}
		System.out.println("迭代器--------------------");
		Iterator iterator = l1.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		System.out.println("列表迭代器-----------------");
		//列表迭代器 正序
		ListIterator listIterator = l1.listIterator();
		while(listIterator.hasNext()) {
			System.out.println(listIterator.next());
		}
		//倒序需要游标最后的时候使用打印才出内容
		System.out.println("列表迭代器2-----------------");
		ListIterator li2=l1.listIterator();
		while(li2.hasNext()) {
			System.out.println(li2.next());
		}
		System.out.println("倒序---------------------");
		while(li2.hasPrevious()) {
			System.out.println(li2.previous());
		}
	}
}

ArrayList和Vector

都是基于数组实现的 List 类，封装了一个动态的、允许再分配的 Object[] 数组，主要使用

initialCapacity 参数来设置该数组的长度，当添加的元素数量 过多的话，则 initialCapacity 会自动增

长，默认长度是 10。

有时候需要注意性能问题，如果向这两个集合中添加大量元素时，可用 ensureCapacity(int

minCapacity) 方法一次性地增加 initialCapacity，这样可以减少重分配的次数，提高新能。

它们也可以使用 ensureCapacity(int minCapacity) 和 trimToSize() 方法来重新分配 Object[] 数组。

Vector 是一个比较老旧的集合，是 ArrayList 的前身，有很多缺点，不建议使用。

ArrayList 是线程不安全的，如果多个线程访问&修改了 ArrayList 集合，就需要手动保证集合的同步

性。

Vector 是线程安全的，所以性能会比 ArrayList 稍低，哪怕是线程安全也不推荐使用。

public class ArrayListDemo2 {

	public static void main(String[] args) {
		ArrayList<String> aList=new ArrayList<String>();
		aList.add("ddd");
		aList.add("zhansgan");
		
		for (String string : aList) {
			System.out.println(string);
		}
		ArrayList aList2=new ArrayList<>();
		aList2.add("dd");
		aList2.add(2);
		
		for (Object object : aList2) {
			System.out.println(object);
		}
		//使用基本数据类型包装类 指定集合泛型
		ArrayList<Integer> aList3=new ArrayList<>();
		
		//迭代器
		Iterator<String>  i1=aList.iterator();
		while(i1.hasNext()) {
			System.out.println(i1.next());
		}	
		//泛型除了可以在集合中使用之外 也可以在类和方法中使用
	}
}

长度不变的集合（Arrays）

Arrays 类的 asList(Object... a) 静态方法，可以把一个数组或指定个数的对象转成一个 List 集合，这个集合

既不是 ArrayList 实现类的实例，也不是 Vector 实现类的实例，而是 Arrays 的内部类 ArrayList 的实

例。

Arrays.ArrayList 是一个固定长度的 List 集合，只能访问元素，不能添加和删除集合中的元素。

其源码如下：

    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

一些小demo代码：

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {

	public static void main(String[] args) {
		//...在方法中书写  调用方法时候可以书写多个参数 
		//注意...必须放置到最后一个参数类型后面
		//asList(T... a) 
		//返回的这个集合  长度不可变   不能添加不能删除
		List<String> l1=  Arrays.asList("张三","李四","王五");
		System.out.println(l1);
		l1.add("钱六");
		System.out.println(l1);
		
		
//		show(1,3,4);
	}
	
//	public static  void  show(Double b,int... a) {
//		
//	}
}