集合笔记 （笔记）

最新推荐文章于 2024-04-28 20:42:36 发布
最新推荐文章于 2024-04-28 20:42:36 发布
阅读量539 收藏 1
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48385654/article/details/119980212
版权

1. 集合的理解和好处

  • 数组
    在这里插入图片描述
  • 集合
    在这里插入图片描述

2. 集合的框架体系

Java 的集合类很多，主要分为两大类

  • 单列集合
    在这里插入图片描述
  • 双列集合
    双列集合
        //1. 集合主要是两组(单列集合 , 双列集合)
        //2. Collection  接口有两个重要的子接口 List Set ,  他们的实现子类都是单列集合
        //3. Map 接口的实现子类 是双列集合，存放的 K-V
 //Collection  
        ArrayList arrayList = new ArrayList();
        arrayList.add("jack");
        arrayList.add("tom");
 //Map
        HashMap hashMap = new HashMap();
        hashMap.put("NO1", "北京");
        hashMap.put("NO2", "上海");

3. Collection 接口和常用方法

Collection 接口实现类的特点
在这里插入图片描述

        List list = new ArrayList();
//	add:添加单个元素
        list.add("jack");
        list.add(10);//相当于 list.add(new Integer(10));
        list.add(true);
        System.out.println("list=" + list);//list=[jack, 10, true]
//	remove:删除指定元素
        list.remove(0);//删除第一个元素
        list.remove(true);//指定删除某个元素
        System.out.println("list=" + list);//list=[10]
//	contains:查找元素是否存在
        System.out.println(list.contains("jack"));//F
//	size:获取元素个数
        System.out.println(list.size());//1
//	isEmpty:判断是否为空
        System.out.println(list.isEmpty());//F
//	clear:清空
	    list.clear();
        System.out.println("list=" + list);//list=[]
//	addAll: 添 加 多 个 元 素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list=" + list);//list=[红楼梦,  三 国 演 义 ]
//	containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//T
//	removeAll：删除多个元素
        list.add("聊斋");
        list.removeAll(list2);
        System.out.println("list=" + list);//list=[聊斋]
//	说明：以 ArrayList 实现类来演示.

Collection 接口遍历元素方式 1-使用Iterator(迭代器)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
迭代器的使用案例

public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));
        System.out.println("col=" + col);//col=[Book{name='三国演义', author='罗贯中', price=10.1}, Book{name='小李飞刀', author='古龙', price=5.1}, Book{name='红楼梦', author='曹雪芹', price=34.6}]
//现在老师希望能够遍历 col 集合
//1. 先得到 col  对应的 迭代器
        Iterator iterator = col.iterator();
//2. 使用 while 循环遍历
//快捷键，快速生成 while => itit
//显示所有的快捷键的的快捷键 ctrl + j
        while (iterator.hasNext()) {//判断是否还有数据
            //返回下一个元素，类型是 Object
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
//3.当退出 while 循环后,这时iterator迭代器,指向最后的元素
//	iterator.next();//抛出异常  NoSuchElementException
//4. 如果希望再次遍历，需要重置我们的迭代器
        iterator = col.iterator();
        System.out.println("===第二次遍历===");
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
    }
class Book {
    private String name;
    private String author;
    private double price;
    public Book(String name, String author, double price) {
        this.name = name;this.author = author;this.price = price;}
    public String getName() { return name;}
    public void setName(String name) {this.name = name;}
    public String getAuthor() {return author;}
    public void setAuthor(String author) {this.author = author;}
    public double getPrice() {return price; }
    public void setPrice(double price) {this.price = price;}
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

Collection 接口遍历对象方式 2-for 循环增强

在这里插入图片描述

  • 练习
    在这里插入图片描述
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog("小黑", 3));
        list.add(new Dog("大黄", 100));
        list.add(new Dog("大壮", 8));
//先使用 for 增强
        for (Object dog : list) {
            System.out.println("dog=" + dog);
        }//dog=Dog{name='小黑', age=3}
         //dog=Dog{name='大黄', age=100}
         //dog=Dog{name='大壮', age=8}
     //增强for，也可以直接在数组中使用
        int[] nums = { 1, 8, 10, 33};
        for (int i : nums){
            System.out.println("i="+i);
        }//i=1    i=8     i=10    i=33
