java基础---集合

集合

含义：

1.集合是java API所提供的一系列类，可以用于动态存放多个对象（集合只能存放对象）

2.集合与数组类似，不同之处在于集合是大小可变的序列，而且元素类型可以不受限定，只要是引用类型（集合中不能放基本数据类型，但可以放基本数据类型的包装类）

3.集合类全部支持泛型，是一种数据安全的用法。

泛型

其实上面我们的程序存在严重的安全隐患

JDK1.4以前：

1、 装入集合的数据都会被当作Object对象来存放，从而失去了自己的实际类型。

2、 从集合中取出元素时，需要进行强制类型转换。效率低，容易产生错误。

从JDK1.5开始，sun公司推出了泛型来解决上述问题：

1、在定义一个集合时就指定集合存储的对象的数据类型

如：Collection coll = new ArrayList();

3、 存入数据时只能存入泛型指定的数据类型，如果存入其他数据类型，则会编译错误，避数据存入时的问题。

coll.add(new Integer(1));

3、从集合中取出元素时，无需转型了。

如：String str1 = it.next();

优点

1、简化集合的使用

2、增强代码的可读性和稳定性

集合框架图：

java集合框架从整体上可以分为两大家族：

1.Collection（接口）家族，该接口下的所有子孙储存的是单一对象。Add(s);

2.Map（接口）家族：该接口下的所有子孙储存的是key-value（键值对）形似的数据。Put(key,value)

另外还有三大分支，均为上述两大家族服务：

1.Iterator（迭代器），主要用于遍历Collection接口及其子类；

2.Comparator（比较器），在集合中储存对象时用于对象之间的比较；

Collections是工具类，该类名带个s，一般就表示工具类。里面提供了 很多静态方法 ，来对Collection集合进行操作。

Collection家族

迭代器

含义：遍历集合中的数据

分类：Iterator 和 ListIterator

Iterator

概念： Iterator是一个接口，它是集合的迭代器，集合可以通过Iterator去遍历集合中的元素，常用API接口：

>

注意：

（1）Iterator只能单向移动。

（2）Iterator.remove()是唯一安全的方式来在迭代过程中修改集合；如果在迭代过程中以任何其它的方式修改了基本集合将会产生未知的行为。而且每调用一次next()方 法，remove()方法只能被调用一次，如果违反这个规则将抛出一个异常。

ListIterator

概念： ListIterator的功能更加强大, 它继承于Iterator接口,只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator，汉化API如下：

由此我们可以推断出ListIterator可以：

(1)双向移动（向前/向后遍历）.

(2)产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引.

(3)可以使用set()方法替换它访问过的最后一个元素.

(4)可以使用add()方法在next()方法返回的元素之前或previous()方法返回的元素之后插入一个元素.

Iterator 和 ListIterator 区别

Iterator ：Collection接口下所有的实现类都可以获取的迭代器，可以在遍历时删除元素

ListIterator ：List接口下所有的实现类可以获取的迭代器，可以在遍历时删除、替换、添加元素，也可以指定下标开始遍历，还可以倒叙遍历

List接口

特点：有序且可重复（因为List接口中添加了许多针对下标操作的方法类）

List接口比Collection接口中新增的几个实用方法：

1、 public Object get(int index)　根据下标，返回列表中的元素

2、 public Object add(int index, Object element);　 在列表的指定位置插入指定元素.将当前处于该位置的元素（如果有的话）和所有后续元素向右移动

3、 public Object set(int index, Object element) ;　用指定元素替换列表中指定位置的元素

4、public Object remove(int index) 移除列表中指定位置的元素

注意：list集合中的元素的索引与数组中元素的索引一样，均是从0开始。

实现类：

​ 1.ArrayList

​ 2.LinkedList

​ 3.Vector（已经弃用）

​ 4.Stack（已经弃用）

ArrayList的调用方法

package com.Xu.Tset2;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Iterator;
import java.util.ListIterator;

