欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

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

程序员文章站 2022-08-14 08:53:58
系统地学习了集合一段时间之后，对于集合各接口及它们实现类的方法区分有些模糊，再次做一些复习总结。我们这里只对集合中的常用实现类的常用方法进行整合。适合小白阅读。...

集合概述

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

相关标签： java

上一篇： PHP中开发XML应用程序之基础篇 添加节点 删除节点 查询节点 查询节

下一篇： WHOOPS PHP调试库的使用

推荐阅读