//使用迭代器
        System.out.println("===使用迭代器来遍历===");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object dog = iterator.next();
            System.out.println("dog=" + dog);
        }//dog=Dog{name='小黑', age=3}
         //dog=Dog{name='大黄', age=100}
         //dog=Dog{name='大壮', age=8}
    }
/**
*创建3个Dog{name, age}对象，放入到 ArrayList 中，赋给 List 引用
*用迭代器和增强 for 循环两种方式来遍历
*重写 Dog 的 toString 方法， 输出 name 和 age
*/
class Dog {
    private String name;
    private int age;
    public Dog(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 "Dog{" +"name='" + name + '\'' + ", age=" + age + '}';}

4. List 接口和常用方法

List 接口基本介绍

在这里插入图片描述

public static void main(String[] args) {
//1. List 集合类中元素有序(即添加顺序和取出顺序一致)、且可重复 [案例]
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("hsp");
        list.add("tom");
        System.out.println("list=" + list);//list=[jack, tom, mary, hsp, tom]
//2. List 集合中的每个元素都有其对应的顺序索引，即支持索引
//	索引是从 0 开始的
        System.out.println(list.get(3));//hsp
    }

List 接口的常用方法

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");
        //	void add(int index, Object ele):
        //	在 index 位置插入 ele 元素
//在 index = 1 的位置插入一个对象
        list.add(1, "张三");
        System.out.println("list=" + list);//list=[张三丰, 张三, 贾宝玉]
//boolean addAll(int index, Collection eles);//从 index 位置开始将 eles 中的所有元素添加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1, list2);
        System.out.println("list=" + list);//list=[张三丰, jack, tom, 张三, 贾宝玉]
//	Object get(int index):获取指定 index 位置的元素
//	int indexOf(Object obj):返回 obj 在集合中首次出现的位置
        System.out.println(list.indexOf("tom"));//2
//	int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位置
        list.add("张三");
        System.out.println("list=" + list);//list=[张三丰, jack, tom, 张三, 贾宝玉, 张三]
        System.out.println(list.lastIndexOf("张三"));//5
//	Object remove(int index):移除指定 index 位置的元素，并返回此元素
        list.remove(0);
        System.out.println("list=" + list);//list=[jack, tom, 张三, 贾宝玉, 张三]
//	Object set(int index, Object ele):设置指定 index 位置的元素为 ele ,  相当于是替换.
        list.set(1, " 玛 丽 ");
        System.out.println("list=" + list);//list=[jack,  玛 丽 , 张三, 贾宝玉, 张三]
//	List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合
// 注意返回的子集合 fromIndex <= subList < toIndex
        List returnlist = list.subList(0, 2);
        System.out.println("returnlist=" + returnlist);//returnlist=[jack,  玛 丽 ]
    }

List 接口练习

/**
添加 10 个以上的元素(比如 String "hello" )，在 2 号位插入一个元素"Java学习"， 
获得第 5 个元素，删除第 6 个元素，修改第 7 个元素，在使用迭代器遍历集合，
要求:使用 List 的实现类 ArrayList 完成。
*/
    public static void main(String[] args) {
        List list = new ArrayList();
        for (int i = 0; i < 12; i++) {
            list.add("hello" + i);
        }
        System.out.println("list=" + list);
//在 2 号位插入一个元素"Java学习"
        list.add(1, "Java学习");
        System.out.println("list=" + list);
//获得第 5 个元素
        System.out.println("第五个元素=" + list.get(4));
//删除第 6 个元素list.remove(5);
        System.out.println("list=" + list);
//修改第 7 个元素
        list.set(6, " 三 国 演 义 ");
        System.out.println("list=" + list);
//在使用迭代器遍历集合
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
    }

List 的三种遍历方式 [ArrayList, LinkedList,Vector]

