超超超超级简单的集合入门！小白放心食用

集合概述

面向对象语言对事物的体现都是以对象的形式，为了方便多个对象的操作，就对对象进行存储，数组就是存储对象常用的一种方式。数组虽然存储对象，但是它一旦创建，大小是固定的，存储的数据类型也必须一致*。有时候我们无法预先知道需要多少个对象，那么用数组存储就不太方便，这时候用集合就能解决了，集合能存储任意类型的对象，并且大小可变。
从各种集合中提取公共要素，形成了一个集合的解决方案，就是java的集合框架(图片为转载)：

Collection集合

*Collection 接口是定义的是所有单列集合中的共性方法(没有带索引的方法)，它没有实现类，是一组对象的接口。下面展示一些 常用共性方法的代码。

利用多态创建集合对象

public class Test01 {
	public static void main(String[] args) {
		/*
		  创建集合对象，可以使用多态
		  没有学过泛型可以先不写 <>
		*/
		Collection<String> coll=new ArrayList<>();
		//集合重写了toString方法
		System.out.println(coll);//[]

增加元素 add(E e)

		/*
		 public boolean add(E e)把给定的对象添加到当前集合中，
		 返回值是boolean类型，一般都返回True，所以可以不用接收
		 */
		boolean b1=coll.add("张三");
		System.out.println(b1);//true
		System.out.println(coll);//[张三]
		coll.add("王五");
		coll.add("李四");
		System.out.println(coll);//[张三, 王五, 李四].

删除指定元素 remove(E e)

		/*
		 	public boolean remove(E e) 把给定的对象在当前集合中删除
		 	返回值是一个boolean值，集合中不存在该元素时则删除失败
		 */
		boolean b2=coll.remove("张三");
		System.out.println(b2);//true
		boolean b3=coll.remove("张三");
		System.out.println(b3);//false

删除集合中的所有元素 clear()

		//public void clear() 删除集合中的元素，但集合还在
		coll.clear();
		System.out.println(coll);//[]
	

判断方法 contains(E e); isEmpty();

		/*
		 	public boolean contains(E e) 判断当前集合中是否有给定的对象
		 */
		System.out.println(coll.contains("张三"));//false
		/*
		 	public boolean isEmpty() 判断当前集合是否为空
		 */
		boolean b4=coll.isEmpty();
		System.out.println(b4);//false

计算元素个数 size()

		//public int size() 判断当前集合的元素个数
		int b5=coll.size();
		System.out.println(b5);//2

集合转数组toArray()

		//public Object[] toArray() 把集合中的元素存储到数组中
		Object[] arr=coll.toArray();
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");//王五 李四
		}
		System.out.println(coll);//[王五，李四]

使用迭代器遍历集合 iterator()

		//使用迭代器迭代遍历集合
		Iterator<String> iterator=coll.iterator();
		while(iterator.hasNext()){//指针从第一个元素的上一个开始，判断是否有下一个元素
			System.out.print(iterator.next()+" ");//打印当前指针的下一个元素
			/*
			 * java.util.ConcurrentModificationException并发修改异常
			 * 迭代时不能对集合进行修改（非迭代器操作）
			 */
			//coll.add("ads");
		}
}

List集合

List 接口是元素有序且可重复的集合(存取顺序相同)，存在下标，即可以通过索引访问(get(index))
它的遍历方式有两种，一种是用迭代器，一种是借助下标使用for循环。
List集合有一个特有的迭代器 ListIterator，支持在迭代过程中添加和修改元素，该方法仅作了解。

ArrayList

ArrayList类是List接口常用的实现类，底层是用长度可变的数组(顺序表)实现的，而数组是按内存位置一次存放，因此查找快，增删慢。它线程不安全，所以效率相对Vector类比较高。
下面展示一些 常用方法的代码 共性方法不再赘述。

public class Test01 {
	public static void main(String[] args) {
		ArrayList<String> arrayList=new ArrayList<>();
		arrayList.add("123");
		arrayList.add("qwe");
		//常用方法
		System.out.println(arrayList.size());
		arrayList.clear();
		System.out.println(arrayList.size());
		System.out.println(arrayList.isEmpty());
		arrayList.add("123");
		arrayList.add("qwe");

通过下标获取元素 get(index)

	System.out.println(arrayList.get(0));//获取第1个元素

使用for循环遍历

		for (int i = 0; i < arrayList.size(); i++) {
			System.out.println(arrayList.get(i));
		}

使用迭代器遍历

		Iterator<String> iterator=arrayList.iterator();
		while(iterator.hasNext()){
			Object object=iterator.next();
			System.out.print(object+" ");
			
		}
	}
	
}

包含关系

