ok！不当人
ok！不当人

Java集合

集合

1.Collection接口

1.1List接口
1.1.1 ArrayList
常用方法

Collection

List

ArrayList

常用方法：

add(E e) 添加元素 添加在末尾

add(int index,E e) 在指定位置添加元素

clear() 从列表中删除所有元素。

contains(Object o) 如果此列表包含指定的元素，则返回 true 。

get(int index) 返回此列表中指定位置的元素。

indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

isEmpty() 如果此列表不包含元素，则返回 true 。

iterator() 以正确的顺序返回该列表中的元素的迭代器。

E remove(int index) 删除该列表中指定位置的元素。

boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。

set(int index, E element) 用指定的元素替换此列表中指定位置的元素。

size() 返回此列表中的元素数。

泛型：用于统一集合中的数据类型

package com.atguigu.test1;
​
import java.util.ArrayList;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/16 9:43
 *  Collection
 *  List
 *  ArrayList
 *
 *  常用方法：
 *  add(E e) 添加元素  添加在末尾
 *  add(int index,E e) 在指定位置添加元素
 *  clear() 从列表中删除所有元素。
 *  contains(Object o) 如果此列表包含指定的元素，则返回 true 。
 *  get(int index) 返回此列表中指定位置的元素。
 *  indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
 *  isEmpty() 如果此列表不包含元素，则返回 true 。
 *  iterator() 以正确的顺序返回该列表中的元素的迭代器。
 *  E remove(int index) 删除该列表中指定位置的元素。
 *  boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
 *  set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
 *  size() 返回此列表中的元素数。
 *
 *  泛型：用于统一集合中的数据类型
 */
public class TestArrayListMethod {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
​
        arrayList.add("a");
        arrayList.add(100);
        arrayList.add(2.5);
        arrayList.add(2.5F);
        arrayList.add(true);
        arrayList.add('A');
        arrayList.add(new int[]{1,2,3,4,5});
​
        System.out.println("-------------------------------------------------------");
​
        ArrayList list = new ArrayList();
​
        list.add("a");
        list.add("b");
        list.add("hello");
        list.add("world");
        list.add("6666");
        list.add("f");
        list.add("a");
​
        System.out.println("集合的长度，元素的个数：" + list.size());
​
        list.add(1, "世界你好");
​
​
        System.out.println("插入一个元素，元素的个数：" + list.size());
​
        System.out.println("下标0元素为：" +  list.get(0));
        System.out.println("下标1元素为：" +  list.get(1));
        System.out.println("下标2元素为：" +  list.get(2));
​
​
        System.out.println("删除下标为0的元素：" + list.remove(0));
        System.out.println("删除内容为'a'的元素：" + list.remove("a"));
        System.out.println("删除内容为'a'的元素：" + list.remove("a"));
​
        System.out.println("原来0的位置元素为：" + list.set(0, "123456789"));;
​
        System.out.println("下标0元素为：" +  list.get(0));
​
        System.out.println("是否包含'a'元素" + list.contains("a"));
        System.out.println("是否包含'b'元素" + list.contains("b"));
​
​
​
        System.out.println("集合是否为空：" + list.isEmpty());
​
        list.clear();
​
        System.out.println("集合是否为空：" + list.isEmpty());
​
        System.out.println(list.size());
​
​
    }
}

遍历方式

ArrayList遍历方式：三种

方式1：普通for循环遍历

方式2：迭代器遍历

方式3：增强for循环遍历

package com.atguigu.test2;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/16 10:21
 *  ArrayList遍历方式：三种
 *  方式1：普通for循环遍历
 *  方式2：迭代器遍历
 *  方式3：增强for循环遍历
 */
public class TestArrayListForeach {
    public static void main(String[] args) {
        List list = new ArrayList(); // 热插拔思想
​
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
​
        // 方式1：普通for循环遍历
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
​
        System.out.println("----------------------------------------------");
​
​
        // 方式2：迭代器遍历
        // 迭代器是无法保证顺序 集合中的元素将原封不动的保存在迭代器对象中
        // 迭代器是没有下标的概念 每次遍历先查询迭代器对象中还有没有元素 如果有 则取出  然后继续遍历
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("----------------------------------------------");
​
        // 方式3：增强for循环遍历 底层实现还是迭代器 是JDK1.5新增的内容 属于对迭代书写格式的简化
​
        for(Integer i : list){
            System.out.println("i = " + i);
        }
​
​
        System.out.println("----------------------------------------------");
        int [] nums = {1,2,3,4,5};
​
        for(int a : nums){
            System.out.println("a = " + a);
        }
​
        for (int num : nums) {
            System.out.println("num = " + num);
        }
​
​
​
​
​
    }
}
​

数据结构

ArrayList 集合特点：有序 有下标 允许重复 允许null元素 线程不安全

当我们调用无参构造，帮我们维护一个长度为0的空数组 注释描述为长度为10的数组 是错误的

当我们第一次添加元素 才将数组的长度改为10

集合扩容：为原来数组长度的1.5倍

增删改查效率：

查询 和 修改 快

添加如果需要扩容的、插入元素的情况 效率较低 因为需要复制数组 或者 移动元素

删除需要移动元素的情况 效率低

1.1.2 Vector

ArrayList 和 Vector的区别？

ArrayList线程不安全 Vector线程安全

ArrayList无参构造维护长度为0空数组 Vector无参构造维护长度为10的数组

ArrayList扩容1.5倍 Vector扩容2倍

ArrayList不允许指定增量 Vector可以指定增量

其他：遍历方式全部相同

 

1. ​ArrayList 的扩容机制

  • ​默认行为：
    ArrayList 的容量在需要扩容时，默认按旧容量的 1.5 倍增长​（即 newCapacity = oldCapacity + (oldCapacity >> 1)）。
    例如，初始容量为 10，扩容后会变为 15，再扩容到 22，依此类推。

  • ​无法指定增量：
    ArrayList ​没有提供外部参数允许用户自定义每次扩容的增量，其增长比例是固定的。

2. ​Vector 的扩容机制

  • ​默认行为：
    如果未指定增量参数，Vector 的容量默认按 ​旧容量的 2 倍增长​（即 newCapacity = oldCapacity * 2）。
    例如，初始容量为 10，第一次扩容到 20，第二次到 40，依此类推。

  • ​允许指定增量：
    Vector 的构造函数中有一个参数 ​**capacityIncrement**，允许用户指定每次扩容的固定增量。
    例如：

    java

    Vector vector = new Vector<>(10, 5); // 初始容量10，增量5
    • 当容量不足时，每次扩容增加 5（而不是默认的翻倍）。
    • 如果 capacityIncrement <= 0，则按默认的 2 倍增长。
package com.atguigu.test3;
​
import java.util.ArrayList;
import java.util.Vector;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/16 14:09
 *  ArrayList 和 Vector的区别？
 *      ArrayList线程不安全  Vector线程安全
 *      ArrayList无参构造维护长度为0空数组 Vector无参构造维护长度为10的数组
 *      ArrayList扩容1.5倍  Vector扩容2倍
 *      ArrayList不允许指定增量 Vector可以指定增量
 *
 *  其他：遍历方式全部相同    
 *
 *
 *
 */
public class TestVector {
    public static void main(String[] args) {
        Vector list = new Vector();
​
        list.add("a");
        list.add("b");
        list.add("hello");
        list.add("world");
        list.add("6666");
        list.add("f");
        list.add("a");
​
        System.out.println("集合的长度，元素的个数：" + list.size());
​
        list.add(1, "世界你好");
​
​
        System.out.println("插入一个元素，元素的个数：" + list.size());
​
        System.out.println("下标0元素为：" +  list.get(0));
        System.out.println("下标1元素为：" +  list.get(1));
        System.out.println("下标2元素为：" +  list.get(2));
​
​
        System.out.println("删除下标为0的元素：" + list.remove(0));
        System.out.println("删除内容为'a'的元素：" + list.remove("a"));
        System.out.println("删除内容为'a'的元素：" + list.remove("a"));
​
        System.out.println("原来0的位置元素为：" + list.set(0, "123456789"));;
​
        System.out.println("下标0元素为：" +  list.get(0));
​
        System.out.println("是否包含'a'元素" + list.contains("a"));
        System.out.println("是否包含'b'元素" + list.contains("b"));
​
​
​
        System.out.println("集合是否为空：" + list.isEmpty());
​
        list.clear();
​
        System.out.println("集合是否为空：" + list.isEmpty());
​
        System.out.println(list.size());
​
    }
}
 
  
1.1.3 LinkedList
 
  
常用方法
 
  
 
   
Collection
 
   
List Deque
 
   
LinkedList
 
   
除了跟ArrayList相同的方法以外 此类还单独提供了专门用于操作头部和尾部的方法
 
   
add(E e) 添加元素 添加在末尾
 
   
add(int index,E e) 在指定位置添加元素
 
   
addFirst() 添加在链表的头部
 
   
addLast() 添加在链表的尾部
 
   
clear() 从列表中删除所有元素。
 
   
contains(Object o) 如果此列表包含指定的元素，则返回 true 。
 
   
get(int index) 返回此列表中指定位置的元素。
 
   
getFirst() 获取链表的头部
 
   
getLast() 获取链表的尾部
 
   
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
 
   
isEmpty() 如果此列表不包含元素，则返回 true 。
 
   
iterator() 以正确的顺序返回该列表中的元素的迭代器。
 
   
E remove(int index) 删除该列表中指定位置的元素。
 
   
removeFirst() 删除链表的头部
 
   
removeLast() 删除链表的尾部
 
   
boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
 
   
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
 
   
size() 返回此列表中的元素数。
 
  
 
  
package com.atguigu.test4;
​
import java.util.LinkedList;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/16 14:30
 *  Collection
 *      List Deque
 *          LinkedList
 *  除了跟ArrayList相同的方法以外 此类还单独提供了专门用于操作头部和尾部的方法
 *
 *    add(E e) 添加元素  添加在末尾
 *    add(int index,E e) 在指定位置添加元素
 *    addFirst() 添加在链表的头部
 *    addLast() 添加在链表的尾部
 *    clear() 从列表中删除所有元素。
 *    contains(Object o) 如果此列表包含指定的元素，则返回 true 。
 *    get(int index) 返回此列表中指定位置的元素。
 *    getFirst() 获取链表的头部
 *    getLast() 获取链表的尾部
 *    indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
 *    isEmpty() 如果此列表不包含元素，则返回 true 。
 *    iterator() 以正确的顺序返回该列表中的元素的迭代器。
 *    E remove(int index) 删除该列表中指定位置的元素。
 *    removeFirst() 删除链表的头部
 *    removeLast() 删除链表的尾部
 *    boolean remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
 *    set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
 *    size() 返回此列表中的元素数。
 */