在这里插入图片描述

    public static void main(String[] args) {
//List 接口的实现子类 Vector LinkedList
//List list = new ArrayList();
//List list = new Vector();
        List list = new LinkedList();
        list.add("jack");
        list.add("tom");
        list.add("鱼香肉丝");
        list.add("北京烤鸭子");
//遍历
//1. 迭代器iterator
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
        System.out.println("=====增强 for=====");//jack  tom  鱼香肉丝  北京烤鸭子
//2. 增强 for
        for (Object o : list) {
            System.out.println("o=" + o);
        }
        System.out.println("=====普通 for====");//o=jack   o=tom   o=香肉丝  o=北京烤鸭子
//3. 使用普通 for
        for (int i = 0; i < list.size(); i++) {
            System.out.println("对象=" + list.get(i));
        }//对象=jack   对象=tom   对象=鱼香肉丝    对象=北京烤鸭子
    }

实现类的练习 2

在这里插入图片描述

public static void main(String[] args) {
        List list = new ArrayList();
//        List list = new LinkedList();
//        List list = new Vector();
        list.add(new Book("红楼梦", "曹雪芹", 100));
        list.add(new Book("西游记", "吴承恩", 10));
        list.add(new Book("水浒传", "施耐庵", 19));
        list.add(new Book("三国演义", "罗贯中", 80));
//如何对集合进行排序
//遍历
        for (Object o : list) {
            System.out.println(o);
        }
//冒泡排序
        sort(list);
        System.out.println("==排序后==");
        for (Object o : list) {
            System.out.println(o);
        }
        /**==排序后==
名称：西游记		价格：10.0		作者：吴承恩
名称：水浒传		价格：19.0		作者：施耐庵
名称：三国演义		价格：80.0		作者：罗贯中
名称：红楼梦		价格：100.0		作者：曹雪芹
         */
    }
    //静态方法
//价格要求是从小到大
    public static void sort(List list) {
        int listSize = list.size();
        for (int i = 0; i < listSize - 1; i++) {
            for (int j = 0; j < listSize - 1 - i; j++) {
//取出对象 Book
                Book book1 = (Book) list.get(j);
                Book book2 = (Book) list.get(j + 1);
                if (book1.getPrice() > book2.getPrice()) {//交换
                    list.set(j, book2);
                    list.set(j + 1, book1);
                }
            }
        }
    }

class Book {
    private String name;
    private String author;
    private double price;
    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getAuthor() { return author; }
    public void setAuthor(String author) { this.author = author; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() { return "名称：" + name + "\t\t价格：" + price + "\t\t作者：" + author; }
}

5. ArrayList 底层结构和源码分析

ArrayList 的注意事项

在这里插入图片描述

//ArrayList 是线程不安全的, 可以看源码 没有 synchronized 关键字修饰
        /*
            public boolean add(E e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        ArrayList arrayList = new ArrayList();
        arrayList.add(null);
        arrayList.add("jack");
        arrayList.add(null);
        arrayList.add("hsp");
        System.out.println(arrayList);//[null, jack, null, hsp]

ArrayList 的底层操作机制源码分析(重点，难点.)

在这里插入图片描述

/* 2 */
//使用无参构造器创建 ArrayList 对象
//        ArrayList list = new ArrayList();
        ArrayList list = new ArrayList(8);
//使用 for 给 list 集合添加 1-10 数据
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
//使用 for 给 list 集合添加 11-15 数据
        for (int i = 11; i <= 15; i++) {
            list.add(i);
        }
        list.add(100);
        list.add(200);
        list.add(null);

在这里插入图片描述
在这里插入图片描述

6. Vector 底层结构和源码剖析

