集合框架知识汇总

集合框架

集合

  • 概念:对象的容器,定义了对多个对象进行操作的常用方法。可以实现数组功能

  • 和数组的区别

    • 数组长度固定,集合长度不固定

    • 数组可以存储基本类型和引用类型,集合只能存储引用类型

  • 总结

    • List集合

      • 有序,有下标,元素可以重复(ArrayList,LinkedList,Vector)

    • Set集合

      • 无序,无下标,元素不可以重复(HashSet,TreeSet)

    • Map集合

      • 存储一对数据,无序,无下标,键不可重复,值可重复。(HashMap,HashTable,TreeMap)

    • Collections

      • 集合工具类,定义了除了存取以外的集合常用方法

Collection体系集合

集合框架知识汇总_第1张图片

Collection父接口

  • 特点:代表一组任意类型的对象,无序,无下标,不能重复

//Collection接口的使用

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo1 {
    public static void main(String[] args) {
       //创建一个集合
        Collection collection=new ArrayList();
        //添加元素
        collection.add("花海");
        collection.add("枫");
        collection.add("晴天");
        System.out.println("元素个数:"+collection.size());
        System.out.println(collection);
        //删除元素
        collection.remove("晴天");
        System.out.println("元素个数:"+collection.size());
        System.out.println(collection);
        //遍历(掌握)
        //使用增强for
        for (Object object:collection) {
            System.out.println(object);
        }
        //迭代器(专门用来遍历集合)
        //hasNext();有没有下一个元素
        //next();获取下一个元素
        //remove();删除当前元素
        Iterator it= collection.iterator();
while (it.hasNext()){
    String object=(String)it.next();
    System.out.println(object);
    it.remove();
}
        System.out.println("元素个数"+collection.size());
//判断
        //判断元素是否存在
        System.out.println(collection.contains("花海"));
        System.out.println(collection.contains("晴天"));
        System.out.println(collection.isEmpty());
    }
}

 集合框架知识汇总_第2张图片

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

    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 +
                '}';
    }
}
---------------------------------------
 import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//Collection的使用(学生信息)
public class Demo2 {
    public static void main(String[] args) {
        //新建一个Collection对象
        Collection collection=new ArrayList();
        Student s1=new Student("林夕",18);
        Student s2=new Student("花海",22);
        Student s3=new Student("枫",12);
        //添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println("元素个数:"+collection.size());
        System.out.println(collection.toString());
        //删除
        collection.remove(s1);
        System.out.println("元素个数:"+collection.size());
        System.out.println(collection.toString());
        //遍历
        //增强for方法
        for (Object object:collection) {
            Student s=(Student)object;
            System.out.println(s.toString());
        }
        //迭代器
        Iterator it=collection.iterator();
        while (it.hasNext()){
          Student st=(Student) it.next();
            System.out.println(st.toString());
            //判断
            System.out.println(collection.contains(s1));
            System.out.println(collection.contains(s2));
            System.out.println(collection.isEmpty());
        }
    }
}   
   

 集合框架知识汇总_第3张图片

 

List子接口

  • 特点:有序,有下标,元素可以重复

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

//List接口的使用
public class Demo1 {
    public static void main(String[] args) {
        //先创建集合
        List list=new ArrayList<>();
        //添加元素
        list.add("林夕");
        list.add("花海");
        list.add(0,"枫");
        list.add("晴天");
        list.add("七里香");
        System.out.println("元素个数"+list.size());
        System.out.println(list.toString());
        //删除元素
        list.remove("花海");
        list.remove(0);
        System.out.println("删除之后"+list.size());
        System.out.println(list.toString());
        //遍历
        //for遍历
        for (int i = 0; i 

集合框架知识汇总_第4张图片

 

import java.util.ArrayList;
import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        //创建list集合
        List list=new ArrayList<>();
        //添加数字数据(自动装箱,成为了包装类)
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //删除
        list.remove((Object) 20);//或者list.remove(0)
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        // .sublist()返回子集合
        System.out.println(list.subList(1,3));
    }
}

集合框架知识汇总_第5张图片

List实现类

  • ArrayList

    • 数组结构实现,查询快,增删慢

  • 源码分析

    • DEFAULT_CAPACITY=10;默认容量

    • elementDate存放元素的数组

    • size 实际元素个数

