java集合体系

最新推荐文章于 2024-09-15 19:46:31 发布

chen158158

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量470

点赞数

分类专栏：集合框架文章标签：黑马程序员 java 二叉树 map iterator

本文链接：https://blog.csdn.net/chen158158/article/details/40317877

版权

集合框架专栏收录该内容

0 篇文章 0 订阅

订阅专栏

1为什么会出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是对象存储最常用的一种方式。

2集合和数组的不同？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

3集合类的特点？

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

4java集合框架图。

5集合框架中的常用接口：

Collection接口有两个子接口：

List（列表），Set（集）。List集合可以存放“重复”元素，并且元素的存取是有序的。Set:不可以存放重复元素，元素存取是无序的。

6List下面两个常用的类ArrayList(底层采用数组实现，查询效率较高)和LinkedList(底层采用链表实现，增删效率较高)，Set集合下面两个常用的类HashSet和TreeSet（存入的元素内部会默认会按照元素的自然顺序进行排序）的常用操作例子。

ArrayList：

<span style="font-size:18px;"><span style="font-size:18px;">public class ListDemo {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		
		al.add("a");
		al.add("b");
		al.add("c");
		al.add("d");
		
		//迭代取出元素
		Iterator<String> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		//增强for循环的方式取出来
		for(String i :  al){
			System.out.println(i);
		}
	}

}</span></span>

HashSet:

<span style="font-size:18px;"><span style="font-size:18px;">public class HashSetDemo {
	public static void main(String[] args) {
		HashSet<String> set = new HashSet<String>();
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");
		set.add("e");
		
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

}</span></span>

7List集合内部是根据存入元素的equals()方法来判断元素是否是“重复”元素，而Set集合存入的元素是首先根据元素的hashCode()方法来判断，如果元素的hashCode()方法返回一致，再根据元素的equals()方法来判断，如果equals()方法返回也一致，那么就认为存入的两个元素的值是一样的。

ArrayList：

<span style="font-size:18px;"><span style="font-size:18px;">/**
 * 重点 了解一下“Set”集合中的元素不是“重复”的，那么其实如何判断“元素”的“重复性”的。
 * 
 * 首先判断元素的“hashcode”,然后会根据元素的equals()方法来确定元素是否是重复的。
 * 所以在真实的开发中，我们需要重写这两个方法。
 * @author chen
 * @date 创建时间：2014-10-15 下午11:00:08 类说明
 */
public class HashSetTest {
	public static void main(String[] args) {

		HashSet<Person> hashSet = new HashSet<Person>();
		hashSet.add(new Person(22, "kobe"));
		hashSet.add(new Person(22, "kobe"));
		hashSet.add(new Person(22, "jiji"));
		hashSet.add(new Person(22, "haha"));
		
		Iterator<Person> it = hashSet.iterator();
		while(it.hasNext()){
			Person p = it.next();
			System.out.println(p.getName() + " : " + p.getAge());
		}

	}

}

class Person {
	private int age;
	
	private String name;

	public Person(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	@Override
	public int hashCode() {

		return this.name.hashCode() + age;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof Person)) {
			Person p = (Person) obj;
			return false;
		} else {
			//只有年龄和名字都相同的情况下，我们才认为Person类是一个“重复”元素。
			Person p = (Person)obj;
			return this.name.equals(p.getName()) && this.age == p.getAge() ;
		}

	}
	
	public int getAge() {
		return age;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}


}
</span></span>

HashSet:

<span style="font-size:18px;"><span style="font-size:18px;">/**
 * 重点 了解一下“Set”集合中的元素不是“重复”的，那么其实如何判断“元素”的“重复性”的。
 * 
 * 首先判断元素的“hashcode”,然后会根据元素的equals()方法来确定元素是否是重复的。
 * 所以在真实的开发中，我们需要重写这两个方法。
 * @author chen
 * @date 创建时间：2014-10-15 下午11:00:08 类说明
 */