public class TestLinkedListMethod {
    public static void main(String[] args) {
        LinkedList list  = new LinkedList();
​
        list.add("a");
        list.add("b");
        list.add("c");
​
        list.addFirst("hello");
        list.addLast("World");
        list.add(1, "666");
        System.out.println(list.size());
​
        System.out.println("-------------------------------------------");
​
        System.out.println(list.get(0));
        System.out.println(list.getFirst());
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        System.out.println(list.get(3));
        System.out.println(list.get(4));
        System.out.println(list.get(5));
        System.out.println(list.getLast());
        System.out.println("-------------------------------------------");
        System.out.println(list.remove());
        System.out.println( list.remove(0));
​
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        System.out.println("-------------------------------------------");
​
        System.out.println(list.get(0));
        System.out.println(list.get(1));
​
        System.out.println(list.set(0, "123456"));
        System.out.println(list.get(0));
​
        System.out.println(list.size());
​
        System.out.println("是否包含'123456'" + list.contains("123456"));
​
        list.clear();
​
        System.out.println(list.isEmpty());
​
​
    }
}
 
  
 
  
遍历方式
 
  
 
   
LinkedList三种遍历方式
 
   
1.普通for循环遍历
 
   
2.迭代器遍历
 
   
3.增强for循环遍历
 
   
不推荐使用普通for循环遍历LinkedList
 
  
 
  
package com.atguigu.test4;
​
import java.util.Iterator;
import java.util.LinkedList;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/16 14:40
 *  LinkedList三种遍历方式
 *  1.普通for循环遍历
 *  2.迭代器遍历
 *  3.增强for循环遍历
 *
 *  不推荐使用普通for循环遍历LinkedList
 */
public class TestLinkedListForeach {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
​
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        // 1.普通for循环遍历
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
​
        System.out.println("--------------------------------");
        // 2.迭代器遍历
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
​
        System.out.println("--------------------------------");
        //  3.增强for循环遍历
​
        for (Integer i : list) {
            System.out.println("i = " + i);
        }
​
​
​
​
    }
}
​
 
  
 
  
数据结构
 
  
Java集合_第1张图片
 
  
 
   
LinkedList集合特点：有序 空间不连续 有下标 可以重复 允许null元素 线程不安全 *
 
   
数据结构：双向链表 没有初始大小 没有上限大小 不需要扩容
 
   
查询、修改 效率低：当我们根据下标查询某一个元素 必须先通过其相邻的元素 才能获取到我们需要的元素
 
   
所以 根据下标查询效率非常低 修改也需要先查询 所以效率也低
 
   
删除 ：不需要移动元素 只需要将删除元素的左右两边的元素进行链接即可 但是因为涉及到查询 所以效率也很低
 
   
添加 ：不需要扩容 也不需要复制元素 所以效率高
 
   
LinkedList对get()方法优化：当查询的下标小于元素个数中间值 则从前往后查找
 
   
如果查询的下标大于等于元素个数中间值 则从后往前查找
 
  
 
  
 
  
1.2Set接口
 
  
1.2.1 HashSet
 
  
 
   
Collection
 
   
Set
 
   
HashSet ： 底层实现为HashMap 我们添加到HashSet中的元素 将被JDK添加到HashMap中 键的位置 值默认以null填充
 
   
此类中没有单个查询的方法 也没有修改的方法
 
   
add(E e) 添加元素
 
   
clear() 删除所有元素
 
   
contains(Object o) 查看是否包含某个元素
 
   
isEmpty() 判断集合长度是否为0
 
   
iterator() 获取集合迭代器
 
   
remove(Object o) 删除元素
 
   
size() 获取元素个数
 
  
 
  
package com.atguigu.test4;
​
import java.util.HashSet;
import java.util.Iterator;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 15:21
 *  Collection
 *  Set
 *  HashSet ： 底层实现为HashMap 我们添加到HashSet中的元素 将被JDK添加到HashMap中 键的位置 值默认以null填充
 *
 *  此类中没有单个查询的方法  也没有修改的方法
 *  add(E e) 添加元素
 *  clear() 删除所有元素
 *  contains(Object o) 查看是否包含某个元素
 *  isEmpty() 判断集合长度是否为0
 *  iterator() 获取集合迭代器
 *  remove(Object o)  删除元素
 *  size() 获取元素个数
 *
 */
public class TestHashSet {
    public static void main(String[] args) {
        // 创建集合对象
        HashSet set = new HashSet();
​
        // 添加元素 如果元素已存在 将添加失败 返回值为false  添加成功 返回值为true
        System.out.println(set.add("abc1"));
        System.out.println(set.add("abc2"));
        System.out.println(set.add("abc3"));
        System.out.println(set.add("abc4"));
        System.out.println(set.add("abc5"));
​
        System.out.println(set.size()); // 打印集合长度
​
        System.out.println(set.contains("abc1")); // 查看是否包含 "abc1" 元素
​
        System.out.println("是否删除成功'abc1'元素：" + set.remove("abc1"));
​
        System.out.println(set.contains("abc1")); // 查看是否包含 "abc1" 元素
​
        System.out.println("-------------------------------------------");
​
        // 遍历方式 2种  因为没有下标 也 没有键
        for(String element : set){
            System.out.println("element = " + element);
        }
​
        System.out.println("-------------------------------------------");
​
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("-------------------------------------------");
​
        set.clear();
​
        System.out.println("集合长度是否为0:" +set.isEmpty());
​
    }
}
​
 
  
 
  
1.2.2 LinkedHashSet
 
  
 
   
LinkedHashSet 有序的Set集合 顺序为根据元素插入的顺序 继承自 HashSet 底层实现为LinkedHashMap
 
   
所以 HashSet中的方法 都可以直接使用
 
  
 
  
package com.atguigu.test4;
​
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 15:35
 *  LinkedHashSet 有序的Set集合 顺序为根据元素插入的顺序 继承自 HashSet 底层实现为LinkedHashMap
 *  所以 HashSet中的方法 都可以直接使用
 */
public class TestLinkedHashSet {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedHashSet set = new LinkedHashSet();
​
        // 添加元素 如果元素已存在 将添加失败 返回值为false  添加成功 返回值为true
        System.out.println(set.add("abc1"));
        System.out.println(set.add("abc4"));
        System.out.println(set.add("abc5"));
        System.out.println(set.add("abc2"));
        System.out.println(set.add("abc3"));
​
        System.out.println(set.size()); // 打印集合长度
​
        System.out.println(set.contains("abc1")); // 查看是否包含 "abc1" 元素
​
        System.out.println("是否删除成功'abc1'元素：" + set.remove("abc1"));
​
        System.out.println(set.contains("abc1")); // 查看是否包含 "abc1" 元素
​
        System.out.println("-------------------------------------------");
​
        // 遍历方式 2种  因为没有下标 也 没有键
        // 增强for循环
        for(String element : set){
            System.out.println("element = " + element);
        }
​
        System.out.println("-------------------------------------------");
​
        // 迭代器遍历
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("-------------------------------------------");
​
        set.clear();
​
        System.out.println("集合长度是否为0:" +set.isEmpty());
    }
}
​
 
  
 
  
1.2.3 TreeSet
 
  
 
   
TreeSet 有序的Set集合 顺序为根据元素比较的顺序 底层实现为TreeMap 最终父接口为 Set接口 所以 Set接口中的方法
 
   
都可以直接使用
 
   
我们可以根据构造方法来指定比较器
 
  
 
  
package com.atguigu.test4;
​
import com.atguigu.test2.Student;
import com.atguigu.test3.Person;
import com.atguigu.test3.PersonComparator;
​
import java.util.TreeSet;
​
/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 15:41
 *  TreeSet 有序的Set集合 顺序为根据元素比较的顺序  底层实现为TreeMap  最终父接口为 Set接口 所以 Set接口中的方法
 *  都可以直接使用
 *  我们可以根据构造方法来指定比较器
 */
public class TestTreeSet {
    public static void main(String[] args) {
        // 创建对象
        TreeSet set = new TreeSet();
​
        // 添加元素
        set.add("a");
        set.add("ad");
        set.add("ae");
        set.add("ab");
        set.add("ac");
        set.add("af");
​
        // 增强for循环遍历
        for (String s : set) {
            System.out.println("s = " + s);
​
        }
​
​
        System.out.println("---------------------------------------------------------");
​
        // 创建对象
        TreeSet stuSet = new TreeSet<>();
        // 创建学生对象 作为添加元素
        Student stu1 = new Student("赵四",26);
        Student stu2 = new Student("广坤",24);
        Student stu3 = new Student("大拿",22);
        Student stu4 = new Student("小宝",23);
​
​
        // 添加元素
        stuSet.add(stu1);
        stuSet.add(stu2);
        stuSet.add(stu3);
        stuSet.add(stu4);
​
        // 打印集合长度
        System.out.println(stuSet.size());
​
        System.out.println("---------------------------------------------------------");
​
        // 创建集合对象 指定比较器对象   
        TreeSet personSet = new TreeSet<>(new PersonComparator());
        // 创建Person对象 作为添加元素
        Person p1 = new Person("赵四", 188);
        Person p2 = new Person("小宝", 199);
        Person p3 = new Person("刘能", 155);
        Person p4 = new Person("大拿", 175);
        
        // 添加元素 
        personSet.add(p1);
        personSet.add(p2);
        personSet.add(p3);
        personSet.add(p4);
​
        // 打印集合长度 
        System.out.println(personSet.size());
​
    }
}
​
 
  
 
  
2.Map接口
 
  
2.1 HashMap
 
  
常用方法
 
  
 
   
HashMap常用方法 ：
 
   
values() : 获取集合中所有的值
 
   
size() ：返回元素个数
 
   
replace(K key, V value) 替换元素
 
   
remove(Object key) 删除元素
 
   
put(K key, V value) 添加元素
 
   
keySet() 获取所有的键的组合
 
   
isEmpty() 判断集合是否为空
 
   
get(Object key) 获取元素
 
   
entrySet() 获取所有键值对的组合
 
   
containsValue(Object value)是否包含某个值
 
   
containsKey(Object key) 是否包含某个键
 
   
clear() 清空集合
 
  
 
  
package com.atguigu.test6;