    • 如果没有向集合中添加任何元素,容量为零,添加任意一个元素以后,容量变为10,10以后,每次扩容后为1.5倍(10.》15)

ArrayList使用


import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Demo3 {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList arrayList=new ArrayList<>();
        Student s1=new Student("林夕",20);
        Student s2=new Student("花海",21);
        Student s3=new Student("晴天",22);
        Student s4=new Student("枫",23);
        //添加对象
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        System.out.println("元素个数:"+arrayList.size());
        System.out.println(arrayList.toString());
        //删除对象
       arrayList.remove((new Student("林夕",20)));
        System.out.println("删除之后:"+arrayList.size());// arrayList.remove(0);
        System.out.println(arrayList.toString());
        //遍历
        //迭代器
       Iterator it= arrayList.iterator();
       while(it.hasNext()){
          Student s=(Student) it.next();
           System.out.println(s.toString());
       }
        System.out.println("-------------------------");
       //列表迭代器
        ListIterator lit = arrayList.listIterator();
       while(lit.hasNext()){
           Student st=(Student) lit.next();
           System.out.println(st.toString());
       }
        System.out.println("-------------------------");
       while ((lit.hasPrevious())){
           Student std=(Student) lit.previous();
           System.out.println(std.toString());
       }
        System.out.println("-------------------------");
       //判断
        System.out.println(arrayList.contains(s2));
        System.out.println(arrayList.isEmpty());
        //查找
        System.out.println(arrayList.indexOf(s2));
 
 }
}
--------------------------------------------
    package 基础语法.Collection.Demo2;

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

    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 boolean equals(Object obj) {
        //判断是不是同一个对象
        if (this==obj){
            return true;
        }
        //判断是否为空
        if (obj==null){
            return false;
        }
        //判断是否为Student类型
        if (obj instanceof Student){
            Student s=(Student)obj;
            //比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        //不满足条件false
        return false;
    }

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

    }
}

 集合框架知识汇总_第6张图片

 

Vector

  • 数组结构实现,查询快,增删慢

  • JDK1.0

import java.sql.SQLOutput;
import java.util.Enumeration;
import java.util.Vector;

public class Demo4 {
    public static void main(String[] args) {
        //创建Vector集合
        Vector vector=new Vector<>();
        Student s1=new Student("林夕",23);
        Student s2=new Student("花海",22);
        Student s3=new Student("枫",24);
        Student s4=new Student("晴天",25);
        //添加对象
        vector.add(s1);
        vector.add(s2);
        vector.add(s3);
        vector.add(s4);
        System.out.println("元素个数:"+vector.size());
        System.out.println(vector.toString());
         //删除
        System.out.println(vector.remove(0));
        //遍历
       Enumeration en= vector.elements();
       while (en.hasMoreElements()){
              Student s=(Student)en.nextElement();
           System.out.println(s);
       }
        //判断
        System.out.println(vector.contains(s2));
        //补充
        System.out.println(vector.firstElement());
        System.out.println(vector.lastElement());
        System.out.println(vector.elementAt(2));
    }
}

集合框架知识汇总_第7张图片

 

LinkedList

  • 链表结构实现,增删快,查询慢

  • 源码分析

    • int size;集合的大小

    • Node first;链表的头节点

    • Node last ;链表的尾节点

import java.sql.SQLOutput;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

//LinkedList
//存储结构,双向链表
public class Demo5 {
    public static void main(String[] args) {
        //创建LinkedList集合
        LinkedList linkedList=new LinkedList<>();
        Student S1=new Student("林夕",20);
        Student S2=new Student("花海",20);
        Student S3=new Student("枫",20);
        Student S4=new Student("晴天",20);
        //添加对象
        linkedList.add(S1);
        linkedList.add(S2);
        linkedList.add(S3);
        linkedList.add(S4);
        System.out.println(linkedList.size());
        System.out.println(linkedList.toString());
        System.out.println("-------------------------------");
        //遍历
        //for循环
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        System.out.println("-------------------------------");
        //增强for循环
        for (Object object:linkedList) {
            Student s=(Student) object;
            System.out.println(s);
        }
        System.out.println("------------------------");
        //迭代器
        Iterator it=linkedList.iterator();
        while(it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s);
        }
        System.out.println("------------------------");
        //列表迭代器
            ListIterator lit= linkedList.listIterator();
        while(lit.hasNext()){
           Student s=  (Student)lit.next();
            System.out.println(s);
        }
        System.out.println("------------------------");
        //判断
        System.out.println(linkedList.contains(S2));
        //获取
        System.out.println(linkedList.indexOf(S2));
    }
}