  • Vector 的基本介绍
    在这里插入图片描述
//无参构造器
//有参数的构造
        Vector vector = new Vector(8);
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
        System.out.println("vector=" + vector);
//解读源码
//1. new Vector() 底层
/*
public Vector() { this(10);
}
补充：如果是	Vector vector = new Vector(8);
走的方法:
public Vector(int initialCapacity) { this(initialCapacity, 0);
}
2.vector.add(i)
2.1//下面这个方法就添加数据到 vector 集合
public synchronized boolean add(E e) { modCount++; ensureCapacityHelper(elementCount + 1); elementData[elementCount++] = e;
return true;
}
2.2//确定是否需要扩容 条件 ： minCapacity - elementData.length>0 private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
//newCapacity = oldCapacity + ((capacityIncrement > 0) ?
//	capacityIncrement : oldCapacity);
//就是扩容两倍.
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0) newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
*/

Vector 和ArrayList 的比较

在这里插入图片描述

7. LinkedList 底层结构

LinkedList 的全面说明

在这里插入图片描述

LinkedList 的底层操作机制

在这里插入图片描述

8. ArrayList 和 LinkedList 比较

在这里插入图片描述

9. Set 接口和常用方法

Set 接口基本介绍

在这里插入图片描述

Set 接口的常用方法

