Java教程

Java核心技术----集合类

本文主要是介绍Java核心技术----集合类,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

一、集合类概述

Java语言的java.util包中提供了一些集合类,这些集合类又被称为容器。常用的集合有List集合、Set集合、Map集合,其中List与Set实现了Collection接口。

二、Collection接口

Collection接口是层次结构中的根接口。构成Collection的单位,被称之为元素。Collection接口通常不能直接使用,但该接口提供了添加元素、删除元素、管理数据的方法。由于List接口与Set接口都继承了Collection接口,因此这些方法对List集合与Set集合是通用的。

package bao;

import java.util.*;

public class Demo1 {        //创建类
	public static void main(String[] args) {
		Collection<String> ls=new ArrayList<>();    //实例化集合类对象
		ls.add("N");           //向集合添加数据
		ls.add("B");
		ls.add("A");
	    Iterator<String> dd=ls.iterator();    //创建迭代器
		while(dd.hasNext()) {                //判断是否有下一个元素
			String str=(String)dd.next();     //获取集合中元素
			System.out.println(str);
		}
		
	}
}



/*输出结果:
N
B
A
 */



 

三、List集合

1、List接口

list集合中的元素允许重复,各元素顺序是对象插入的顺序。

List接口继承了Collection接口,因此包含Collection中的所有方法,此外,List接口还定义了以下两个非常重要的方法。

get(int index):获得指定索引位置的元素。

set(int index , Object obj):将集合中指定索引位置的对象修改为指定的对象。

2、List接口的实现类 

List接口的常用实现类有ArrayListLinkedList

ArrayList类:实现了可变的数组,允许所有元素,包括null,并可以根据索引位置对集合进行快速的随机访问。缺点是向指定的索引位置插入对象或删除对象的速度较慢

List<E> lis=new ArrayList<>();

LinkedList类:采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象。但对于随机访问集合中的对象,使用LinkedList类实现List集合的效率较慢。

List<E> lis1=new LinkedList<>();

package bao;

import java.util.*;

public class Demo1 {        //创建类
	public static void main(String[] args) {
		List<String> ls=new ArrayList<>();    //实例化集合类对象
		ls.add("N");           //向集合添加数据
		ls.add("B");
		ls.add("A");
		int i=(int)(Math.random()*ls.size());     //获得0-2之间的随机数
		System.out.println("随机数获取素组中的元素:"+ls.get(i));
		ls.remove(2);                       //将索引的第二个元素从集合中删除
		System.out.println("将索引的第二个元素从集合中删除后的元素组是:");
	for(int j=0;j<ls.size();j++) {                //判断是否有下一个元素
			 
			System.out.println(ls.get(j));
		}
		
	}
}



/*输出结果:
随机数获取素组中的元素:A
将索引的第二个元素从集合中删除后的元素组是:
N
B
 */



 

四、Set集合

Set集合中的对象不按特定的方式排序,只是简单地把对象加入集合中,但Set集合中不能包含重复对象。Set集合由Set接口和Set接口的实现类组成。Set接口继承了Collection接口,因此包含Collection接口的所有方法。

HashSet:HashSet是Set接口的典型实现,大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素,因此具有很好的存取和查找性能。底层数据结构是哈希表。哈希表一个元素为链表的数组,综合了数组与链表的优点。

HashSet具有以下特点:

  • 不能保证元素的排列顺序,顺序可能与添加顺序不同,顺序也可能发生变化;
  • HashSet不是同步的;
  • 集合元素值可以是null;

TreeSet:TreeSet是SortedSet接口的实现类,TreeSet可以确保集合元素处于排序状态

TreeSet类增加的方法

package bao;

import java.util.Iterator;
import java.util.TreeSet;

public class Demo1 implements Comparable<Object>{        //创建类,实现Comparable接口
	String name;
	long id;
	
	public Demo1(String name,long id) {
	this.id=id;
	this.name=name;
		
	}
	public int compareTo(Object o) {
		Demo1 dem=(Demo1)o;
		int result=id>dem.id?1:(id==dem.id?0:-1);
		return result;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name=name;
	}
	
	public long getId() {
		return id;
	}
	
	public void setId(long id) {
		this.id=id;
	}
	
