第五章泛型&集合

超、凢脫俗 2023-02-28 15:17 20阅读 0赞

### 目录 ###

*   *  5.1、泛型
     *  5.2、集合
     *   *  5.2.1、Collection接口
         *  5.2.2、List接口
         *  5.2.3、Set接口
         *  5.2.4、Map接口
     *  5.3、Collections类

--------------------

## 5.1、泛型 ##

概述：泛型是是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型类：

// 格式：修饰符 class 类名<类型> { }
    class Generic<T> { 
    	private T t;
    
    	public T getT() { 
    		return t;
    	}
    
    	public void setT(T t) { 
    		this.t = t;
    	}
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		Generic<String> g1 = new Generic<String>();
    		g1.setT("String");
    		System.out.println(g1.getT());
    		Generic<Integer> g2 = new Generic<Integer>();
    		g2.setT(100);
    		System.out.println(g2.getT());
    		Generic<Boolean> g3 = new Generic<Boolean>();
    		g3.setT(true);
    		System.out.println(g3.getT());
    	}
    }

泛型方法：

// 格式：修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
    class Generic { 
    	public <T> void show(T t) { 
    		System.out.println(t);
    	}
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		Generic g = new Generic();
    		g.show("String");
    		g.show(100);
    		g.show(true);
    	}
    }

泛型接口：

// 修饰符 interface 接口名<类型> { }
    interface Generic<T> { 
    	void show(T t);
    }
    
    class GenericImpl<T> implements Generic<T> { 
    	@Override
    	public void show(T t) { 
    		System.out.println(t);
    	}
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		Generic<String> g1 = new GenericImpl<String>();
    		g1.show("String");
    		Generic<Integer> g2 = new GenericImpl<Integer>();
    		g2.show(30);
    		Generic<Boolean> g3 = new GenericImpl<Boolean>();
    		g3.show(true);
    	}
    }

类型通配符：

类型通配符：<?>
        List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
        
    类型通配符上限：<? extends 类型>
        List<? extends Number>：它表示的类型是Number或者其子类型
        
    类型通配符下限：<? super 类型>
        List<? super Number>：它表示的类型是Number或者其父类型

可变参数：

public class Main { 
    	public static void main(String[] args) { 
    		System.out.println(sum(10));
    		System.out.println(sum(10, 20));
    		System.out.println(sum(10, 20, 30));
    		System.out.println(sum(10, 20, 30, 40));
    		System.out.println(sum(10, 20, 30, 40, 50));
    		System.out.println(sum(10, 20, 30, 40, 50, 60));
    		System.out.println(sum(10, 20, 30, 40, 50, 60, 70));
    		System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80));
    		System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80, 90));
    		System.out.println(sum(10, 20, 30, 40, 50, 60, 70, 80, 90, 100));
    	}
    
    	// 格式：修饰符 返回值类型 方法名(数据类型… 变量名) { }
    	public static int sum(int... a) { 
    		int sum = 0;
    		for (int i : a) { 
    			sum += i;
    		}
    		return sum;
    	}
    }

## 5.2、集合 ##

概述：提供一种可变的存储模型，存储的数据容量可以随时发生改变

体系：

![image-20200716202401541][]

### 5.2.1、Collection接口 ###

子接口特点：

1.  List接口：按照顺序存取，元素可以重复，有索引，可使用迭代器、增强for循环、普通for循环遍历
2.  Set接口：不按照顺序存取，元素不可以重复，没有索引，可使用迭代器、增强for循环遍历