集合框架知识汇总_第8张图片

 

ArrayList和Linkedlist的区别

  • ArrayList创建的地址连续 ,查询快,增删慢

  • LinkedList创建的不连续,查询慢,增删快

泛型

  • java泛型是JDk1.5中引入的一个新特性,其本质是参数化类型,把类型作为参数传递

  • 常见形式有泛型类,泛型接口,泛型方法

    • 语法T 称作类型占位符,表示一种引用类型

  • 好处

    • 提高代码的重用性

    • 防止类型转换出现异常。提高代码的安全性

泛型类

//泛型类   语法  类名   T是类型占位符,表示一种引用类型,如果多个使用逗号隔开
public class MyGeneric {
    //使用泛型T
    //1创建变量
    T t;
    //2泛型作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
   //3 泛型作为方法的返回值
   public T getT(){
        return t;
   }
}
===============================
    public class Test {
    public static void main(String[] args) {
        //使用泛型类创建对象
        //注意:1 泛型只能使用引用类型 2 不同泛型类型之间不能相互赋值

        MyGeneric myGeneric=new MyGeneric<>();
        myGeneric.show("林夕");
        myGeneric.t="花海";
        String str=myGeneric.getT();

        MyGeneric  myGeneric1=new MyGeneric<>();
        myGeneric1.show(200);
        myGeneric1.t=100;
        Integer integer=myGeneric1.getT();
    }
}

集合框架知识汇总_第9张图片

泛型接口

public interface MyGenericFace {
    String name="林夕";
    T server(T t);
}
----------------------------------------
public class MyGenericFaceImp implements MyGenericFace{
    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}
---------------------------------------
    public class MyGenericFaceImp1 implements MyGenericFace{
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}
-------------------------------------
     MyGenericFaceImp imp=new MyGenericFaceImp();
        imp.server("林夕");


        MyGenericFaceImp1 imp1=new MyGenericFaceImp1<>();
        imp1.server(123);

 

泛型方法

//泛型方法    语法  < T>返回值类型
public class MyGenericMethod {
   public   T  show(T t){
       System.out.println("泛型方法:"+t);
       return t;
   }  
}
-------------------------
     //泛型方法
        MyGenericMethod myGenericMethod=new MyGenericMethod();
        myGenericMethod.show("林夕");
        myGenericMethod.show(123);

 

泛型集合

  • 概念:参数化类型,类型安全的集合,强制集合元素的类型必须一致

  • 特点

    • 编译时即可检查,而非运行时抛出异常

    • 访问时,不必类型转换(拆箱)

    • 不同泛型之间引用不能相互赋值,泛型不存在多态