public class Test{
	public static void main(String[] args){
        
        ArrayList<String> list = new ArrayList<>();//<>中指定需要储存的类型
        //添加元素
        list.add("铁蛋");
        list.add("二狗");
        list.add("狗子");
        list.add("小红");
        
        //获取元素的个数
        int size = list.size();
        System.out.println("元素的个数为："+size);
        
        //设置指定下标上的元素
        list.set(0,"大狗");
        
        //获取指定下标上的元素
        String elment = list.get(0);//大狗
        
        //在指定下标上插入元素
        list.add(1,"铁蛋");//集合长度加一
        
        //遍历集合 - for
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
        
        //批量添加，使用工具类
        ArrayList<String> newList1 = new ArrayList<>();
        Collections.addAll(newList1,"大毛","二毛","三毛","四毛");
        ArrayList<String> newList2 = new ArrayList<>();
        Collections.addAll(newList2,"aaa","bbb","ccc","ddd");
        
        //将新集合中所有元素添加到指定集合的末尾
        list.addAll(newList1);
        
        //将新集合中所有元素添加到指定集合的指定下标
        list.addAll(2,newList2);
        
        //清空集合中所有的元素
        //list.clear();
        
        System.out.println("判断集合中是否包含某个元素：" + list.contains("大毛"));//true
        
        ArrayList<String> newList3 = new ArrayList<>();
        Collections.addAll(newList3,"bbb","ccc","aaa");
        System.out.println("判断集合中是否包含某个集合中的所有元素：" + list.containsAll(newList3));//true
        
        //获取元素在集合中的下标
        int index = list.indexOf("三毛");
        System.out.println("元素在集合中的下标："+index);
        
        //判断集合是否为空
        boolean empty = list.isEmpty();//false - 不为空    true - 为空
        System.out.println(empty);// false
        
        //删除
        list.remove(3);//依据下标删除元素
        list.remove("三毛");//依据元素删除元素
        
        //删除 - 去交集
        ArrayList<String> newList4 = new ArrayList<>();
        Collections.addAll(newList4,"bbb","ccc","1111");
        list.removeAll(newList4);//删除bbb，ccc
        
        System.out.println("-------------------");
        //遍历集合 - for
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
       
        //保留交集
        ArrayList<String> newList5 = new ArrayList<>();
        Collections.addAll(newList5,"大狗","二狗","狗子","大毛","二毛","四毛","铁蛋");
        list.retainAll(newList5);//

        System.out.println("-------------------");
        //遍历集合 - for
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
        
        //获取开始下标到结束下标的元素并返回新的集合
        List<String> subList = list.subList(1,3);
        
        //将集合转换为数组
        Object[] array = subList.toArray();
        System.out.println(Arrays.toString(array));
        
        //遍历 - foreach
		for (String element : list) {
			System.out.println(element);
		}
		
		System.out.println("-------------");
		//遍历 - Iterator迭代器
		Iterator<String> it = list.iterator();//获取Iterator迭代器对象
		while(it.hasNext()){//判断是否有可迭代的元素
			String e = it.next();//返回下一个元素
			System.out.println(e);
		}
        
		System.out.println("-------------");
		//遍历 - ListIterator迭代器
		ListIterator<String> listIterator = list.listIterator();//获取ListIterator迭代器对象
		while(listIterator.hasNext()){//判断是否有可迭代的元素
			String e = listIterator.next();//返回下一个元素
			System.out.println(e);
		}
    }
}

LinkedList的调用方法

package com.Xu.LinkedList;

import java.util.LinkedList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;



public class linkedList{
	public static void main(String[] args){
        
        LinkedList<String> list = new LinkedList<>();//<>中指定需要储存的类型
        //添加元素
        list.add("铁蛋");
        list.add("二狗");
        list.add("狗子");
        list.add("小红");
        
        //获取元素的个数
        int size = list.size();
        System.out.println("元素的个数为："+size);
        
        //设置指定下标上的元素
        list.set(0,"大狗");
        
        //获取指定下标上的元素
        String elment = list.get(0);//大狗
        
        //在指定下标上插入元素
        list.add(1,"铁蛋");//集合长度加一
        
        
        
        
        //遍历集合 - for
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
        
        //批量添加，使用工具类
        LinkedList<String> newList1 = new LinkedList<>();
        Collections.addAll(newList1,"大毛","二毛","三毛","四毛");
        LinkedList<String> newList2 = new LinkedList<>();
        Collections.addAll(newList2,"aaa","bbb","ccc","ddd");
        
        //将新集合中所有元素添加到指定集合的末尾
        list.addAll(newList1);
        
        //将新集合中所有元素添加到指定集合的指定下标
        list.addAll(2,newList2);
        
        //清空集合中所有的元素
        //list.clear();
        
        System.out.println("判断集合中是否包含某个元素：" + list.contains("大毛"));//true
        
        LinkedList<String> newList3 = new LinkedList<>();
        Collections.addAll(newList3,"bbb","ccc","aaa");
        System.out.println("判断集合中是否包含某个集合中的所有元素：" + list.containsAll(newList3));//true
        
        //获取元素在集合中的下标
        int index = list.indexOf("三毛");
        System.out.println("元素在集合中的下标："+index);
        
        //判断集合是否为空
        boolean empty = list.isEmpty();//false - 不为空    true - 为空
        System.out.println(empty);// false
        
        //删除
        list.remove(3);//依据下标删除元素
        list.remove("三毛");//依据元素删除元素
        
        //删除 - 去交集
        LinkedList<String> newList4 = new LinkedList<>();
        Collections.addAll(newList4,"bbb","ccc","1111");
        list.removeAll(newList4);//删除bbb，ccc
        
        System.out.println("-------------------");
        //遍历集合 - for
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
        
        
        //保留交集
        LinkedList<String> newList5 = new LinkedList<>();
        Collections.addAll(newList5,"大狗","二狗","狗子","大毛","二毛","四毛","铁蛋");
        list.retainAll(newList5);//

        System.out.println("-------------------");
        //遍历集合 - for
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
        
        //获取开始下标到结束下标的元素并返回新的集合
        List<String> subList = list.subList(1,3);
        
        //将集合转换为数组
        Object[] array = subList.toArray();
        System.out.println(Arrays.toString(array));
        
        
        //遍历 - foreach
		for (String element : list) {
			System.out.println(element);
		}
		
		System.out.println("-------------");
		//遍历 - Iterator迭代器
		Iterator<String> it = list.iterator();//获取Iterator迭代器对象
		while(it.hasNext()){//判断是否有可迭代的元素
			String e = it.next();//返回下一个元素
			System.out.println(e);
		}
        
		System.out.println("-------------");
		//遍历 - ListIterator迭代器
		ListIterator<String> listIterator = list.listIterator();//获取ListIterator迭代器对象
		while(listIterator.hasNext()){//判断是否有可迭代的元素
			String e = listIterator.next();//返回下一个元素
			System.out.println(e);
		}
        
        
    }

}

