Java面试知识点：集合、Set、泛型、HashSet、HashMap

淩亂°似流年 2022-09-07 12:08 88阅读 0赞

# Java面试知识点：集合、Set、泛型、HashSet、HashMap #

答案：

1.集合

集合和数组的对比小结  
1,数组的长度是不可变的，集合的长度是可变的。  
2 ,数组可以存基本数据蟀和引用数据类型。  
集合只能存引用数据类型，如野存基本数据类型，需要存对应的包装类。

迭代器小结  
• lterator<E> iterator() :创建迭代器对象，默认指向当前集合的0索引。  
• boolean hasNext() :判断当前位置是否有元素可以被取出  
• E next() ：获取当前位置的元素，将迭代器对象移向下一个索引位置  
增强for循环  
增强for:简化数组和Collection集合的遍历  
• 它是JDK5之后出现的,其内部原理是一个Iterator迭代器  
•实现Iterable接口的类才可以使用迭代器和增强for

package com.xy;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test01
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/18 0018 10:18
     * @Version: 1.0
     */
    public class test01 {
        public static void main(String[] args) {
            Collection<String> collection=new ArrayList<>();
            collection.add("杨大大");
            System.out.println(collection);
            collection.add("恒大大");
            collection.remove("恒大大");
            System.out.println(collection);
            collection.removeIf((String s)->{
                return s.length()<=3;
            });
            System.out.println(collection);
        }
    }
    
    
    
    
    
    package com.xy;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test02
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/18 0018 15:41
     * @Version: 1.0
     */
    public class test02 {
        public static void main(String[] args) {
            Collection<String> collection=new ArrayList<>();
            collection.add("杨大大");
            collection.add("恒大大");
            Iterator<String> iterator=collection.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
            for (String s:collection
                 ) {
                System.out.println(s);
            }
        }
    }
    
    
    
    
    
    package com.xy;
    
    import java.util.LinkedList;
    
    /**
     * @ProjectName: day01
     * @Package: com.xy
     * @ClassName: test03
     * @Author: 杨路恒
     * @Description:
     * @Date: 2021/8/18 0018 19:18
     * @Version: 1.0
     */
    public class test03 {
        public static void main(String[] args) {
            LinkedList<String> linkedList=new LinkedList<>();
            linkedList.add("杨大大");
            linkedList.add("恒大大");
            for (int i = 0; i < linkedList.size(); i++) {
                System.out.println(linkedList.get(i));
            }
            linkedList.addFirst("杨");
            linkedList.addLast("恒");
            for (String s : linkedList) {
                System.out.println(s);
            }
            System.out.println(linkedList.getFirst());
            System.out.println(linkedList.getLast());
            linkedList.remove(0);
            linkedList.removeFirst();
            linkedList.removeLast();
            for (int i = 0; i <linkedList.size() ; i++) {
                System.out.println(linkedList.get(i));
            }
        }
    }

2.Set集合

Set集合概述和特点  
Set集合特点  
• 可以去除重复  
• 存取顺序不一致  
• 没有带索引的方法，所以不能使用普通for循环遍历，也不能通过获取索引来获取，删除Set集合里面的元素

Set集合练习  
• 存储字符串并遍历

public class test04Set集合{
        public static void main(String[] args) {
            Set<String> strings=new TreeSet<>();
            strings.add("杨大大");
            strings.add("恒大大");
            Iterator<String> iterator = strings.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
            for (String string : strings) {
                System.out.println(string);
            }
    
            TreeSet<Integer> treeSet=new TreeSet<>();
            treeSet.add(1);
            treeSet.add(2);
            treeSet.add(3);
            System.out.println(treeSet);
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 3][]

代码如下：

public class Student implements Comparable<Student>{
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(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 String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Student o) {
            int i = this.age - o.age;
            i=i==0?this.name.compareTo(o.name):i;
            return i;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
    
            Student student = (Student) o;
    
            if (age != student.age) return false;
            return name != null ? name.equals(student.name) : student.name == null;
        }
    