Set子接口

  • 特点:无序,无下标,元素不可重复

  • 方法:全部继承自Collection中的方法

    set接口使用

  • import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    //测试Set接口的使用
    public class Demo1 {
        public static void main(String[] args) {
        //创建集合
        Set set=new HashSet<>();
        //添加数据
        set.add("林夕");
        set.add("花海");
        set.add("枫");
        set.add("晴天");
        System.out.println(set.size());
        System.out.println(set.toString());
          //删除数据
            set.remove("林夕");
            System.out.println(set.toString());
            //遍历
            //增强for
            for (String string:set) {
                System.out.println(string);
            }
            System.out.println("--------------------------------");
            //使用迭代器
            Iterator it=set.iterator();
            while (it.hasNext()){
                System.out.println( it.next());
            }
            System.out.println("----------------------------------");
            //判断
            System.out.println(set.contains("花海"));
            System.out.println(set.isEmpty());
    }
    }

    集合框架知识汇总_第10张图片

    HashSet使用

  • 基于HashSet计算元素存放位置

  • 当存入的元素的哈希码相同时,会调用equals进行确认,若结果为true,则拒绝后者存入

  •  

    import java.util.HashSet;
    import java.util.Iterator;
    
    //HashSet集合的使用
    //存储结构  哈希表(数组+链表+红黑树)
    public class Demo2 {
        public static void main(String[] args) {
            //创建HashSet集合
            HashSet  hashSet=new HashSet<>();
            //添加元素
            hashSet.add("林夕");
            hashSet.add("花海");
            hashSet.add("枫");
            hashSet.add("七里香");
            hashSet.add("晴天");
            System.out.println("元素个数:"+hashSet.size());
            System.out.println(hashSet.toString());
            //删除元素
            hashSet.remove("林夕");
            System.out.println("删除之后:"+hashSet.size());
            //遍历
            //增强for循环
            for (String string:hashSet) {
                System.out.println(string);
            }
            System.out.println("========================");
            //迭代器
            Iterator it=hashSet.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
            System.out.println("=============================");
            //判断
            System.out.println(hashSet.contains("七里香"));
            System.out.println(hashSet.isEmpty());
        }
    }
    

    集合框架知识汇总_第11张图片

     

    public class Person {
        private String name;
        private int 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 String toString() {
            return "Person [name="+name+",age="+age+"]";
        }
    
        @Override
        public int hashCode() {
            int n1=this.name.hashCode();
            int n2=this.age;
            return  n1+n2;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (this==obj){
                return true;
            }
            if (obj==null){
                return false;
            }
            if (obj instanceof Person ){
                Person p=(Person)obj;
                if (this.name.equals(p.getName())&&this.age==p.getAge());
                return true;
            }
               return  false;
        }
    }
    ============================================================
        import java.util.HashSet;
    import java.util.Iterator;
    
    //HashSet的使用
    //1 根据Hashcode计算保存的位置,如果此位置为空则直接保存,如果不为空执行第二步
    //2  在执行equals方法,如果equals方法为true,则认为重复,否则,形成链表
    public class Demo3 {
        public static void main(String[] args) {
            //创建persons集合
            HashSet persons=new HashSet<>();
            //添加元素
            Person p1=new Person("林夕",18);
            Person p2=new Person("花海",18);
            Person p3=new Person("晴天",18);
            Person p4=new Person("枫",18);
            persons.add(p1);
            persons.add(p2);
            persons.add(p3);
            persons.add(p4);
            persons.add((new Person("花海",18)));
            System.out.println(persons.size());
            System.out.println(persons.toString());
            //删除数据
            persons.remove(p1);
            System.out.println("删除之后:"+persons.size());
            System.out.println(persons.toString());
            //遍历
          //增强for
            for (Person person:persons) {
                System.out.println(person);
            }
            //迭代器
            Iterator it=persons.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
            //判断
            System.out.println(persons.contains(p2));
            System.out.println(persons.isEmpty());
        }
    }

    集合框架知识汇总_第12张图片

     

  • 注意点(重写hashcode时为什么使用31?)

    • 31是质数,尽量减少散列冲突

    • 提高执行效率(31*i=(i>>5)-i)

    • TreeSet

  • 基于排列顺序实现元素不重复

  • 实现了SortedSet接口,对集合元素自动排序

  • 元素对象的类型必须实现Comparable接口,指定排序规则

  • 通过CompareTo方法确定是否为重复元素

     

  • 
    public class Person  implements Comparable {
        private String name;
        private int 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 String toString() {
            return "Person [name="+name+",age="+age+"]";
        }
    
        @Override
        public int hashCode() {
            int n1=this.name.hashCode();
            int n2=this.age;
            return  n1+n2;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (this==obj){
                return true;
            }
            if (obj==null){
                return false;
            }
            if (obj instanceof Person ){
                Person p=(Person)obj;
                if (this.name.equals(p.getName())&&this.age==p.getAge());
                return true;
            }
               return  false;
        }
    //先按姓名比,再按年龄比
        @Override
        public int compareTo(Person o) {
            int n1=this.getName().compareTo(o.getName());
            int n2=this.age-o.getAge();
            return n1==0?n2:n1;
        }
    }
    --------------------------------------
        
    import java.util.Iterator;
    import java.util.TreeSet;
    
    //TreeSet的使用
    //存储结构(红黑树)
    //元素必须实现Comparable接口,compareTo()方法返回值为0,认为为重复元素
    public class Demo5 {
        public static void main(String[] args) {
    
        TreeSet personTreeSet=new TreeSet<>();
        Person p1=new Person("xyz",19);
        Person p2=new Person("asd",17);
        Person p3=new Person("qwe",18);
        Person p4=new Person("asd",16);
            personTreeSet.add(p1);
            personTreeSet.add(p2);
            personTreeSet.add(p3);
            personTreeSet.add(p4);
            System.out.println(personTreeSet.size());
            System.out.println(personTreeSet.toString());
            personTreeSet.remove(p1);
            System.out.println(personTreeSet.size());
            for (Person person:personTreeSet
                 ) {
                System.out.println(person);
            }
           Iterator it= personTreeSet.iterator();
            while (it.hasNext()){
                System.out.println(it.next());
            }
            System.out.println(personTreeSet.contains(p2));
            System.out.println(personTreeSet.isEmpty());
    }
    }

 集合框架知识汇总_第13张图片

 

  • Comparator**:实现定制比较(比较器)

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