  • 和 List 接口一样, Set 接口也是 Collection 的子接口，因此，常用方法和 Collection 接口一样.

Set 接口的遍历方式

在这里插入图片描述

Set 接口的常用方法举例

//1. 以 Set  接口的实现类 HashSet  来讲解 Set  接口的方法
//2. set  接口的实现类的对象(Set 接口对象), 不能存放重复的元素,  可以添加一个 null
//3. set  接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
//4. 注意：取出的顺序的顺序虽然不是添加的顺序，但是取出顺序是固定的.
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");//重复set.add("jack");
        set.add("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加 null
        for (int i = 0; i < 10; i++) {
            System.out.println("set=" + set);
        }//循环输出，表明添加的顺序和取出的顺序不一致，但取出顺序是固定的
//遍历
//方式 1： 使用迭代器
        System.out.println("=====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        set.remove(null);//删除内容
//方式 2:  增强 for
        System.out.println("=====增强 for====");
        for (Object o : set) {
            System.out.println("o=" + o);
        }
//set 接口对象，不能通过索引来获取

10. Set 接口实现类-HashSe（不懂，未掌握）

HashSet 的全面说明

在这里插入图片描述

//1. 构造器走的源码
/*
public HashSet() {
            map = new HashMap<>();
        }
2. HashSet 可以存放 null, 但是只能有一个 null, 即元素不能重复
*/
        Set hashSet = new HashSet();
        hashSet.add(null);
        hashSet.add(null);
        System.out.println("hashSet=" + hashSet);

HashSet 案例说明

    public static void main(String[] args) {
        HashSet set = new HashSet();
//说明
//1. 在执行 add 方法后，会返回一个 boolean 值
//2. 如果添加成功，返回 true, 否则返回 false
//3. 可以通过 remove 指定删除哪个对象
        System.out.println(set.add("john"));//T
        System.out.println(set.add("lucy"));//T
        System.out.println(set.add("john"));//F
        System.out.println(set.add("jack"));//T
        System.out.println(set.add("Rose"));//T
        set.remove("john");
        System.out.println("set=" + set);//3 个  set=[Rose, lucy, jack]
        set = new HashSet();//重置
        System.out.println("set=" + set);//0   set=[]
//4 Hashset 不能添加相同的元素/数据?
        set.add("lucy");//添加成功
        set.add("lucy");//加入不了
        set.add(new Dog("tom"));//OK
        set.add(new Dog("tom"));//Ok
        System.out.println("set=" + set);//et=[Dog{name='tom'}, lucy, Dog{name='tom'}]
//在加深一下. 非常经典的面试题.
//看源码，做分析， 先给留一个坑，以后讲完源码，就了然
//去看他的源码，即 add 到底发生了什么?=> 底层机制.
        set.add(new String("hsp"));//ok
        set.add(new String("hsp"));//加入不了.
        System.out.println("set=" + set);//set=[hsp, Dog{name='tom'}, lucy, Dog{name='tom'}]
    }

class Dog { //定义了 Dog 类
    private String name;
    public Dog(String name) { this.name = name; }
    @Override
    public String toString() {
        return "Dog{" + "name='" + name + '\'' + '}';
    }
}

HashSet 底层机制说明

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

HashSet 练习

在这里插入图片描述

    public static void main(String[] args) {
        /**
         定义一个 Employee 类，该类包含：private 成员属性 name,age
         要求: 创建 3 个 Employee 对象放入 HashSet 中
         当name和age的值相同时，认为是相同员工,不能添加到HashSet集合中
         */
        HashSet hashSet = new HashSet();
        hashSet.add(new Employee("milan", 18));//ok
        hashSet.add(new Employee("smith", 28));//ok
        hashSet.add(new Employee("milan", 18));//加入不成功.
//回答,加入了几个? 3 个hashSet=[Employee{name='milan', age=18},Employee{name='smith', age=28}, Employee{name='milan', age=18}]
        System.out.println("hashSet=" + hashSet);
    }//hashSet=[Employee{name='smith', age=28}, Employee{name='milan', age=18}]
//创建 Employee
class Employee {
    private String name;
    private int age;
    public Employee(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; }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public void setAge(int age) { this.age = age; }
//如果 name 和 age 值相同，则返回相同的 hash 值
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Objects.equals(name, employee.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

11. Set 接口实现类-LinkedHashSet（不懂，未掌握）

LinkedHashSet 的全面说明

在这里插入图片描述
在这里插入图片描述

LinkedHashSet 练习

在这里插入图片描述

   public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(new Car(" 奥 拓 ", 1000));//OK
        linkedHashSet.add(new Car(" 奥 迪 ", 300000));//OK
        linkedHashSet.add(new Car("法拉利", 10000000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));//加入不了
        linkedHashSet.add(new Car("保时捷", 70000000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));//加入不了
        System.out.println("linkedHashSet=" + linkedHashSet);
    }//linkedHashSet=[
//   Car{name=' 奥 拓 ', price=1000.0},
//    Car{name=' 奥 迪 ', price=300000.0},
//    Car{name='法拉利', price=1.0E7},
//    Car{name='奥迪', price=300000.0},
//    Car{name='保时捷', price=7.0E7}]
/**
 * Car 类(属性:name,price)，	如果 name 和 price 一样，
 * 则认为是相同元素，就不能添加。 5min
 */
class Car {
    private String name;
    private double price;
    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
    @Override
    public String toString() {
        return "\nCar{" +
                "name='" + name + '\'' + ", price=" + price +
                '}';
    }
//重写 equals 方法 和 hashCode
//当 name 和 price 相同时， 就返回相同的 hashCode 值, equals 返回 t
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }
}

12. Map 接口和常用方法（不懂，未掌握）

Map 接口实现类的特点 [很实用]

在这里插入图片描述
在这里插入图片描述

Map 接口常用方法

Map 接口遍历方法

在这里插入图片描述
在这里插入图片描述

Map 接口实现类-HashMap（不懂，未掌握）

HashMap 小结

在这里插入图片描述

HashMap 底层机制及源码剖析

在这里插入图片描述

HashMap 底层机制及源码剖析

在这里插入图片描述

14. Map 接口实现类-Hashtable（不懂，未掌握）

HashTable 的基本介绍

在这里插入图片描述

Hashtable 和 HashMap 对比

在这里插入图片描述

15. Map 接口实现类-Properties（不懂，未掌握）

基本介绍

在这里插入图片描述

基本使用

16. 总结-开发中如何选择集合实现类(记住)

在这里插入图片描述

TreeSet源码解读

    public static void main(String[] args) {
//1. 当我们使用无参构造器，创建 TreeSet 时，仍然是无序的
//2. 老师希望添加的元素，按照字符串大小来排序
//3. 使用 TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
//	并指定排序规则
//4. 简单看看源码
/*
1.构造器把传入的比较器对象，赋给了 TreeSet 的底层的 TreeMap 的属性 this.comparator
public TreeMap(Comparator<? super K> comparator)
     { this.comparator = comparator;
}
2.在 调用 treeSet.add("tom"),  在底层会执行到
if (cpr != null) {//cpr 就是我们的匿名内部类(对象)
   do {
     parent = t;
     //动态绑定到我们的匿名内部类(对象)compare cmp = cpr.compare(key, t.key);
     if (cmp < 0)
          t = t.left;
     else if (cmp > 0)
          t = t.right;
     else //如果相等，即返回 0,这个 Key 就没有加入
     return t.setValue(value);
 } while (t != null);
}
*/
//	TreeSet treeSet = new TreeSet();
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//下面 调用 String 的 compareTo 方法进行字符串大小比较
//如果老韩要求加入的元素，按照长度大小排序
//return ((String) o2).compareTo((String) o1);
                return ((String) o1).length() - ((String) o2).length();
            }
        });
// 添 加 数 据 .
        treeSet.add("jack");
        treeSet.add("tom");//3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc");//3
        System.out.println("treeSet=" + treeSet);
    }//treeSet=[a, sp, tom, jack]