public class HashSetTest {
	public static void main(String[] args) {

		HashSet<Person> hashSet = new HashSet<Person>();
		hashSet.add(new Person(22, "kobe"));
		hashSet.add(new Person(22, "kobe"));
		hashSet.add(new Person(22, "jiji"));
		hashSet.add(new Person(22, "haha"));
		
		Iterator<Person> it = hashSet.iterator();
		while(it.hasNext()){
			Person p = it.next();
			System.out.println(p.getName() + " : " + p.getAge());
		}

	}

}

class Person {
	private int age;
	
	private String name;

	public Person(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	@Override
	public int hashCode() {

		return this.name.hashCode() + age;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof Person)) {
			Person p = (Person) obj;
			return false;
		} else {
			//只有年龄和名字都相同的情况下，我们才认为Person类是一个“重复”元素。
			Person p = (Person)obj;
			return this.name.equals(p.getName()) && this.age == p.getAge() ;
		}

	}
	
	public int getAge() {
		return age;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}


}
</span></span>

8TreeSet对于存入的元素是会进行排序的。当我们在TreeSet当中存入自定义的元素时，需要实现Comparable接口，指定元素的排序方式。

<span style="font-size:18px;"><span style="font-size:18px;">package collections;
import java.util.*;
/**
 * 
 * 
 * @author chen jian xiang 
 *
 */
public class TreeSetTest2
{
	public static void main(String[] args)
	{
		TreeSet<Student> ts = new TreeSet<Student>();
		
		ts.add(new Student("xiaowang",20));
		ts.add(new Student("xiaoming",30));//这里会报错。第二个对象会加不进去，因为TreeSet对加入进去的元素默认是按“自然顺序”排序的。当加入自定义的对象时、
											//就必须将自定义的类实现Comparable接口，然后实现接口中的compareTo()方法。自定义加入元素的排序的方式。
		ts.add(new Student("xiaohua03",36));
		ts.add(new Student("xiaohua05",36));
		
		Iterator iterator = ts.iterator();
		while(iterator.hasNext())
		{
			Object object = iterator.next();
			Student s = (Student)object;
			System.out.println(s.name + "::" + s.age);
		}

	}

}

class Student implements Comparable//因为TreeSet的add(Object object)默认会将加入的“元素”按照元素的“自然顺序”进行排序，如果加入的是自定义的对象，那么就必须实现Comparable接口
									//并且实现compareTo方法。
{
	
	String name;
	int age;
	public Student(String name,int age)
	{
		this.name = name;
		this.age = age;
		
	}
	@Override
	public int compareTo(Object o)
	{
		if(!(o instanceof Student))
		{
			new RuntimeException("加入对象不是学生对象");
			
		}
		Student student = (Student)o;
		if(this.age > student.age)
		return 1;
		if(this.age == student.age)//当出现ts.add(new Student("xiaohua03",36));ts.add(new Student("xiaohua05",36));这两个对象的时候
									//如果只判断年龄，因为他们两个的年龄相同。就返回0的话。那么下面的xiaohua05就会加不进去。所以在年龄相同的情况下
									//我们需要判断他们的姓名。因为姓名的类型是“字符串”。所以我们可以调用他的compareTo方法（String类也实现了Comparable接口，实现了compareTo（）方法）
			
		{
			return this.name.compareTo(student.name);//在年龄相同的情况下，继续判断名字。这也就可以避免当出现要添加对象的年龄相同，名字不同的情况。只能加入一个对象的状况。
		}
			
		return -1;
			
		
		
	}
	public String getName()
	{
		return name;
	}
	public int age()
	{
		return age;
	}
}
</span></span>

9：Map集合的使用：

该集合存储键值对。一对一往里存，而且要保证键的唯一性。翻阅api文档有一些常用的方法：put,putAll,clear,remove(Object key),containKey(),containsValue(),get(Object key)等等。

map集合取值的常见的一些方法：

