黑马程序员-java集合框架

最新推荐文章于 2024-03-14 20:49:58 发布

LinsCode

最新推荐文章于 2024-03-14 20:49:58 发布

阅读量550

点赞数

分类专栏：日志

本文链接：https://blog.csdn.net/LinsCode/article/details/26073885

版权

日志专栏收录该内容

12 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

java中的集合框架实际上就是数据的组织结构，也即数据结构。

数组和集合类的区别：
1，数组虽然也可以存储对象，但长度是固定的，集合长度是固定的
2，数组中可以存储基本数据类型，集合只能存储对象

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

集合中存储的都是对象的引用，即对象的存储地址值。

java集合框架图：

Collection接口的一些方法；
增加：
boolean add(E e)，添加一个元素。
boolean addAll(Collection c),添加一个集合中的所有元素。

删除：
void clear(),将集合中的元素全部删除。
boolean remove(Object obj)删除指定的元素。
boolean remove(Collection c),删除部分元素，这部分元素属于c集合中的元素。

判断：
boolean contains(Object obj),判断集合中是否有obj这个对象的引用。
boolean containsAll(Collection c)，集合中是否包含集合c中所有的元素。
boolean isEmpty()，集合是否为空。

获取：
int size()，获取集合中的元素个数。

取交集：
boolean retainAll(Collection c),在前集合中保留与c集合中相同的元素，如果两个集合的元素相同，则返回false，如果调用retainAll修改了当前集合的值，返回true。

获取集合中的所有元素：
Iterator<E> iterator()，获得集合的迭代器以遍历元素。

Collection
|--List：元素是有序的，元素可以重复
|--Set：元素师无序的，元素不可以重复

Collection接口的子接口List：
ArrayList:底层数据结构是数组，线程不同步，ArrayList替代了Vector，查询元素效率较高。
LinkedList：底层的数据结构是链表，线程不同步，增删元素的效率较高。
Vector：底层数据结构式数组，想成同步，Vector无论查询和增删都很慢。

ArrayList(除了Collection中方法外的特有方法)：
添加：
void add(int index, E element)，将指定的元素插入此列表中的指定位置。
boolean addAll(int index, Collection<? extends E> c)，从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。

删除：
E remove(int index)，移除此列表中指定位置上的元素。

获取：
E get(int index)，返回此列表中指定位置上的元素。
int indexOf(Object o)，返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

修改：
E set(int index, E element)，用指定的元素替代此列表中指定位置上的元素。

获取所有元素：
通过集合对象.iterator()获得ArrayList集合的迭代器，此时遍历数据时，如果对集合进行了增删操作，会发生ConcurrentModificationException异常。
原因是在直接对集合进行元素的添加时，迭代器并不知道，因此JVM会抛出异常。
解决方法是使用listIterator()，它支持对元素的曾删改查的操作，在遍历之后，会将迭代器中的元素情况反馈到集合中。

使用listIterator()的例子：
public class test
{
public static void main(String[] args) throws Exception
{
  List<String> list = new ArrayList<String>();
  list.add("a");
  list.add("b");
  list.add("c");

  ListIterator<String> it = list.listIterator();
  while(it.hasNext())
  {
   String string = (String)it.next();
   if("b".equals(string))
   {
    list.add("d");
   }
   System.out.println(string);
  }
  System.out.println(list);
}
}

LinkedList:
添加：
void add(int index, E element)，将元素添加到链表的指定位置。
boolean addAll(int index, Collection<? extends E> c) 将一个集合中的所有元素添加到链表指定位置。
void addFirst(E e)，将指定元素插入此列表的开头。
void addLast(E e)，将指定元素插入此列表的末尾。

删除:
E poll()，获取并移除链表的第一个元素。
E pollFirst()，获取并移除链表的第一个元素，若链表为空，返回null。
E pollLast()，获取并移除链表的最后个元素。
E remove()，获取并移除链表的第一个元素。
E remove(int index)，获取并移除链表的指定位置处的元素。
E removeFirst()，获取并移除链表的第一个元素。
E removeLast()，获取并移除链表的最后个元素，若链表为空，返回null。

