Java集合相关Collection、List、Set

最新推荐文章于 2023-11-02 00:15:00 发布

liuchonghua

最新推荐文章于 2023-11-02 00:15:00 发布

阅读量231

点赞数 1

分类专栏： Java 文章标签： Collection Set List 并发修改异常

本文链接：https://blog.csdn.net/liuchonghua/article/details/80201017

版权

Java 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

概念

集合是一种容器，可以存储不同类型的元素且长度可变。

区别

集合和数组的区别
	长度区别	内容区别	存储类型的区别
集合	长度可变	可以存储不同类型的元素	只能存储引用类型
数组	长度固定	只能存储同一种类型的元素	可以存储基本类型，也可以存储引用类型

List集合和Set集合的区别
List	Set
有序的 (存储和取出一致)	无序性(不能保证迭代的顺序,基于hashMap)
可以允许重复元素	元素不能重复，可以为null

集合的继承体系

集合:Collection:子接口有两个,两个子接口分别对应多个子实现类,多个集合数据结构不同,但是他们有共性内容,将共性内容
抽取出来,就可以集合继承体系图。

Collection集合

层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。

一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

常用的方法

添加功能

boolean add(Object e)

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

public class Test {
	public static void main(String[] args) {
		// Collection是个接口类，需要通过子类去创建对象
		Collection c = new ArrayList();
		System.out.println(c);// []
		// add方法返回值是boolean类型只要添加就返回true
		boolean b = c.add("hello");
		c.add("word");
		System.out.println(c);// [hello, word]
		System.out.println(b);// true
	}
}

boolean addAll(Collection c)

添加一个集合中的所有元素

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

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		Collection b = new ArrayList();
		b.add("hello");
		b.add("word");
		b.add("java");
		System.out.println(c);// [hello, word]
		System.out.println(b);// [hello, word, java]
		c.addAll(b);//将b集合的全部元素添加到c集合的最后
		System.out.println(c);// [hello, word, hello, word, java]
	}
}

删除功能

void clear()

删除集合中所有元素(暴力删除)

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

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		System.out.println(c);// [hello, word]
		c.clear();// 暴力删除所有元素
		System.out.println(c);// []
	}
}

boolean remove(Object o)

删除集合中的指定元素

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

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		System.out.println(c);// [hello, word]
		c.remove("hello");//删除指定元素
		System.out.println(c);// [word]
	}
}

boolean removeAll(Collection c)

删除两个集合中交集部分，只要删除一个元素返回值就为true

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

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		c.add("like");
		Collection b = new ArrayList();
		b.add("hello");
		b.add("word");
		b.add("java");
		System.out.println(c);// [hello, word, like]
		System.out.println(b);// [hello, word, java]
		System.out.println(c.removeAll(b));// true
		// removeAll删除的是c集合和b集合的交集部分，只要删除一个元素返回值就为true
		System.out.println(c);// [like]
	}
}

判断功能

boolean contains(Object o)

集合中是否包含指定的元素

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

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		// contains判断是否包含指定元素
		System.out.println(c.contains("java"));// false
		System.out.println(c.contains("word"));// true
	}
}

boolean containsAll(Collection c)

判断一个集合中是否包含另一个集合中所有的元素。全部包含返回值才为true

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

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		c.add("like");
		c.add("java");
		Collection b = new ArrayList();
		b.add("hello");
		b.add("word");
		b.add("java");
		System.out.println(c);// [hello, word, like, java]
		System.out.println(b);// [hello, word, java]
		System.out.println(c.containsAll(b));// true
	}
}

isEmpty()

判断集合是否为空

import java.util.ArrayList;
import java.util.Collection;
public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		System.out.println(c.isEmpty());// false
	}
}

获取功能

int size()

获取集合中的元素数

import java.util.ArrayList;
import java.util.Collection;
public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		System.out.println(c.size());// 2
	}
}

交集功能

boolean retainAll(Collection c)

A集合对B集合取交集元素

交集的元素要去A集合中,boolean返回值表达的A集合的元素是否发生变化,如果发生变化,则返回true,否则,返回false

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

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		c.add("like");
		Collection b = new ArrayList();
		b.add("hello");
		b.add("word");
		b.add("java");
		System.out.println(c);// [hello, word, like]
		System.out.println(b);// [hello, word, java]
		System.out.println(c.retainAll(b));// true
		//只要两个集合存在交集部分就返回true
		System.out.println(c);// [hello, word]
		//取得的交集部分存到了c中
		System.out.println(b);// [hello, word, java]
	}
}