ArrayList 跟 LinkedList在使用层相同，LinkedList多了队列模式和栈模式

队列模式:先进先出

package com.Xu.LinkedList;

import java.util.LinkedList;

public class Test01 {
	public static void main(String[] args) {
		/**
		 * linkedList队列模式：先进先出
		 */
		LinkedList<String> list = new LinkedList<>();
		
        list.add("铁蛋");
        list.add("二狗");
        list.add("狗子");
        list.add("小红");
		
		while(!list.isEmpty()) {
			
			String removeFirst = list.removeFirst();
			System.out.println(removeFirst);
		}
        
		System.out.println("元素个数为："+list.size());
        
	}
}

栈模式：先进后出

package com.dream.linkedlist_class;

import java.util.LinkedList;

public class Test03 {

	public static void main(String[] args) {
        
		LinkedList<String> list = new LinkedList<>();
		
		list.add("铁蛋1");
		list.add("铁蛋2");
		list.add("铁蛋3");
		list.add("铁蛋4");
		list.add("铁蛋5");
		
		while(!list.isEmpty()){
			//删除最后一个元素，并返回
			String element = list.removeLast();
			System.out.println(element);
		}
		
		System.out.println("集合中元素的个数：" + list.size());
		
	}
}

铁蛋5
铁蛋4
铁蛋3
铁蛋2
铁蛋1
集合中元素的个数：0

Vector（已弃用）

在应用层与上述两种类的方式相同

Vector是元老级别的集合类，在JDK1.0开始。JDK1.2开始才推出集合框架的概念，考虑到当时很多 程序员习惯使用Vector，就让Vector多实现了List接口，这样才将其保留下来

Vector老的方法

package com.dream.vector_class;
import java.util.Enumeration;
import java.util.Vector;

public class Test02 {
	
	public static void main(String[] args) {
        
		Vector<String> v = new Vector<>();
		
		//添加元素
		v.addElement("铁蛋1");
		v.addElement("铁蛋2");
		v.addElement("铁蛋3");
		v.addElement("铁蛋4");
		v.addElement("铁蛋5");
		v.addElement("铁蛋6");
		
		//删除
		v.removeElement("铁蛋成2");//依据元素删除元素
		v.removeElementAt(2);//依据下标山存储元素
		
		//遍历
		Enumeration<String> elements = v.elements();
		while(elements.hasMoreElements()){
			String nextElement = elements.nextElement();
			System.out.println(nextElement);
		}
	}
}

铁蛋1
铁蛋3
铁蛋5
铁蛋6

Stack（已弃用）

package com.dream.stack_class;
import java.util.Stack;
public class Test01 {
	
	public static void main(String[] args) {
        
		Stack<String> stack = new Stack<>();
		//添加元素 - 将元素压入栈顶
		stack.push("铁蛋1");
		stack.push("铁蛋2");
		stack.push("铁蛋3");
		stack.push("铁蛋4");
		stack.push("铁蛋5");
		
		System.out.println("距离栈顶的位置(从1开始)：" + stack.search("铁蛋2"));
		while(!stack.empty()){
			//获取栈顶第一个元素，并返回
			//String element = stack.peek();
			
			//删除栈顶第一个元素，并返回
			String element = stack.pop();
			System.out.println(element);
		}
		System.out.println(stack.size());
	}
}

距离栈顶的位置(从1开始)：4
铁蛋5
铁蛋4
铁蛋3
铁蛋2
铁蛋1
0

Set接口

特点：无序且不可重复

实现类：

1. HashSet
2. LinkedHashSet
3. TreeSet

比较器接口

作用：排序时使用

分类：

​ 内置比较器：Comparable - compareTo()

​ 外置比较器：Comparator - compare()

使用场景：

​ 内置比较器：对象要想存入TreeSet、TreeMap中，对象所属的类必须要实现内置比较器

​ 外置比较器：当内置比较的规则不满足现在的需求，但又不能改动内置比较器规则时

优先级别：外置比较器 > 内置比较器

HashSet的调用方法