public class Test02 {
	public static void main(String[] args) {
		ArrayList c=new ArrayList();
		ArrayList c1=new ArrayList();
		c.add("q");
		c.add("a");
		c.add("b");
		c.add("c");
		print(c);
		c1.add("a");
		c1.add("b");
		c1.add("c");

把c1的元素放到c中 并集

	c.addAll(c1);
	print(c);

删除c中与c1相同的元素 补集

		c.removeAll(c1);
		print(c);

保留c中与c1相同的元素 其他的删除 交集

		c.retainAll(c1);
		print(c);
	}

打印函数

	public static void print(ArrayList arrayList) {
		Iterator iterator=arrayList.iterator();
		while(iterator.hasNext()){
			System.out.print(iterator.next());
		}
		System.out.println();
	}
}

LinkedList

LinkedList实现类底层使用链表实现，即增删效率较高，查询速度慢

Vector

Vector的原理和Arraylist相同，但是它线程是安全的，所以效率比较低。

Set集合

Set 接口是元素无序的不可重复的集合(存取顺序大概率不同)，是不存在下标的，即不可以通过索引访问，遍历时也不能用for循环，只能用迭代器。

HashSet

HashSet 是Set常用的实现类，底层是由哈希表实现的，所有元素是按hashcode的值存放的，它线程不安全，存取速度快。它只能自然排序。

TreeSet

TreeSet 是Set接口的子接口SortedSet的唯一实现类，底层是使用红—黑数的数据结构实现的。能通过元素继承Compareable接口，重写compareTo方法，来实现对元素的定制排序，默认是自然排序。
下面的案例是定制排序，首先按照年龄排序，年龄一样按照姓名排序，如果两个都相同则不会重复存入：

public class Test01 {
	public static void main(String[] args) {
		//test1();
		System.out.println("-----------");
		Student stu1=new Student("张三", 17);
		Student stu2=new Student("李四", 19);
		Student stu9=new Student("李四", 120);
		//名字和年纪都相同则不会存入
		Student stu10=new Student("李四", 19);
		Student stu3=new Student("王五", 20);
		Student stu4=new Student("赵六", 25);
		Student stu5=new Student("A", 30);
		Student stu6=new Student("B", 35);
		Student stu7=new Student("C", 18);
		Student stu8=new Student("D", 24);
		TreeSet<Student> set2=new TreeSet<>();
		set2.add(stu1);
		set2.add(stu2);
		set2.add(stu3);
		set2.add(stu4);
		set2.add(stu5);
		set2.add(stu6);
		set2.add(stu7);
		set2.add(stu8);
		set2.add(stu9);
		set2.add(stu10);
		
		Iterator<Student> iterator2=set2.iterator();
		while(iterator2.hasNext()){
			System.out.println(iterator2.next());
		}
		
	}
}