TreeMap源码解读

    public static void main(String[] args) {
//使用默认的构造器，创建 TreeMap, 是无序的(也没有排序)
/*
要求：按照传入的 k(String) 的大小进行排序
*/
//	TreeMap treeMap = new TreeMap();
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//按照传入的 k(String) 的大小进行排序
//按照 K(String) 的长度大小排序
//return ((String) o2).compareTo((String) o1);
                return ((String) o2).length() - ((String) o1).length();
            }
        });
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "克瑞斯提诺");
        treeMap.put("smith", "斯密斯");
        treeMap.put("zs", "张三");//加入不了
        System.out.println("treemap=" + treeMap);
        //treemap={kristina=克瑞斯提诺, smith=斯密斯, jack=杰克, tom=汤姆, zs=张三}
/*
解读源码：
1.构造器. 把传入的实现了 Comparator 接口的匿名内部类(对象)，传给给 TreeMap 的 comparator
public TreeMap(Comparator<? super K> comparator) {
     this.comparator = comparator;
}
2.调用 put 方法
2.1第一次添加, 把 k-v 封装到 Entry 对象，放入 root
Entry<K,V> t = root;
if (t == null) {
      compare(key, key); // type (and possibly null) check
      root = new Entry<>(key, value, null);
      size = 1;
      modCount++;
      return null;
}
2.2以后添加
Comparator<? super K> cpr = comparator;
if (cpr != null) {
      do { //遍历所有的 key ,  给当前 key 找到适当位置
            parent = t;
            cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的 compare
            if (cmp < 0)
                t = t.left;
            else if (cmp > 0)
                t = t.right;
            else	//如果遍历过程中，发现准备添加 Key 和当前已有的 Key 相等，就不添加
            return t.setValue(value);
         } while (t != null);
}
*/

17. Collections 工具类

Collections 工具类介绍

在这里插入图片描述

排序操作：（均为static 方法)

在这里插入图片描述
在这里插入图片描述

    public static void main(String[] args) {
        //创建ArrayList 集合，用于测试.
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("king");
        list.add("milan");
        list.add("tom");
//reverse(List)：反转 List 中元素的顺序
        Collections.reverse(list);
        System.out.println("list=" + list);//list=[tom, milan, king, smith, tom]
//shuffle(List)：对 List 集合元素进行随机排序
//        for (int i = 0; i < 5; i++) {
            Collections.shuffle(list);
            System.out.println("list=" + list);//list=[milan, tom, tom, king, smith]
//        }
//sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        Collections.sort(list);
        System.out.println("自然排序后");
        System.out.println("list=" + list);//list=[king, milan, smith, tom, tom]
//sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        //我们希望按照 字符串的长度大小排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //可以加入校验代码.
                return ((String) o2).length() - ((String) o1).length();
            }
        });
        System.out.println("字符串长度大小排序=" + list);//字符串长度大小排序=[milan, smith, king, tom, tom]
//swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
        //比如
        Collections.swap(list, 0, 1);
        System.out.println("交换后的情况");
        System.out.println("list=" + list);//list=[smith, milan, king, tom, tom]
//Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        System.out.println("自然顺序最大元素=" + Collections.max(list));//自然顺序最大元素=tom
//Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        //比如，我们要返回长度最大的元素
        Object maxObject = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();//返回最小 o1与o2互换
            }
        });
        System.out.println("长度最大的元素=" + maxObject);//长度最大的元素=smith