转换功能

Object[] toArray()

将集合转换成数组

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("hello");
		c.add("word");
		c.add("like");
		// toArray返回值是Object类的对象数组
		Object[] o = c.toArray();
		System.out.println(Arrays.toString(o));// [hello, word, like]
		// 转化成字符串类型输出
		for (int i = 0; i < o.length; i++) {
			String s = (String) o[i];// 向下转型，String继承自Object
			System.out.print(s + ",");
		}
		/**
		 * hello,word,like,
		 */
	}
}

在集合中存储对象

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

class Student {
	private String mane;
	private int age;

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public String getMane() {
		return mane;
	}

	public void setMane(String mane) {
		this.mane = mane;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Student(String mane, int age) {
		super();
		this.mane = mane;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [姓名=" + mane + ", 年龄=" + age + "]";
	}

}

public class Test {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		Student s1 = new Student("张三", 20);
		Student s2 = new Student("李四", 21);
		Student s3 = new Student("王五", 25);
		Student s4 = new Student("赵六", 24);
		c.add(s1);
		c.add(s2);
		c.add(s3);
		c.add(s4);
		// 转换成数组
		Object[] objs = c.toArray();
		for (int i = 0; i < objs.length; i++) {
			Student s = (Student) objs[i];// 向下转型成Student类
			System.out.println(s.toString());
		}
	}
}
/**
Student [姓名=张三, 年龄=20]
Student [姓名=李四, 年龄=21]
Student [姓名=王五, 年龄=25]
Student [姓名=赵六, 年龄=24]
 * */

迭代器遍历集合

interface Iterator迭代器

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

class Student {//创建一个学生类
	private String String;
	private int age;

	public String getString() {
		return String;
	}

	public void setString(String string) {
		String = string;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(java.lang.String string, int age) {
		super();
		String = string;
		this.age = age;
	}

}

public class IteratorDemo {
	public static void main(String[] args) {
		ArrayList a = new ArrayList();
		a.add("java");
		a.add("javaee");
		a.add("hello");
		ArrayList b = new ArrayList();
		Student s1 = new Student("张三", 18);
		Student s2 = new Student("李四", 21);
		Student s3 = new Student("王五", 17);
		b.add(s1);
		b.add(s2);
		b.add(s3);
		Iterator it = a.iterator();// 通过集合获取迭代器对象
		while (it.hasNext()) {// 判断是否还存在下一个需要遍历的对象，防止出现NoSuchElementException异常
			// 需要同时输出字符串长度，注意length()方法是String类型特有的方法，需要类型转化
			String s = (String) it.next();// 强制类型转化
			System.out.println(s + "---" + s.length());
		}
		Iterator it2 = b.iterator();
		while (it2.hasNext()) {
			Student stu = (Student) it2.next();//转化为自定义对象
			System.out.println(stu.getString() + "---" + stu.getAge());
		}
	}
}
/**
java---4
javaee---6
hello---5
张三---18
李四---21
王五---17
 */

iterator()

该方法是集合对象的方法，以正确的顺序返回该集合中的元素的迭代器。

hasNext()

判断迭代器中是否还存在下一个元素，如果存在则返回true。

next()

返回迭代器中的下一个元素。

List集合

interface List extends Collection

List集合允许存储的元素可重复，并且存入的顺序与取出的顺序一致。

List集合特有的方法

添加功能

void add(int index,Object element)

在指定位置处添加指定元素

获取功能

Object get(int index)

返回列表中指定位置的元素

listIterator()

以当前List集合构造列表迭代器

删除功能

Object remove(int index)

删除指定位置处的元素，返回值是被删除的元素。

修改功能

Object set(int index, Object element)

用指定element元素替换掉指定位置处的元素，返回值是被替换的元素

import java.util.ArrayList;
import java.util.List;

public class Text01 {
	public static void main(String[] args) {
		List lis = new ArrayList();
		lis.add("java");
		lis.add("hello");
		lis.add("word");
		System.out.println(lis);// [java, hello, word]
		// 在指定位置添加元素
		lis.add(1, "eclipse");// 在下标为1的部位插入eclipse
		System.out.println(lis);// [java, eclipse, hello, word]
		// 获取指定位置的元素
		System.out.println(lis.get(2));// hello
		// 删除指定位置的元素
		Object ob = lis.remove(1);
		System.out.println(lis);// [java, hello, word]
		// remove返回值是被删除的元素
		System.out.println(ob);// eclipse
		// 替换指定位置的元素
		Object o = lis.set(2, "Android");
		System.out.println(lis);// [java, hello, Android]
		// set返回值是被替换的元素
		System.out.println(o);// word
	}
}

List集合专有的迭代器ListIterator

Lise集合也可以使用lterator迭代器遍历，但是List集合有专用的ListIterator迭代器，可以提供更多的功能。

ListIterator是个接口，需要通过listIterator()方法来构造列表迭代器对象。

常用方法

boolean hasNext()

判断是否有下一个可以迭代的元素(正向遍历)

Object next()

获取下一个元素

boolean hasPrevious()

判断是否有上一个可以迭代元素(逆向遍历)

Object previous()

返回上一个元素

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

public class Text01 {
	public static void main(String[] args) {
		List lis = new ArrayList();
		lis.add("java");
		lis.add("hello");
		lis.add("word");
		ListIterator lt = lis.listIterator();
		while (lt.hasNext()) {// 正向遍历
			String s = (String) lt.next();
			System.out.print(s + " ");// java hello word
		}
		System.out.println();
		while (lt.hasPrevious()) {// 逆向遍历
			String s2 = (String) lt.previous();
			System.out.print(s2 + " ");// word hello java
		}
	}
}

Set集合

HashSet集合的add方法底层依赖于双列集合HashMap,它依赖于两个方法,HashCode()方法和equals()方法。

先比较元素的HashCode()码值是否一样,再比较equals()方法确保传入的元素不重复。

元素的唯一性

import java.util.HashSet;
import java.util.Set;

public class SetTest {