通用方法：

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    public class Main { 
    	public static void main(String[] args) { 
    		// 创建集合
    		Collection<String> collection = new ArrayList<String>();
    
    		// 添加元素
    		collection.add("张三");
    		collection.add("张三");
    		collection.add("李四");
    		collection.add("李四");
    		collection.add("王五");
    		collection.add("王五");
    		System.out.println(collection.toString());
    
    		// 移除元素
    		collection.remove("张三");
    		System.out.println(collection.toString());
    
    		// 判断元素
    		boolean isContains = collection.contains("李四");
    		System.out.println(isContains);
    
    		// 判断集合是否为空
    		boolean isEmpty = collection.isEmpty();
    		System.out.println(isEmpty);
    
    		// 获取集合元素个数
    		int size = collection.size();
    		System.out.println(size);
    
    		// 用迭代器遍历集合
    		Iterator<String> iterator = collection.iterator();
    		while (iterator.hasNext()) { 
    			System.out.println(iterator.next());
    		}
    
    		// 用增强for循环遍历
    		for (String s : collection) { 
    			System.out.println(s);
    		}
    
    		// 添加另外集合元素
    		Collection<String> c = new ArrayList<String>();
    		c.add("小可爱");
    		c.add("大可爱");
    		collection.addAll(c);
    		System.out.println(collection.toString());
    
    		// 清空集合所有元素
    		collection.clear();
    		System.out.println(collection.toString());
    	}
    }

### 5.2.2、List接口 ###

子类特点：

1.  ArrayList集合：底层是数组结构实现，查询快、增删慢
2.  LinkedList集合：底层是链表结构实现，查询慢、增删快

通用方法：

import java.util.ArrayList;
    import java.util.List;
    import java.util.ListIterator;
    
    public class Main { 
    	public static void main(String[] args) { 
    		// 创建集合
    		List<String> list = new ArrayList<String>();
    
    		// 添加元素
    		list.add("张三");
    		list.add("张三");
    		list.add("李四");
    		list.add("李四");
    		list.add("王五");
    		list.add("王五");
    		System.out.println(list.toString());
    
    		// List独有方法：E get(int index)
    		String s = list.get(0);
    		System.out.println(s);
    
    		// List独有方法：E set(int index, E element)
    		list.set(2, "xiaoqi");
    		System.out.println(list.toString());
    
    		// List独有方法：ListIterator<E> listIterator()
    		ListIterator<String> listIterator = list.listIterator();
    		// 使用列表迭代器：从前向后迭代
    		while (listIterator.hasNext()) { 
    			System.out.println(listIterator.next());
    		}
    		// 使用列表迭代器：从后向前迭代
    		while (listIterator.hasPrevious()) { 
    			System.out.println(listIterator.previous());
    		}
    
    		// List独有遍历：普通for循环遍历
    		for (int i = 0; i < list.size(); i++) { 
    			System.out.println(list.get(i));
    		}
    	}
    }

注意事项：

LinkedList集合的特有方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void addFirst(E e)</td> 
   <td>在该列表开头插入指定的元素</td> 
  </tr> 
  <tr> 
   <td>public void addLast(E e)</td> 
   <td>在该列表末尾追加指定的元素</td> 
  </tr> 
  <tr> 
   <td>public E getFirst()</td> 
   <td>返回此列表中的第一个元素</td> 
  </tr> 
  <tr> 
   <td>public E getLast()</td> 
   <td>返回此列表中的最后一个元素</td> 
  </tr> 
  <tr> 
   <td>public E removeFirst()</td> 
   <td>从此列表中删除并返回第一个元素</td> 
  </tr> 
  <tr> 
   <td>public E removeLast()</td> 
   <td>从此列表中删除并返回最后一个元素</td> 
  </tr> 
 </tbody> 
</table>

### 5.2.3、Set接口 ###

子类特点：

1.  HashSet集合：底层由哈希表支撑，元素存取无序，对象添加需要重写hashCode和equals方法
2.  TreeSet集合：底层由二叉树支撑，元素顺序存取，对象排序需要继承Comparable接口重写compareTo方法、或者使用Comparator初始化

HashSet演示：