import java.util.HashMap;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/16 16:10
 *  HashMap常用方法 ：
 *  values() : 获取集合中所有的值
 *  size() ：返回元素个数
 *  replace(K key, V value) 替换元素
 *  remove(Object key) 删除元素
 *  put(K key, V value) 添加元素
 *  keySet()  获取所有的键的组合
 *  isEmpty() 判断集合是否为空
 *  get(Object key) 获取元素
 *  entrySet() 获取所有键值对的组合
 *  containsValue(Object value)是否包含某个值
 *  containsKey(Object key) 是否包含某个键
 *  clear() 清空集合
 */
public class TestHashMapMethod {
    public static void main(String[] args) {
        HashMap map = new HashMap();

        map.put("CN", "中国");
        map.put("RU", "俄罗斯");
        map.put("US", "美国");
        map.put("JP", "小日本");
        map.put("KR", "小棒棒");


        System.out.println(map.get("CN"));

        map.put("CN", "中华人民共和国");

        System.out.println(map.get("CN"));

        System.out.println(map.size());

        System.out.println("删除元素的值为：" + map.remove("JP"));

        map.replace("KR", "小西巴");

        System.out.println(map.get("KR"));

        System.out.println(map.containsKey("KR"));

        System.out.println(map.containsValue("小日本"));

        map.clear();

        System.out.println(map.isEmpty());

    }
}
 
  
 
  
遍历方式
 
  
 
   
遍历HashMap 6种方式
 
   
1.获取所有的键 根据键获取值
 
   
2.获取所有的值
 
   
3.获取所有的键值对的组合
 
   
4.获取所有的键的迭代器
 
   
5.获取所有的值的迭代器
 
   
6.获取所有的键值对组合的迭代器
 
  
 
  
package com.atguigu.test6;

import java.util.*;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/16 16:19
 *  遍历HashMap 6种方式
 *  1.获取所有的键 根据键获取值
 *  2.获取所有的值
 *  3.获取所有的键值对的组合
 *  4.获取所有的键的迭代器
 *  5.获取所有的值的迭代器
 *  6.获取所有的键值对组合的迭代器
 */
public class TestHashMapForeach {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("CN", "中国");
        map.put("RU", "俄罗斯");
        map.put("US", "美国");
        map.put("JP", "小日本");
        map.put("KR", "小棒棒");

        // 1.获取所有的键 根据键获取值
        Set keys = map.keySet();
        for(String key : keys){
            System.out.println(key + "====" + map.get(key));
        }

        System.out.println("----------------------------------------------------");

        // 2.获取所有的值

        Collection values = map.values();
        for(String value : values){
            System.out.println(value);
        }

        System.out.println("----------------------------------------------------");
        //  3.获取所有的键值对的组合
        Set> entries = map.entrySet();

        for (Map.Entry entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();

            System.out.println(key + "====" + value);
        }

        System.out.println("----------------------------------------------------");

        // 4.获取所有的键的迭代器

        Iterator iterator = map.keySet().iterator();

        while(iterator.hasNext()){
            String key = iterator.next();
            System.out.println(key + "====" + map.get(key));
        }

        System.out.println("----------------------------------------------------");
        // 5.获取所有的值的迭代器
        Iterator iterator1 = map.values().iterator();

        while(iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
        System.out.println("----------------------------------------------------");

        // 6.获取所有的键值对组合的迭代器

        Iterator> iterator2 = map.entrySet().iterator();

        while(iterator2.hasNext()){
            Map.Entry entry = iterator2.next();

            System.out.println("entry = " + entry);

        }


    }
}
 
  
 
  
数据结构
 
  
Java集合_第2张图片
 
  
 
   
回顾我们之前所学习的数据结构：
 
   
ArrayList ： 数组结构 空间连续 查询 修改 快 添加 删除 慢
 
   
LinkedList：双向链表结构 空间不连续 查询 修改 慢 添加 删除 快
 
   
HashMap数据结构
 
   
JDK1.7 数组 + 单向链表
 
   
JDK1.8 数组 + 单向链表 + 红黑树
 
   
HashMap集合特点：无序 没有下标 允许重复的值 但是不允许重复的键 允许null的键以及null的值 线程不安全
 
   
增删改查效率 通常情况下是比较高的
 
   
HashMap中的每个元素是一个Node对象 属于Entry接口的实现类 所以我们也称HashMap中的元素为Entry对象
 
   
每个Node对象中包含四部分(四个属性)：key值、value值、根据key计算出来的hash值、下一个元素的引用next
 
   
元素添加过程：当我们第一次添加元素 底层初始化长度为16的数组 根据hash值对数组长度-1(第一次 hash值 & (length - 1 : 15) ) 进行&与运算
 
   
得到的整数表示存放数组中的下标(0~15)
 
   
如果此下标为值为null 则直接存放
 
   
如果此下标位置不为null 则先判断是否为相同的key (判断依据：使用两个key进行equals以及hashCode比较 equals比较为true hashCode相同则认为是相同的key)
 
   
如果为相同的key 则直接覆盖
 
   
如果不为相同的key 判断当前节点为树节点还是链表节点
 
   
如果为树节点 则添加在树中
 
   
如果为链表 则添加在链表的末尾
 
   
 
   
转换红黑树机制：当链表的长度大于8 并且数组的长度大于64 将单向链表转换为红黑树
 
   
取消树化的机制：当链表的元素个数小于6 将红黑树转换为单向链表
 
   
HashMap扩容机制：当数组的使用率达到75%就扩容 扩容为数组扩容2倍
 
  
 
  
 
  
 
   
了解：
 
   
虽然JDK8中加入了红黑树 但是 数组 + 单向链表 依然是HashMap中的数据结构常态
 
   
因为转换为红黑树的概率是非常低的 低于千万分之一
 
   
扩容以后会对数组中的元素进行重新排列 排列规则为继续使用hash值对新的长度-1进行&与运算
 
   
最终有两种结果：
 
   
1.继续保存在原来的位置
 
   
2.移动到原来的位置加上扩容的长度的位置
 
  
 
  
 
   
红黑树特点
 
   
1.每个节点只能是红色或者黑色。
 
   
2.根节点必须是黑色。
 
   
3.红色的节点，它的叶节点只能是黑色。
 
   
4.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
 
   
由以上四个特性我们可以看出一些红黑树的特点：
 
   
从根基节点到最远叶节点的路径（最远路径）肯定不会大于根基节点到最近节点的路径（最短路径）的两倍长。这是因为性质3保证了没有相连的红色节点，性质4保证了从这个节点出发的不管是哪一条路径必须有相同数目的黑色节点，这也保证了有一条路径不能比其他任意一条路径的两倍还要长。
 
  
 
  
2.2Hashtable
 
  
 
   
HashMap和Hashtable的区别？
 
   
HashMap是线程不安全的
 
   
Hashtable线程安全
 
   
HashMap使用懒加载思想 当我们第一次添加元素 将初始化长度为16的数组
 
   
Hashtable在调用无参构造即初始化长度为11数组
 
   
HashMap扩容为2倍
 
   
Hashtable扩容为2倍 +1
 
   
HashMap使用与运算获取应该存放的数组的下标
 
   
Hashtable使用取余运算获取应该存放的数组的下标
 
   
与运算效率更高
 
   
除以上区别以外 方法 遍历方式 完全一样
 
  
 
  
package com.atguigu.test1;

import java.util.HashMap;
import java.util.Hashtable;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 11:16
 *  HashMap和Hashtable的区别？
 *      HashMap是线程不安全的
 *      Hashtable线程安全
 *
 *      HashMap使用懒加载思想 当我们第一次添加元素 将初始化长度为16的数组
 *      Hashtable在调用无参构造即初始化长度为11数组
 *
 *      HashMap扩容为2倍
 *      Hashtable扩容为2倍 +1
 *
 *      HashMap使用与运算获取应该存放的数组的下标
 *      Hashtable使用取余运算获取应该存放的数组的下标
 *      与运算效率更高
 *
 *      除以上区别以外 方法 遍历方式 完全一样
 */
public class TestHashtable {
    public static void main(String[] args) {
        Hashtable map = new Hashtable();

        map.put("CN", "中国");
        map.put("KR", "韩国");

        System.out.println(map.get("CN"));

        System.out.println("删除元素的值为：" + map.remove("JP"));

        map.replace("KR", "小西巴");

        System.out.println(map.get("KR"));

        map.clear();

        System.out.println(map.isEmpty());
    }
}
 
  
 
  
2.3Properties
 
  
 
   
Properties类用于后续读取配置文件信息 属于Hashtable的子类
 
   
因为继承自Hashtable 所以 可以直接访问父类的 put或者 putAll方法
 
   
但是不推荐使用 因为Properties类存在的意义在于 只希望用户添加键以及值都为字符串的数据
 
   
所以应该使用setProperty()方法添加数据
 
  
 
  
package com.atguigu.test1;

import java.util.Properties;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 11:25
 *  Properties类用于后续读取配置文件信息  属于Hashtable的子类
 *  因为继承自Hashtable 所以 可以直接访问父类的 put或者 putAll方法
 *  但是不推荐使用 因为Properties类存在的意义在于 只希望用户添加键以及值都为字符串的数据
 *  所以应该使用setProperty()方法添加数据
 */