	public static void main(String[] args) {
		Demo1 emo1=new Demo1("大娃",10101);
		Demo1 emo2=new Demo1("二娃",12211);
		Demo1 emo3=new Demo1("三娃",102322);
		Demo1 emo4=new Demo1("四娃",101232);
		TreeSet<Demo1> tree=new TreeSet<>();
		
		tree.add(emo1);
		tree.add(emo2);
		tree.add(emo3);
		tree.add(emo4);
 
		Iterator<Demo1>it=tree.iterator();            //set集合中所有的对象迭代器
		System.out.println("Set集合中的所有元素:");
		while(it.hasNext()) {
			Demo1 stu=(Demo1)it.next();
			System.out.println(stu.getId()+" "+stu.getName());
		}
		
		it=tree.headSet(emo2).iterator();                 //截取排在emo2对象之前的对象
		System.out.println("截取前面部分的集合:");
		while(it.hasNext()) {
			Demo1 stu=(Demo1)it.next();
			System.out.println(stu.getId()+" "+stu.getName());
		}
		
		it=tree.subSet(emo2, emo3).iterator();            //截取排在emo2与emo3之间的对象
		System.out.println("截取中间部分的集合");
		while(it.hasNext()) {
			Demo1 stu=(Demo1)it.next();
			System.out.println(stu.getId()+" "+stu.getName());
		}
		
	}
}



/*输出结果:
Set集合中的所有元素:
10101 大娃
12211 二娃
101232 四娃
102322 三娃
截取前面部分的集合:
10101 大娃
截取中间部分的集合
12211 二娃
101232 四娃
 */



 

 

五、Map集合

Map集合没有继承Collection接口,其提供的是key到value的映射。

1、Map接口

Map接口提供了将key映射到值的对象。一个映射不能包含重复的key,每个key最多只能映射到一个值。

 

package bao;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo1 {        //创建类
	public static void main(String[] args) {
		Map<String,String>map=new HashMap<>();       //创建Map实例
		map.put("01", "大娃");                        //向集合中添加对象
		map.put("02", "二娃");
		Set<String>set=map.keySet();                //构建Map集合中所有Key对象的集合
		Iterator<String>it=set.iterator();          //创建集合迭代器
		System.out.println("key集合中的元素:"); 
		while(it.hasNext()) {                      //遍历集合
			System.out.println(it.next());
		}
		Collection<String> cl=map.values();         //构建Map集合中所有value值的集合
		it=cl.iterator();
		System.out.println("value集合中的元素:");
		while(it.hasNext()) {                          //遍历集合
			System.out.println(it.next());
		}
	}
}



/*输出结果:
key集合中的元素:
01
02
value集合中的元素:
大娃
二娃
 */

2、Map接口的实现类

Map接口常用的实现类有HashMap和TreeMap。建议使用HashMap类实现Map集合,因为由HashMap类实现的Map集合对于添加和删除映射关系效率更高。

HashMap:HashMap是基于哈希表的Map接口的实现,HashMap通过哈希码对其内部的映射关系进行快速查找;(散列码键值对速度更快)

TreeMap:而TreeMap中的映射关系存在一定的顺序,如果希望Map集合中的对象也存在一定的顺序,应该使用TreeMap类实现Map集合。(树状键值对存放有序)

package bao;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Demo1 {        //创建类
	public static void main(String[] args){     //主方法
	Map<String,String>map=new HashMap<>();      //由HashMap实现的Map对象
	 
	Emp emp=new Emp("852","大娃");        //创建Emp对象
	Emp emp2=new Emp("125","二娃");
	Emp emp3=new Emp("147","三娃");
	Emp emp4=new Emp("369","四娃");
	Emp emp5=new Emp("666","五娃");
	
	map.put(emp4.getE_id(), emp4.getE_name());     //将对象添加到集合中
	map.put(emp5.getE_id(), emp5.getE_name());
	map.put(emp.getE_id(), emp.getE_name());
	map.put(emp2.getE_id(), emp2.getE_name());
	map.put(emp3.getE_id(), emp3.getE_name());
	
	Set<String>set=map.keySet();                 //获取Map集合中的Key对象的集合
	Iterator<String>it=set.iterator();
	System.out.println("HashMap类实现的Map集合,无序:");
	while(it.hasNext()) {
		String str=(String)it.next();
		String name=(String)map.get(str);            //遍历Map集合
		System.out.println(str+" "+name);		
	}
	
	
 	 TreeMap<String,String>treemap=new TreeMap<>();       //创建TreeMap集合对象
 	 treemap.putAll(map);                          //向集合添加对象
 	 Iterator<String>iter=treemap.keySet().iterator();
 	System.out.println("TreeMap类实现的Map集合,键对象升序:");
 	while(iter.hasNext()) {                     //遍历TreeMap集合对象
		String str=(String)iter.next();               //获取集合中的所有key对象
		String name=(String)treemap.get(str);           //获取集合中的所有value对象
		System.out.println(str+" "+name);		
	}
	}
}



/*输出结果:
key集合中的元素:
HashMap类实现的Map集合,无序:
125 二娃
147 三娃
852 大娃
369 四娃
666 五娃
TreeMap类实现的Map集合,键对象升序:
125 二娃
147 三娃
369 四娃
666 五娃
852 大娃

 */



 

这篇关于Java核心技术----集合类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!