        @Override
        public int hashCode() {
            int result = name != null ? name.hashCode() : 0;
            result = 31 * result + age;
            return result;
        }
    }
    
    
    
    
    public class test05Set集合 {
        public static void main(String[] args) {
            /*TreeSet<Student> treeSet=new TreeSet<>(new Comparator<Student>() {
                @Override
                public int compare(Student o1, Student o2) {
                    //o1表示现在要存入的那个元素
                    //o2表示已经存入到集合中的元素
                    int i = o1.getAge() - o2.getAge();  //主要条件
                    i=i==0?o1.getName().compareTo(o2.getName()):i;  //次要条件
                    return i;
                }
            });*/
            TreeSet<Student> treeSet=new TreeSet<>(
                    (Student o1, Student o2)->{
                        int i = o1.getAge() - o2.getAge();  //主要条件
                        i=i==0?o1.getName().compareTo(o2.getName()):i;  //次要条件
                        return i;
                    }
            );
    
            treeSet.add(new Student("杨大大",22));
            treeSet.add(new Student("恒大大",23));
            treeSet.add(new Student("路大大",23));
            System.out.println(treeSet);//不实现implements Comparable<Student>会报Exception in
            // thread "main" java.lang.ClassCastException:
            // com.xy.Student cannot be cast to java.lang.Comparable
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 4][]

3.泛型  
（1）泛型概述  
泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型 它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数  
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢?  
顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型  
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 5][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 6][]

代码如下：

（1）泛型类：

package com.xy;
    
    public class Generic<T>{
        private T t;
    
        public T getT() {
            return t;
        }
    
        public void setT(T t) {
            this.t = t;
        }
    }
    
    
    
    
    public class test06泛型 {
        public static void main(String[] args) {
            TreeSet treeSet=new TreeSet();
            treeSet.add("杨大大");
    //        treeSet.add(6);
    
            Generic<String> generic=new Generic<>();
            generic.setT("杨大大");
            Generic<Integer> generic1=new Generic<>();
            generic1.setT(6);
            System.out.println(generic.getT());
            System.out.println(generic1.getT());
            Generic1<Integer> generic11=new Generic1Impl();
            generic11.show(6);
        }
    }

（2）泛型接口

public interface Generic1<T> {
        void show(T t);
    }
    
    
    
    
    public class Generic1Impl implements Generic1 {
        @Override
        public void show(Object o) {
    
        }
    }
    
    
    
