Java--集合

一、泛型

1.1 概述

• 参数化数据类型
  • 在创建对象的时候指定类中属性的数据类型
  • 动态设置，扩展性增强
• 放入数据的时候就检查数据的类型

1.2 自定义泛型类

public class Student<T, G> {
    String name;
    int age;
    T stuId;
    G gender;
}

二、Set接口

2.1 概述

• 无序：Set 不保证其元素的顺序，具体的顺序取决于其具体实现类。
• 唯一性：Set 保证集合中的元素不重复。如果试图将重复的元素添加到集合中，添加操作将不会影响集合。
• 基本操作：Set 接口继承了 Collection 接口中的基本操作，如 add, remove, contains, size, clear, isEmpty 等。

2.2 实现类

• HashSet
• LinkedHashSet
• TreeSet

三、HashSet

3.1 概述

• 此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。
• 此实现不是同步的。

3.2 创建对象

import java.util.HashSet;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 构造方法摘要 
            HashSet() 
                      构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 

            HashSet(int initialCapacity) 
                      构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。 
                      
            HashSet(int initialCapacity, float loadFactor) 
                      构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。 
         */
        
        //  构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 
        HashSet<String> set01 = new HashSet<String>();
        
        HashSet<String> set02 = new HashSet<String>(1000);
        
        HashSet<String> set03 = new HashSet<String>(1024, 0.95F);
    }
}

3.3 HashSet的无序不重复

import java.util.HashSet;

public class Demo02 {
    public static void main(String[] args) {
        // 创建集合
        HashSet<String> set = new HashSet<String>();
        
        // 添加数据
        
        // 无序
        set.add("吕布");
        set.add("马超");
        set.add("赵云");
        set.add("张飞");
        System.out.println(set);
        
        // 不重复
        set.add("赵云");
        set.add("张飞");
        System.out.println(set);
    }
}

import java.util.HashSet;

public class Demo03 {
    public static void main(String[] args) {
        // 创建集合
        HashSet<Student> stus = new HashSet<Student>();
        stus.add(new Student("吕布", 22, "骁勇善战"));
        stus.add(new Student("马超", 23, "骁勇善战"));
        stus.add(new Student("张飞", 25, "骁勇善战"));
        System.out.println(stus);
        
        stus.add(new Student("张飞", 25, "骁勇善战"));
        System.out.println(stus);
    }
}

class Student {
    String name;
    int age;
    String info;

    public Student(String name, int age, String info) {
        super();
        this.name = name;
        this.age = age;
        this.info = info;
    }
    
    @Override
    public int hashCode() {
        System.out.println(name + "调用了hashCode方法");
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((info == null) ? 0 : info.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        System.out.println(name + "调用了equals方法");
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (info == null) {
            if (other.info != null)
                return false;
        } else if (!info.equals(other.info))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", info=" + info + "]";
    }

}

四、LinkedHashSet

4.1 概述

• 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
• 此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。
• 此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。

4.2 存取有序

import java.util.LinkedHashSet;

public class Demo04 {
    public static void main(String[] args) {
        /**
         *  LinekdHashSet
         *      无序【无索引】
         *      不重复
         *      可预知迭代顺序【存取顺序一致】
         */
        
        LinkedHashSet<String> set = new LinkedHashSet<String>();
        // 存取一致【可预知迭代顺序】
        set.add("吕布");
        set.add("马超");
        set.add("赵云");
        set.add("张飞");
        System.out.println(set);
        
        // 不重复
        set.add("赵云");
        set.add("张飞");
        System.out.println(set);
        
        for (String name : set) {
            System.out.println(name);
        }
    }
}

五、TreeSet【重点】

5.1 概述

• 基于 TreeMap 的 NavigableSet 实现。
• 排序方式具体取决于使用的构造方法：
  • 使用元素的自然顺序对元素进行排序
  • 根据创建 set 时提供的 Comparator 进行排序

5.2 创建对象

import java.util.TreeSet;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 构造方法摘要 
            TreeSet() 
                      构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。 
            TreeSet(Comparator<? super E> comparator) 
                      构造一个新的空 TreeSet，它根据指定比较器进行排序。 
         */
        //  构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。 
        TreeSet<Integer> set01 = new TreeSet<Integer>();
        