package com.dream.hashset_class;
import java.util.HashSet;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：使用HashSet方法
		 * 
		 * 特点：去重+无序
		 */
		
		HashSet<String> set = new HashSet<>();
		
        set.add("铁蛋");
        set.add("二狗");
        set.add("狗子");
        set.add("小红");
        set.add("小明");
		
		//获取元素的个数
		int size = set.size();
		System.out.println("获取元素的个数：" + size);//5

		HashSet<String> newSet1 = new HashSet<>();
		Collections.addAll(newSet1, "aaa","bbb","ccc","小明");//利用集合工具类进行批量添加
		set.addAll(newSet1);//将新集合中所有的元素添加到指定集合的末尾
		
		//清空集合中所有的元素
		//set.clear();
		
		System.out.println("判断集合中是否包含某个元素：" + set.contains("二狗"));//true
		
		HashSet<String> newSet2 = new HashSet<>();
		Collections.addAll(newSet2, "eee","ddd","fff","ggg");//利用集合工具类进行批量添加
		System.out.println("判断集合中是否包含某个集合中所有元素：" + set.containsAll(newSet2));//false
		
		boolean empty = set.isEmpty();//有元素-false 没有元素-true
		System.out.println("判断集合中是否没有元素：" + empty);//false
		
		//删除
		set.remove("狗子");//依据元素删除元素
		
		//删除 - 去交集
		HashSet<String> newSet3 = new HashSet<>();
		Collections.addAll(newSet3, "fff","aaa","bbb","xxx");//利用集合工具类进行批量添加
		set.removeAll(newSet3);
		
		//保留交集	
		HashSet<String> newSet4 = new HashSet<>();
		Collections.addAll(newSet4, "小林","小刚","二狗","狗子","小红","yyy");//利用集合工具类进行批量添加
		set.retainAll(newSet4);
		
		//将集合转换为数组
		Object[] array = set.toArray();
		System.out.println(Arrays.toString(array));
		
		System.out.println("-------------");
		
		//遍历 - foreach
		for (String element : set) {
			System.out.println(element);
		}
		
		System.out.println("-------------");
		
		//遍历 - Iterator迭代器
		Iterator<String> it = set.iterator();//获取Iterator迭代器对象
		while(it.hasNext()){//判断是否有可迭代的元素
			String e = it.next();//返回下一个元素
			System.out.println(e);
		}
	}
}

获取元素的个数：5
判断集合中是否包含某个元素：true
判断集合中是否包含某个集合中所有元素：false
判断集合中是否没有元素：false
[二狗, 小红]
-------------
二狗
小红
-------------
二狗
小红

LinkedHashSet的调用方法

package com.dream.linkedhashset_class;

import java.util.LinkedHashSet;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 使用LinkedHashSet方法
		 * 特点：去重+有序(输入输出顺序一致)
		 */
		LinkedHashSet<String> set = new LinkedHashSet<>();
		
		//添加元素
		set.add("老王1");
		set.add("老王2");
		set.add("老王3");
		set.add("老王4");
		set.add("老王5");
		
		//获取元素的个数
		int size = set.size();
		System.out.println("获取元素的个数：" + size);//5

		LinkedHashSet<String> newSet1 = new LinkedHashSet<>();
		Collections.addAll(newSet1, "aaa","bbb","ccc","老王5");//利用集合工具类进行批量添加
		set.addAll(newSet1);//将新集合中所有的元素添加到指定集合的末尾
		
		//清空集合中所有的元素
		//set.clear();
		
		System.out.println("判断集合中是否包含某个元素：" + set.contains("老王2"));//true
		
		LinkedHashSet<String> newSet2 = new LinkedHashSet<>();
		Collections.addAll(newSet2, "eee","ddd","fff","ggg");//利用集合工具类进行批量添加
		System.out.println("判断集合中是否包含某个集合中所有元素：" + set.containsAll(newSet2));//false
		
		boolean empty = set.isEmpty();//有元素-false 没有元素-true
		System.out.println("判断集合中是否没有元素：" + empty);//false
		
		//删除
		set.remove("老王3");//依据元素删除元素
		
		//删除 - 去交集
		LinkedHashSet<String> newSet3 = new LinkedHashSet<>();
		Collections.addAll(newSet3, "fff","aaa","bbb","xxx");//利用集合工具类进行批量添加
		set.removeAll(newSet3);
		
		//保留交集	
		LinkedHashSet<String> newSet4 = new LinkedHashSet<>();
		Collections.addAll(newSet4, "林成","卢永刚","老王2","老王3","老王4","yyy");//利用集合工具类进行批量添加
		set.retainAll(newSet4);
		
		//将集合转换为数组
		Object[] array = set.toArray();
		System.out.println(Arrays.toString(array));
		
		System.out.println("-------------");
		
		//遍历 - foreach
		for (String element : set) {
			System.out.println(element);
		}
		
		System.out.println("-------------");
		
		//遍历 - Iterator迭代器
		Iterator<String> it = set.iterator();//获取Iterator迭代器对象
		while(it.hasNext()){//判断是否有可迭代的元素
			String e = it.next();//返回下一个元素
			System.out.println(e);
		}
	}
}

获取元素的个数：5
判断集合中是否包含某个元素：true
判断集合中是否包含某个集合中所有元素：false
判断集合中是否没有元素：false
[老王4, 老王2]
-------------
老王4
老王2
-------------
老王4
老王2

TreeSet

TreeSet的特点是自然排序，就是存进去的数据会根据内置的比较器来排序，

也可以根据需求自行编写外置比较器，外置比较器优先于内置比较器运行。

TreeSet方法的使用与 上述的使用方法相同，不同点在于输出的数据是自动排序好的。

TreeSet排序的使用

1.数字排序和字典排序

package com.dream.treeset_class;

import java.util.TreeSet;

public class Test02 {
	
	public static void main(String[] args) {
		/**
		 * TreeSet排序
		 * 
		 * 需求：创建两个TreeSet对象，分别存Integer、String
		 * 
		 * TreeSet：自然排序（根据不同的类型，选择不同排序规则）
		 * 
		 * TreeSet存Integer：数字排序
		 * TreeSet存String：字典排序
		 */
		
		TreeSet<Integer> set1 = new TreeSet<>();
		set1.add(5);//Integer.valueOf(5);
		set1.add(1);//Integer.valueOf(1);
		set1.add(4);//Integer.valueOf(4);
		set1.add(2);//Integer.valueOf(2);
		set1.add(6);//Integer.valueOf(6);
		set1.add(3);//Integer.valueOf(3);
		set1.add(3);//Integer.valueOf(3);
		for (Integer integer : set1) {
			System.out.println(integer);
		}
		
		TreeSet<String> set2 = new TreeSet<>();
		set2.add("c");
		set2.add("d");
		set2.add("a");
		set2.add("b");
		for (String string : set2) {
			System.out.println(string);
		}
	}

}