import java.util.Collection;
    import java.util.HashSet;
    
    class Student { 
    	private String name;
    	private Integer age;
    
    	public Student() { 
    		super();
    	}
    
    	public Student(String name, Integer age) { 
    		super();
    		this.name = name;
    		this.age = age;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public Integer getAge() { 
    		return age;
    	}
    
    	public void setAge(Integer age) { 
    		this.age = age;
    	}
    
    	@Override
    	public String toString() { 
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    
    	@Override
    	public int hashCode() { 
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((age == null) ? 0 : age.hashCode());
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Student other = (Student) obj;
    		if (age == null) { 
    			if (other.age != null)
    				return false;
    		} else if (!age.equals(other.age))
    			return false;
    		if (name == null) { 
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		// 创建集合
    		Collection<Student> collection = new HashSet<Student>();
    
    		// 添加元素
    		collection.add(new Student("张三", 20));
    		collection.add(new Student("张三", 20));
    		collection.add(new Student("李四", 21));
    		collection.add(new Student("李四", 21));
    		collection.add(new Student("王五", 22));
    		collection.add(new Student("王五", 22));
    		System.out.println(collection.toString());
    	}
    }

TreeSet演示：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

import java.util.Collection;
    import java.util.Comparator;
    import java.util.TreeSet;
    
    class Student { 
    	private String name;
    	private Integer age;
    
    	public Student() { 
    		super();
    	}
    
    	public Student(String name, Integer age) { 
    		super();
    		this.name = name;
    		this.age = age;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public Integer getAge() { 
    		return age;
    	}
    
    	public void setAge(Integer age) { 
    		this.age = age;
    	}
    
    	@Override
    	public String toString() { 
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    }
    
    public class Main { 
    	public static void main(String[] args) { 
    		// 创建集合
    		Collection<Student> collection = new TreeSet<Student>(new Comparator<Student>() { 
    			@Override
    			public int compare(Student s1, Student s2) { 
    				// 主要条件
    				int sort1 = s1.getAge() - s2.getAge();
    				// 次要条件
    				int sort2 = sort1 == 0 ? s1.getName().compareTo(s2.getName()) : sort1;
    				return sort2;
    			}
    		});
    
    		// 添加元素
    		collection.add(new Student("王五", 22));
    		collection.add(new Student("王五", 22));
    		collection.add(new Student("张三1", 20));
    		collection.add(new Student("张三0", 20));
    		collection.add(new Student("李四0", 18));
    		collection.add(new Student("李四1", 18));
    		System.out.println(collection.toString());
    	}
    }

### 5.2.4、Map接口 ###

接口特点：

1.  键值对映射关系
2.  一个键对应一个值，键不可以重复，值可以重复
3.  凡是对象作为HashMap的键时，对象添加需要重写hashCode和equals方法

通用方法：

import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    
    public class Main { 
    	public static void main(String[] args) { 
    		// 创建集合
    		Map<String, String> map = new HashMap<String, String>();
    
    		// 添加元素
    		map.put("吕布", "貂蝉");
    		map.put("项羽", "虞姬");
    		map.put("郭靖", "黄蓉");
    		map.put("后裔", "嫦娥");
    		System.out.println(map.toString());
    
    		// 删除元素
    		map.remove("郭靖");
    		System.out.println(map.toString());
    
    		// 判断集合是否包含指定键
    		boolean containsKey = map.containsKey("吕布");
    		System.out.println(containsKey);
    
    		// 判断集合是否包含指定值
    		boolean containsValue = map.containsValue("貂蝉");
    		System.out.println(containsValue);
    
    		// 判断集合是否为空
    		boolean isEmpty = map.isEmpty();
    		System.out.println(isEmpty);
    
    		// 获取集合元素个数
    		int size = map.size();
    		System.out.println(size);
    
    		// 清空集合所有元素
    		map.clear();
    		System.out.println(map.toString());
    
    		// 添加另外集合元素
    		Map<String, String> m = new HashMap<String, String>();
    		m.put("张三", "李四");
    		m.put("王五", "小六");
    		map.putAll(m);
    		System.out.println(map.toString());
    
    		// 根据键获取值
    		System.out.println(map.get("张三"));
    
    		// 获取所有键的集合
    		Set<String> keySet = map.keySet();
    		// 迭代器遍历
    		Iterator<String> keysIterator = keySet.iterator();
    		while (keysIterator.hasNext()) { 
    			System.out.println(keysIterator.next());
    		}
    		// 增强for遍历
    		for (String key : keySet) { 
    			System.out.println(key);
    		}
    
    		// 获取所有值的集合
    		Collection<String> values = map.values();
    		// 迭代器遍历
    		Iterator<String> valuesIterator = values.iterator();
    		while (valuesIterator.hasNext()) { 
    			System.out.println(valuesIterator.next());
    		}
    		// 增强for遍历
    		for (String value : values) { 
    			System.out.println(value);
    		}
    
    		// 获取所有键值对对象的集合
    		Set<Entry<String, String>> entrySet = map.entrySet();
    		// 迭代器遍历
    		Iterator<Entry<String, String>> entrySetIterator = entrySet.iterator();
    		while (entrySetIterator.hasNext()) { 
    			Entry<String, String> entry = entrySetIterator.next();
    			String key = entry.getKey();
    			String value = entry.getValue();
    			System.out.println(key + ":" + value);
    		}
    		// 增强for遍历
    		for (Entry<String, String> entry : entrySet) { 
    			String key = entry.getKey();
    			String value = entry.getValue();
    			System.out.println(key + ":" + value);
    		}
    	}
    }

## 5.3、Collections类 ##

描述：是针对集合操作的工具类

成员方法：

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void sort(List list)</td> 
   <td>将指定的列表按升序排序</td> 
  </tr> 
  <tr> 
   <td>public static void reverse(List list)</td> 
   <td>反转指定列表中元素的顺序</td> 
  </tr> 
  <tr> 
   <td>public static void shuffle(List list)</td> 
   <td>使用默认的随机源随机排列指定的列表</td> 
  </tr> 
 </tbody> 
</table>

示例代码：斗地主洗牌

import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.TreeSet;
    
    public class Main { 
    	public static void main(String[] args) { 
    		// 创建HashMap，键是编号，值是牌面
    		HashMap<Integer, String> hm = new HashMap<Integer, String>();
    		// 创建ArrayList，存储编号
    		ArrayList<Integer> array = new ArrayList<Integer>();
    		// 创建花色数组和点数数组
    		String[] colors = {  "♦", "♣", "♥", "♠" };
    		String[] numbers = {  "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2" };
    		// 从0开始往HashMap里面存储编号并存储对应的牌面，同时往ArrayList里面存储编号
    		int index = 0;
    		for (String number : numbers) { 
    			for (String color : colors) { 
    				hm.put(index, color + number);
    				array.add(index);
    				index++;
    			}
    		}
    		hm.put(index, "小王");
    		array.add(index);
    		index++;
    		hm.put(index, "大王");
    		array.add(index);
    		// 洗牌(洗的是编号)
    		Collections.shuffle(array);
    		// 发牌(发的是编号)
    		TreeSet<Integer> playerSet1 = new TreeSet<Integer>();
    		TreeSet<Integer> playerSet2 = new TreeSet<Integer>();
    		TreeSet<Integer> playerSet3 = new TreeSet<Integer>();
    		TreeSet<Integer> dpSet = new TreeSet<Integer>();
    		for (int i = 0; i < array.size(); i++) { 
    			int x = array.get(i);
    			if (i >= array.size() - 3) { 
    				dpSet.add(x);
    			} else if (i % 3 == 0) { 
    				playerSet1.add(x);
    			} else if (i % 3 == 1) { 
    				playerSet2.add(x);
    			} else if (i % 3 == 2) { 
    				playerSet3.add(x);
    			}
    		}
    		// 调用看牌方法
    		lookPoker("player1", playerSet1, hm);
    		lookPoker("player2", playerSet2, hm);
    		lookPoker("player3", playerSet3, hm);
    		lookPoker("dp", dpSet, hm);
    	}
    
    	/** * 看牌方法 * @param name 玩家名称 * @param ts 牌面编号 * @param hm 牌面集合 */
    	public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) { 
    		System.out.print(name + ": ");
    		for (Integer key : ts) { 
    			String poker = hm.get(key);
    			System.out.print(poker + " ");
    		}
    		System.out.println();
    	}
    }

[image-20200716202401541]: /images/20230209/0910b3dbc98a4126925c62420eb1c9ed.png