        set01.add(22);
        set01.add(12);
        set01.add(22);
        set01.add(32);
        System.out.println(set01);
    }
}

5.3 自然顺序【内置类型】

• 按照元素的自然顺序排序

import java.util.TreeSet;

public class Demo02 {
    public static void main(String[] args) {
        TreeSet<Integer> set01 = new TreeSet<Integer>();
        // 不重复 && 可排序
        set01.add(22);
        set01.add(12);
        set01.add(22);
        set01.add(32);
        System.out.println(set01);
        
        // 创建集合存储字符串
        TreeSet<String> set02 = new TreeSet<String>();
        set02.add("Tony");
        set02.add("Tom");
        set02.add("Jerry");
        set02.add("Jack");
        set02.add("Lucy");
        System.out.println(set02);
    }
}

5.4 自然顺序【自定义类型】

• 自定义的类型存入TreeSet集合之前需要实现一个接口Comparable
  • 重写compareTo方法，在方法中自定义比较的规则

import java.util.TreeSet;

public class Demo03 {
    public static void main(String[] args) {
        // 创建TreeSet集合存储Person对象
        TreeSet<Person> persons = new TreeSet<Person>();
        
        // 添加数据
        persons.add(new Person("Tony", 23));
        persons.add(new Person("Tom", 3));
        persons.add(new Person("Jerry", 1));
        persons.add(new Person("Jack", 23));
        
        System.out.println(persons);
    }
}

class Person implements Comparable<Person> {
    String name;
    int age;

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(Person p) {
        // 先使用年龄比较
        int result = this.age - p.age;
        
        // 如果result==0,年龄是相同的,再使用name属性比较
        if (result == 0) {
            // 下面的compareTo方法是字符串比较的方法
            result = this.name.compareTo(p.name);
        }
        return result;
    }

}

5.5 Comparator

import java.util.Comparator;
import java.util.TreeSet;

public class Demo04 {
	public static void main(String[] args) {
		Comparator<People> comparator = new Comparator<People>() {
			@Override
			public int compare(People p1, People p2) {
				// 先使用年龄比较
				int result = p1.age - p2.age;
				
				// 如果result==0,年龄是相同的,再使用name属性比较
				if (result == 0) {
					// 下面的compareTo方法是字符串比较的方法
					result = p1.name.compareTo(p2.name);
				}
				return result;
			}
		};
		
		// 创建TreeSet集合存储Person对象
		TreeSet<People> peoples = new TreeSet<People>(comparator);
		
		// 添加数据
		peoples.add(new People("Tony", 23));
		peoples.add(new People("Tom", 3));
		peoples.add(new People("Jerry", 1));
		peoples.add(new People("Jack", 23));
		
		System.out.println(peoples);
	}
}

class People {
	String name;
	int age;

	public People(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "People [name=" + name + ", age=" + age + "]";
	}
}

六、Collections

6.1 概述

• 操作集合的一个工具
• 提供的方法
  • 查询最值
  • 排序
  • 翻转
  • 填充
  • 交换
  • 轮转
  • 替换
  • … …

6.2 常用方法