	public static void main(String[] args) {
		Set<String> s = new HashSet<String>();
		// HashSet：Set集合的子实现类
		s.add("java");
		s.add("java");
		s.add("hello");
		s.add("hello");
		s.add("java");
		// 遍历
		for (String str : s) {
			System.out.print(str + " ,");// java ,hello ,
		}
	}

}

集合中的并发修改异常

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Text01 {
	public static void main(String[] args) {
		List lis = new ArrayList();
		lis.add("java");
		lis.add("hello");
		lis.add("word");
		//查询集合中是否有java如果有就添加javaee
		Iterator it = lis.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			if (s.equals("java")) {
				lis.add("javaee");
			}
		}
		System.out.println(lis);
	}
}
/**
Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(Unknown Source)
	at java.base/java.util.ArrayList$Itr.next(Unknown Source)
	at ListDemo.Text01.main(Text01.java:16)
 */

上述代码发生并发修改异常ConcurrentModificationException，当迭代器正在遍历集合时不允许同时进行修改。

解决办法

可以使用ListIterator迭代器中的add方法来添加，Iterator迭代器中没有add方法

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

public class Text01 {
	public static void main(String[] args) {
		List lis = new ArrayList();
		lis.add("java");
		lis.add("hello");
		lis.add("word");
		// 查询集合中是否有java如果有就添加javaee
		ListIterator it = lis.listIterator();
		while (it.hasNext()) {
			String s = (String) it.next();
			if (s.equals("java")) {
				it.add("javaee");
			}
		}
		System.out.println(lis);// [java, javaee, hello, word]

	}
}

用普通for循环的方式遍历

import java.util.ArrayList;
import java.util.List;

public class Text01 {
	public static void main(String[] args) {
		List lis = new ArrayList();
		lis.add("java");
		lis.add("hello");
		lis.add("word");
		// 查询集合中是否有java如果有就添加javaee
		for (int i = 0; i < lis.size(); i++) {
			String s = (String) lis.get(i);
			if (s.equals("java")) {
				lis.add("javaee");
			}
		}
		System.out.println(lis);// [java, hello, word, javaee]

	}
}

liuchonghua

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java集合相关Collection、List、Set

概念集合是一种容器，可以存储不同类型的元素且长度可变。区别集合和数组的区别长度区别内容区别存储类型的区别集合长度可变可以存储不同类型的元素只能存储引用类型数组长度固定只能存储同一种类型的元素可以存储基本类型，也可以存储引用类型集合的继承体系集合:Collection:子接口有两个,两个子接口分别对应多个子实现类,多个集合数据结构不同,但是他们有共性内容,将共性内容抽取出来,就可以集合继承体系图。...
复制链接

扫一扫