一、 Set 接口及实现类
Set接口不能存储重复元素
Set接口继承了Collection接口。Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的
Set接口有两个实现类：
● HashSet ：HashSet类中的元素不能重复
● TreeSet ：可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
● HashSet
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
/*
Set:元素不重复
HashSet：元素是无序的
*/
HashSet<String> set = new HashSet<>();
set.add("a");
set.add("b");
set.add("c");
set.add("a");
set.add("d");
System.out.println(set);
//set.clear();
set.contains("a");
set.isEmpty();
set.remove("a");//没有索引,故而不能用for循环，只能用增强for和迭代器
set.size();
set.iterator();
}
}
HashSet在添加元素时，是如何判断元素重复的：
当我们向集合中添加一个元素时，如果每次都使用equals()比较内容是否相等，效率会很低
在底层会调用hashCode()方法
-- 在Object中的hashCode()返回的是地址，不能用
-- 而是调用String类中重写的hashCode()方法，返回的是根据内容计算的哈希值遍历时，会先比较内容的哈希值是否相等，会提高比较的效率，
但是Hash值会可能存在问题：内容不同，哈希相同（例如“通话”和“种地”的哈希值相同）此种情况下再调用 equals()内容
import javax.xml.transform.Source;
import java.sql.SQLOutput;
import java.util.HashSet;
public class HashSetDemo2 {
/*
HashSet在添加元素时，是如何判断元素重复的:
当我们向集合中添加一个元素时，如果每次都使用equals()比较内容是否相等，效率会很低
在底层会调用hashCode()方法
-- 在Object中的hashCode()返回的是地址，不能用
-- 而是调用String类中重写的hashCode()方法，返回的是根据内容计算的哈希值
遍历时，会用哈希值先比较是否相等，会提高比较的效率，
但是Hash值会可能存在问题，内容不同，哈希相同（例如“通话”和“种地”的哈希值相同）
此种情况下再调用 equals()内容
*/
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("a");
set.add("b");
set.add("c");
set.add("a");
set.add("d");
System.out.println(set);
for (String s : set){
System.out.println(s);
}
}
}
● TreeSet
可以给Set集合中的元素进行指定方式的排序。由于这些自定义的类型的数据没有实现Comparable接口，因此无法直接在TreeSet集合中进行排序操作。
解决方案：
要求TreeSet集合中存储的元素所在的类必须实现Comparable接口，并重写comoareTo()方法，然后TreeSet集合就会对该类型使用compareTo()方法进行比较，并默认进行升序排序
public class Student implements Comparable<Student>{
private int num;
private String name;
public Student() {
}
public Student(int num, String name) {
this.num = num;
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Student o) {
int temp = this.num - o.num;
return temp == 0 ? this.name.compareTo(o.name) : temp;
}
}
import java.util.Iterator;
import java.util.TreeSet;
/*
放入学生信息
要给自定义数据要实现compareTo接口
*/
public class TreeSetDemo2 {
public static void main(String[] args) {
Student s1 = new Student(20,"张三1");
Student s2 = new Student(21,"张三2");
Student s3 = new Student(20,"张三3");
Student s4 = new Student(23,"张三4");
Student s5 = new Student(20,"张三1");
TreeSet<Student> treeSet = new TreeSet<>();
treeSet.add(s4);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s1);
treeSet.add(s5);
System.out.println(treeSet);
}
}
● Set 接口集合迭代
• 增强for循环
import java.util.Iterator;
import java.util.TreeSet;
/*
放入学生信息
要给自定义数据要实现compareTo接口
*/
public class TreeSetDemo2 {
public static void main(String[] args) {
Student s1 = new Student(20,"张三1");
Student s2 = new Student(21,"张三2");
Student s3 = new Student(20,"张三3");
Student s4 = new Student(23,"张三4");
Student s5 = new Student(20,"张三1");
TreeSet<Student> treeSet = new TreeSet<>();
treeSet.add(s4);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s1);
treeSet.add(s5);
System.out.println(treeSet);
Iterator<Student> iterator = treeSet.iterator();
for(Student a : treeSet){
System.out.println(a.getNum()+a.getName());
}
}
}
• 迭代器遍历
二、 Map 接口 ※
将键映射到值的对象
Map接口的特性
数据存储是以 (键,值) 的形式存储
键不能重复，值可以重复
一个键只能映射到一个值
一个映射不能包含重复的键，每个键最多只能映射到一个值，即 值 -> 键 是 一对多 的形式
● Map 接口常用方法
V put(K key,V value) //一次向Map里放入一个键值对
V remove(Object key) //通过键删除
void clear() //清空 map
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
V get(Object key)
Collection<V> values()
Set<K> keySet()
Set<Map.Entry<K,V>> entrySet()
● HashMap ※
HashMap中元素的key值不能重复， 排列顺序是不固定的，可以存储一个为null的键。
其在存储时到底是什么结构？※
首先用到 Hash数组（查询快，定位快），长度默认为16，创建Hash数组主要是用来定位
然后通过输入的 key 来计算出一个 int类型 的 hash值（hash%数组长度），然后在该 hash值 的索引处创建一个 Next = NULL 的链表
当下一个 key 计算出来的hash值与存在的相同时（即hash冲突），比较该位置的值，如果不相同，则向下链接新节点（拉链法），即将后来的元素添加到之前元素的Next节点；如果相同，则用后来的键的值覆盖原来的值
当某一hash节点处的链表过长（ >=8 ）时（会影响速度），且哈希数组长度 >=64时，链表会自动转为红黑树
当哈希表的负载因子为0.75时，会自动扩容为原来数组长度的2倍
• HashMap方法
import java.util.Collection;
import java.util.HashMap;
public class HashMapDemo {
public static void main(String[] args) {
/*
Map接口的特性
数据存储是 (键,值)的形式存储
键不能重复，值可以重复
一个键只能映射到一个值
*/
HashMap<String,String> map = new HashMap<>();
map.put("a","aa"); //(键,值)
map.put("b","bb");
map.put("w","ww");
map.put("c","cc");
map.put("d","bb"); //值可以重复
map.put("a","aaa"); //用第二次加进的值覆盖了第一次键的值
System.out.println(map);
//删除指定的键并返回对应的值
System.out.println(map.remove("a"));
System.out.println(map);
//清除 map
/*
map.clear();
System.out.println(map);
*/
//判断map中键值对的个数是否为空
System.out.println(map.isEmpty());
//判断是否有输入的键
System.out.println(map.containsKey("b"));
//判断是否有输入的值
System.out.println(map.containsValue("bb"));
//获得 键的值
System.out.println(map.get("b"));
//返回map的所有值
System.out.println(map.values());
}
}
● TreeMap
TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。
import java.util.TreeMap;
/*
TreeMap
键可以排序
键元素必须实现 Comparable接口，重写compareTo()
*/
public class TreeMapDemo1 {
public static void main(String[] args) {
TreeMap<Integer,String> treeMap = new TreeMap<>();
treeMap.put(2,"aa");
treeMap.put(1,"bb");
treeMap.put(3,"aa");
treeMap.put(5,"cc");
treeMap.put(4,"ee");
treeMap.put(2,"bb");
System.out.println(treeMap);
}
}
● HashTable
/*
在HashMap中可以存储一个 键 或者 值 为null的对象
但Hashtable不能存储，会直接报错
*/
三、 Map集合遍历
● 根据键找值
• 获取所有键的集合
• 遍历键的集合，获取到每一个键
• 根据键找值
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Traverse1 {
public static void main(String[] args) {
/*
方法一：先拿到所有的键，遍历键，根据键找值
*/
// Collection<String> values = Map.values();
// System.out.println(values);
HashMap<String,String> map = new HashMap<>();
map.put("a","aa");
map.put("b","bb");
map.put("w","ww");
map.put("c","cc");
System.out.println(map);
//第一种遍历方式
Set<String> keyset = map.keySet();
for(String key : keyset){
System.out.println(key+":"+map.get(key));
}
}
}
● 根据键值对对象找键和值
• 获取所有键值对对象的集合
• 遍历键值对对象的集合，获取到每一个键值对对象
• 根据键值对对象找键和值
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Traverse1 {
public static void main(String[] args) {
// Collection<String> values = Map.values();
// System.out.println(values);
HashMap<String,String> map = new HashMap<>();
map.put("a","aa");
map.put("b","bb");
map.put("w","ww");
map.put("c","cc");
System.out.println(map);
//推荐的遍历方式
Set<Map.Entry<String,String>> entries = map.entrySet();
for(Map.Entry entry : entries){
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
四、 Collections类
Collections是集合类的工具类，与数组的工具类Arrays类似
addAll(Collection<? super T> c , T ... elements); //向集合中添加一个可变长度的数组
binarySearch(List<? extends Comparable<? super T >> list, T key)
sort(List<T> list) //根据元素的自然顺序 对指定列表按升序进行排序
sort(List<T> list, Comparator<? super T> c) //根据指定比较器产生的顺序对指定列表进行排序。
swap(List<?> list, int i , int j) //在指定List的指定位置 i , j 处交换元素
copy(List<? super T> dest , List<? extends T> src) ; //将集合复制
// 注意 dest size >= src.size
fill(List<? super T> list, T obj) //覆盖
max(Collection<? extends T> coll) //最大值
min(Collection<? extends T> coll) //最小值
replaceAl l(List<T> list , T oldVal , T newVal) //用 newVal 覆盖 list 中的 oldVal
reverse(List<?> list) //反转列表中元素的顺序
shuffle(List<?> list) //对List集合元素进行随机排序
copy(dest , src) //集合复制
addAll（）：向集合中添加一个可变长度的数组
import java.util.*;
public class CollectionsDemo1 {
public static void main(String[] args) {
HashMap<String,String> map = new HashMap<>();
map.put("a","aaa");
map.put("b","bbb");
map.put("c","ccc");
map.put("d","ddd");
map.put("e","eee");
/*
addAll(Collection < ? super T > c, T... elements);
父类对象（可以传进Collection接口的所有对象）
T ... elements ：可变长度的 T类型的参数
作用：向集合中添加元素
*/
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Collections.addAll(list,3,4,5,6);
System.out.println(list);
//test(1,2,3,4);
}
/*
int ... a 可变长度的参数，本质是一个数组
一个参数列表中只能有一个可变长度参数
且必须放在参数列表最后
*/
// public static void test(int ... a){
// System.out.println(Arrays.toString(a));
// }
}
sort（）：排序，需要根据元素重写
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class CollectionsDemo2 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Collections.addAll(list,3,5,2,4);
System.out.println(list);
//排序---自定义排序规则
//创建了一个实现Comparator接口的匿名内部类对象，就是省去创建一个类，简化了语法
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2.intValue()-o1.intValue();
}
});
Collections.sort(list);
System.out.println(list);
}
}
copy（）：将原集合的值复制到目标集合
注：目标集合必须非空，且目标集合的size>=原集合
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class CollectionsDemo3 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println(list);
//交换指定位置上的元素
Collections.swap(list,0,1);
System.out.println(list);
System.out.println();
//将一个集合的元素复制到另一个集合去
ArrayList<Integer> list1 = new ArrayList<>();
//如果目标集合的为空，那copy事会报错
list1.add(5);
list1.add(6);
list1.add(7);
//且目标集合的 size >= 原集合的 size，否则报错
list1.add(8);
Collections.copy(list1,list);
System.out.println(list);
System.out.println(list1);
}
}
其他：
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsDemo4 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println(list);
//最大值
System.out.println(Collections.max(list));
//最小值
System.out.println(Collections.min(list));
//用newVal覆盖oldVal
Collections.replaceAll(list,3,5);
System.out.println(list);
Collections.replaceAll(list,5,3);
//翻转集合元素顺序
Collections.reverse(list);
System.out.println(list);
//对集合元素随机排序
Collections.shuffle(list);
System.out.println(list);
}
}
五、 泛型
● 什么是泛型
● 泛型，即“参数化类型” 。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
● 参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。
● Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，泛型的好处就是在编译的时候能够检查类型安全。
● 泛型类
泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口
public class Demo<T>{
/ /T可以为任意标识符，常见的如T、E、K、V等形式的参数常用于表示泛型
private T key; / /key这个成员变量的类型为T,T的类型由外部指定
public Demo(T key) {
/ /泛型构造方法形参key的类型也为T，T的类型由外部指定
this.key = key;
}
public T getKey(){ / /泛型方法getKey的返回值类型为T，T的类型由外部指定
return key;
}
}
传入的实参类型需与泛型的类型参数类型相同，即为Integer.
1.泛型的类型参数只能是类类型
2.泛型的类型参数可以有多个
3.如果没有定义具体类型,默认为Object
● 从泛型类派生子类
父类：
public class A<T> {
T data;
}
子类也是泛型类，子类和父类的泛型类型要一致
class A<T> extends Demo<T>
/*
父类是泛型类
方法一：直接给子类也定义为泛型类
*/
public class B<T> extends A<T>{
public static void main(String[] args) {
B b = new B();
b.data = "String类型";
}
}
子类不是泛型类，父类要明确泛型的数据类型
class A extends Demo<String>
/*
父类是泛型类
方法二：若子类不是泛型类，那就要在子类中明确指出父类中的泛型
//public class B extends A<String>{
*/
public class B extends A<String>{
public static void main(String[] args) {
B b = new B();
b.data = "String类型";
}
}
● 泛型接口
泛型接口与泛型类的定义及使用基本相同。
public interface Demo<T> { //定义一个泛型接口 }
子类也是泛型类，子类和父类的泛型类型要一致
class A<T> implements Demo<T>{ }
子类不是泛型类，父类要明确泛型的数据类型
public class A implements Demo<String> { }
● 类型擦除
泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛到信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为一类型擦除。
泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型。
案例:
public class Demo<T>{
T name;
public Demo(T name) {
this.name= name;
}
}
Demo是一个泛型类，我们查看它在运行时的状态信息可以通过反射。
Demo<String> demo= new Demo<String>("jim");
Field f = eclz.getField(“name”);
System.out.println(f.getName()+" type:"+f.getType());
name type:java.lang.Object
