java中的集合框架

最新推荐文章于 2023-01-03 14:54:45 发布

飘荡的IT人

最新推荐文章于 2023-01-03 14:54:45 发布

阅读量417

点赞数 1

分类专栏： java语言基础

本文链接：https://blog.csdn.net/sdizoe/article/details/45479237

版权

java语言基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java 中的集合框架

一、综合：

为什么会出现集合框架？
因为每一个集合都有一定的共同点：对外的接口、接口的实现、对集合中数据的运算，所以为了表示和操作集合从而规定一种统一的标准的体系结构出来，因此出现了集合框架。
集合框架包含两部分：接口和类
集合类：
为什么会出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
集合类的特点：
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
数组与集合类的不同：
数组于集合虽同时容器，但是数组既可以存储对象又可以存储基本数据类型，但是长度不可以改变，而集合类可以改变。
当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型（参见具体泛型的内容）。

Java中集合类的关系图：

Set和List接口是Collection接口派生的两个子接口

Map实现类用于保存具有映射关系的数据（key-value）。

二：Collection和Map

Collection接口有两个子接口：
List(列表)，Set(集合)
List: 可存放重复元素，元素的存取是有序的。
Set: 不可以存放重复元素，元素的存取是无序的。

Map于Collection在集合中是并列存在的，Map存储的是key-value值，Map集合没有直接去除元素方法，而是先转成Set集合，再通过迭代获取元素。

Collection接口:
Collection接口是List、Set和Queue接口的父接口，同时可以操作这三个接口。

Collection中的比较常用的方法：(详情见java API 1.6.0)
1.添加：
add(E e)
addAll(Collection<? extends E> c)
2:删除
remove(Object o)
removeAll(Collection<?> c)
clear()

3：判断
contains(Object o)
isEmpty()

4：获取
iterator()
size()

5: 获取交集
retainAll(Collection<?> c)

这里通过一个例子来说明Collection的添加元素、删除元素、返回集合中元素的个数以及清空集合元素的方法。

class CollectionDemo
{
public static void main(String[] args) 
{

base_method();
}
public static void base_method()
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();

//1，添加元素。
al.add("java01");//add(Object obj);collection中是addObject类型
al.add("java02");
al.add("java03");
al.add("java04");

//打印原集合。
sop("原集合:"+al);


//3，删除元素。
al.remove("java02");
al.clear();//清空集合。


//4，判断元素。
sop("java03是否存在:"+al.contains("java03"));
sop("集合是否为空？"+al.isEmpty());


//2，获取个数。集合长度。
sop("size:"+al.size());

//打印改变后的集合。
sop(al);


//获取迭代器，用于取出集合中的元素。
Iterator it = al.iterator();
while(it.hasNext())
{
sop(it.next());
}

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

补充：Collection中的toArray方法：

为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。

指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。

举例说明：

import java.util.*;
class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		String[] arr = al.toArray(new String[al.size()]);

		System.out.println(arr);



	}
}

List接口中常用的类：
Vector:是同步的，因此线程安全，但是速度慢，已被ArrayList取代

ArrayList:该类实现了可变的数组，允许所有元素，包括null，可以根据索引位置对集合进行快速的查询，但增删速度较慢。

语法格式：List<> list = new ArrayList<>();

LinkedList:链表结构，增删速度快

语法格式：List<>list2 = new LinkedList<>();

List接口的常用方法：

方法	返回值
add(int index,Object obj)	void
addAll(int index,Collection c)	boolean
remove(int index)	Object
get(int index)	Object
indexOf(Object obj)	int
lastIndecOf(Object obj)	int
subList(int formIndex,int toIndex)	List
set(int index,E element)	Object
listIterator	ListIterator

怎么将自定义对象作为元素存到ArrayList集合中，并去除重复元素？

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public boolean equals(Object obj)
	{

		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
		//System.out.println(this.name+"....."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}
	/**/
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public void setName(String name)
	{
	this.name = name;
	}
	public void setAge(int age)
	{
	this.age = age;
	}
}
class ArrayListTest2 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();

		al.add(new Demo());

		al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
		//al.add(new Person("lisi02",32));
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi04",35));
		al.add(new Person("lisi03",33));
		//al.add(new Person("lisi04",35));

		
		//al = singleElement(al);

		sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。


		Iterator it = al.iterator();


		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}


	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器。
		ArrayList newAl = new ArrayList();

		Iterator it = al.iterator();

		while(it.hasNext())
		{
			Object obj = it.next();

			if(!newAl.contains(obj))
				newAl.add(obj);

		}

		return newAl;
	}
}