1
2
3
4
5
6
a
b
c
d

2.内置比较器排序

先写一个Student类，类实现Comparable接口并重写compareTo方法（代码最后一个方法）

package com.Xu.TrreSet;
//implements Comparable实现接口
public class Student implements Comparable<Student>{
	private String name;
	private int age;
	
	public Student() {
		// TODO Auto-generated constructor stub
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "姓名：" + name + " 年龄：" + age;
	}
	
    //重写方法，根据年龄排序
	@Override
	public int compareTo(Student o) {//根据年龄排序
		//this.age<o.age返回-1，this.age>o.age返回1，相同返回0
		return Integer.compare(this.age, o.age);
	}
}

测试类

package com.Xu.TrreSet;
import java.util.TreeSet;
public class Test {
	public static void main(String[] args) {
		
		TreeSet<Student> set = new TreeSet<Student>();
		//添加元素
		//添加元素时调用内置比较器，返回1就放在之前元素的后面，-1放前面，0则表示元素重复，不添加
		set.add(new Student("小明1",17));
		set.add(new Student("小明2",15));
		set.add(new Student("小明3",13));
		set.add(new Student("小明4",19));
		set.add(new Student("小明5",18));
		set.add(new Student("小明6",14));
		set.add(new Student("小明6",14));
		set.add(new Student("小明8",16));
		//遍历
		for (Student student : set) {
			System.out.println(student);
		}
	}
}

姓名：小明3 年龄：13
姓名：小明6 年龄：14
姓名：小明2 年龄：15
姓名：小明8 年龄：16
姓名：小明1 年龄：17
姓名：小明5 年龄：18
姓名：小明4 年龄：19

使用外置比较器

测试类2

package com.Xu.TrreSet;

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

public class Test2 {
	public static void main(String[] args) {
		
		TreeSet<Student> set = new TreeSet<Student>( new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				return Integer.compare(o1.getAge(), o2.getAge());
			}
		});//外置比较器
		//添加元素
		//添加元素时调用内置比较器，返回1就放在之前元素的后面，-1放前面，0则表示元素重复，不添加
		set.add(new Student("小明1",17));
		set.add(new Student("小明2",15));
		set.add(new Student("小明3",13));
		set.add(new Student("小明4",19));
		set.add(new Student("小明5",18));
		set.add(new Student("小明6",14));
		set.add(new Student("小明6",14));
		set.add(new Student("小明8",16));
		
		//遍历
		for (Student student : set) {
			System.out.println(student);
		}
	}
}

Map家族

实现类：

1.HashMap

2.LinkedHashMap

3.Hashtable

4.ConcurrentHashMap

5.TreeMap

6.Properties

四种实现类的特点：

共同点：调用的方法都是一样的
特点：
HashMap：存储键值对，无序，允许存null键，线程不安全
LinkedHashMap：存储键值对，有序，允许存null键，线程不安全
Hashtable：存储键值对，无序，不允许存null键，线程安全(直接在方法中上锁，效率低)，已弃用
ConcurrentHashMap：存储键值对，无序，不允许存null键，线程安全(局部加锁，效率高)

HashMap的调用方法

与Collection家族成员不同，Map家族是没有迭代器的。并且Map家族的使用层面相对于Collection家族成员会有差别。HashMap key是唯一的，value可以重复，HashMap 存储键值对、无序的

package com.Xu.HashMap_class;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class HashMap_class {
    /**
		 * HashMap的方法使用
		 * 	HashMap key是唯一的，value可以重复
		 * 	HashMap 存储键值对、无序的
		 */
	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();
		
		//添加元素
		map.put("铁蛋", 18);
		map.put("二狗", 19);
		map.put("大腰子", 21);
		map.put("狗蛋", 20);
		map.put("老王", 21);
		Integer put = map.put("小杨",23);
		System.out.println(put);
		
		//清空集合
		//map.clear();
		
		System.out.println("判断集合中是否有某个key："+map.containsKey("铁蛋"));
		System.out.println("判断集合中是否有某个value："+map.containsValue(23));
		
		//通过key获取对应的value
		System.out.println("通过key获取对应的value：" +map.get("二狗"));
		System.out.println("通过key获取对应的value：" +map.getOrDefault("刘杨", 55));
		
		System.out.println("判断集合中是否没有元素："+map.isEmpty());
		
		HashMap<String, Integer> newMap1 = new HashMap<>();
		newMap1.put("aaa", 10);
		newMap1.put("bbb", 20);
		newMap1.put("ccc", 30);
		map.putAll(newMap1);//将新集合中的所有元素添加到map集合中
		
		//添加元素
		//如果有key就不添加，返回在集合中的value
		//如果没有key，就添加k-v
		Integer putIfAbsent = map.putIfAbsent("二狗", 100);
		System.out.println(putIfAbsent);
		
		//删除
		map.remove("小杨");//通过key删除映射关系
		map.remove("二狗", 19);//通过k-v删除映射关系
		
		//替换
		Integer replace = map.replace("大腰子", 45);//通过key替换value
		System.out.println("返回替换前的value值：" + replace);
		
		//替换
		map.replace("大腰子", 45, 18);
		
		//替换
		Integer put2 = map.put("大腰子", 19);//添加元素，如果有相同key，就替换value，并返回
		System.out.println("返回替换前的value值：" + put2);
		
		System.out.println("获取集合中的映射关系的个数：" + map.size());
		
		//获取所有的value
		Collection<Integer> values = map.values();
		System.out.println(values);
		System.out.println("---------------");

		//遍历-keySet()
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key+"-----"+value);
		}
		
		//遍历-entrySet()
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key+"--"+value);
			
		}
	}
}