public class TestProperties {
    public static void main(String[] args) {
        // 获取系统相关的所有的属性
        Properties properties = System.getProperties();

        // 调用list方法 传入 System.out参数 表示使用System.out 进行打印所有的系统信息
        properties.list(System.out);


        // 创建Properties对象
        Properties pro = new Properties();


        // 调用setProperty方法添加数据
        pro.setProperty("a1", "b1");
        pro.setProperty("a2", "b2");
        pro.setProperty("a3", "b3");
        pro.setProperty("a4", "b4");
        pro.setProperty("a5", "b5");

        System.out.println("-------------------------");

        // 调用getProperty() 方法 根据键 获取数据
        System.out.println(pro.getProperty("a1"));

        // 调用list方法 传入 System.out参数 表示使用System.out 进行打印所有的pro对象信息
        pro.list(System.out);







    }
}

 
  
 
  
2.4 LinkedHashMap
 
  
 
   
LinkedHashMap一个有序的Map集合 顺序为添加顺序 继承自HashMap 所以
 
   
父类中的方法 依然可以正常使用
 
   
常用方法 以及 遍历方式 与HashMap完全一致
 
  
 
  
package com.atguigu.test2;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 14:05
 *  LinkedHashMap一个有序的Map集合 顺序为添加顺序 继承自HashMap 所以
 *  父类中的方法 依然可以正常使用
 *
 *  常用方法 以及 遍历方式 与HashMap完全一致
 *
 */
public class TestLinkedHashMap {
    public static void main(String[] args) {
        // 创建LinkedHashMap对象
        LinkedHashMap map = new LinkedHashMap<>();
        // 添加元素
        map.put("d", 4);
        map.put("b", 2);
        map.put("c", 3);
        map.put("e", 5);
        map.put("g", 7);
        map.put("a", 1);
        map.put("f", 6);

        // 调用entrySet方法 获取到map集合中所有的元素  返回值为set集合
        Set> entries = map.entrySet();

        // 遍历集合 Set集合 无序 只能通过迭代器 或者 增强for循环遍历
        for (Map.Entry entry : entries) {
            System.out.println(entry); // 直接打印entry对象 调用此对象的toString方法 
        }


    }
}

 
  
 
  
2.5 TreeMap
 
  
 
   
TreeMap 有序的Map集合 顺序为根据键比较的顺序
 
   
常用方法 、遍历方式 与HashMap完全相同
 
  
 
  
package com.atguigu.test2;

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

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 14:13
 * TreeMap 有序的Map集合 顺序为根据键比较的顺序
 * 常用方法 、遍历方式  与HashMap完全相同
 */
public class TestTreeMap {
    public static void main(String[] args) {
        TreeMap map = new TreeMap<>();

        map.put(562, "a");
        map.put(10, "a");
        map.put(20, "a");
        map.put(147, "a");
        map.put(258, "a");
        map.put(666, "a");

        // 调用entrySet()方法 获取到 所有的元素集合 返回值为Set集合
        Set> entries = map.entrySet();

        // 增强for循环遍历
        for (Map.Entry entry : entries) {

            System.out.println(entry); // 直接调用entry对象的toString方法
        }


    }
}

 
  
 
   
如果需要使用自定义的数据类型作为TreeMap的键 则必须实现Comparable接口 重写 compareTo方法
 
   
或者 自定义比较器 实现 Comparator接口
 
   
实现Comparable接口 泛型书写为Student 表示比较的对象为Student类型的
 
  
 
  
package com.atguigu.test2;

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

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 14:17
 *
 *  如果需要使用自定义的数据类型作为TreeMap的键 则必须实现Comparable接口 重写 compareTo方法
 *  或者 自定义比较器 实现 Comparator接口
 */
// 实现Comparable接口 泛型书写为Student 表示比较的对象为Student类型的
public class Student implements  Comparable{
    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(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public static void main(String[] args) {
        TreeMap map = new TreeMap();
        // 调用有参构造创建对象
        Student stu1 = new Student("赵四",26);
        Student stu2 = new Student("广坤",24);
        Student stu3 = new Student("大拿",22);
        Student stu4 = new Student("小宝",23);

        // 添加元素
        map.put(stu1,"a");
        map.put(stu2,"b");
        map.put(stu3,"c");
        map.put(stu4,"d");

        // 调用方法 获取所有的 元素 集合
        Set> entries = map.entrySet();

        // 增强for循环遍历
        for (Map.Entry entry : entries) {
            System.out.println("entry = " + entry); // 直接打印对象
        }


    }

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

    /**
     *  重写 compareTo方法  自定义比较规则
     * @param stu the object to be compared.
     * @return
     */
    @Override
    public int compareTo(Student stu) {
//        if(this.getAge() > stu.getAge()){ // 当前对象的年龄大于传入对象的年龄
//            return 1; // 返回正数
//        }else if(this.getAge() < stu.getAge()){ // 当前对象的年龄小于传入对象的年龄
//            return -1; // 返回负数
//        }
//        return 0; // 以上条件都不成立 表示两个对象的年龄相等 则 返回0


      // return  this.getAge() > stu.getAge() ? 1 :  (this.getAge() < stu.getAge() ? -1  : 0) ;
       return stu.getAge() - this.getAge();
    }
}

 
  
 
   
自定义Person类比较器 实现 Comparator接口
 
   
Comparable 接口 和 Comparator接口的区别？
 
   
Comparable接口属于自然排序 (直接在本类中定义比较规则)
 
   
Comparator接口属于非自然排序 (需要单独定义类来编写比较规则)
 
   
如果我们不能修改比较对象类 则需要单独编写比较器来实现对象比较 可以使用
 
   
Comparator接口
 
  
 
  
package com.atguigu.test3;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 14:38
 */
public class Person {
    private String name;
    private double height;

    public Person(String name, double height) {
        this.name = name;
        this.height = height;
    }

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }
}

 
  
package com.atguigu.test3;

import java.util.Comparator;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 14:39
 *  自定义Person类比较器 实现 Comparator接口
 *
 *  Comparable 接口 和  Comparator接口的区别？
 *  Comparable接口属于自然排序 (直接在本类中定义比较规则)
 *  Comparator接口属于非自然排序 (需要单独定义类来编写比较规则)
 *
 *  如果我们不能修改比较对象类 则需要单独编写比较器来实现对象比较 可以使用
 *  Comparator接口
 *
 */
public class PersonComparator implements Comparator {
    /**
     *  重写 compare方法  自定义比较规则  最终返回值为int类型
     * @param p1 the first object to be compared.
     * @param p2 the second object to be compared.
     * @return
     */
    @Override
    public int compare(Person p1, Person p2) {
        // p1大于p2 返回正数  p1小于p2 返回负数  p1==p2 返回0
        return  p1.getHeight() > p2.getHeight() ? 1 :  (p1.getHeight() < p2.getHeight() ? -1  : 0) ;
    }
}

 
  
package com.atguigu.test3;

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

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 14:42
 */
public class TestPerson {
    public static void main(String[] args) {
        // 创建 TreeMap集合对象  键为Person类型
        TreeMap map = new TreeMap<>(new PersonComparator());

        Person p1 = new Person("赵四", 188);
        Person p2 = new Person("小宝", 199);
        Person p3 = new Person("刘能", 155);
        Person p4 = new Person("大拿", 175);

        // 添加元素
        map.put(p1,"a");
        map.put(p2,"a");
        map.put(p3,"a");
        map.put(p4,"a");

        System.out.println("集合元素个数：" + map.size());

        // 调用entrySet方法 获取所有的集合元素对象
        Set> entries = map.entrySet();

        // 遍历集合
        for (Map.Entry entry : entries) {
            // 打印集合中的entry对象
            // 将调用TreeMap集合中 重写的toString方法
            // 继续调用 键 和 值的 toString方法
            // 所有 Person类型的键  也需要重写toString
            System.out.println("entry = " + entry);

        }


    }
}

 
  
3.Set集合 HashMap中的键 去除重复的依据？
 
  
 
   
两个对象 equals比较为true 并且hashCode相同 认为是重复的对象
 
  
 
  
package com.atguigu.test5;

import com.atguigu.test2.Student;

import java.util.HashSet;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 15:51
 *  Set集合 HashMap中的键  去除重复的依据？
 *  两个对象 equals比较为true  并且hashCode相同 认为是重复的对象
 */
public class TestSet {
    public static void main(String[] args) {
        // 创建集合对象
        HashSet set = new HashSet<>();

        // 创建学生对象
        Student stu1 = new Student("赵四",26);
        Student stu2 = new Student("赵四",26);
        Student stu3 = new Student("赵四",26);
        Student stu4 = new Student("赵四",26);


        // 使用equals比较是否为true 如果Student类重写 使用本类 如果没有重写 用父类
        System.out.println(stu1.equals(stu2));
        System.out.println(stu1.equals(stu3));
        System.out.println(stu1.equals(stu4));

        //打印hash值 调用hashCode方法 如果Student类重写 使用本类 如果没有重写 用父类
        System.out.println(stu1.hashCode());
        System.out.println(stu2.hashCode());
        System.out.println(stu3.hashCode());
        System.out.println(stu4.hashCode());

        // 添加元素 重写之后 只能添加一个元素
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        set.add(stu4);


        // 打印集合长度
        System.out.println(set.size());



    }
}

 
  
package com.atguigu.test2;

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

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/18 14:17
 *
 *  如果需要使用自定义的数据类型作为TreeMap的键 则必须实现Comparable接口 重写 compareTo方法
 *  或者 自定义比较器 实现 Comparator接口
 */