获取：
E get(int index) ，获得指定位置处的元素。
E getFirst() ，获得链表中第一个元素。
E getLast()，获得链表中最后一个元素。
int indexOf(Object o) ，返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int lastIndexOf(Object o) ，返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

修改：
E set(int index, E element)，将此列表中指定位置的元素替换为指定的元素。

获取所有元素：
ListIterator<E> listIterator(int index)：返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。

Collection接口的子接口Set：
HashSet：底层数据结构是哈希表，线程不同步，高效。
LinkedSet：有序，HashSet的子类。
TreeSet：底层数据结构是二叉树，不同步，可对元素进行排序。

HashSet：
hash算法存储数据方式是将集合划分为若干各存储区域，根据对象的hashCode()值来决定应该将其存在哪个区域中。
在java应用程序执行期间，同一对象多次调用hashCode()时必须生成相同的hash值，如果两个对象经过equals()比较相等，则他们的hash值也必须相等。
反之，如果两个对象经过euqals()比较不相等，则他们的hash值不一定相等，如果hash值相等，将其存储在这个对应的区域中。
HashSet存储的例子：

//存储由该类创建的对象

<span style="font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:18px;">class Student
{
	private String name;
	private int age;
	
	public Student(String name,int age) //构造函数 
	{
		this.name = name;
		this.age = age;
	}

	public int hashCode()   //根据属性返回相应的哈希值
	{
		return this.name.hashCode()+this.age*37;
	}

	public boolean equals(Object obj)  //当属性都相等时equals返回真，此时它们的哈希值也相等 
	{
		Student student = (Student)obj;
		
		return this.name.equals(student.name) && this.age == student.age;
	}
	
	public String toString()
	{
		return name+"::"+age;
	}
	
}
public class test
{
	public static void main(String[] args) throws Exception
	{
		HashSet<Student> set = new HashSet<Student>();
	       //创建4个Student对象，其中t1和t4经equals比较是相等的	
		Student t1 = new Student("zhangsan", 11);
		Student t2 = new Student("zhangsan", 12);
		Student t3 = new Student("zhangsan", 13);
		Student t4 = new Student("zhangsan", 11);
              //加入HashSet集合		
		set.add(t1);
		set.add(t2);
		set.add(t3);
		set.add(t4);
		//打印集合中的数据
		for(Student s: set)
		{
			System.out.println(s);
		}
	}
}</span></span>

我们看到，只打印了三个对象的toString，实际上对象t4根本就没有加入到集合中去，原因是当执行加入t4的代码时，程序先得到t4的哈希值，它与t1的哈希值是相等的，t1已经存放在了这块区域中，接下来程序会通过equals判断t4与t1是否是相等的，经判断相等，就不往这个区域加入t4了，也就是t4根本就没有被加入到集合中。

ThreeSet：

用于对集合中的元素按照指定的顺序排序，如果元素不具备比较性，则在编译时会抛出ClassCastException异常。
为了让自定义类的对象具备比较性，需要实现Cmparable接口，并复写compareTo函数，这样存储元素时，各元素才具有比较性。
TreeSet中保证元素唯一性的方式既意思参考比较方法的结果是否为0，如果返回值为0，则视两个对象重复，不存。
TreeSet集合排序有两种方式，实现Comparable接口和在TreeSet构造函数中传一个Comparator比较器。
1，如果TreeSet中的构造参数为null，则使用元素的自然顺序，即使用compareTo函数确定元素的比较性（让元素自身具备比较性）。
2，如果TreeSet中的构造参数为一个Comparator比较器，则使用compare函数确定元素的比较性（让集合自身具备比较性）。

注：
1，如果主要元素的比较结果为0，一般再比较次要元素。
2，如果集合中的元素已经按自然排序存储，若此时想要将它们倒序存储，只需在TreeSet构造函数中传入一个反向比较器-Collections.reverseOrder() 。

使用TreeSet对元素进行排序的例子：

按照年龄大小进行排序。

