java_SE面试基础知识：集合2

目录

1、Collcetion集合

2、Map集合

3、HashSet

4、LinkedHashSet

---

/*
集合框架：		
	底层：
子类集合【孙子辈】： 【1】Vector集合	【1】ArrayList集合	【1】LinkedList集合	【2】TreeSet集合	【2】HashSet集合	【2】LinkedHashSet集合
	顶层：
				子辈接口1 List接口：1 有序的集合【存储与去除元素顺序相同】
						2 允许重复元素
						3 存在索引，可以使用for循环遍历
				子辈接口2 Set接口：1 不允许重复元素
						2 没有索引，不允许for循环遍历
						3 无序集合【除了最后一个集合】
				父辈接口 Collection接口：
						1 定义的是所有单列集合的共性方法
						2 所有单列集合都可以使用共性方法
						3 没有带索引的方法

Iterator迭代器：通用的遍历集合取出元素方式。
 */

1、Collcetion集合

/*
* java.util.Collection
* 1 共性的方法：1.1 public boolean add(E e): 把给定的对象添加到集合中
*             返回值是boolean值，一般不用接收，因为没有什么意义
*       1.2 public void clear():清空集合中的元素
*       1.3 public boolean remove(E e): 把给定的对象在当前集合中删除
*             返回值是boolean值，集合中存在元素，删除然后返回true，没有这个元素，删除失败返回false
*       1.4 public boolean contains(E e):判断当前集合是否包含给定对象
*               返回值是boolean值,包含返回true，不包含返回false
*       1.5 public boolean isEmpty():判断当前集合是否为空
*                返回值是boolean值,为空返回true，不为空返回false
*       1.6 public int size():返回集合中元素的个数
*       1.7 public Object[] toArray():把集合中的元素，存储到数组中。
2、Collection类
public static <T> boolean addAll(Collection<T> c,...elements)  	往集合添加多个元素
public static void shuffle(List<?> list)  						打乱集合中的元素顺序
public static <T>  void sort(List<T> list) 						将集合中的元素按默认顺序排序 默认升序
 public static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。
* */
public class Collection_01 {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();//多态 创建对象[子类随便改]
        System.out.println(coll);//[]  不是地址值，说明重写了toString方法
        //1.1 添加
        boolean b1=coll.add("张三");
        //System.out.println(b1);//true 一般返回true，又不是我们想要的值，所以接受没有意义
        System.out.println(coll);//[张三]
        coll.add("李四");
        coll.add("赵六");
        coll.add("王五");
        coll.add("田七");
        System.out.println(coll);//[张三, 李四, 赵六, 王五, 田七]
        //1.3 删除
        boolean b2=coll.remove("赵四");
        boolean b3=coll.remove("张三");
        System.out.println(b2);//false
        System.out.println(b3);//true
        System.out.println(coll);//[李四, 赵六, 王五, 田七]
        //1.4 包含
        boolean b4=coll.contains("赵四");
        System.out.println(b4);//false
        //1.5 当前集合是否为空
        boolean b6 = coll.isEmpty();
        System.out.println(b6);//false
        //1.6 元素个数
        int size=coll.size();
        System.out.println(size);//4
        //1.7 把集合中的元素存储到数组
        Object[] arr=coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);//李四赵六王五田七
        }
        System.out.println("\n");
        //1.2 清空集合所有元素
        coll.clear();
        System.out.println(coll);//[]
    }
}

/*
java.util.Collections
* public static <T>  void sort(List<T> list) 将集合中的元素按默认顺序排序 默认升序
注意：被排序的集合必须实现Comparable接口，重写接口的方法compare To定义排序的规则
排序规则：Comparable接口的排序规则：
自己（this）-参数；升序 反过来就是降序
return this.getAge()-person.getAge();//按年领升序排序

public static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。
* Comparable与Comparator的区别：
*   Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则
*   Comparator：相当于找一个第三方当裁判，比较这两个
* Comparator排序规则：return i1-i2;//升序
                return i2-i1;//降序
*  */
public class Person implements Comparable<Person>{
    private String name;
    private  int age;

    public Person() {
    }

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