// 实现Comparable接口 泛型书写为Student 表示比较的对象为Student类型的
public class Student implements  Comparable{
    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(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public static void main(String[] args) {
        TreeMap map = new TreeMap();
        // 调用有参构造创建对象
        Student stu1 = new Student("赵四",26);
        Student stu2 = new Student("广坤",24);
        Student stu3 = new Student("大拿",22);
        Student stu4 = new Student("小宝",23);

        // 添加元素
        map.put(stu1,"a");
        map.put(stu2,"b");
        map.put(stu3,"c");
        map.put(stu4,"d");

        // 调用方法 获取所有的 元素 集合
        Set> entries = map.entrySet();

        // 增强for循环遍历
        for (Map.Entry entry : entries) {
            System.out.println("entry = " + entry); // 直接打印对象
        }


    }

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

    /**
     *  重写 compareTo方法  自定义比较规则
     * @param stu the object to be compared.
     * @return
     */
    @Override
    public int compareTo(Student stu) {
//        if(this.getAge() > stu.getAge()){ // 当前对象的年龄大于传入对象的年龄
//            return 1; // 返回正数
//        }else if(this.getAge() < stu.getAge()){ // 当前对象的年龄小于传入对象的年龄
//            return -1; // 返回负数
//        }
//        return 0; // 以上条件都不成立 表示两个对象的年龄相等 则 返回0


      // return  this.getAge() > stu.getAge() ? 1 :  (this.getAge() < stu.getAge() ? -1  : 0) ;
       return stu.getAge() - this.getAge();
    }

    @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 Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

 
  
在 Java 集合框架中，有序性的定义可能涉及 ​插入顺序、访问顺序​ 或 ​自然排序。以下是不同集合类型的有序性分类及具体实现：
 
  
 
  
​一、List 接口（有序，按插入顺序）​
 
  
所有 List 的实现类都严格按元素插入顺序存储，支持通过索引（index）访问。
 
  
     
   
  • ​**ArrayList**：基于动态数组，按插入顺序保存。
    •  
   
  • ​**LinkedList**：基于双向链表，按插入顺序保存。
    •  
   
  • ​**Vector**：线程安全的动态数组，行为同 ArrayList。
    •  
   
  • ​**Stack**：继承自 Vector，按插入顺序，但为后进先出（LIFO）。
    •  
   
  • ​**CopyOnWriteArrayList**​（线程安全）：按插入顺序。
    •  
  
 
  
示例：​
 
  
 
  
java
 
  
List list = new ArrayList<>();
list.add("A"); // 索引 0
list.add("B"); // 索引 1
System.out.println(list.get(1)); // 输出 B
 
  
 
  
​二、Set 接口（部分有序）​
 
  
1. ​按插入顺序维护
 
  
     
   
  • ​**LinkedHashSet**：
     内部使用链表维护插入顺序，遍历顺序与添加顺序一致。 
     
    java
     
    Set set = new LinkedHashSet<>();
set.add("B");
set.add("A");
System.out.println(set); // 输出 [B, A]
     
    •  
  
 
  
2. ​按自然排序或比较器排序
 
  
     
   
  • ​**TreeSet**：
     基于红黑树，按元素的自然顺序（Comparable）或自定义比较器（Comparator）排序。 
     
    java
     
    Set treeSet = new TreeSet<>();
treeSet.add("B");
treeSet.add("A");
System.out.println(treeSet); // 输出 [A, B]（按字母顺序）
     
    •  
  
 
  
3. ​无序 Set
 
  
     
   
  • ​**HashSet**：基于哈希表，不保证顺序。
    •  
   
  • ​**ConcurrentSkipListSet**：虽然线程安全，但实际基于排序（类似 TreeSet）。
    •  
  
 
  
 
  
​三、Map 接口（部分有序）​
 
  
1. ​按插入顺序或访问顺序维护
 
  
     
   
  • ​**LinkedHashMap**： 
    
       
     
    • 默认按插入顺序遍历。
      •  
     
    • 可配置为按访问顺序（最近访问的元素移到末尾），适合实现 LRU 缓存。
      •  
    
     
     
    java
     
    Map linkedMap = new LinkedHashMap<>();
linkedMap.put("B", 2);
linkedMap.put("A", 1);
System.out.println(linkedMap.keySet()); // 输出 [B, A]

// 按访问顺序
Map lruCache = new LinkedHashMap<>(16, 0.75f, true);
lruCache.put("A", 1);
lruCache.put("B", 2);
lruCache.get("A"); // 访问 A
System.out.println(lruCache.keySet()); // 输出 [B, A]
     
    •  
  
 
  
2. ​按自然排序或比较器排序
 
  
     
   
  • ​**TreeMap**：
     基于红黑树，按键的自然顺序或自定义比较器排序。 
     
    java
     
    Map treeMap = new TreeMap<>();
treeMap.put("B", 2);
treeMap.put("A", 1);
System.out.println(treeMap.keySet()); // 输出 [A, B]
     
    •  
  
 
  
3. ​无序 Map
 
  
     
   
  • ​**HashMap**：基于哈希表，不保证顺序。
    •  
   
  • ​**Hashtable**：线程安全但无序。
    •  
   
  • ​**ConcurrentHashMap**：线程安全且无序。
    •  
  
 
  
 
  
​四、Queue 接口（部分有序）​
 
  
1. ​按优先级排序
 
  
     
   
  • ​**PriorityQueue**：
     基于堆结构，按元素的自然顺序或比较器排序，出队时按优先级。 
     
    java
     
    Queue pq = new PriorityQueue<>();
pq.add(3);
pq.add(1);
pq.add(2);
while (!pq.isEmpty()) {
    System.out.print(pq.poll() + " "); // 输出 1 2 3
}
     
    •  
  
 
  
2. ​按 FIFO/LIFO 顺序
 
  
     
   
  • ​**LinkedList**​（作为 Queue 使用）：按先进先出（FIFO）顺序。
    •  
   
  • ​**ArrayDeque**：支持 FIFO 或 LIFO（取决于方法调用）。
    •  
  
 
  
 
  
​总结：有序集合分类
 
  
 
    
    
 
     ​集合类型​ 
     ​实现类​ 
     ​有序性规则​ 
    
 
    
    
    
 
     List 
     ArrayList, LinkedList 
     严格插入顺序 
    
 
    
 
     Set（有序） 
     LinkedHashSet 
     插入顺序 
    
 
    
 
     Set（排序） 
     TreeSet 
     自然顺序或比较器排序 
    
 
    
 
     Map（有序） 
     LinkedHashMap 
     插入顺序或访问顺序 
    
 
    
 
     Map（排序） 
     TreeMap 
     自然顺序或比较器排序 
    
 
    
 
     Queue（优先级） 
     PriorityQueue 
     自然顺序或比较器排序（堆结构） 
    
 
    
 
     Queue（FIFO/LIFO） 
     LinkedList, ArrayDeque 
     先进先出（FIFO）或后进先出（LIFO） 
    
 
    
  
 
  
 
  
​选择建议
 
  
     
   
  • ​需要插入顺序：使用 ArrayList、LinkedHashSet、LinkedHashMap。
    •  
   
  • ​需要排序：使用 TreeSet、TreeMap。
    •  
   
  • ​需要线程安全且有序：CopyOnWriteArrayList（List）、ConcurrentSkipListSet（Set）、ConcurrentSkipListMap（Map）。
    •  
  
 
  
4. Collections工具类
 
  
 
   
Collections 集合工具类 此类中的方法全部为静态方法 此类中提供了用于操作集合的各种方法
 
   
swap(List list, int i, int j) 交换指定位置的集合中的元素
 
   
sort(List list, Comparator c) 根据指定的比较器引起的顺序对指定的列表进行排序。
 
   
reverse(List list) 反转指定列表中元素的顺序。
 
   
replaceAll(List list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。
 
   
min(Collection coll) 根据其元素的 自然顺序返回给定集合的最小元素。
 
   
max(Collection coll) 根据其元素的 自然顺序返回给定集合的最大元素。
 
   
fill(List list, T obj) 用指定的元素代替指定列表的所有元素。
 
   
binarySearch(List> list, T key)使用二叉搜索算法搜索指定对象的指定列表。
 
  
 
  
package com.atguigu.test1;

import javax.rmi.CORBA.Stub;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/19 9:21
 *  Collections 集合工具类 此类中的方法全部为静态方法  此类中提供了用于操作集合的各种方法
 *
 *  swap(List list, int i, int j) 交换指定位置的集合中的元素
 *  sort(List list, Comparator c) 根据指定的比较器引起的顺序对指定的列表进行排序。
 *  reverse(List list) 反转指定列表中元素的顺序。
 *  replaceAll(List list, T oldVal, T newVal) 将列表中一个指定值的所有出现替换为另一个。
 *  min(Collection coll) 根据其元素的 自然顺序返回给定集合的最小元素。
 *  max(Collection coll) 根据其元素的 自然顺序返回给定集合的最大元素。
 * fill(List list, T obj) 用指定的元素代替指定列表的所有元素。
 * binarySearch(List> list, T key)使用二叉搜索算法搜索指定对象的指定列表。
 *
 */
public class TestCollections {
    public static void main(String[] args) {
        List list = new ArrayList<>();

        list.add(125);
        list.add(896);
        list.add(666);
        list.add(258);
        list.add(321);

        // 将集合按照升序排序
        Collections.sort(list);
        for (Integer integer : list) {
            System.out.println("integer = " + integer);
        }
        System.out.println("--------------------------------------");

        // 使用二分法查找集合中的元素   要求集合必须先排序
        int index = Collections.binarySearch(list, 666);

        System.out.println("index = " + index);
        // 使用二分法查找集合中的元素   要求集合必须先排序
        int i = Collections.binarySearch(list, 456);

        System.out.println("i = " + i);

        System.out.println("--------------------------------------");

        // 获取集合中最大元素  要求元素必须可以比较大小 即 实现Comparable接口 或者 定义Comparator实现类
        Integer max = Collections.max(list);

        System.out.println("max = " + max);
        // 获取集合中最小元素  要求元素必须可以比较大小 即 实现Comparable接口 或者 定义Comparator实现类
        Integer min = Collections.min(list);

        System.out.println("min = " + min);

        System.out.println("--------------------------------------");
        // 翻转集合
        Collections.reverse(list);

        for (Integer integer : list) {
            System.out.println("integer = " + integer);
        }

        System.out.println("--------------------------------------");
        // 交换指定位置的元素
        Collections.swap(list, 0, 3);

        for (Integer integer : list) {
            System.out.println("integer = " + integer);
        }
        System.out.println("--------------------------------------");
        // 使用指定元素填充集合
        Collections.fill(list, 999);

        for (Integer integer : list) {
            System.out.println("integer = " + integer);
        }


    }
}

 
  
5.泛型
 
  
 
   
泛型： 用于统一数据类型
 
   
泛型可以使用的位置：类、接口、形参、返回值、属性
 
   
自定义泛型，如何书写
 
   
(泛型的名称可以使用任何单词 字母 大小写都可以 但是我们只推荐使用一些有公认的含义的一些大写字母 )
 
   
K Key 键
 
   
V Value 值
 
   
T Type 类型
 
   
E Element 元素
 
   
R Return 返回值
 
   
P Parameter 参数
 
   
N Number 数值
 
   
泛型初始化的时机：
 
   
1.类声明的泛型 是随着当前类创建对象初始化
 
   
2.接口声明的泛型 是随着实现类实现接口初始化
 
   
目前所学习的泛型达到，看到了知道什么意思即可
 
  
 
  
package com.atguigu.test2;

import java.util.*;

/**
 * @author WHD
 * @description TODO
 * @date 2023/8/19 9:38
 *  泛型： 用于统一数据类型
 *
 *  泛型可以使用的位置：类、接口、形参、返回值、属性
 *
 *  自定义泛型，如何书写
 *  (泛型的名称可以使用任何单词 字母 大小写都可以 但是我们只推荐使用一些有公认的含义的一些大写字母 )
 *
 *  K   Key         键
 *  V   Value       值
 *  T   Type        类型
 *  E   Element     元素
 *  R   Return      返回值
 *  P   Parameter   参数
 *  N   Number      数值
 *
 *  泛型初始化的时机：
 *  1.类声明的泛型 是随着当前类创建对象初始化
 *  2.接口声明的泛型 是随着实现类实现接口初始化
 *
 *  目前所学习的泛型达到，看到了知道什么意思即可
 */
public class TestGenericType {
}

class  A{
    public void m1(T t){
        System.out.println("t = " + t);
    }

    public  T m2(){
        return null;
    }

    /**
     *  在类上声明的泛型 是不能直接用于静态方法中的
     *  因为类声明的泛型 必须通过new对象才可以具体化
     *  而静态方法不需要通过对象调用
     * @param list
     * @return
     * @param 
     */
    public static  E m3(List list){
        return list.get(0);
    }



}

class B{
    public void m1(Object t){
        System.out.println("t = " + t);
    }

    public  Object m2(){
        return null;
    }
}

class TestA{
    public static void main(String[] args) {
        A a1 = new A();
        a1.m1("abc");
        System.out.println(a1.m2());

        A a2 = new A();
        a2.m1(100);
        System.out.println(a2.m2());

        A a3 = new A();
        a3.m1(100.5);
        System.out.println(a3.m2());

    }
}

interface C{
    R m1(P p);
}
class C1 implements  C{
    @Override
    public Boolean m1(String s) {
        return "abc".startsWith("a");
    }
}
class C2 implements  C{
    @Override
    public Double m1(String s) {
        return Double.parseDouble(s);
    }
}
class TestC{
    public static void main(String[] args) {
        C1 c1 = new C1();
        System.out.println(c1.m1("abc"));


        C2 c2 = new C2();
        System.out.println(c2.m1("123"));
    }
}
class Animal{}
class Pet extends Animal{}
class Dog extends Pet{}
class Cat extends Pet{}

class Garfield extends Cat{}


class TestPet{

    public static void m1(List list){}

    // 泛型是不存在类型自动提升
    // 要求形参为Pet类型 或者 Pet类的任意子类类型
    // ? extends 父类  ： 表示泛型可以为父类 以及 父类的任何子类类型
    // 这种方式属于给泛型设置上限 没有下限 任何子类 间接子类 都可以
    public static void m2(List list){}

    /**
     *  要求：泛型为Dog 以及 Dog类的任何父类
     *  ? super 子类： 表示泛型可以为子类 以及 任何子类的父类
     *  表示设置泛型的下限 没有上限
     * @param set
     */
    public static void m3(Set set){
    }

    public static void main(String[] args) {
        Set set1 = new HashSet<>();
        Set set2 = new LinkedHashSet<>();
        Set set3 = new HashSet<>();
        Set set4 = new HashSet<>();
        m3(set1);
        m3(set2);
        m3(set3);
        m3(set4);

        System.out.println("------------------------------------");
        Vector list1 = new Vector();
        ArrayList list2 = new ArrayList<>();
        LinkedList list3 = new LinkedList();
        m1(list1);
        m1(list2);
        m1(list3);

        System.out.println("------------------------------------");

        Vector list4 = new Vector();
        ArrayList list5 = new ArrayList<>();
        m2(list4);
        m2(list5);
        m2(list1);
//        ArrayList list6 = new ArrayList<>();
//        m2(list6);

        ArrayList list7 = new ArrayList<>();
        m2(list7);

    }
}


 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,windows,python)

        

            

                
    
                    
  • python 读excel每行替换_Python脚本操作Excel实现批量替换功能
                        weixin_39646695
python读excel每行替换
                        
    Python脚本操作Excel实现批量替换功能大家好，给大家分享下如何使用Python脚本操作Excel实现批量替换。使用的工具Openpyxl，一个处理excel的python库，处理excel，其实针对的就是WorkBook，Sheet，Cell这三个最根本的元素~明确需求原始excel如下我们的目标是把下面excel工作表的sheet1表页A列的内容“替换我吧”批量替换为B列的“我用来替换的
    
                    
    • 
                    
  • 移动端城市区县二级联动选择功能实现包
                        good2know

                        
    本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
    
                    
    • 
                    
  • 15个小技巧，让我的Windows电脑更好用了！
                        曹元_

                        
    01.桌面及文档处理第一部分的技巧，主要是围绕桌面的一些基本操作，包括主题设置、常用文档文件快捷打开的多种方式等等。主题换色默认情况下，我们的Win界面可能就是白色的文档界面，天蓝色的图表背景，说不出哪里不好看，但是就是觉得不够高级。imageimage说到高级感，本能第一反应就会和暗色模式联想起来，如果我们将整个界面换成黑夜模式的话，它会是这样的。imageimage更改主题颜色及暗色模式，我们
    
                    
    • 
                    
  • 9、汇编语言编程入门：从环境搭建到简单程序实现
                        神经网络酱
汇编语言MEPISGNU工具链
                        
    汇编语言编程入门：从环境搭建到简单程序实现1.数据存储介质问题解决在处理数据存储时，若要使用MEPIS系统，需确保有其可访问的存储介质。目前，MEPIS无法向采用NTFS格式（常用于Windows2000和XP工作站）的硬盘写入数据。不过，若硬盘采用FAT32格式，MEPIS就能进行写入操作。此外，MEPIS还能将文件写入软盘和大多数USB闪存驱动器。若工作站连接到局域网，还可通过FTP协议或挂载
    
                    
    • 
                    
  • 深入解析JVM工作原理：从字节码到机器指令的全过程
                        

                        
    一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
    
                    
    • 
                    
  • MotionLCM 部署优化 踩坑解决bug
                        AI算法网奇
aigc与数字人深度学习宝典文生motion
                        
    目录依赖项windowstorchok：渲染黑白图问题解决：humanml3d：sentence-t5-large下载数据：报错：Nomodulenamed'sentence_transformers'继续报错：fromtransformers.integrationsimportCodeCarbonCallback解决方法：推理相关转mesh：module‘matplotlib.cm‘hasno
    
                    
    • 
                    
  • JVM 内存模型深度解析：原子性、可见性与有序性的实现
                        练习时长两年半的程序员小胡
JVM深度剖析：从面试考点到生产实践jvmjava内存模型
                        
    在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
    
                    
    • 
                    
  • Java | 多线程经典问题 - 售票
                        Ada54

                        
    一、售票需求1）同一个票池2）多个窗口卖票，不能出售同一张票二、售票问题代码实现（线程与进程小总结，请戳：Java|线程和进程，创建线程）step1：定义SaleWindow类实现Runnable接口，覆盖run方法step2：实例化SaleWindow对象，创建Thread对象，将SaleWindow作为参数传给Thread类的构造函数，然后通过Thread.start()方法启动线程step3
    
                    
    • 
                    
  • SpringMVC的执行流程
                        

                        
    1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
    
                    
    • 
                    
  • JAVA接口机结构解析
                        秃狼
SpringBoot八股文Javajava学习
                        
    什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
    
                    
    • 
                    
  • 最新阿里四面面试真题46道：面试技巧+核心问题+面试心得
                        风平浪静如码

                        
    前言做技术的有一种资历，叫做通过了阿里的面试。这些阿里Java相关问题，都是之前通过不断优秀人才的铺垫总结的，先自己弄懂了再去阿里面试，不然就是去丢脸，被虐。希望对大家帮助，祝面试成功，有个更好的职业规划。一，阿里常见技术面1、微信红包怎么实现。2、海量数据分析。3、测试职位问的线程安全和非线程安全。4、HTTP2.0、thrift。5、面试电话沟通可能先让自我介绍。6、分布式事务一致性。7、ni
    
                    
    • 
                    
  • EasyPlayer播放器系列开发计划2025
                        xiejiashu
EasyPlayerEasyPlayerEasyPlayer播放器RTSP播放器js播放器Web播放器
                        
    EasyPlayer系列产品发展至今，已经超过10年，从最早的EasyPlayerRTSP播放器，到如今维护的3条线：EasyPlayer-RTSP播放器：Windows、Android、iOS；EasyPlayerPro播放器：Windows、Android、iOS；EasyPlayer.js播放器：H5；这3个播放器各有各的应用场景，用户量也是巨大，像RTSP版本的播放器，到今天依然还有很多低
    
                    
    • 
                    
  • 包含日志获取webshell
                        陈望_ning

                        
    日志文件关闭：Apache目录下的httpd.conf文件#ErrorLog"logs/error.log"#CustomLog"logs/access.log"common加#号为注释不产生日志文件如果去掉#将会在Apache/logs/目录下产生日志文件linux:access_logerror_logwindows:access.logerror.logaccess_log每一行记录了一次网
    
                    
    • 
                    
  • 图论算法经典题目解析：DFS、BFS与拓扑排序实战
                        周童學
数据结构与算法深度优先算法图论
                        
    图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
    
                    
    • 
                    
  • 【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge
                        本本本添哥
002-进阶开发能力java
                        
    一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
    
                    
    • 
                    
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    
                    
    • 
                    
  • Java 队列
                        tryxr
java开发语言队列
                        
    队列一般用什么哪种结构实现队列的特性数据入队列时一定是从尾部插入吗数据出队列时一定是从头部删除吗队列的基本运算有什么队列支持随机访问吗队列的英文表示什么是队列队列从哪进、从哪出队列的进出顺序队列是用哪种结构实现的Queue和Deque有什么区别Queue接口的方法Queue中的add与offer的区别offer、poll、peek的模拟实现如何利用链表实现队列如何利用顺序表实现队列什么叫做双端队列
    
                    
    • 
                    
  • JVM 内存分配与回收策略：从对象创建到内存释放的全流程
                        

                        
    在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
    
                    
    • 
                    
  • 代码随想录算法训练营第三十五天
                        

                        
    01背包问题二维题目链接01背包问题二维题解importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);intM=sc.nextInt();intN=sc.nextInt();int[]space=newint[M];int[]value=new
    
                    
    • 
                    