null
判断集合中是否有某个key：true
判断集合中是否有某个value：true
通过key获取对应的value：19
通过key获取对应的value：55
通过key获取对应的value：23
判断集合中是否没有元素：false
19
返回替换前的value值：21
返回替换前的value值：18
获取集合中的映射关系的个数：7
[10, 30, 20, 21, 18, 19, 20]
---------------
aaa-----10
ccc-----30
bbb-----20
老王-----21
铁蛋-----18
大腰子-----19
狗蛋-----20
aaa--10
ccc--30
bbb--20
老王--21
铁蛋--18
大腰子--19
狗蛋--20

下述三次调用方法相同就不做运行演示了

LinkedHashMap的调用方法

package com.Xu.linkedhashmap_class;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
public class linkedhashmap_class {
	public static void main(String[] args) {
		LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
		//添加元素
		map.put("铁蛋", 18);
		map.put("二狗", 19);
		map.put("大腰子", 21);
		map.put("狗蛋", 20);
		map.put("老王", 21);
		Integer put = map.put("刘杨帆",23);
		System.out.println(put);
		//清空集合
		//map.clear();
		System.out.println("判断集合中是否有某个key："+map.containsKey("铁蛋"));
		System.out.println("判断集合中是否有某个value："+map.containsValue(23));
		//通过key获取对应的value
		System.out.println("通过key获取对应的value：" +map.get("二狗"));
		System.out.println("通过key获取对应的value：" +map.getOrDefault("刘杨", 55));
		System.out.println("判断集合中是否没有元素："+map.isEmpty());
		LinkedHashMap<String, Integer> newMap1 = new LinkedHashMap<>();
		newMap1.put("aaa", 10);
		newMap1.put("bbb", 20);
		newMap1.put("ccc", 30);
		map.putAll(newMap1);//将新集合中的所有元素添加到map集合中
		//添加元素
		//如果有key就不添加，返回在集合中的value
		//如果没有key，就添加k-v
		Integer putIfAbsent = map.putIfAbsent("二狗", 100);
		System.out.println(putIfAbsent);
		//删除
		map.remove("刘杨帆");//通过key删除映射关系
		map.remove("二狗", 19);//通过k-v删除映射关系
		//替换
		Integer replace = map.replace("大腰子", 45);//通过key替换value
		System.out.println("返回替换前的value值：" + replace);
		//替换
		map.replace("大腰子", 45, 18);
		//替换
		Integer put2 = map.put("大腰子", 19);//添加元素，如果有相同key，就替换value，并返回
		System.out.println("返回替换前的value值：" + put2);
		System.out.println("获取集合中的映射关系的个数：" + map.size());
		//获取所有的value
		Collection<Integer> values = map.values();
		System.out.println(values);
		//遍历-keySet()
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key+"-----"+value);
		}
		//遍历-entrySet()
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key+"--"+value);
		}
	}
}

Hashtable的调用方法

package com.Xu.hashtable_class;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Map.Entry;
import java.util.Set;
public class Hashtable_class {
	public static void main(String[] args) {
		Hashtable<String, Integer> map = new Hashtable<>();
		//添加元素
		map.put("铁蛋", 18);
		map.put("二狗", 19);
		map.put("大腰子", 21);
		map.put("狗蛋", 20);
		map.put("老王", 21);
		Integer put = map.put("刘杨帆",23);
		System.out.println(put);
		//清空集合
		//map.clear();
		System.out.println("判断集合中是否有某个key："+map.containsKey("铁蛋"));
		System.out.println("判断集合中是否有某个value："+map.containsValue(23));
		//通过key获取对应的value
		System.out.println("通过key获取对应的value：" +map.get("二狗"));
		System.out.println("通过key获取对应的value：" +map.getOrDefault("刘杨", 55));
		System.out.println("判断集合中是否没有元素："+map.isEmpty());	
		Hashtable<String, Integer> newMap1 = new Hashtable<>();
		newMap1.put("aaa", 10);
		newMap1.put("bbb", 20);
		newMap1.put("ccc", 30);
		map.putAll(newMap1);//将新集合中的所有元素添加到map集合中
		//添加元素
		//如果有key就不添加，返回在集合中的value
		//如果没有key，就添加k-v
		Integer putIfAbsent = map.putIfAbsent("二狗", 100);
		System.out.println(putIfAbsent);
		//删除
		map.remove("刘杨帆");//通过key删除映射关系
		map.remove("二狗", 19);//通过k-v删除映射关系
		//替换
		Integer replace = map.replace("大腰子", 45);//通过key替换value
		System.out.println("返回替换前的value值：" + replace);
		//替换
		map.replace("大腰子", 45, 18);
		//替换
		Integer put2 = map.put("大腰子", 19);//添加元素，如果有相同key，就替换value，并返回
		System.out.println("返回替换前的value值：" + put2);
		System.out.println("获取集合中的映射关系的个数：" + map.size());
		//获取所有的value
		Collection<Integer> values = map.values();
		System.out.println(values);
		//遍历-keySet()
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key+"-----"+value);
		}
		//遍历-entrySet()
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key+"--"+value);
		}
	}
}