    public Person(String name, int age) {
        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 int compareTo(Person person) {
       // return 0;//认为元素都是相同的
        //自定义比较的规则，如：比较两个人的年领
        return this.getAge()-person.getAge();//按年领升序排序
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Collections_lianxi_2 {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);

        Collections.sort(list, new Comparator<Integer>() {
            //重写比较的规则
            @Override
            public int compare(Integer i1, Integer i2) {
                //return i1-i2;//升序
                return i2-i1;//降序
            }
        });
        System.out.println(list);
        ArrayList<Person> list1=new ArrayList<>();
        list1.add(new Person("a迪丽热巴",18));
        list1.add(new Person("古力娜扎",20));
        list1.add(new Person("杨幂",17));
        list1.add(new Person("b杨幂",18));

        /*Collections.sort(list1, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getAge()-p2.getAge();//年领升序
            }
        });*/
        Collections.sort(list1, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int result = o1.getAge() - o2.getAge();
                //如果年领相等，比较姓名第一个字
                if(result==0){
                    result=o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
        });

        System.out.println(list1);
    }
}

2、Map集合

/*Map集合
HashMap
Hashtable

Collection集合为单链集合，Map集合为双链集合
Map集合：
	特点：1、一个元素包含两个值，由Key键和Value值组成
	2、Key和Vaule的数据类型允许不同。
	3、Key不允许重复，Value可以重复
	4、Key与Value一一对应
常见子类：
	java.util.HashMap集合 implements Map<k,v>
		特点：1、查询速度快，底层为Hash表，无序
		JDK1.8之前：数组+单向链表
		JDK1.8之后：数组+单项链表/红黑树【链表长度超过8时】
		2、HashMap集合，存储元素与取出元素的顺序有可能不一致。
	java.util.LinkHashMap集合 extends HashMap集合<k,v>集合
		特点：1、底层是哈希表+链表【保证迭代顺序】 有序
		2、LinkedHashMap集合是一个有序集合，存储元素和取出元素顺序一致。


     1、 public V put(K key, V value)  把制定键与指定值添加到Map中
            一般不接收返回值 V:存储键值对时，key不重复，返回null
                            key重复，使用新的value替换重复老key的value，返回老key的value
             void putAll(Map<? extends K,? extends V> m) 
                  从指定映射中将所有映射关系复制到此映射中（可选操作）。 

    2、public V remove(Object key)  从此映射中移除指定键的映射关系（如果存在）。
            返回值V：key存在返回被删除的值
                key不存在返回null
    3、 public V get(Object key)    返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
            key存在，返回对应值
            key不存在，返回null
    4、 boolean containsKey(Object key) 判断集合是否包含指定键
        包含返回true
        不包含返回false
    遍历： 通过键找值：
           5、Set<K> keySet() 把map集合所有key取出来存储到set集合中
                5.1 遍历set集合：迭代器；增强for
                5.2 使用get方法通过key获取value
		   6、Map.Entry<K.V>：在Map集合中有一个内部接口Entry
			 作用：当Map集合已创建，就会自动创建一个Entry对象来记录键值对。
                6.1 Set<Map.Entry<K,V>> entrySet()  将Map集合内部的多个Entry对象取出，存储到一个Set集合中
                6.2 遍历Set集合获取每一个Entry对象
                6.3 使用Map.Entry<K,V>里的方法：
                    K getKey()  返回与此项对应的键。
                    V getValue() 返回与此项对应的值。


Hashtable<K,V>集合，实现了Map接口，底层为哈希表
*   特点：1、不允许为空；【引用数据类型默认为空】
*       2、单线程
*      Hashtable 底层是一个哈希表，线程安全，单线程，速度慢；
*      HashMap 底层是一个哈希表，线程不安全，多线程，速度快；
*       在JDK1.2之后被HashMap取代，但他的子类Properties仍然使用，他是唯一一个和IO流结合的集合。
*/

/*Hashtable<K,V>集合，实现了Map接口，底层为哈希表
*   特点：1、不允许为空；【引用数据类型默认为空】
*       2、单线程
*      Hashtable 底层是一个哈希表，线程安全，单线程，速度慢；
*      HashMap 底层是一个哈希表，线程不安全，多线程，速度快；
*       在JDK1.2之后被HashMap取代，但他的子类Properties仍然使用，他是唯一一个和IO流结合的集合。
* HashMap存储自定义类型键值：
*   Map集合保证Key值唯一，作为Key的元素，必须重写hashCode方法和equals方法，以保证key唯一。
*  */
import java.util.Objects;

public class Person1 {
    private String name;
    private int age;