class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList link = new LinkedList();

		link.addLast("java01");
		link.addLast("java02");
		link.addLast("java03");
		link.addLast("java04");

		sop(link);
		sop(link.getFirst());
		sop(link.getFirst());
		sop(link.getLast());
		sop(link.removeFirst());
		sop(link.removeFirst());

		sop("size="+link.size());

		while(!link.isEmpty())
		{
			sop(link.removeLast());
		}

	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

<span style="background-color: rgb(240, 240, 240);">class HashSetTest </span>{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a2",12));//插入重复元素
		hs.add(new Person("a4",14));

		Iterator it = hs.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public void setName(String name)
	{
	this.name = name;
	}
	public void setAge(int age)
	{
	this.age = age;
	}
	
	public int hashCode()
	{
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age*37;//返回的int值
	}

	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
}

|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.

TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。

compareTo方法返回值为int 。比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
也种方式也成为元素的自然顺序，或者叫做默认顺序。

TreeSet的第二种排序方式：
当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法。

下面举两个例子：说明TreeSet的这两种排序方法

元素需要实现Comparable接口，覆盖compareTo方法：

class TreeSetDemo 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi08",19));
		ts.add(new Student("lisi007",20));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
		}
	}
}


class Student implements Comparable//该接口强制让学生具备比较性。
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public int compareTo(Object obj)
	{

		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}

	public String getName()
	{
		return name;

	}
	public int getAge()
	{
		return age;
	}
	public void setName(String name)
	{
	this.name = name;
	}
	public void setAge(int age)
	{
	this.age = age;}}

实现Comparator接口，覆盖compare方法。比如按照字符串长度排序：

import java.util.*;
class  TreeSetTest
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new StrLenComparator());
		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

class StrLenComparator implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		String s1 = (String)o1;
		String s2 = (String)o2;	

		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));

<span style="white-space:pre">		</span>//先比较字符串的长度，如果长度相等再利用字符串自身的比较方式进行比较
		if(num==0)
			return s1.compareTo(s2);
		return num;
	}
}

Map集合：Map<K,V>

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

方法	返回值
put(K key, V value)	V
putAll(Map<? extends K,? extends V> m)	void
clear()	void
remove(Object key)	V
containsValue(Object value)	boolean
containsKey(Object key)	boolean
isEmpty()	boolean
get(Object key)	V
size()	int
values()	Colection<V>
entrySet()	Set<Map,Entry<K,V>>
keySet()	Set<K>

M ap接口实现的常用的类：

|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，但必须保持键的唯一性，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序，因为它还实现了java.util.SortedMap接口，在添加、删除操作中TreeMap类比HashMap类的性能差一些

HashMap举例：

<span style="color:#666666;">import java.util.*;
class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		//添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
		//并且put方法会返回被覆盖的值。
		System.out.println("put:"+map.put("01","zhangsan1"));
		System.out.println("put:"+map.put("01","wnagwu"));
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");

		System.out.println("containsKey:"+map.containsKey("022"));
		System.out.println("remove:"+map.remove("02"));
		System.out.println("get:"+map.get("023"));
		map.put("04",null);
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
		System.out.println("get:"+map.get("04"));
	Collection<String> coll = map.values();//获取map集合中所有的值。
	System.out.println(coll);
	System.out.println(map);
	}
}</span>

import java.util.*;
class MapDemo2 
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		map.put("02","zhangsan2");
		map.put("03","zhangsan3");
		map.put("01","zhangsan1");
		map.put("04","zhangsan4");

		//将Map集合中的映射关系取出。存入到Set集合中。
		Set<Map.Entry<String,String>> entrySet = map.entrySet();

		Iterator<Map.Entry<String,String>> it = entrySet.iterator();

		while(it.hasNext())//遍历<span style="font-family: Arial, Helvetica, sans-serif;">entrySet的集合对象</span>
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();//获取集合中的所有key对象
			String value = me.getValue();//获取集合中的所有value值
		}

		/*
		//先获取map集合的所有键的Set集合,keySet();
		Set<String> keySet = map.keySet();

		//有了Set集合。就可以获取其迭代器。
		Iterator<String> it = keySet.iterator();

		while(it.hasNext())
		{
			String key = it.next();//获取hashMap中的所有key对象
			//有了键可以通过map集合的get方法获取其对应的值。
			String value  = map.get(key);
		}

		*/
	}
}

总结：java集合类中所包含的方法很多，有时候会难以分清楚，通过一定的总结慢慢梳理才会牢记于心。这是我开始学习总结java的第一步，希望以后自己能够坚持思考性的总结，这样才会一天天进步。