    public class test06泛型 {
        public static void main(String[] args) {
            TreeSet treeSet=new TreeSet();
            treeSet.add("杨大大");
    //        treeSet.add(6);
    
            Generic<String> generic=new Generic<>();
            generic.setT("杨大大");
            Generic<Integer> generic1=new Generic<>();
            generic1.setT(6);
            System.out.println(generic.getT());
            System.out.println(generic1.getT());
            Generic1<Integer> generic11=new Generic1Impl();
            generic11.show(6);
        }
    }

（3）

public class test07泛型 {
        public static void main(String[] args) {
            List<?> list=new ArrayList<Object>();
            List<?> list1=new ArrayList<Number>();
            List<?> list2=new ArrayList<Integer>();
            List<? extends Number> list3=new ArrayList<Number>();
            List<? extends Integer> list4=new ArrayList<Integer>();
            List<? super Number> list5=new ArrayList<Number>();
            List<? super Integer> list6=new ArrayList<Integer>();
        }
    }

4.HashSet  
哈希值  
哈希值（哈希码值）：是JDK根据对象的地址或者属性值，算出来的int类型的整数  
Object类中有一个方法可以获取对象的哈希值  
• public int hashCode()：根据对象的地址值计算出来的哈希值  
对象的哈希值特点  
• 如果没有重写hashCode方法，那么是根据对象的地址值计算出的哈希值。同一个对象多次调用hashCode()方法返回的哈希值是相同的不同对象的哈希值是不一样的。  
• 如果重写了hashCode方法，一般都是通过对象的属性值计算出哈希值。  
如果不同的对象属性值是一样的，那么计算出来的哈希值也是一样的。

HashSet1.7版本原理总结  
• 底层结构：哈希表。（数组+链表）  
• 数组的长度默认为16,加载因子为0.75  
• 首先会先获取元素的哈希值，计算出在数组中应存入的索引  
判断该索引处是否为null  
如果是null ,直接添加  
如果不是null ,则与链表中所有的元素，通过equals方法比较属性值 只要有一个相同，就不存，如果都不一样，才会存入集合。  
HashSet1.8版本原理解析  
底层结构：哈希表。（数组、链表、红黑树的结合体）。  
当挂在下面的元素过多，那么不利于添加，也不利于查询，所以在JDK8以后, 当链表长度超过8的时候,自动转换为红黑树。

代码如下：

public class test09HashSet {
        public static void main(String[] args) {
            HashSet<String> hashSet=new HashSet<>();
            hashSet.add("杨大大");
            hashSet.add("恒大大");
            Iterator<String> iterator = hashSet.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
            for (String s : hashSet) {
                System.out.println(s);
            }
        }
    }
    
    
    public class test10HashSet {
        public static void main(String[] args) {
            HashSet<Student> hashSet=new HashSet<>();
            hashSet.add(new Student("杨大大",22));
            hashSet.add(new Student("恒大大",23));
            hashSet.add(new Student("杨大大",22));
            /**
             * 结论：
             *      如果HashSet集合要存储自定义对象，那么必须重写hashCode和equals方法。
             */
            for (Student student : hashSet) {
                System.out.println(student.hashCode());
            }
        }
    }

5.HashMap

代码如下：

public class test11HashMap {
        public static void main(String[] args) {
            Map<String,String> map=new HashMap<>();
            map.put("1","杨大大");
            map.put("2","恒大大");
            System.out.println(map);
            System.out.println(map.get("1"));
            System.out.println(map.size());
            Set<String> strings = map.keySet();
            System.out.println(strings);
            Collection<String> values = map.values();
            System.out.println(values);
            for (String s : strings) {
                System.out.println(map.get(s));
            }
        }
    }
    
    
    
    
    
    public class test12HashMap {
        public static void main(String[] args) {
            Map<String,Student> map=new HashMap<>();
            map.put("1",new Student("杨大大",22));
            map.put("2",new Student("恒大大",22));
            Set<String> keySet = map.keySet();
            for (String s : keySet) {
                System.out.println(map.get(s));
            }
            Set<Map.Entry<String, Student>> entries = map.entrySet();
            for (Map.Entry<String, Student> entry : entries) {
                System.out.println(entry);
            }
        }
    }
    
    
    
    
    
    public class test13HashMap {
        public static void main(String[] args) {
            Map<Student,String> map=new HashMap<>();
            map.put(new Student("杨大大",22),"西安");
            map.put(new Student("恒大大",22),"上海");
            Set<Student> keySet = map.keySet();
            for (Student s : keySet) {
                System.out.println(map.get(s));
            }
            Set<Map.Entry<Student, String>> entries = map.entrySet();
            for (Map.Entry<Student, String> entry : entries) {
                System.out.println(entry);
            }
            map.put(new Student("恒大大",22),"上海");
    
        }
    }
    
    
    
    
    public class test14HashMap {
        public static void main(String[] args) {
            ArrayList<HashMap<String,String>> array=new ArrayList<>();
            HashMap<String,String> map=new HashMap<>();
            map.put("杨大大","22");
            map.put("恒大大","22");
            HashMap<String,String> map1=new HashMap<>();
            map1.put("杨大大","22");
            map1.put("恒大大","22");
            array.add(map);
            array.add(map1);
            for (HashMap<String, String> hashMap : array) {
                System.out.println(hashMap);
            }
    
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70]: /images/20220829/eb536720fb4a41b6b362b5d4c3fbd06b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 1]: /images/20220829/ab0e97fa3ef9415bb63ab236d476861e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 2]: /images/20220829/a4845cf38562497fbe6ded89ed4bd754.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 3]: /images/20220829/aa18e3961c134849b029db2a7539a895.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 4]: /images/20220829/6cef64b0956843e1b6b99cd916eb5efc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210823153136108.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmcxMzU2Mzc1ODEyOA_size_16_color_FFFFFF_t_70 6]: /images/20220829/b8b45969c1f846a3b4c1245eaaf25d77.png