李阿狗

导航

Java集合框架个人总结

Java集合框架个人总结

集合主要分为两大类：①单列集合Collection ②双列集合Map

集合存储的都是引用类型，不可是基础类型，如果保存基础类型需要用包装类。

1.Collection接口

​ 1.1 List子接口

​ 1.2 ArraryList类

​ 1.3 Vector类

​ 1.4 LinkedList类

​ 1.5 泛型 ★

​ 1.6 Set接口

​ 1.7 HashSet

​ 1.8TreeSet

2.Map 接口

​ 2.1 HashMap

​ 2.2 Hashtable

​ 2.3 Properties

​ 2.4 TreeMap

3. Collections工具类

单列集合Collection结构图

Collection接口

集合层次结构中的根界面 。 集合表示一组被称为其元素的对象。 一些集合允许重复元素（Lis），而其他集合不允许（Set）。 有些被命令和其他无序。 JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List 。 该界面通常用于传递集合，并在需要最大的通用性的情况下对其进行操作。

public class CollectionTest {
    public static void main(String[] args) {
        //ArrayList 是 Collection的实现类
        Collection col = new ArrayList();
        String c1 = "张三";
        String c2 = "李四";
        String c3 = "王五";
        //向集合中添加元素 add方法
        col.add(c1);
        col.add(c2);
        col.add(c3);
        col.add(c2);
        System.out.println(col);
        System.out.println(col.size());
        //判断集合是否为空和集合是否包含元素
        System.out.println(col.contains(c2));
        System.out.println(col.contains("王五"));
        System.out.println(col.isEmpty());
        System.out.println("-----------------------");
        //遍历集合
        //一、for each方法遍历
        for (Object o : col) {
            System.out.println((String)o);
		//col.remove(o);
        }
        System.out.println(col);
        System.out.println("-----------------------");
        //二、Iterator 迭代器迭代遍历
        Iterator it = col.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
            it.remove();
        }
        System.out.println("-----------------------");
        col.add(new String("周六"));
        System.out.println(col);
    }
}

代码说明一：

添加元素add();

清除集合中所有元素clear();

删除集合中指定元素remove();

返回此集合中的元素数size();

返回此集合的迭代器iterator();

注意：在迭代过程中，不可以用remove删除元素；可以用Iterator.remove()删除当前元素。

*** 代码说明二：***

Collection col = new ArrayList(); 和后面的List list = new ArrayList();

在new一个新对象时，左边尽量使用接口（或者抽象类），以保持代码的最大灵活性。

①java是面向对象语言，面向对象一个重要的原则就是“依赖倒置原则”。依赖抽象（接口），而非具体（实现类）。List是接口，ArrayList是实现类。它允许list可以轻松地在接口的不同实现之间切换。

②List的实现类包括List，Vector，LinkedList , Stack…
使用List list = new ArrayList();你将来如果需要改成线程安全的Vector，不必注意一开始使用的是ArrayList还是Vector还是其他的实现类。而是只把创建时使用ArrayList改成Vector就行了。即List list = new Vector();

这种方法实现解耦合，大大提高代码使用的灵活性和通用性。

public class Student {
    private String name;
    private int 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;
    }

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "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);
    }
}