  • python笔记14介绍几个魔法方法
                        抢公主的大魔王
pythonpython
                        
    python笔记14介绍几个魔法方法先声明一下各位大佬，这是我的笔记。如有错误，恳请指正。另外，感谢您的观看，谢谢啦！(1).__doc__输出对应的函数，类的说明文档print(print.__doc__)print(value,...,sep='',end='\n',file=sys.stdout,flush=False)Printsthevaluestoastream,ortosys.std
    
                    
    • 
                    
  • 微信公众号回调java_处理微信公众号消息回调
                        weixin_39607620
微信公众号回调java
                        
    1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
    
                    
    • 
                    
  • Anaconda 和 Miniconda：功能详解与选择建议
                        古月฿
python入门pythonconda
                        
    Anaconda和Miniconda详细介绍一、Anaconda的详细介绍1.什么是Anaconda？Anaconda是一个开源的包管理和环境管理工具，在数据科学、机器学习以及科学计算领域发挥着关键作用。它以Python和R语言为基础，为用户精心准备了大量预装库和工具，极大地缩短了搭建数据科学环境的时间。对于那些想要快速开展数据分析、模型训练等工作的人员来说，Anaconda就像是一个一站式的“数
    
                    
    • 
                    
  • 环境搭建 | Python + Anaconda / Miniconda + PyCharm 的安装、配置与使用
                        

                        
    本文将分别介绍Python、Anaconda/Miniconda、PyCharm的安装、配置与使用，详细介绍Python环境搭建的全过程，涵盖Python、Pip、PythonLauncher、Anaconda、Miniconda、Pycharm等内容，以官方文档为参照，使用经验为补充，内容全面而详实。由于图片太多，就先贴一个无图简化版吧，详情请查看Python+Anaconda/Minicond
    
                    
    • 
                    