<span style="font-size:18px;"><span style="font-size:18px;">** 
 * @author chen 
 * @date 创建时间：2014-10-20 下午10:35:11 
 * 类说明 
 * 
 * map键值映射对，必须保证键的唯一性，一个“键”只能对应一个值，不能包含重复的键。
 * 
 * map集合常见的实现类：
 *     HashTable:底层是哈希表数据结构，不可以存入null键和null值，这是jdk1.0中出现的，线程同步的。效率低。
 *     HashMap:底层是哈希表数据结构，可以存放null键和null值，从jdk1.2开始使用，线程不同步，效率高。
 *     TreeMap:底层是二叉树数据结构，线程不同步，可用于给Map集合中的键排序。
 *     和set很像，其实在java中，set的底层就大量使用了map的方法。
 *     
 * 
 * 
 */

public class MapTest1 {
	
	public static void main(String[] args) {
		Map<String,String> hashMap = new HashMap<String,String>();
		
		hashMap.put("a", "kobe");
		hashMap.put("b", "kobe");
		hashMap.put("c", "dengkeng");
		hashMap.put("d", "maidi");
		hashMap.put("e", "shark");
		
		System.out.println("----------使用增强for循环取值----------------------");
		for(Entry<String,String> entry : hashMap.entrySet()){
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println("key : " + key + ", value : " + value);
		}
		
		System.out.println("----------keySet的方式去取值----------------------");
		Set<String> set = hashMap.keySet();
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			String key = it.next();
			String value = hashMap.get(key);
			System.out.println("key : " + key + ", value : " + value);
		}
		
		System.out.println("----------entrySet的方式去取值----------------------");
		Set<Entry<String,String>> sets = hashMap.entrySet();
		Iterator<Entry<String,String>> its  = sets.iterator();
		while(its.hasNext()){
			Entry<String,String> entry = its.next();
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println("key : " + key + ", value : " + value);
		}
	}

}</span></span>

关于TreeMap的一些特点：

例子：设计一个engineer实体，存入TreeMap集合中，根据指定的需求，保证元素的“唯一性”，以及如果engineer存入“二叉树”结构的集合，需要保证engineer具备自定义的“排序性":

<span style="font-size:18px;"><span style="font-size:18px;">/** 
 * @author chen 
 * @date 创建时间：2014-10-20 下午11:07:25 
 * 类说明 
 * 
 * 自定义元素，按照指定的需求，在TreeMap中，按照指定的要求进行排序。
 */

public class Engineer implements Comparable<Engineer> {
	private int age;
	private String name;
	
	public Engineer(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	@Override
	public int hashCode() {
		return this.name.hashCode() + this.getAge() * 34;
	}

	@Override
	public boolean equals(Object obj) {
		//比较完元素的hashCode方法，回来进行equals()方法的比较，只有age和name都相等的元素，我们才认为是重复元素。
		if(!(obj instanceof Engineer)){
			return false;
		}
		Engineer e = (Engineer) obj;
		return this.age == e.getAge() && this.name.equals(e.getName());
	}


	//自定义的元素之间“比较”的方法,需求是根据Engineer的age属性进行自然排序
	@Override
	public int compareTo(Engineer e) {
		
		//转换成“包装类”，进行排序
		int num = new Integer(this.age).compareTo(e.age);
		//如果两个元素“年龄”相同的话，那么我们就根据Engineer的“年龄”的自然顺序进行排序。
		if(num == 0){
			return this.name.compareTo(e.getName());
		}
		return num;
	}
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
	public static void main(String[] args) {
		TreeMap<String,Engineer> treeMap = new TreeMap<String,Engineer>();
		treeMap.put("a", new Engineer(20, "kobe"));
		treeMap.put("b", new Engineer(20, "dengkeng"));
		treeMap.put("c", new Engineer(21, "dengkeng"));
		treeMap.put("d", new Engineer(22, "shark"));
		treeMap.put("e", new Engineer(30, "xiaoming"));
		
		Set<Entry<String,Engineer>> set = treeMap.entrySet();
		Iterator<Entry<String,Engineer>> it = set.iterator();
		while(it.hasNext()){
			Entry<String,Engineer> engires = it.next();
			String key = engires.getKey();
			Engineer engineer =  engires.getValue();
			System.out.println("key:" + key + ",name: " + engineer.getName() + ", age:" + engineer.getAge());
			
		}
	}
	

}</span>
</span>