public class CollectionTest {
    public static void main(String[] args) {
        //ArrayList 是 Collection的实现类
        Collection col = new ArrayList();
        Student s1 = new Student("张三",14);
        Student s2 = new Student("李四",15);
        Student s3 = new Student("王五",16);
        //向集合中添加元素 add方法
        col.add(s1);
        col.add(s2);
        col.add(s3);
        System.out.println(col);
        System.out.println(col.size());
        //判断集合是否为空和集合是否包含元素
        System.out.println(col.contains(s1));//true
        System.out.println(col.contains(new Student("王五",16) ));//true
        System.out.println(col.isEmpty());//false
        System.out.println("-----------------------");
        //遍历集合
        //一、for each方法遍历
        for (Object o : col) {
            System.out.println(o);
//            col.remove(o);
        }
        System.out.println(col);
        System.out.println("-----------------------");
        //二、Iterator 迭代器迭代遍历
        Iterator it = col.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

代码说明三：

用contains代码来确定某元素是否属于某个集合和remove从集合中删除某个元素的时候，是调用了该元素对象的Equals方法，如果引用对象的类（Student）中没用重写Equals方法，则默认比较对象的地址是否相同，则上述代码中System.out.println(col.contains(new Student("王五",16) ));应该返回fasle。但是在Student中，重写了Equals方法，添加了用name和age去判断是否为同一个对象，所以System.out.println(col.contains(new Student("王五",16) ));中返回了true。

List子接口（有序、有下标、元素可以重复）

除了继承了collection的所有方法外，List接口的实现类可以用下标去访问元素。

增加方法：

void add(int index, Object o) 在index位置插入对象o

boolean addAll(int index, Collection c) 讲一个集合中的元素添加到此集合中的index位置

Object get(int index) 返回集合中指定位置的元素

List subList(int fromIndex, int toIndex) 返回fromIndex和toIndex之间的集合元素

ListIterator listIterator() 返回List特有的迭代器，可以向前或者向后遍历，添加、删除、修改元素

public class ListTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        String c1 = "张三";
        String c2 = "李四";
        String c3 = "王五";
        //向集合中添加元素 add方法
        list.add(c1);
        list.add(c2);
        list.add(c3);
        list.add(c2);
        System.out.println(list.toString());
        System.out.println(list.size());
        //判断集合是否为空和集合是否包含元素
        System.out.println(list.contains(c2));
        System.out.println(list.contains("王五"));
        System.out.println(list.isEmpty());
        System.out.println("-----------------------");
        //遍历集合
        //一、使用for遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-----------------------");
        //二、for each方法遍历
        for (Object o : list) {
            System.out.println((String)o);
            //col.remove(o);
        }
        System.out.println("-----------------------");
        //三、Iterator 迭代器迭代遍历
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("-----------------------");
        //四、使用列表迭代器
        ListIterator lit = list.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.next());
        }
        System.out.println("-------------------------");
        while (lit.hasPrevious()){
            System.out.println(lit.previous());
        }
        System.out.println(list);
    }
}

代码说明：

列表迭代器ListIterator从后向前判断时，必须先运行一边从前向后判断。

ArrayList类

数组结构实现，查询快、增删慢

jdk1.2版本，运行效率快、线程不安全

package com.company.Collection;

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

public class ArrayTest {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        //1.添加元素
        Student s1 = new Student("张三",14);
        Student s2 = new Student("李四",15);
        Student s3 = new Student("王五",16);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("元素个数："+arrayList.size());
        System.out.println(arrayList.toString());
        //2.删除元素
        arrayList.remove(s1);
        System.out.println("元素个数："+arrayList.size());
        System.out.println(arrayList.toString());
        //3.遍历元素
        //3.1使用迭代器
        System.out.println("3.1使用迭代器");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //3.2使用列表迭代器
        System.out.println("3.2使用列表迭代器");
        ListIterator lit = arrayList.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.next());
        }
        //4判断
        System.out.println(arrayList.contains(new Student("王五",16)));
        System.out.println(arrayList.isEmpty());
        //5查找
        System.out.println(arrayList.indexOf(new Student("王五",16)));
        System.out.println(arrayList.get(1));
    }
}

源码分析：

ArrayList：

默认容量：DEFAULT_CAPACITY = 10； 注意：如果没用向集合中添加任何元素，容量为0。添加任意一个元素之后，容量为10。每次扩容都为原来容量的1.5倍。

存放元素的数组：elementData；

实际元素格式：size；

add添加元素：

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//10
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

Vector

数组结构实现，查询快、增删慢；

JDK1.0版本，运行效率慢、线程安全。

目前开发使用不多，了解即可。

package com.company.Collection;

import java.util.Enumeration;
import java.util.Vector;