  • 你竟然还在用克隆删除？Conda最新版rename命令全攻略！
                        曦紫沐
Python基础知识conda虚拟环境管理
                        
    文章摘要Conda虚拟环境管理终于迎来革命性升级！本文揭秘Conda4.9+版本新增的rename黑科技，彻底告别传统“克隆+删除”的繁琐操作。从命令解析到实战案例，手把手教你如何安全高效地重命名Python虚拟环境，附带版本检测、环境迁移、故障排查等进阶技巧，助你提升开发效率10倍！一、颠覆认知：Conda居然自带重命名功能？很多开发者仍停留在“Conda无法直接重命名环境”的认知阶段，实际上自
    
                    
    • 
                    
  • centos7安装配置 Anaconda3
                        

                        
    Anaconda是一个用于科学计算的Python发行版,Anaconda于Python，相当于centos于linux。下载[root@testsrc]#mwgethttps://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-5.2.0-Linux-x86_64.shBegintodownload:Anaconda3-5.2.0-L
    
                    
    • 
                    
  • Pandas：数据科学的超级瑞士军刀
                        科技林总
DeepSeek学AI人工智能
                        
    **——从零基础到高效分析的进化指南**###**一、Pandas诞生：数据革命的救世主****2010年前的数据分析噩梦**：```python#传统Python处理表格数据data=[]forrowincsv_file:ifrow[3]>100androw[2]=="China":data.append(float(row[5])#代码冗长易错！```**核心痛点**：-Excel处理百万行崩
    
                    
    • 
                    
  • 学C++的五大惊人好处
                        

                        
    为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
    
                    
    • 
                    
  • Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
                        Tony666688888
javawindows开发语言
                        
    针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
    
                    
    • 
                    
  • 【Jupyter】个人开发常见命令
                        TIM老师
#Pycharm&VSCodepythonJupyter
                        
    1.查看python版本importsysprint(sys.version)2.ipynb/py文件转换jupyternbconvert--topythonmy_file.ipynbipynb转换为mdjupyternbconvert--tomdmy_file.ipynbipynb转为htmljupyternbconvert--tohtmlmy_file.ipynbipython转换为pdfju
    
                    
    • 
                    
  • 用代码生成艺术字：设计个性化海报的秘密
                        

                        
    本文围绕“用代码生成艺术字：设计个性化海报的秘密”展开，先概述代码生成艺术字在海报设计中的独特价值，接着介绍常用的代码工具（如HTML、CSS、JavaScript等），详细阐述从构思到实现的完整流程，包括字体样式设计、动态效果添加等，还分享了提升艺术字质感的技巧及实际案例。最后总结代码生成艺术字的优势，为设计师提供打造个性化海报的实用指南，助力提升海报设计的独特性与吸引力，符合搜索引擎SEO标准
    
                    
    • 
                                
  • iOS http封装
                                    374016526
ios服务器交互http网络请求
                                    