/*
	实现TreeSet定制排序需要将集合里的元素必须实现Comparable接口，重写CompareTo方法
*/
public class Student implements Comparable<Student>{
	private String name;
	private int age;
	//有参构造方法
	public Student(String name, int age) {
		super();
		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 int compareTo(Student stu) {
		
		int age=this.age;
		int age2=stu.getAge();
		String name=this.name;
		String name2=stu.getName();
		/*
			this.x表示当前的对象，参数里的表示上一个
			这里的比较可以通过打印this.x 和stu 来查看
		*/
		//System.out.println("this.name:"+name+" this.age"+age+" name:"+name2+" age+"+age2);
		
		if (age==age2) {
			return name.compareTo(name2);
		}else if(age>age2){
			return 1;
		}else{
			return -1;
		}
		
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

}

LinkedHashSet

底层使用链表技术实现，但是结合了哈希值实现存储，增删效率高，查询效率低。

Map集合

Map 接口是定义的是所有双列集合中的共性方法，是一组key/vale对的集合。存储的是键值对(key/value)的集合，其中key是不允许重复的，并且每个key只允许映射到一个值。

HashMap

HashMap底层是哈希表存储的，它没有对值排序，可以存入null值，null键。并且线程是不安全的。
下面展示一些 常用方法及遍历方法

public class Test02 {
	public static void main(String[] args) {
		HashMap<String,String> hashMap=new HashMap<>();
		hashMap.put("1", "a");
		hashMap.put("2", "b");
		hashMap.put("3", "c");
		hashMap.put("4", "d");
		System.out.println(hashMap.size());
		System.out.println(hashMap.get("1"));//获取键为1的值
		System.out.println(hashMap.values());//获取所有的值
		System.out.println(hashMap.size());
		System.out.println(hashMap.isEmpty());
//		hashSet.clear();
		System.out.println(hashSet.isEmpty());
		print1(hashMap);
		print2(hashMap);
		print3(hashMap);
	}

方法一：将键利用keySet()方法转为set集合，并用迭代器遍历输出

	public static void print1(HashMap<String,String> hashMap) {
		Set<String> set=hashMap.keySet();
		Iterator<String> iterator=set.iterator();
		while(iterator.hasNext()){
			String n=iterator.next();
			System.out.print(n+" ");
			String s=hashMap.get(n);//根据键获取值
			System.out.print(s+"\n");
		}

方法二：将键利用keySet()方法转为set集合，并用增强for循环遍历输出

	public static void print2(HashMap<String,String> hashMap) {
		Set<String> set=hashMap.keySet();
		for (String string : set) {
			String value=hashMap.get(string);//根据键获取值
			System.out.println(string+"-"+value);
		}
	}

方法三：将键值利用entrySet()方法转为set,并用迭代器遍历输出

	public static void print5(HashMap<String,String> hashMap) {
		Set<Map.Entry<String, String>> set=hashMap.entrySet();
		Iterator<Map.Entry<String, String>> iterator=set.iterator();
		while(iterator.hasNext()){
			Map.Entry<String, String> s=iterator.next();
			String key=s.getKey();
			String value=s.getValue();
			System.out.println(key+":"+value);
		}
	}

方法四：将键值利用entrySet()方法转为set,并用增强for循环遍历输出

	public static void print6(HashMap<String,String> hashMap) {
		Set<Map.Entry<String, String>> set=hashMap.entrySet();
		for (Entry<String, String> entry : set) {
			System.out.println(entry);
		}
	}	

方法五：将值利用values()方法转为Collection,并用迭代器遍历输出，只能遍历值，键不能遍历

	public static void print3(HashMap<String,String> hashMap) {
		Collection<String> coll=hashMap.values();
		Iterator<String> iterator=coll.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}

方法六：将值利用values()方法转为Collection,并用增强for循环遍历输出，这种方式只能遍历值，键不能遍历

	public static void print4(HashMap<String,String> hashMap) {
		Collection<String> coll=hashMap.values();
		for (String string : coll) {
			System.out.println(string);
		}
	}

方式七：lambda表达式

	public static void print7(HashMap<String,String> hashMap) {
		
		hashMap.forEach((t1,t2)-> System.out.println(t1+"=="+t2));
		
	}

方式八：entrySet和顺序流

	public static void print8(HashMap<String,String> hashMap) {
		  hashMap.entrySet().stream().forEach((entry)->
		  System.out.println(entry.getKey()+"=="+entry.getValue()));

		
	}

方式九：entrySet和并行流

	public static void print9(HashMap<String,String> hashMap) {
		hashMap.entrySet().stream().parallel().forEach((entry)-> 
		System.out.println(entry.getKey()+"=="+entry.getValue()));

		
	}

}

TreeMap

TreeMap底层是哈希表存储的，对key进行排序(要求key值实现Comparable接口)。

应用总结

Collection	接口，用于引用 LIst Set的实现对象
List	元素可重复 需要保留存储顺序： 1. 查询多用ArrayList； 2.存取多用LinkedList； 3.需要线程安全用Vector。
Set	元素无序，并且不可重复： 1.需要给元素排序用TreeSet； 2.不需要则用HashSet，因为效率高 3.需要去掉重复元素，并且要保留存储顺序用LikedHashSet。
Map	需要保留key/value形式的数据： 1.需要给元素排序用TreeMap； 2.不需要则用HashMap，因为效率高

例题：
请用面向对象思想描述商品清单，要求如下：
(1)、商品有：商品编号，名称，价格，地址等信息
(2)、购物清单(集合)中有多种商品
(3)、可通过购物清单中某商品编号获知该商品的其他信息
(4)、可计算购物清单中商品的总价

public class Test {
	public static void main(String[] args) {
		Goods goods1 = new Goods("绿茶", "1002", 3.5, "河北");
		Goods goods2 = new Goods("白茶", "1003", 3.0, "河南");
		Goods goods3 = new Goods("清茶", "1004", 3.2, "湖北");
		Goods goods4 = new Goods("红茶", "1005", 5.5, "湖南");
		HashMap<String, Goods> hashMap = new HashMap<String, Goods>();
		hashMap.put(goods1.getId(), goods1);
		hashMap.put(goods2.getId(), goods2);
		hashMap.put(goods3.getId(), goods3);
		hashMap.put(goods4.getId(), goods4);
		double count = 0;
		Set<String> keySet = hashMap.keySet();
		Iterator<String> iterator = keySet.iterator();
		while (iterator.hasNext()) {
			String ID = iterator.next();
			Goods goods = hashMap.get(ID);
			System.out.println(goods);
			count += goods.getPrice();
		}
		System.out.println("总价为       " + count);

	}
}

public class Goods {
	private String name;
	private String id;
	private double price;
	private String address;
	public Goods(String name, String id, double price, String address) {
		super();
		this.name = name;
		this.id = id;
		this.price = price;
		this.address = address;
	}
	@Override
	public String toString() {
		return "Goods [name=" + name + ", id=" + id + ", price=" + price + ", address=" + address + "]";
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	
}

本文地址：https://blog.csdn.net/qq_44768955/article/details/107684335