    public Person1() {
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person1 person1 = (Person1) o;
        return age == person1.age &&
                Objects.equals(name, person1.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person1{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

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

public class Map_01lianxi {
    public static void main(String[] args) {
        show01();
        show02();
    }
    //          key:Person类型 必须重写hashCode和equals方法，以保证唯一性
    //          value：String    可以重复
    private static void show02(){
        HashMap<Person1,String> map=new HashMap<>();
        map.put(new Person1("女王",18),"英国");
        map.put(new Person1("秦始皇",108),"秦国");
        map.put(new Person1("普京",18),"俄国");
        map.put(new Person1("普京",18),"中国");//重写完hashCode和equals后，key重复的老value消失
        //entryset+增强for
        Set<Map.Entry<Person1, String>> set = map.entrySet();
        for(Map.Entry<Person1,String> entry:set){
            Person1 key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"=>"+value);
        }

    }
    // =========================================================================
    //            key：String类型 ；String类重写hashCode方法和equals方法，以保证唯一性。
    //            value：Person1类型；可以重复
    private static void show01() {
        HashMap<String,Person1> map=new HashMap<>();
        map.put("北京",new Person1("张三",18));
        map.put("上海",new Person1("李四",19));
        map.put("北京",new Person1("赵六",18));//key重复会让老的value替换新的value
        //keyset+增强for遍历
        Set<String> set = map.keySet();
        for(String key:set) {
            Person1 value = map.get(key);
            System.out.println(key + "=>" + value);
        }
    }
}

3、HashSet

/*给HashSet集合存储自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的存储方式，才能保证HashSet对象唯一

哈希值：是一个十进制整数，由系统随机给出【就是对象的逻辑地址值，不是真实的物理地址】
在Object类有一个方法可以获取对象的哈希值
int hashCode() 返回该对象的哈希值
public native int hashCode();
native:代表该方法调用的是本地的操作系统的方法。

HashSet<String> set1=new HashSet<>();
set1.add("重地")
	add方法调用“重地”【String】的hashCode方法，计算字符串“重地”的哈希值，比如哈希值是12346
	然后就会找集合中有没有哈希值是12346的元素，发现没有
	就会把“重地”存储到集合中 挂在哈希值为12346的位置上
	
	set1.add("通话")
	add方法调用“通话”的hashCode方法，计算字符串“a通话”的哈希值，为12346
	然后就会找集合中有没有哈希值是12346的元素，发现有，即产生了哈希冲突
	“通话”就会调用equals方法和哈希值相同的元素进行内容比较，"通话".equals("重地")，
	返回false，两个元素内容不相同，就把“通话”存储到集合中。挂在哈希值为12346的位置上

*/

4、LinkedHashSet

/*
* java.util.LinkedHashSet集合 extends HashSet集合
* LinkedHashSet特点：
* 底层是一个哈希表（数组+链表/红黑树）+链表：多了一条链表结构（记录元素的存储顺序），保证元素有序
*
*  */

import java.util.HashSet;
import java.util.LinkedHashSet;
public class LinkedHashSet_lianxi {
    public static void main(String[] args) {
        HashSet<String> set=new HashSet<>();
        set.add("www");
        set.add("aaa");
        set.add("aaa");
        set.add("itcast");
        System.out.println(set);//[aaa, www, itcast] 无序，不允许重复

        LinkedHashSet<String> linked=new LinkedHashSet<>();
        linked.add("www");
        linked.add("aaa");
        linked.add("aaa");
        linked.add("itcast");//[aaa, www, itcast] 有序，不允许重复


    }
}

javaSE面试基础知识：集合1_z输关的博客-CSDN博客