    程序开发避免不了与服务器的交互，这里打包了一个自己写的http交互库。希望可以帮到大家。 
  
内置一个basehttp，当我们创建自己的service可以继承实现。 
  
KuroAppBaseHttp *baseHttp = [[KuroAppBaseHttp alloc] init]; 
[baseHttp setDelegate:self]; 
[baseHttp 
    
                                
    • 
                                
  • lolcat ：一个在 Linux 终端中输出彩虹特效的命令行工具
                                    brotherlamp
linuxlinux教程linux视频linux自学linux资料
                                    
      
那些相信 Linux 命令行是单调无聊且没有任何乐趣的人们，你们错了，这里有一些有关 Linux 的文章，它们展示着 Linux 是如何的有趣和“淘气” 。 
在本文中，我将讨论一个名为“lolcat”的小工具 – 它可以在终端中生成彩虹般的颜色。 
何为 lolcat ? 
Lolcat 是一个针对 Linux，BSD 和 OSX 平台的工具，它类似于 cat 命令，并为 cat
    
                                
    • 
                                
  • MongoDB索引管理（1）——[九]
                                    eksliang
mongodbMongoDB管理索引
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2178427 一、概述 
      数据库的索引与书籍的索引类似，有了索引就不需要翻转整本书。数据库的索引跟这个原理一样，首先在索引中找，在索引中找到条目以后，就可以直接跳转到目标文档的位置，从而使查询速度提高几个数据量级。 
      不使用索引的查询称
    
                                
    • 
                                
  • Informatica参数及变量
                                    18289753290
Informatica参数变量
                                    
    下面是本人通俗的理解，如有不对之处，希望指正 info参数的设置：在info中用到的参数都在server的专门的配置文件中（最好以parma）结尾 下面的GLOBAl就是全局的，$开头的是系统级变量，$$开头的变量是自定义变量。如果是在session中或者mapping中用到的变量就是局部变量，那就把global换成对应的session或者mapping名字。 
 
 
[GLOBAL] $Par
    
                                
    • 
                                
  • python 解析unicode字符串为utf8编码字符串
                                    酷的飞上天空
unicode
                                    
    php返回的json字符串如果包含中文，则会被转换成\uxx格式的unicode编码字符串返回。 
在浏览器中能正常识别这种编码，但是后台程序却不能识别，直接输出显示的是\uxx的字符，并未进行转码。 
  
转换方式如下 
  
  
>>> import json
>>> q = '{"text":"\u4
    
                                
    • 
                                
  • Hibernate的总结
                                    永夜-极光
Hibernate
                                    
    1.hibernate的作用,简化对数据库的编码,使开发人员不必再与复杂的sql语句打交道 
  
做项目大部分都需要用JAVA来链接数据库，比如你要做一个会员注册的 页面，那么 获取到用户填写的 基本信后，你要把这些基本信息存入数据库对应的表中，不用hibernate还有mybatis之类的框架，都不用的话就得用JDBC，也就是JAVA自己的，用这个东西你要写很多的代码，比如保存注册信
    
                                
    • 
                                
  • SyntaxError: Non-UTF-8 code starting with '\xc4'
                                    随便小屋
python
                                    
    刚开始看一下Python语言，传说听强大的，但我感觉还是没Java强吧！ 
写Hello World的时候就遇到一个问题，在Eclipse中写的，代码如下 
'''
Created on 2014年10月27日

@author: Logic
'''
print("Hello World!"); 
 运行结果 
SyntaxError: Non-UTF-8 
    
                                
    • 
                                
  • 学会敬酒礼仪 不做酒席菜鸟
                                    aijuans
菜鸟
                                    
    俗话说，酒是越喝越厚，但在酒桌上也有很多学问讲究，以下总结了一些酒桌上的你不得不注意的小细节。 
 细节一：领导相互喝完才轮到自己敬酒。敬酒一定要站起来，双手举杯。  
 细节二：可以多人敬一人，决不可一人敬多人，除非你是领导。  
 细节三：自己敬别人，如果不碰杯，自己喝多少可视乎情况而定，比如对方酒量，对方喝酒态度，切不可比对方喝得少，要知道是自己敬人。  
 细节四：自己敬别人，如果碰杯，一
    
                                
    • 
                                
  • 《创新者的基因》读书笔记
                                    aoyouzi
读书笔记《创新者的基因》
                                    
    创新者的基因 
  
创新者的“基因”，即最具创意的企业家具备的五种“发现技能”：联想，观察，实验，发问，建立人脉。 
  
第一部分破坏性创新，从你开始 
第一章破坏性创新者的基因 
如何获得启示： 
发现以下的因素起到了催化剂的作用：(1) -个挑战现状的问题；(2)对某项技术、某个公司或顾客的观察；(3) -次尝试新鲜事物的经验或实验；(4)与某人进行了一次交谈，为他点醒
    
                                
    • 
                                
  • 表单验证技术
                                    百合不是茶
JavaScriptDOM对象String对象事件
                                    
    js最主要的功能就是验证表单,下面是我对表单验证的一些理解,贴出来与大家交流交流  ,数显我们要知道表单验证需要的技术点, String对象,事件,函数 
  
一:String对象;通常是对字符串的操作; 
  
1,String的属性; 
  
    字符串.length;表示该字符串的长度;
   var str= "java"
    
                                
    • 
                                
  • web.xml配置详解之context-param
                                    bijian1013
javaservletweb.xmlcontext-param
                                    
    一.格式定义： 
<context-param>  
	<param-name>contextConfigLocation</param-name>  
	<param-value>contextConfigLocationValue></param-value>  
</context-param> 
作用：该元
    
                                
    • 
                                
  • Web系统常见编码漏洞（开发工程师知晓）
                                    Bill_chen
sqlPHPWebfckeditor脚本
                                    
    1.头号大敌：SQL Injection 
原因：程序中对用户输入检查不严格，用户可以提交一段数据库查询代码，根据程序返回的结果， 
获得某些他想得知的数据，这就是所谓的SQL Injection，即SQL注入。 
本质: 
对于输入检查不充分，导致SQL语句将用户提交的非法数据当作语句的一部分来执行。 
示例： 
String query = "SELECT id FROM users
    
                                
    • 
                                
  • 【MongoDB学习笔记六】MongoDB修改器
                                    bit1129
mongodb
                                    
    本文首先介绍下MongoDB的基本的增删改查操作，然后，详细介绍MongoDB提供的修改器，以完成各种各样的文档更新操作    MongoDB的主要操作 
 
 show dbs 显示当前用户能看到哪些数据库 
 use foobar 将数据库切换到foobar 
 show collections 显示当前数据库有哪些集合 
 db.people.update，update不带参数，可
    
                                
    • 
                                
  • 提高职业素养，做好人生规划
                                    白糖_
人生
                                    
      
培训讲师是成都著名的企业培训讲师，他在讲课中提出的一些观点很新颖，在此我收录了一些分享一下。注：讲师的观点不代表本人的观点，这些东西大家自己揣摩。 
  
1、什么是职业规划：职业规划并不完全代表你到什么阶段要当什么官要拿多少钱，这些都只是梦想。职业规划是清楚的认识自己现在缺什么，这个阶段该学习什么，下个阶段缺什么，又应该怎么去规划学习，这样才算是规划。 
  
    
                                
    • 
                                
  • 国外的网站你都到哪边看？
                                    bozch
技术网站国外
                                    
    学习软件开发技术，如果没有什么英文基础，最好还是看国内的一些技术网站，例如：开源OSchina，csdn，iteye,51cto等等。 
个人感觉如果英语基础能力不错的话，可以浏览国外的网站来进行软件技术基础的学习，例如java开发中常用的到的网站有apache.org 里面有apache的很多Projects,springframework.org是spring相关的项目网站,还有几个感觉不错的
    
                                
    • 
                                
  • 编程之美-光影切割问题
                                    bylijinnan
编程之美
                                    
    
package a;

public class DisorderCount {

	/**《编程之美》“光影切割问题”
	 * 主要是两个问题：
	 * 1.数学公式（设定没有三条以上的直线交于同一点）：
	 * 两条直线最多一个交点，将平面分成了4个区域；
	 * 三条直线最多三个交点，将平面分成了7个区域；
	 * 可以推出：N条直线 M个交点，区域数为N+M+1。

    
                                
    • 
                                
  • 关于Web跨站执行脚本概念
                                    chenbowen00
Web安全跨站执行脚本
                                    
    跨站脚本攻击(XSS)是web应用程序中最危险和最常见的安全漏洞之一。安全研究人员发现这个漏洞在最受欢迎的网站,包括谷歌、Facebook、亚马逊、PayPal,和许多其他网站。如果你看看bug赏金计划,大多数报告的问题属于 XSS。为了防止跨站脚本攻击,浏览器也有自己的过滤器,但安全研究人员总是想方设法绕过这些过滤器。这个漏洞是通常用于执行cookie窃取、恶意软件传播,会话劫持,恶意重定向。在
    
                                
    • 
                                
  • [开源项目与投资]投资开源项目之前需要统计该项目已有的用户数
                                    comsci
开源项目
                                    
     
 
 
        现在国内和国外,特别是美国那边,突然出现很多开源项目,但是这些项目的用户有多少,有多少忠诚的粉丝,对于投资者来讲,完全是一个未知数,那么要投资开源项目,我们投资者必须准确无误的知道该项目的全部情况,包括项目发起人的情况,项目的维持时间..项目的技术水平,项目的参与者的势力,项目投入产出的效益.....
    
                                
    • 
                                
  • oracle alert log file（告警日志文件）
                                    daizj
oracle告警日志文件alert log file
                                    
    The alert log is a chronological log of messages and errors, and includes the following items: 
 
All internal errors (ORA-00600), block corruption errors (ORA-01578), and deadlock errors (ORA-00060) 
    
                                
    • 
                                
  • 关于 CAS SSO 文章声明
                                    denger
SSO
                                    
    由于几年前写了几篇 CAS 系列的文章，之后陆续有人参照文章去实现，可都遇到了各种问题，同时经常或多或少的收到不少人的求助。现在这时特此说明几点： 
 
1.  那些文章发表于好几年前了，CAS 已经更新几个很多版本了，由于近年已经没有做该领域方面的事情，所有文章也没有持续更新。 
 
2. 文章只是提供思路，尽管 CAS 版本已经发生变化，但原理和流程仍然一致。最重要的是明白原理，然后
    
                                
    • 
                                
  • 初二上学期难记单词
                                    dcj3sjt126com
englishword
                                    
    lesson 课 
traffic 交通 
matter 要紧；事物 
happy 快乐的，幸福的 
second 第二的 
idea 主意；想法；意见 
mean 意味着 
important 重要的，重大的 
never 从来，决不 
afraid 害怕 的 
fifth 第五的 
hometown 故乡，家乡 
discuss 讨论；议论 
east 东方的 
agree 同意；赞成 
bo
    
                                
    • 
                                
  • uicollectionview 纯代码布局, 添加头部视图
                                    dcj3sjt126com
Collection
                                    
    #import <UIKit/UIKit.h>

@interface myHeadView : UICollectionReusableView
{
    UILabel   *TitleLable;
}
-(void)setTextTitle;
@end
 
#import "myHeadView.h"

@implementation m
    
                                
    • 
                                
  • N 位随机数字串的 JAVA 生成实现
                                    FX夜归人
javaMath随机数Random
                                    
    /**
 * 功能描述 随机数工具类<br />
 * @author FengXueYeGuiRen
 * 创建时间 2014-7-25<br />
 */
public class RandomUtil {
    //  随机数生成器
    private static java.util.Random random = new java.util.R
    
                                
    • 
                                
  • Ehcache（09）——缓存Web页面
                                    234390216
ehcache页面缓存
                                    
    页面缓存 
目录 
1       SimplePageCachingFilter 
1.1      calculateKey 
1.2      可配置的初始化参数 
1.2.1     cach
    
                                
    • 
                                
  • spring中少用的注解@primary解析
                                    jackyrong
primary
                                    
    这次看下spring中少见的注解@primary注解，例子 
 
 

@Component
public class MetalSinger implements Singer{

    @Override
    public String sing(String lyrics) {
        return "I am singing with DIO voice
    
                                
    • 
                                
  • Java几款性能分析工具的对比
                                    lbwahoo
java
                                    
    Java几款性能分析工具的对比 
摘自：http://my.oschina.net/liux/blog/51800 
  
在给客户的应用程序维护的过程中，我注意到在高负载下的一些性能问题。理论上，增加对应用程序的负载会使性能等比率的下降。然而，我认为性能下降的比率远远高于负载的增加。我也发现，性能可以通过改变应用程序的逻辑来提升，甚至达到极限。为了更详细的了解这一点，我们需要做一些性能
    
                                
    • 
                                
  • JVM参数配置大全
                                    nickys
jvm应用服务器
                                    
    JVM参数配置大全 
 
/usr/local/jdk/bin/java -Dresin.home=/usr/local/resin -server -Xms1800M -Xmx1800M -Xmn300M -Xss512K -XX:PermSize=300M -XX:MaxPermSize=300M -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=5 -
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(14) - squid、Varnish
                                    rensanning
varnish
                                    
    （一）squid 
 
安装 
 
# yum install httpd-tools -y
# htpasswd -c -b /etc/squid/passwords squiduser 123456
# yum install squid -y 
 
设置 
 
# cp /etc/squid/squid.conf /etc/squid/squid.conf.bak
# vi /etc/
    
                                
    • 
                                
  • Spring缓存注解@Cache使用
                                    tom_seed
spring
                                    
    参考资料 
http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/ 
http://swiftlet.net/archives/774 
  
缓存注解有以下三个： 
@Cacheable      @CacheEvict     @CachePut
    
                                
    • 
                                
  • dom4j解析XML时出现"java.lang.noclassdeffounderror: org/jaxen/jaxenexception"错误
                                    xp9802

                                    
    java.lang.NoClassDefFoundError: org/jaxen/JaxenExc 
关键字: java.lang.noclassdeffounderror: org/jaxen/jaxenexception 
使用dom4j解析XML时，要快速获取某个节点的数据，使用XPath是个不错的方法，dom4j的快速手册里也建议使用这种方式 
执行时却抛出以下异常： 
Exceptio
    
                                
    •