import java.util.ArrayList;
import java.util.Collections;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
			static <T> boolean addAll(Collection<? super T> c, T... elements) 
			          将所有指定元素添加到指定 collection 中。 
			static <T extends Comparable<? super T>> void sort(List<T> list) 
			          根据元素的自然顺序 对指定列表按升序进行排序。 
			static void swap(List<?> list, int i, int j) 
			          在指定列表的指定位置处交换元素。 
			static void shuffle(List<?> list) 
			          使用默认随机源对指定列表进行置换。 
			static <T> T max(Collection<? extends T> coll) 
			          返回给定 collection 的最大元素。 
			static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 
			          根据元素的自然顺序 返回给定 collection 的最小元素。 
			static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
			          使用另一个值替换列表中出现的所有某一指定值。 
			static void reverse(List<?> list) 
			          反转指定列表中元素的顺序。 
			static void rotate(List<?> list, int distance) 
			          根据指定的距离轮换指定列表中的元素。 
			static <T> void fill(List<? super T> list, T obj) 
			          使用指定元素替换指定列表中的所有元素。 
		 */
		// 创建集合
		ArrayList<Integer> list = new ArrayList<Integer>();
		
		// 添加数据
		list.add(11);
		list.add(12);
		list.add(15);
		list.add(10);
		System.out.println(list);
		
		// 批量添加数据
		Collections.addAll(list, 23,324,45,56,22);
		System.out.println(list);
		
		// 集合排序
		Collections.sort(list);
		System.out.println(list);
		
		// 交换指定位置的元素
		Collections.swap(list, 0, 1);
		System.out.println(list);
		
		// 随机分布
		Collections.shuffle(list);
		System.out.println(list);
		
		// 最值
		System.out.println(Collections.max(list));
		System.out.println(Collections.min(list));
		
		// 替换
		Collections.replaceAll(list, 324, 666);
		System.out.println(list);
		
		// 集合排序
		Collections.sort(list);
		System.out.println(list);
		
		// 翻转
		Collections.reverse(list);
		System.out.println(list);
		
		// 轮转
		Collections.rotate(list, 3);
		System.out.println(list);
		
		// 填充
		Collections.fill(list, 888);
		System.out.println(list);
	}
}

七、Map接口

7.1 概述

• 双列集合：一列key，一列value
• 将键映射到值的对象。
  • 一个映射不能包含重复的键；【键不能重复】
  • 每个键最多只能映射到一个值【值可以重复】

7.2 实现类

HashMap

LinkedHashMap

HashTable

TreeMap

Properties

7.3 常用方法

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 方法摘要 
		 * 增
			 V put(K key, V value) 
			          将指定的值与此映射中的指定键关联（可选操作）。 
			 void putAll(Map<? extends K,? extends V> m) 
			          从指定映射中将所有映射关系复制到此映射中（可选操作）。 
		 
		 * 删
			 V remove(Object key) 
			          如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。 
			 void clear() 
			          从此映射中移除所有映射关系（可选操作）。 
		 
		 * 改
			 V put(K key, V value) 
			          将指定的值与此映射中的指定键关联（可选操作）。 
			 void putAll(Map<? extends K,? extends V> m) 
			          从指定映射中将所有映射关系复制到此映射中（可选操作）。 
		 
		 * 查
			 int size() 
			          返回此映射中的键-值映射关系数。 
			 V get(Object key) 
			          返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。 
			 boolean containsKey(Object key) 
			          如果此映射包含指定键的映射关系，则返回 true。 
			 boolean containsValue(Object value) 
			          如果此映射将一个或多个键映射到指定值，则返回 true。 
		 
			 Set<K> keySet() 
			          返回此映射中包含的键的 Set 视图。 
			 Collection<V> values() 
			          返回此映射中包含的值的 Collection 视图。 
			 Set<Map.Entry<K,V>> entrySet() 
			          返回此映射中包含的映射关系的 Set 视图。 
		 */
		// 创建Map的实现类对象:动态方式创建
		Map<String, Integer> scores = new HashMap<String, Integer>();
		
		// 添加映射
		scores.put("张飞", 88);
		scores.put("吕布", 98);
		scores.put("孙悟空", 99);
		scores.put("白龙马", 108);
		scores.put("宋江", 110);
		scores.put("贾宝玉", 145);
		
		System.out.println(scores);
		
		// 修改数据
		scores.put("孙悟空", 149);
		System.out.println(scores);
		
		// 通过key删除映射
		Integer remove = scores.remove("贾宝玉");
		System.out.println(remove);
		System.out.println(scores);
		
		// 映射的个数
		System.out.println(scores.size());
		
		// 通过key查询对应的value
		System.out.println(scores.get("孙悟空"));
		
		// 是否包含指定的键或者值
		System.out.println(scores.containsKey("孙悟空"));
		System.out.println(scores.containsKey("贾宝玉"));
		
		System.out.println(scores.containsValue(98));
		System.out.println(scores.containsValue(199));
		
		// 获取所有的key
		Set<String> keys = scores.keySet();
		System.out.println(keys);
		
		// 获取所有的值
		Collection<Integer> values = scores.values();
		System.out.println(values);
		
		// 获取所有的键值映射
		Set<Entry<String, Integer>> entrySet = scores.entrySet();
		System.out.println(entrySet);
	}
}