ConcurrentHashMap的调用方法

package com.Xu.concurrenthashmap_class;
import java.util.Collection;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
public class concurrenthashmap {
	public static void main(String[] args) {
		ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
		//添加元素
		map.put("铁蛋", 18);
		map.put("二狗", 19);
		map.put("大腰子", 21);
		map.put("狗蛋", 20);
		map.put("老王", 21);
		Integer put = map.put("刘杨帆",23);
		System.out.println(put);
		//清空集合
		//map.clear();
		System.out.println("判断集合中是否有某个key："+map.containsKey("铁蛋"));
		System.out.println("判断集合中是否有某个value："+map.containsValue(23));
		//通过key获取对应的value
		System.out.println("通过key获取对应的value：" +map.get("二狗"));
		System.out.println("通过key获取对应的value：" +map.getOrDefault("刘杨", 55));
		System.out.println("判断集合中是否没有元素："+map.isEmpty());
		ConcurrentHashMap<String, Integer> newMap1 = new ConcurrentHashMap<>();
		newMap1.put("aaa", 10);
		newMap1.put("bbb", 20);
		newMap1.put("ccc", 30);
		map.putAll(newMap1);//将新集合中的所有元素添加到map集合中
		//添加元素
		//如果有key就不添加，返回在集合中的value
		//如果没有key，就添加k-v
		Integer putIfAbsent = map.putIfAbsent("二狗", 100);
		System.out.println(putIfAbsent);
		//删除
		map.remove("刘杨帆");//通过key删除映射关系
		map.remove("二狗", 19);//通过k-v删除映射关系
		//替换
		Integer replace = map.replace("大腰子", 45);//通过key替换value
		System.out.println("返回替换前的value值：" + replace);
		//替换
		map.replace("大腰子", 45, 18);
		//替换
		Integer put2 = map.put("大腰子", 19);//添加元素，如果有相同key，就替换value，并返回
		System.out.println("返回替换前的value值：" + put2);
		System.out.println("获取集合中的映射关系的个数：" + map.size());
		//获取所有的value
		Collection<Integer> values = map.values();
		//遍历-keySet()
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key+"-----"+value);
		}
		//遍历-entrySet()
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key+"--"+value);
		}
	}
}

TreeMap

TreeMap 跟TreeSet一样都有比较器，其实TreeSet的底层是靠TreeMap实现的，所以他们有很多的相似之处。TreeMap是存的K-V的键值对

TreeMap默认自然排序是默认根据key值排序的

package com.Xu.treemap_class;

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test01 {
	public static void main(String[] args) {
        //添加元素
		TreeMap<String, Integer> map = new TreeMap<>();
		map.put("ccc", 18);
		map.put("bbb", 15);
		map.put("eee", 18);
		map.put("aaa", 18);
		map.put("ddd", 18);
        
        //获取TreeMap的键值对对象entrySet
		Set<Entry<String,Integer>> entrySet = map.entrySet();
      	
        //遍历entrySet
        //entry.getKey()：获取entrySet的key值
        //entry.getValue()获取entrySet的value值
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println(entry.getKey()+"----------"+entry.getValue());
		}	
	}
}

内置比较器:

编写学生类实现Comparable接口并重写compareTo方法，根据年龄排序

package com.Xu.treemap_class;

public class Student implements Comparable<Student>{
	private String name;
	private int age;
	public Student() {

	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "姓名：" + name + " 年龄：" + age;
	}
	//按照年龄排序
	@Override
	public int compareTo(Student o) {
		return this.age - o.age;
	}
}

测试类1

package com.Xu.treemap_class;

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test02 {
	public static void main(String[] args) {
		
		TreeMap<Student, Character> map = new TreeMap<>();
		
		map.put(new Student("大毛",26),'男');
		map.put(new Student("二毛",31),'男');
		map.put(new Student("三毛",29),'男');
		map.put(new Student("四毛",26),'男');
		map.put(new Student("五毛",33),'男');
		map.put(new Student("六毛",28),'男');
        //遍历
		Set<Entry<Student, Character>> entrySet = map.entrySet();
		for (Entry<Student, Character> entry : entrySet) {
			System.out.println(entry.getKey()+" - "+entry.getValue());
		}	
	}
}

姓名：大毛 年龄：26 - 男
姓名：六毛 年龄：28 - 男
姓名：三毛 年龄：29 - 男
姓名：二毛 年龄：31 - 男
姓名：五毛 年龄：33 - 男

外置比较器:

测试类2

package com.Xu.treemap_class;