<span style="font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:18px;">class Student implements Comparable<Student>
{
	public String name;
	public int age;
	
	public int compareTo(Student o) //覆盖compareTo函数，如果年龄相等，则比较姓名 
	{
		int num = this.age-o.age;
		if(num == 0)
			num = this.name.compareTo(o.name);
		return num;
	}
       //构造函数
	public Student(String name,int age) 
	{
		this.name = name;
		this.age = age;
	}

	public int hashCode()//根据属性获得哈希值 
	{
		return this.name.hashCode()+this.age*37;
	}
       //如果属性都相等，则返回true
	public boolean equals(Object obj) 
	{
		Student student = (Student)obj;
		
		return this.name.equals(student.name) && this.age == student.age;
	}
	
	public String toString()
	{
		return name+"::"+age;
	}
	
}

public class test
{
	public static void main(String[] args) throws Exception
	{
		TreeSet<Student> set = new TreeSet<Student>();
     		Student t1 = new Student("zhangsan1", 11); //创建四个对象
		Student t2 = new Student("zhangsan2", 12);
		Student t3 = new Student("zhangsan3", 13);
		Student t4 = new Student("zhangsan4", 11);
		set.add(t1);  //加入到集合中
		set.add(t2);
		set.add(t3);
		set.add(t4);
		
		for(Student s:set)
		{
			System.out.println(s);
		}
	}
}</span></span>

如果需要改成按照姓名进行排序，只需修改main函数，传递一个比较器即可。

public class test
{
public static void main(String[] args) throws Exception
{

//在构造函数中传递一个比较器，集合中的元素按比较器中的compare方法进行比较排序
   TreeSet<student> set = new TreeSet<Student>(new Comparator<Student>()
  {
   public int compare(Student o1, Student o2)
   {
    int num = o1.name.compareTo(o2.name);
    if(num == 0)
     num = o1.age - o2.age;
    return num;
   }
  });

//创建四个对象并将其加入到集合中
  Student t1 = new Student("zhangsan1", 11);
  Student t2 = new Student("zhangsan2", 12);
  Student t3 = new Student("zhangsan3", 13);
  Student t4 = new Student("zhangsan4", 11);
  set.add(t1);
  set.add(t2);
  set.add(t3);
  set.add(t4);

  for(Student s:set)
  {
   System.out.println(s);
  }
}
}

这次打印的结果就是按照姓名进行排序的了。

Map集合：
Hashtable：底层是哈希表数据结构，是线程同步的，不可以存储null键，null值。
HashMap：底层是哈希表数据结构，是线程不同步的，可以存储null键，null值。
TreeMap: 底层是二叉树数据结构，可以对map集合中的键进行指定顺序的排序。

map集合存储元素时是按一次存储一对元素的方式进行的，一个是键(key)，一个是值(value)。键于值之前有对应（映射）关系。
但同时必须保证map集合中键的唯一性。

添加：
1，put(key,value),当存储的键有相同的时，新的值会替代老的值，并将老的值返回。如果键没有重复，返回null。p
2，void putAll(Map map)，将map中的所有键值对存储到当前map中。

删除：
1，void clear(),清空所有键值对。
2，V remove(Object key),删除指定键值对。

判断：
1，boolean isEmpty(),集合是否为空
2, boolean containsKey(K key)，是否包含key 。
3，boolean containsValue(V value),是否包含value。

取出：
1，int size(),获得集合中键值对的数量、
2，Collection values()，获得值得集合。

把map集合转成set的方法：
1, Set<K> keySet() ,返回此映射中包含的键的 Set 集合。

Set<K> keys = map.keySet();
for(K key:keys)
{
V value = (V)map.get(key);
System.out.println(key+"::"+value);
}

2，Set<Map.Entry<K,V>> entrySet() ，返回此映射中包含的映射关系的 Set 集合，即取出的是键值对的映射关系。
Set<Map.Entry<K,V>> mapSets = map.entrySet();
for(Map.Entry mapentry:mapsets)
{
System.out.println(mapentry.getKey()+"::"+mapentry.getValue());
}