public class VectorTest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add("北京");
        vector.add("上海");
        vector.add("深圳");
        //遍历
        //枚举器
        Enumeration en = vector.elements();
        while (en.hasMoreElements()){
            System.out.println(en.nextElement().toString());
        }
        //判断
        System.out.println(vector.contains("上海"));
        //其他方法
        System.out.println(vector.firstElement());
        System.out.println(vector.lastElement());
    }
}

LinkedList

链表结构实现，增删快，查询慢。

存储结构：双向链表。

package com.company.Collection;

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

public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        //1.添加元素
        Student s1 = new Student("张三",14);
        Student s2 = new Student("李四",15);
        Student s3 = new Student("王五",16);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println(linkedList.size());
        System.out.println(linkedList.toString());
        //2.删除元素
//        linkedList.remove(s2);
//        linkedList.remove(new Student("王五",16));
        //3.遍历
        //3.1 for 循环
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        //3.2 for each
        for (Object o : linkedList) {
            System.out.println(((Student)o).toString());
        }
        //3.3使用迭代器
        Iterator it = linkedList.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //3.4 使用列表迭代器
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.next());
        }
        while (lit.hasPrevious()){
            System.out.println(lit.previous());
        }
        //4 判断
        System.out.println(linkedList.contains(s2));
        //5 获取
        System.out.println(linkedList.indexOf(s1));
        System.out.println(linkedList.get(linkedList.indexOf(s1)));
    }

}

泛型

泛型类

package com.company.MyGeneric;
/**
 * 泛型类
 * 语法：类名<T>
 *  T是占位符，表示一种类型，如果编写多个使用逗号隔开
 */
public class MyGeneric<T>{
    //使用泛型T
    //1.创建变量
    T t;
    //2.作为方法的参数
    public void show(T t){
        System.out.println(t);
    }
    //3.作为方法的返回值
    public T getT(){
        return t;
    }
}

public class TestGeneric {
    public static void main(String[] args) {
        MyGeneric<String> myGeneric= new MyGeneric<>();
        myGeneric.t="hello";
        myGeneric.show("123dadas");
        System.out.println(myGeneric.getT());

        MyGeneric<Integer> myGeneric2 = new MyGeneric();
        myGeneric2.t = 100;
        myGeneric2.show(200);
        System.out.println(myGeneric2.getT());
    }
}

1.泛型只能是引用类型

2.不同泛型类型对象之间不能相互赋值

MyGeneric<Integer> myGeneric3 = myGeneric; //错误的赋值

泛型接口

1.泛型接口的数据类型可以在实现类定义的时候确定

2.泛型接口的数据类型也可以在使用实现类的时候确定

package com.company.MyGeneric;

public interface MyInterface <T>{
    String name = "张三";
    T server(T t);
}

package com.company.MyGeneric;

public class MyImpl implements MyInterface<String>{

    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}

package com.company.MyGeneric;

public class MyImpl2<T> implements MyInterface<T>{
    @Override
    public T server(T t) {
        System.out.println(t.toString());
        return t;
    }
}

package com.company.MyGeneric;

import com.company.Collection.Student;

public class TestGeneric {

    public static void main(String[] args) {
        MyImpl my = new MyImpl();
        my.server("asdada");

        MyImpl2<Student> myImpl2 = new MyImpl2();
        myImpl2.server(new Student("李狗",20));
    }
}

泛型方法

package com.company.MyGeneric;

public class MyGenericMethod {
    //泛型方法
    public <T> T show(T t){
        System.out.println("泛型方法");
        System.out.println(t);
        return t;
    }
}

package com.company.MyGeneric;

import com.company.Collection.Student;

public class TestGeneric {

    public static void main(String[] args) {
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show(new Student("Dog",23));
    }
}

泛型好处

（1）提高代码的重用性

（2）防止类型转换异常，提高代码的去安全性

泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一种。

特点：

  1. 编译时即可检查，而非运行时抛出异常
  2. 访问时，不必类型转换（拆箱）
  3. 不同泛型之间引用不能相互赋值，泛型不存在多态