//TreeSet接口
//Comparator:实现定制比较(比较器)
public class Demo6 {
    public static void main(String[] args) {
        TreeSet personTreeSet=new TreeSet<>(new Comparator() {
           //创建集合,并指定比较规则
            @Override
            public int compare(Person o1, Person o2) {
                int n1= o1.getAge()- o2.getAge();
                int n2=o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        Person p1=new Person("xyz",19);
        Person p2=new Person("asd",17);
        Person p3=new Person("qwe",16);
        Person p4=new Person("asd",16);
        personTreeSet.add(p1);
        personTreeSet.add(p2);
        personTreeSet.add(p3);
        personTreeSet.add(p4);
        System.out.println(personTreeSet.size());
        System.out.println(personTreeSet.toString());
    }
}

TreeSet案例

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

*//TreeSet**使用

**//comparator**实现字符串排序
*public class Demo7 {
    public static void main(String[] args) {



    TreeSet  treeSet=new TreeSet<>(new Comparator() {
        @Override
        public int compare(String o1, String o2) {
            int n1=o1.length()-o2.length();
            int n2=o1.compareTo(o2);
            return n1==0?n2:n1;
        }
    });
    treeSet.add("asd");
    treeSet.add("asdf");
    treeSet.add("asdgh");
    treeSet.add("asdjjll");
    treeSet.add("asdtdwggtghrtr");
    System.*out*.println(treeSet.toString());
}
}

 

 Map体系集合

集合框架知识汇总_第14张图片

 

  • Map接口特点

    • 用于储存任意键值对(key-value)

    • 键:无序,无下标,不允许重复(唯一)

    • 值:无序,无下标,允许重复

Map父接口

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

//Map接口的使用    1储存的是键值对,2键不可以重复,值可以重复,3无序
public class Demo1 {
    public static void main(String[] args) {
        //创建Map集合
        Map  map=new HashMap<>();
        //添加元素
        map.put("林","夕");
        map.put("花","海");
        map.put("晴","天");
        map.put("一路","向北");
        System.out.println("元素个数:"+map.size());
        System.out.println(map.toString());
        //删除元素
        map.remove("林");
        System.out.println("删除之后:"+map.size());
        //遍历
        //1 使用KeySet();
        for (String key: map.keySet()
             ) {
            System.out.println(key+"----"+map.get(key));
        }
        System.out.println("---------------");
        //2 使用entrySet();方法
        for (Map.Entry entry: map.entrySet()
             ) {
            System.out.println(entry.getKey()+"---------------"+entry.getValue());
        }
        System.out.println("---------------------------------------");
        //判断
        System.out.println(map.containsKey("花"));
        System.out.println(map.containsValue("向北"));
        System.out.println(map.isEmpty());
    }
}

集合框架知识汇总_第15张图片

 

Map集合的实现类

  • HashMap

    • 线程不安全,运行效率快:允许null作为key或者value

import java.util.Objects;

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

    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 "name:"+name+"age:"+age;
    }

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
=========================================
    //HashMap集合的使用
//存储结构:哈希表(数组+链表+红黑树)
import java.util.HashMap;
import java.util.Map;

public class Demo2 {
    public static void main(String[] args) {
        //创建HashMap集合
        HashMap hashMap=new HashMap<>();
        //添加元素
        Student s1=new Student("林夕",18);
        Student s2=new Student("花海",16);
        Student s3=new Student("枫",17);
        Student s4=new Student("晴天",19);
        hashMap.put(s1,"西安");
        hashMap.put(s2,"广州");
        hashMap.put(s3,"上海");
        hashMap.put(s4,"北京");
        hashMap.put(new Student("晴天",19),"北京");
        System.out.println("元素个数:"+hashMap.size());
        System.out.println(hashMap.toString());
        //删除
        hashMap.remove("s1");
        System.out.println("删除之后:"+hashMap.size());
        //遍历
        //keySet();方法
        for (Student key: hashMap.keySet()
             ) {
            System.out.println(key+"----------"+hashMap.get(key));
        }
        System.out.println("=========================");
        //entrySet();方法
        for (Map.Entry entry: hashMap.entrySet()
             ) {
            System.out.println(entry.getKey()+"------"+entry.getValue());
        }
        System.out.println("==========================");
        //判断
        System.out.println(hashMap.containsKey("s2"));
        System.out.println(hashMap.containsValue("上海"));
        System.out.println(hashMap.isEmpty());
    }
}

集合框架知识汇总_第16张图片

 

  • 源码分析

1 static final int  DEFAULT_INITIAL_CAPACITY=1<<4;//hashMap初始容量(16)
2 static final int  MAXIMUM_CAPACITY=1<<30;//hashmap的数组最大容量
3 static final float DEFAULT_LOAD_FACTOR=0.75f;//默认加载因子
4 static final int  TREEITY_THRESHOLD=8;//JDK1.8 当链表长度大于8时,调整成红黑树
5 static final int  UNTREEIFY_THRESHOLD=6;//JDK1.当链表长度小于6时,调整成链表
6 static final int  MIN_TREEIFY_CAPAITY=64;//JDK1.8;当链表长度大于8时,并且集合元素个数大于等于64时,调整成红黑树
7 transient Node[] table;//哈希表中的数值
8 size;//元素个数
  • 总结

    • HashMap刚创建时,table时null,为了节省空间,当添加第一个元素时,table容量调整为16;

    • 当元素个数大于阈值(16*0.75=12)时,扩容后的大小变为原来的两倍。目的是减少调整元素的个数

    • JDK1.8以前,链表是头插入,JDK1.8以后是尾插入

  • Hashtable:

    • 线程安全,运行效率慢,不允许null作为key或是value

  • Properties:

    • Hashtable的子类,要求key和value都是String。通常用于配置文件的读取

  • TreeMap:

    • 实现了SortedMap接口,可以对key进行自动排序

import java.util.Objects;

public class Student implements Comparable{
    private String name;
    private  int age;

    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 "name:"+name+"age:"+age;
    }

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

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

    @Override
    public int compareTo(Student o) {
        int n2=this.age-o.getAge();
        return n2;
    }
}

------------------------------
import java.util.Map;
import java.util.TreeMap;
import java.util.TreeSet;

//TreeMap的使用
public class Demo3 {
    public static void main(String[] args) {
        //创建集合
        TreeMap treeMap=new TreeMap<>();
        //添加对象
        Student s1=new Student("林夕",18);
        Student s2=new Student("花海",16);
        Student s3=new Student("枫",17);
        Student s4=new Student("晴天",19);
        treeMap.put(s1,"西安");
        treeMap.put(s2,"广州");
        treeMap.put(s3,"上海");
        treeMap.put(s4,"北京");
        System.out.println(treeMap.size());
        System.out.println(treeMap.toString());
        //删除
        treeMap.remove(s1);
        System.out.println(treeMap.size());
        //遍历
        //使用keySet
        for (Student key:treeMap.keySet()
             ) {
            System.out.println(key+"------"+treeMap.get(key));
        }
        System.out.println("========================");
        
        for (Map.Entry  entry:treeMap.entrySet()
             ) {
            System.out.println(entry.getKey()+"----------"+entry.getValue());
        }
        System.out.println("==============================");
        //判断
        System.out.println(treeMap.containsKey(s1));
        System.out.println(treeMap.containsValue("上海"));
        System.out.println(treeMap.isEmpty());
    }
}

集合框架知识汇总_第17张图片 

 

 

Collections工具类

  • 概念:集合工具类,定义了除了存取以外的集合常用方法

import java.util.*;

//Collections工具类的使用
public class Demo2 {
    public static void main(String[] args) {
        //创建集合
        List  list=new ArrayList<>();
        //添加元素
        list.add(12);
        list.add(2);
        list.add(124);
        list.add(5);
        list.add(16);
        list.add(18);
        list.add(10);
        //sort();排序
        System.out.println("排序之前:"+list.toString());
        Collections.sort(list);
        System.out.println("排序之后:"+list.toString());
        //binarySeach二分查找
      int num=  Collections.binarySearch(list,10);
        System.out.println(num);
        //copy复制
        List dest=new ArrayList<>();
        for (int j = 0; j  list2=Arrays.asList(names);
        System.out.println(list2);
//把基本类型数组转为集合时,需要改成包装类
        Integer[] nums={12,3345,6677,};
        List list3=Arrays.asList(nums);
        System.out.println(list3);
    }
}

集合框架知识汇总_第18张图片

 

你可能感兴趣的:(java,数据结构,jvm)