TreeMap有根据键值对键值对进行排序的功能，在构造函数中，就像TreeSet一样可以通过传递一个比较器是的集合中的键值对按集合自身进行排序。
如果比较器为null，则按自然顺序进行排序。
例如还用上面的学生类，每个学生对应一个居住地，并对学生按年龄进行排序。

<span style="font-size:18px;">public class test
{
	public static void main(String[] args) throws Exception
	{      //创建一个TreeMap集合，该集合中的键元素按Student中的compareTo函数进行比较排序
		Map<Student, String> map = new TreeMap<Student, String>();
              //往map中加入键值对		
		map.put(new Student("zhangsan1", 11),"beijing");
		map.put(new Student("zhangsan2", 12),"tianjing");
		map.put(new Student("zhangsan3", 13),"nanjing");
		map.put(new Student("zhangsan4", 11),"xian");
		//获得键值的集合
		Set<Student> sets = map.keySet();
		for(Student s: sets)
		{
			System.out.println(s+"::"+map.get(s));//打印键值对
		}
	}
}</span>

需要按姓名进行排序时：

<span style="font-size:18px;">public class test
{
	public static void main(String[] args) throws Exception
	{     //传递一个比较器使得集合中的键元素根据compare函数按姓名进行排序
		Map<Student, String> map = new TreeMap<Student, String>(new Comparator<Student>()
		{
			public int compare(Student o1, Student o2) 
			{
				int num = o1.name.compareTo(o2.name);
				if(num == 0)
					num = o1.age - o2.age;
				return num;
			}
		});
		
                map.put(new Student("zhangsan1", 11),"beijing");   //往map集合中加入键值对              		                 
                map.put(new Student("zhangsan2", 12),"tianjing");
		map.put(new Student("zhangsan3", 13),"nanjing");
		map.put(new Student("zhangsan4", 11),"xian");
		
		Set<Student> sets = map.keySet();
		for(Student s: sets)
		{
			System.out.println(s+"::"+map.get(s));
		}
	}
}</span>

打印结果是按Student中的姓名属性排序了的键值对。

Collections：

它给集合提供了更多的功能，这个类不需要创建对象，内部提供的都是静态方法。

一些常见方法：
排序：
1，static <T extends Comparable<? super T>> void sort(List<T> list) ，根据元素的自然顺序对指定列表按升序进行排序。
2，static <T> void sort(List<T> list, Comparator<? super T> c)，根据指定比较器产生的顺序对指定列表进行排序。

获取最大最小值：
1，static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)，据元素的自然顺序，返回给定 collection 的最大元素。
2，static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)，根据指定比较器产生的顺序，返回给定 collection 的最大元素。
3，static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)，据元素的自然顺序，返回给定 collection 的最小元素。
4，static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)，根据指定比较器产生的顺序，返回给定 collection 的最小元素。

二分查找：
1，static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) ，使用二分搜索法搜索指定列表，以获得指定对象
2，static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) ，使用二分搜索法搜索指定列表，以获得指定对象。

反向比较：
1，static <T> Comparator<T> reverseOrder() ，回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
2，static <T> Comparator<T> reverseOrder(Comparator<T> cmp)，返回一个比较器，它强行逆转指定比较器的顺序。

Collections类中还提供了对集合中所有函数进行同步封装的函数，并返回相应的同步集合。

Arrays：

用于操作数组对象的工具类，里面都是静态方法。
这些静态方法包括对数组元素进行查找，排序，复制，填充，比较等。

数组变集合（asList）：
最重要的一个方法是将数组编程List集合。将数组变成List集合的好处在于可以用操作List集合中的方法来操作元素。
但要注意的一点是，如果数组中的元素师基本类型，则会将数组作为该集合中的元素存在。

集合变数组（toArray）：
1,当直指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
2，当指定类型的数组长度大于了集合的size，就不会创建数组，而是使用传递进来的数组。
集合变数组是为了限定对元素的操作，只要获取这些元素即可。

java集合框架给我们提供了丰富和有用的数据结构和算法，这样就只需要关注数据的存储方式而不需要具体如何去实现数据的存储结构，大大减轻了写程序的负担和提高了代码的质量。

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com