package com.company.Collection;

import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("hello");
        arrayList.add("OkFine");
//        arrayList.add(123456);
//        arrayList.add(new Student("Dog",20));
        for (String s : arrayList) {
            System.out.println(s);
        }
    }
}

Set接口

特点：无序、无下标、元素不可重复

package com.company.Collection;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        //1. 添加数据
        set.add("苹果");
        set.add("香蕉");
        set.add("菠萝");
        System.out.println(set.size());
        System.out.println(set.toString());
        //2.删除数据
        set.remove("香蕉");
        System.out.println(set.toString());
        //3. 遍历【重点】
        //3.1使用增强for
        for (String s : set) {
            System.out.println(s);
        }
        //3.2 使用迭代器
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //判断
        System.out.println(set.contains("菠萝"));
    }
}

HashSet

  • 基于HashCode实现元素不重复
  • 当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入

存储结构：哈希表（数组+链表+红黑树）

package com.company.Collection;

import java.util.HashSet;

public class HashSetTest {
    public static void main(String[] args) {
        //新建集合
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("Dog");
        hashSet.add("Cat");
        hashSet.add("Pig");
        System.out.println(hashSet.size());
        System.out.println(hashSet.toString());
        //遍历 【同Set】
        //3.1增强for
        //3.2迭代器
        //4 判断
        System.out.println(hashSet.contains("Cat"));
    }
}

HashSet存储过程：

  1. 根据HashCode计算保存的位置，如果位置为空，则之间保存，如果不为空，则执行第二部
  2. 再执行equals方法，如果equals 方法为true，则认为是重复的，否者形成链表
package com.company.Collection;

import java.util.Objects;

public class Student {
    private String name;
    private int 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;
    }

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "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() {
        int n1 = this.name.hashCode();
        int n2 = this.age;
        return n1+n2;
    }
}

package com.company.Collection;

import java.util.HashSet;

public class HashSetTest2 {
    public static void main(String[] args) {
        HashSet <Student> hashSet = new HashSet<>();
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
        hashSet.add(s1);
        hashSet.add(s2);
        hashSet.add(s3);
        hashSet.add(new Student("王五",25));
        System.out.println(hashSet.size());
        System.out.println(hashSet.toString());
    }
}

TreeSet

存储结构：红黑树

  • 基于排序顺序实现元素不重复
  • 实现了SortedSet接口，对集合元素自动排序
  • 元素对象的类型必须实现Comparable接口，指定排序规则
  • 通过CompareTo方法确定是否为重复元素
package com.company.Collection;

import java.util.TreeSet;

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("xyz");
        treeSet.add("abc");
        treeSet.add("qwe");
        System.out.println(treeSet.size());
        System.out.println(treeSet.toString());
        //遍历 1.使用增强for 2.使用迭代器 同Set
        //判断
        System.out.println(treeSet.contains("abc"));
    }
}

TreeSet使用时，需要满足以下两点中的任一点

  1. TreeSet集合内的元素实现Comparable接口

package com.company.Collection;

import java.util.Objects;

public class Student implements Comparable<Student>{
    private String name;
    private int 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;
    }

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "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() {
        int n1 = this.name.hashCode();
        int n2 = this.age;
        return n1+n2;
    }

    //先必n2再比n1
    @Override
    public int compareTo(Student o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.age-o.age;
        return n1==0?n2:n1;
    }
}

package com.company.Collection;

import java.util.TreeSet;

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>();
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        System.out.println(treeSet.size());
    }
}
  1. 实现定制比较Comparator（比较器）
package com.company.Collection;

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

public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int n1 = o1.getAge()-o2.getAge();
                int n2 = o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        System.out.println(treeSet.size());
    }
}

Map父接口

  • 特点：存储一堆数据（key-Value）,无序，无下标，键不可重复，值可重复。

  • 方法：

  1. V put（K Key， V value）//将对象存入到集合中
  2. Object get（Object key） //根据键获取对应的值
  3. Set<K> //返回所有的key
  4. Collection<K> values() //返回包含所有值的Collection集合。
  5. Set<Map.Entry<K,V>> //键值匹配的Set集合

