第十章总结

m0_67210901

已于 2022-05-23 14:20:28 修改

阅读量157

点赞数

文章标签：链表 java 数据结构

于 2022-05-23 14:08:09 首次发布

本文链接：https://blog.csdn.net/m0_67210901/article/details/124924317

版权

1.集合类概念

java.util包中提供了一些集合类，这些集合类又被称为容器.提到容器不难想到数组，集合类与数组的不同之处是，数组的长度是固定的，集合的长度是可变的；数组用来存放基本类型的数据，集合用来存放对象的引用。常用的集合有List集合、Set集合和Map集合，其中List与Set继承了Collection接口，各接口还提供了不同的实现类。

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

List集合

List集合包括List接口以及List接口的所有实现类。List集合中的元素允许重复，各元素的顺序就是对象插入的顺序。类似Java数组，用户可以使用索引（元素在集合中的位置)来访问集合中的元素

List接口

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

List接口的实现类
Las接口由于不能直接实例化，因此，在JDK中提供了其实现子类。最常用的实施子类有ArrayList类与Linked List类，分别如下。
(1)ArrayList类的优点是实现了可变的数组，允许保存所有元素，包括null，并可以根据索引位置对集合进行快速的随机访问；缺点是向指定的索引位置插入对象或删除对象的速度较慢。因为AmayLiat实质上是使用数组来保存集合中的元素的，在增加和删除指定位置的元素时、虚拟机会建新的数组。效率低，所以在对元素做大量的增删操作时不适合使用ArrayList集合。

(2) LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用Linked List类实现的List集合的效率较高；但对于随机访问集合中的对象，使用 LinkedList 类实现List集合的效率较低.
技巧：
实例化List接口对象时，建议优先使用ArayList，只有在插入和删除操作特别频繁时，才使用 LinkedList

import java.util.*;
 
public class ListTest {
 
	public static void main(String[] args) {//主方法
		List<String>list=new ArrayList<>();//创建集合对象
		list.add("a");//向集合添加元素
		list.add("b");
		list.add("c");
		int i=(int)(Math.random()*list.size());//获取0~2之间的随机数
		System.out.println("随机获取数组中的元素："+list.get(i));
		list.remove(2);//将指定索引位置的元素从集合中移除
		System.out.println("将索引是'2'的元素从数组移除后，数组中的元素是：");//输出
		for(int j=0;j<list.size();j++){//遍历循环集合
		System.out.println(list.get(j));//获取指定索引处的值
	}
	}
}

Iterator迭代器

在java.until包中提供了一个Iterator接口，该接口是一个专门对Collection进行迭代的迭代器

迭代器：循环遍历集合中的元素

Iterator的next()方法返回的是Object。

程序中使用Iterator迭代器时，可以使用Collection接口中的iterator()方法返回一个Iterator对象。

import java.util.*;//导入java.until包，其他实例都要添加该语句
 