7.4 遍历Map集合【重点】

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Demo02 {
	public static void main(String[] args) {
		
		/**
		 *	遍历Map集合
		 *		通过Key遍历
		 *			获取所有的Key，遍历key，获取每一个key对应的value
		 *		通过entry遍历
		 */
		
		// 创建Map的实现类对象:动态方式创建
		Map<String, Integer> map = new HashMap<String, Integer>();
		
		// 添加映射
		map.put("张飞", 88);
		map.put("吕布", 98);
		map.put("孙悟空", 99);
		map.put("白龙马", 108);
		map.put("宋江", 110);
		map.put("贾宝玉", 145);
		System.out.println(map);
		
		// 获取所有的key
		Set<String> keys = map.keySet();
		
		System.out.println("==============key + foreach===============");
		for (String key : keys) {
			System.out.println(key + "---" + map.get(key));
		}
		
		System.out.println("==============key + iterator===============");
		// 获取key集合的迭代器
		Iterator<String> keyIt = keys.iterator();
		while (keyIt.hasNext()) {
			String key = keyIt.next();
			System.out.println(key + "---" + map.get(key));
		}
		
		// 获取map集合的映射关系集
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		
		System.out.println("==============entry + foreach===============");
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println(entry.getKey() + "====" + entry.getValue());
		}
		
		System.out.println("==============entry + iterator===============");
		Iterator<Entry<String, Integer>> entryIt = entrySet.iterator();
		while(entryIt.hasNext()) {
			Entry<String, Integer> entry = entryIt.next();
			System.out.println(entry.getKey() + "====" + entry.getValue());
		}
	}
}

八、HashMap

8.1 概述

• 基于哈希表的 Map 接口的实现类。
• 除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。
• HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。
  • 容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。【数组的长度】
  • 加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。【数据量和容量的比例】
• 当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作【扩容】
  • 从而哈希表将具有大约两倍的桶数。

8.2 创建对象

构造方法摘要
HashMap() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
HashMap(int initialCapacity, float loadFactor) 构造一个带指定初始容量和加载因子的空 HashMap。
HashMap(Map<? extends K,? extends V> m) 构造一个映射关系与指定 Map 相同的新 HashMap。

8.3 常用方法

• 参考Map集合中的方法【方法基本相同】

九、HashTable

9.1 概述

• 此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
• 除了同步和不允许使用 null 之外，Hashtable 类与HashMap 大致相同。

9.2 子类Properties

• HashTable的一个子类，表示一个持久的属性集
• 项目开发常用

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Demo01 {
	public static void main(String[] args) throws FileNotFoundException, IOException {
		// 创建属性集
		Properties properties = new Properties();
		System.out.println(properties);
		
		// properties.setProperty("username", "zhangsan");
		// properties.setProperty("password", "sanzhang");
		
		// 加载外部配置文件
		properties.load(new FileInputStream("user.properties"));
		
		System.out.println(properties);
		
		// 读取属性集中的数据
		System.out.println(properties.getProperty("username"));
		System.out.println(properties.getProperty("password"));
	}
}