遍历时EntrySet效率高于Set

package com.company.Collection;

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

public class MapTest {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("China", "中国");
        map.put("America", "美国");
        map.put("Uk", "英国");
        System.out.println(map.size());
        System.out.println(map.toString());

        //遍历
        //1.使用ketSet()
        Set<String> set = map.keySet();
        for (String s : set) {
            System.out.println(s+"="+map.get(s));
        }
        //2.使用entrySet()
        Set<Map.Entry<String,String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
    }
}

HashMap

jdk1.2版本，线程不安全，运行效率快；允许使用null作为key或者是value。

默认加载容量15，默认加载因子0.75

使用Key的hashcode和equals作为重复

package com.company.Collection;

import java.util.HashMap;

public class HashMapTest {
    public static void main(String[] args) {
        HashMap<Student,String> students = new HashMap<>();
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
        students.put(s1, "北京");
        students.put(s2, "上海");
        students.put(s3, "深圳");
        students.put(new Student("王五",25),"深圳");
        System.out.println(students.size());
        System.out.println(students.toString());

    }

}

Student类中重新了hashcode和equals函数，以年龄和姓名的值作为比较是否相同。上面程序输出：

3

源码分析

  1. HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16
  2. 当元素个数大于阈值（16-0.75）=12时，会进行扩容，扩容大小为原来的2倍。目的是减少调整元素的个数。
  3. jdk1.8，当每个链表长度大于8，并且数组元素个数大于64时，会调整为红黑树，目的是提高执行效率
  4. jdk1.8，当链表长度小于6时，调整成链表
  5. jdk1.8以前，链表是头插入，jdk1.8以后是尾插入

Hashtable

  • JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value。

目前用的不多。

Properties

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

主要用于流的操作。

TreeMap

  • 实现了SortedMap接口（是）Map的子接口，可以对Key自动排序。
package com.company.Collection;

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

public class TreeMapTest {
    public static void main(String[] args) {
        TreeMap<Student,String> students = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int n2 = o1.getAge()-o2.getAge();
                int n1 = o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",24);
        Student s3 = new Student("王五",25);
        students.put(s1, "北京");
        students.put(s2, "上海");
        students.put(s3, "深圳");
        System.out.println(students.size());
        System.out.println(students.toString());
        //遍历
        //1.keyset遍历
        Set<Student> set = students.keySet();
        for (Student student : set) {
            System.out.println(student+"="+students.get(student));
        }
        //2.entryset()遍历
        Set<Map.Entry<Student,String>> entries=students.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
    }
}

Collections工具类

package com.company.Collection;

import java.lang.reflect.Array;
import java.util.*;

public class CollectionsTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(200);
        list.add(250);
        list.add(300);
        list.add(12);
        System.out.println("排序之前"+list.toString());
        Collections.sort(list);
        System.out.println("排序之后"+list.toString());

        //二分查找
        int i = Collections.binarySearch(list, 200);
        System.out.println(i);

        //负值
        List<Integer> list1 = new ArrayList<>();
        for (int i1 = 0; i1 < list.size(); i1++) {
            list1.add(0);
        }
        Collections.copy(list1, list);
        System.out.println(list1.toString());

        //反转
        Collections.reverse(list);
        System.out.println("反转之后"+list.toString());

        //打乱
        Collections.shuffle(list);
        System.out.println("打乱之后"+list.toString());


        //补充：list转为数组
        Integer[] i1 = list.toArray(new Integer[0]);
        System.out.println(i1.length);
        System.out.println(Arrays.toString(i1));

        //数组变为集合
        String[] names = {"张三","李四","王五"};
        List<String> list2 = Arrays.asList(names);
        //集合是一个受限集合，不能添加删除
        System.out.println(list2);
    }
}

posted on 2022-04-26 20:38  李阿狗  阅读(38)  评论(0)  编辑  收藏  举报