import java.util.Map.Entry;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class Test04 {
	public static void main(String[] args) {
		
		TreeMap<Student, Character> map = new TreeMap<>(new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				return o1.getAge() - o2.getAge();
			}
		});
		map.put(new Student("大毛",26),'男');
		map.put(new Student("二毛",31),'男');
		map.put(new Student("三毛",29),'男');
		map.put(new Student("四毛",26),'男');
		map.put(new Student("五毛",33),'男');
		map.put(new Student("六毛",28),'男');
		
		Set<Entry<Student, Character>> entrySet = map.entrySet();
		
		for (Entry<Student, Character> entry : entrySet) {
			System.out.println(entry.getKey()+" - "+entry.getValue());
			
		}
	}
}

姓名：大毛 年龄：26 - 男
姓名：六毛 年龄：28 - 男
姓名：三毛 年龄：29 - 男
姓名：二毛 年龄：31 - 男
姓名：五毛 年龄：33 - 男

Properties

Properties是用来获取配置文件信息的一个类

使用方法：

1.写一个配置文件

文件名：DBConfig.properties

注意：DBConfig.properties文件需要放在项目的src文件夹下才能获取

内容：

username=asdfg
password=123123

2.编写代码获取文件内容

package com.Xu.treemap_class;
import java.io.IOException;
import java.util.Properties;

public class Test03 {
	public static void main(String[] args) throws IOException {
		
		//创建配置文件的对象
		Properties properties = new Properties();
		
		//将配置文件加载到对象中
		properties.load(Test03.class.getClassLoader().getResourceAsStream("DBConfig.properties"));

		//获取配置文件中数据
        String property = properties.getProperty("username");
		String property2 = properties.getProperty("passwork");
		System.out.println(property+"---"+property2);
	}
}

asdfg---123123

注意

1. Collection 与 Map的区别

Collection 存单个值，可以获取迭代器进行遍历

Map存两个值(Key-Value)，不可以获取迭代器，不能遍历（Map可以间接遍历）

2. 理解Set为什么是无序

无序：存入顺序和取出顺序不一致，无序不等于随机

3. ArrayList 与 LinkedList的区别

使用上的区别：

​ LinkedList添加了

​ 队列模式-先进先出（removeFirst（））

​ 栈模式-先进后出（removeLast（））

效率上的区别：由于ArrayList底层数据结构是一维数组，LinkedList底层数据结构是双向链表

​ 添加 - 不扩容的情况：ArrayList快

​ 添加 - 扩容的情况：LinkedList快

​ 删除：LinkedList快

​ 修改：ArrayList快

​ 查询：ArrayList快

​ 注意：工作中常用ArrayList，因为很多需求都需要使用查询功能，ArrayList查询更快

4. 各种集合的应用场景

ArrayList：存数据，线程不安全

LinkedLinked：队列模式、栈模式，线程不安全

Vector：弃用，线程安全

Stack：弃用，线程安全

HashSet：去重+无序，线程不安全

LinkedHashSet：去重+有序，线程不安全

TreeSet：排序，线程不安全

HashMap：存key+value，key去重，无序，线程不安全

LinkedHashMap：存key+value，key去重，有序，线程不安全

Hashtable：弃用，存key+value，key去重，无序，线程安全，分段式加锁-效率低

ConcurrentHashMap：存key+value，key去重，无序，线程安全，局部加锁、CAS-效率高

TreeMap：存key+value，针对于Key排序

Properties：配置文件

3

2.编写代码获取文件内容

package com.Xu.treemap_class;
import java.io.IOException;
import java.util.Properties;

public class Test03 {
	public static void main(String[] args) throws IOException {
		
		//创建配置文件的对象
		Properties properties = new Properties();
		
		//将配置文件加载到对象中
		properties.load(Test03.class.getClassLoader().getResourceAsStream("DBConfig.properties"));

		//获取配置文件中数据
        String property = properties.getProperty("username");
		String property2 = properties.getProperty("passwork");
		System.out.println(property+"---"+property2);
	}
}

asdfg---123123

注意

1. Collection 与 Map的区别

Collection 存单个值，可以获取迭代器进行遍历

Map存两个值(Key-Value)，不可以获取迭代器，不能遍历（Map可以间接遍历）

2. 理解Set为什么是无序

无序：存入顺序和取出顺序不一致，无序不等于随机

3. ArrayList 与 LinkedList的区别

使用上的区别：

​ LinkedList添加了

​ 队列模式-先进先出（removeFirst（））

​ 栈模式-先进后出（removeLast（））

效率上的区别：由于ArrayList底层数据结构是一维数组，LinkedList底层数据结构是双向链表

​ 添加 - 不扩容的情况：ArrayList快

​ 添加 - 扩容的情况：LinkedList快

​ 删除：LinkedList快

​ 修改：ArrayList快

​ 查询：ArrayList快

​ 注意：工作中常用ArrayList，因为很多需求都需要使用查询功能，ArrayList查询更快

4. 各种集合的应用场景

ArrayList：存数据，线程不安全

LinkedLinked：队列模式、栈模式，线程不安全

Vector：弃用，线程安全

Stack：弃用，线程安全

HashSet：去重+无序，线程不安全

LinkedHashSet：去重+有序，线程不安全

TreeSet：排序，线程不安全

HashMap：存key+value，key去重，无序，线程不安全

LinkedHashMap：存key+value，key去重，有序，线程不安全

Hashtable：弃用，存key+value，key去重，无序，线程安全，分段式加锁-效率低

ConcurrentHashMap：存key+value，key去重，无序，线程安全，局部加锁、CAS-效率高

TreeMap：存key+value，针对于Key排序

Properties：配置文件