//Object min(Collection)
//Object min(Collection，Comparator)
//上面的两个方法，参考max即可
//int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
        System.out.println("tom出现的次数=" + Collections.frequency(list, "tom"));//tom出现的次数=2
//void copy(List dest,List src)：将src中的内容复制到dest中
        ArrayList dest = new ArrayList();
//为了完成一个完整拷贝，我们需要先给dest 赋值，大小和list.size()一样
        for(int i = 0; i < list.size(); i++) {
            dest.add("");
        }
//拷贝
        Collections.copy(dest, list);
        System.out.println("dest=" + dest);//dest=[smith, milan, king, tom, tom]
//boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
        //如果list中，有tom 就替换成 汤姆
        Collections.replaceAll(list, "tom", "汤姆");
        System.out.println("list替换后=" + list);//list替换后=[smith, milan, king, 汤姆, 汤姆]
    }
江夬
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合笔记（超详细）
2dog的博客
06-10 2928
课程内容 1、集合的概述 2、Collection 3、List 4、Arraylist、LinkedList、Vector 5、泛型 6、Set 7、Map 8、Collections工具类 9、斗地主的制牌、洗牌和发牌 集合的体系结构 1、集合分类： 单列集合：每个元素都是一个单独的个体 双列集合：每个操作都是针对一对数据来进行的，一对数据作为 一个单位 2、单列集合的体系： ...
随手笔记（一）
qq_33359960的博客
12-29 413
Selenium chromedrive
Java集合学习笔记
heianwajueji的博客
03-23 306
计算键的哈希值，再计算哈希值确定存放位置，如果位置上的数据不为空，则比较键的哈希值，再比较键的equals。Put方法没有被重写，重写的是newNode（）方法，同时LinkedHashMap中的Entry继承了HashMap中的Node，在Node的基础上增加了一对指针，记录增加元素的先后。*contains方法：判断集合中是否含有某元素，两者比较的不是地址，而是内容，用equals方法按顺序依次比较集合中的元素，所以元素如果是自定义的类，要重写equals方法，否则调用父类。具体的执行原理与栈相仿。
集合学习笔记
最新发布
a1686799661的博客
04-28 523
1，集合，数组都是对多个数据进行存储操作的结构，简称Java容器。说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi）数据库中2.1数组在存储多个数据方面的特点：>一旦初始化以后，其长度就确定了。>数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如：String[]arr；int[] arr1；2.2数组在储存多个数据方面的缺点：>一旦初始化以后，其长度就不可修改。
离散数学之集合笔记一
dream_follower的博客
02-02 2613
1.1 集合的定义 集合： 是由指定范围内的满足给定条件的所有对象聚集在一起构成，每一个对象称 为这个集合的元素。 外延公理 + 空集存在公理 + 无序对公理 + 并集公理 + 幂集公理 + 无穷公理 + 替换公理 + 正则公理 + 选择公理。 (ZFC 公理化集合论) 1.2 集合的表示 通常情况下 用带或不带下标的大写英文字母表示集合: A; B; C; · · · ; A1; B1; C1...
Java集合超详细学习笔记
qq_42285526的博客
03-14 987
集合学习笔记
Java集合学习笔记.pdf
11-28
Java集合学习笔记.pdf
java集合框架笔记
03-18
List set ArraryList Map java集合框架笔记 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用
集合笔记整理.doc
07-27
集合是Java编程中重要的数据结构，它主要用于存储一组不重复的数据。集合分为单列集合（Collection）和双列集合（Map）。单列集合是用于存储单一数据，而双列集合则是用于存储键值对的数据。 **单列集合 Collection...
Map集合笔记
10-10
### Map集合概述与特点 #### 一、Map集合的特点及概念 Map集合是Java集合框架中的重要组成部分之一，主要用于存储键值对（key-value pairs）。它与Collection接口不同，Collection接口用于存储单个对象，而Map接口...
java超强笔记
12-03
随着对基础知识的掌握，笔记会进一步带你探索Java集合框架，包括数组列表、链表、队列、栈、映射等数据结构，以及它们在实际问题中的应用。此外，多线程编程也是Java的一大亮点，笔记会介绍线程的创建与同步机制，如...
集合总结的笔记
Nazi_的博客
07-19 320
集合 首先就是集合和数组的区别： 1、长度可变性：数组定义时需要指定长度，长度不可变；集合定义时不需要指定长度，长度可变。 2、存放的数据类型：数组可以存放基本数据类型的数据也可以存放引用数据类型的数据；集合只能存放引用数据类型的数据（但是基本数据类型可以自动装箱为引用数据类型，然后存进去）。 3、元素类型：数组在定义时需要指定元素类型，定义后数组只能存放该数据类型的数据；集合定义时可以不指定数据类型，可以存放不同引用数据类型的数据。 集合分类 Collection 单列集合的顶层接口 ├——-List 接
常用集合知识笔记(全)
qq_51097279的博客
03-15 1136
集合 可以分为两大类：Collection和Map，其中Collection是一个个存放数据的，而Map是一对一对存放数据的 Collection是一个接口，有两个重要的子接口：List和Set，其中List是有序的可以重复的，Set是无序的不可重复的 List接口重要的实现类：ArrayList、LinkedList、Vector(已淘汰) Set接口重要的实现类：HashSet(重要)、TreeSet Collection接口实现类的特点： 1.Collection的实现类可以存放多个元素，每个元素可以
集合笔记
qq_27356623的博客
11-22 219
集合学习笔记1集合：1.1类集设置的目的1.2 Collection 接口List 接口Map 1集合： 1.1类集设置的目的 对象数组有那些问题？ 普通的对象数组的最大问题在于数组中的元素个数是固定的，不能动态的扩充大小，所以最早的时候可以通过链表实现一个动态对象数组。但是这样做毕竟太复杂了，所以在 Java 中为了方便用户操作各个数据结构， 所以引入了类集的概念，有时候就可以把类集称为 java 对数据结构的实现。 类集中最大的几个操作接口：Collection、Map、Iterator，这三个接口
集合基础笔记
m0_51664084的博客
02-13 283
集合基础笔记，Java集合基础相关内容 ​ 1.集合概述 集合类的特点： 提供一种存储空间可变的存储模型，存储的数据容量可以发生改变 ArrayList<E>: 可调整大小的数组实现。<E>是一种特殊的数据类型，泛型 使用方法：在出现E的地方我们使用引用数据类型替换即可 举例：ArrayList<String>,ArrayList<Student> 2.ArrayList构造方法和添加方法 public ArrayList();创建一个空的集合对
Java常用集合总结笔记
Dylancy的博客
07-14 1367
常用集合Collection、Map以及其子类集合的学习总结
关于集合(每日笔记)
a2209963的博客
09-21 207
关于集合(每日笔记) 什么是集合? 集合是作为数据结构的载体,可以对元素景象加工和输出,以一定的算法实现最基本的增删改查功能因此集合是所有编程语言的基础 数组(了解) 数组可以使用索引下标进行快速定位,并获取指定位置的元素 数组的下标是从0开始的,这源于BCPL语言,它将指针设置在0位置,用数组下标作为直接偏移量进行计算 如果下标从1开始,计算机偏移量就要使用当前下标减1的操作.加减法运算在数组下...
java学习day15
tony_lcd的专栏
12-09 166
一  集合 (1)java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储。   而对多个元素进行存储，前面我们学习过数组，数组的弊端，长度固定。这样，数组将不能   满足变化的要求。所以，java就提供了集合供我们使用。 (2)集合的特点： 1、长度可以发生改变 2、只能存储对象 3、可以存储多种类型对象(一般存储的还是同一种) (3)集合和数组的区别
Java笔记--集合
qq_37438740的博客
07-16 422
Java集合笔记 1 集合与数组的区别 编程中，常常需要集中存放多个数据，我们可以使用数组来进行保存，但是数组长度不可变化，一旦在初始数组时指定了数组长度，这个数组长度就是不可变化的，对于变化长度的数据来说，数组就不适用了。此外，数组也不适合用于存储具有映射关系的数据，此时，用集合就变得十分方便了,集合提供了一系列的方法，列如排序，判断，使得编程变得方便。 2 Java集合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值