public class IteratorTest {//创建类
	public static void main(String[] args) {//主方法
		Collection<String>list=new ArrayList<>();//实例化集合类对象
		list.add("a");//向集合添加数据
		list.add("b");
		list.add("c");
Iterator<String>it=list.iterator();//创建迭代器
while(it.hasNext()){//判断是否有下一个元素
	String str=(String)it.next();//获取集合中的元素
	System.out.println(str);
}

Set集合
Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但Set集合中不能包含重复的对象。Set集合有Set接口和Set接口的实现类组成。

Set接口
Set接口是一个不包含重复元素的集合，由于其继承了 Collection 接口，因此包含 Collection 接口的所有方法。
注意：
Set的构造有一个约束条件，传入的 Collection 对象不能有重复值，必须小心操作可变对象(Mutable Object)。如果一个Set中的可变元素改变了自身状态导致Object、equals(Object)=true，则会出现一些问题。
由于Set集合中不允许有重复元素出现，因此，在向Set集合中添加元素时，需要先判断元素是否已经存在，再确定是否执行添加操作，例如HashSet的流程如图10.3所示。

Set接口的实现类
Set接口常用的实现类有HashSet类与TreeSet类，分别如下。
(1)HashSet是Set接口的一个实现类，它不允许有重复元素，HashSet主要依据哈希算法直接将元素指定到一个地址上。当向HashSet集合中添加一个元素时，会调用equals方法来判断该位置是否有重复元素。判断是通过比较它们的HashCode来进行比较的。HashSet集合的常用方法都是重写了Set接口中的方法。此集合允许保存null.
(2)TreeSet类不仅实现了Set接口，还实现了java. uti LSortedSet 接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以制定排序规则，让集合按照我们想要的方式进行排序。TreeSet类新增的方法如表10.4所示。此集合不能保存null。
表10.4TreeSet类增加的方法

说明：
比较器，即 Comparator 接口，它提供一个抽象方法compare(To1，To2)，这个方法指定了两个对象的比较规则，如果ol大于a2，方法返回正数(通常为+1)；如果ol等于o2，方法返回0；如果ol小于o2，方法返回负数(通常为-1】
还有另一个接口也能实现比较规则： Comparable 。它提供一个抽象方法comparcTo(To)，将调用方法的对象与参数对象进行比较，返回值的规则与上面的 Comparator . compare()方法相同。
如果想制定TreeSet的排序规则，可以在实例化TrecSet对象时，将一个已写好的比较器作为构造参数传入，或者让TreeSet中的所有元素都实现 Comparable 接口。
技巧：
HashSct类和TreeSet类都是Set接口的实现类，它们当中都不允许有重复元素，但HashSet类不关心元素之间的顺序，而TheeSet类则在希望按照元素的自然顺序进行排序时使用(自然顺序的意思是与插入顺序无关，而是和元素本身的内容和特质有关，

TreeSet自定义排序

一、引入排序

	@Test
	public void test1() {
		TreeSet treeSet = new TreeSet();
		treeSet.add(10);
		treeSet.add(11);
		treeSet.add(13);
		treeSet.add(12);
		for (Object object : treeSet) {
			System.out.print(object + " " );
		}	
	}

运行结果：10 11 12 13

结论：默认进行升序排列

思考：但是对于自定义对象呢？

```
   /*  
        实体类：Book
    */
    public class Book { 
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
    }
   /*  
        测试类
    */
     @Test
     public void test2() {
		
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(2, "西游记", "曹雪芹",13.0);
	Book book3 = new Book(3, "水浒传", "曹雪芹",12.0);
		
	TreeSet treeSet = new TreeSet();
	treeSet.add(book1);
	treeSet.add(book2);
	treeSet.add(book3);
	for (Object object : treeSet) {
		Book book = (Book)object;
		System.out.println(book.getBookName() + book.getPrice());
	   }
		
	}
```
解决方案：1、自然排序 2、定制排序

二、自定义类型排序
如果集合存储的是自定义类型，当存入自定义的引用类型的时候就必须考虑到元素要求具有可排序性，不然会引发ClassCastException异常，所以要对自定义类型进行处理，必须要实现 Comparable或Compared接口。当把一个对象加入TreeSet集合中时，TreeSet调用该对象的compareTo(Object obj)方法与容器中的其他对象比较大小，然后根据红黑树算法决定它的存储位置。

2.1 自然排序
TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系，然后将集合元素按升序排列，这种方式就是自然排序。（比较的前提：两个对象的类型相同）。

操作步骤：

1、Book类实现Comparable接口；

2、重写Comparable接口中的compareTo方法。
```
  /*
      Book类
      compareTo(T o) ： 比较此对象与指定对象的顺序。
      特别注意在重写Compareto方法时，注意排序 ！！！
  */ 
   public class Book implements Comparable{ // 第一步：实现Comparable接口
   
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
 
        
        public int compareTo(Object o) {    // 第二步：重写Comparable接口中的compareTo方法。
                // 若想按照价格从小到大排序，则需要return  = 1 ，即已存在数据大于待存数据
		Book book = (Book)o;
	        int flag = (int)(this.getPrice() - book.getPrice()); 
		return flag;
 	}
 
    }
   /*
       测试类
   */
    @Test
    public void test3() {
		
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(2, "西游记", "曹雪芹",13.0);
	Book book3 = new Book(3, "水浒传", "曹雪芹",12.0);
		
	TreeSet treeSet = new TreeSet();
	treeSet.add(book1);
	treeSet.add(book2);
	treeSet.add(book3);
	for (Object object : treeSet) {
		Book book = (Book)object;
		System.out.println(book.getBookName() + book.getPrice());
	}
		
	}
```
TreeSet的自然排序是根据集合元素的大小，TreeSet将他们以升序排列。如果需要实现定制排序，例如降序，则可以使用Comparator接口。该接口里包含一个int compare（T o1， T o2）方法，该方法用于比较o1和o2的大小。如果需要实现定制排序，则需要在创建TreeSet集合对象时，并提供一个Comparator对象与该TreeSet集合关联，由该Comparator对象负责集合元素的排序逻辑。

操作步骤：

让集合构造方法接收Comparator的实现类的compare()方法。
```
   /*  
        实体类：Book
    */
    public class Book { 
    	private Integer bookId;
	private String bookName;
	private String bookAuthor;
	private Double price;
    }
   /** 
       测试类
   */
   @Test
   public void test4() {
		
	Book book1 = new Book(1, "红楼梦", "曹雪芹",11.0);
	Book book2 = new Book(1, "西游记", "曹雪芹",3.0);
	Book book3 = new Book(1, "水浒传", "曹雪芹",12.0);
	/**
           compare有两个参数，o1和o2，如果
	   o1 < o2  返回负数,
	   o1 = o2  返回正数,
           o1 > o2 返回正数。
        */
	TreeSet treeSet = new TreeSet(new Comparator() {   // 匿名内部类操作
	public int compare(Object o1, Object o2) {	
               Book book1 = (Book)o1;
               Book book2 = (Book)o2;			
	       return (int)( book1.getPrice() - book2.getPrice());				
		}
			
	});
		treeSet.add(book1);
		treeSet.add(book2);
		treeSet.add(book3);
		for (Object object : treeSet) {
			Book book = (Book)object;
			System.out.println(book.getBookName() + book.getPrice());
		}
		
	}
```
在现实生活中，每辆车都有唯一的车牌号，通过车牌号可以查询到这辆车的详细信息，这两者是一对一的关系，在应用程序中，如果想存储这种具有对应关系的数据，则需要使用JDK中提供的Map接口。Map接口没有继承 Collection 接口，其提供的是key到value的映射。Map中不能包含相同的key，每个key只能映射一个value.另外，key还决定了存储对象在映射中的存储位置，但不是由key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值来确定存储对象在映射中的存储位置。Map集合包括Map接口以及Map接口的所有实现类。
10.5.1 Map接口
Map接口提供了将key映射到值的对象。一个映射不能包含重复的key，每个key最多只能映射一个值。Map接口的常用方法及说明如表10.5所示。
表10.5 Map接口中的常用方法

Map接口的实现类
Map接口常用的实现类有HashMap和TreeMap两种，分别如下。
(1)HashMap类是基于哈希表的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性。HashMap通过哈希表对其内部的映射关系进行快速查找、此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
(2)TreeMap类不仅实现了Map接口，还实现了java、uili、SortedMap接口，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时，TreeMap类比HashMap类性能稍差。由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null.

集合的使用场合
前面介绍了Java中最常见的3种集合：List集合、Set集合和Map集合，那么在实际开发中，具体何时应该选择哪种集合呢？这里我们总结了以下原则。
(1) List集合关注的是索引，其元素是顺序存放的，例如一个班的学生成绩，成绩可以重复，就可以使用List集合存取，
(2) Set集合关注唯一性，它的值不允许重复，例如每个班的学生的学号，每个学生的学号是不能重复的.
(3) Map集合关注的是唯一的标识符(KEY)，它将唯一的键映射到某个元素，例如每个班学生的学号与姓名的映射，每个学号对应一个学生的姓名，学号是不能重复的，但是学生的姓名有可能重复。