小琪爱学习

集合进阶（双列集合、HashMap、LinkedHashMap、TreeMap、Collections）

一、双列集合

1、双列集合的特点

2、双列集合的常见API

3、Map的遍历方式

3.1第一种遍历方式：键找值（keySet）

3.2第二种遍历方式：键值对（entrySet）Entry：键值对对象

3.3第三种遍历方式：Lambda表达式（forEach）

二、HsahMap集合

1、HashMap的特点

2、HashMap的底层原理

3、小结

4、HashMap练习

4.1存储学生对象并遍历

4.2Map集合案例-统计投票人数

三、LinkedHashMap

编辑

四、TreeMap

1、练习TreeMap基本应用

2、练习统计个数

3、小结

编辑

五、原码解析

1、HashMap的底层原理（一）

1.1源码中的类型介绍

1.2HashMap中的每一个元素是什么？

2、HashMap的底层原理（二）

2.1看源码前的准备工作

2.2创建对象、第一种情况：添加元素（添加第一个元素，即数组位置为null）底层原理

2.3第二种情况：添加其他元素（数组位置不为null）底层原理

编辑

2.4为什么hashcode值要与数组长度-1做一次“与”运算？【★】

2.5 第三种情况：添加元素（数组位置不为null，键重复，元素覆盖）

3、TreeMap中的底层源码（一）

3.1为什么这里的默认颜色为BLACK？

3.2TreeMap中每一个节点的内部属性

3.3TreeMap类中的成员变量以及构造器

3.4面试小问题

六、可变参数

1、普通示例

2、数组使用示例

3、JDK5-可变参数

4、可变参数小细节

5、小结

七、Collections

编辑1、addAll() 批量添加元素

2、shuffle() 打乱List集合元素的顺序

3、其它方法

八、综合练习

1、自动点名器

2、自动点名器2（概率——随机面）

3、自动点名器3（不会重复且会循环点名——辅助列表）

4、自动点名器4（权重）

2、Map集合案例——省和市

一、双列集合

1、双列集合的特点

在Map中定义了双列集合所有的共性方法：

2、双列集合的常见API

示例代码
添加元素：put()

//1.创建Map集合的对象
         Map m = new HashMap<>();

         //2.添加元素
        //put方法的细节:
        //添加/覆盖

        //在添加数据的时候。如果键不存在，那么直接把键值对对象添加到map集合当中，方法返回null
        //在添加数据的时候，如果键是存在的，那么把原有的键值对对象覆盖，会把被覆盖的值进行返回。
        m.put("郭靖","黄蓉");
        m.put("韦小宝","沐剑屏");
        m.put("杨过","小龙女");

        //String value = m.put("韦小宝", "双儿");
        //System.out.println(value);

put小细节：

在添加数据的时候。如果键不存在，那么直接把键值对对象添加到map集合当中，方法返回null

在添加数据的时候，如果键是存在的，那么把原有的键值对对象覆盖，会把被覆盖的值进行返回。

删除元素：删除元素，返回删除值 remove()

//删除
        String reuslt = m.remove("郭靖");
        System.out.println(reuslt);

清空元素：clear()

//清空
        m.clear();

判断是否包含：containsKey()

//判断是否包含
        boolean keyResult = m.containsKey("郭靖");
        System.out.println(keyResult);

        boolean valueResult = m.containsKey("小龙女");
        System.out.println(valueResult);

判空判断：isEmpty()

        boolean result = m.isEmpty();
        System.out.println(result);

长度：size()

//长度
        int size = m.size();
        System.out.println(size);

3、Map的遍历方式

3.1第一种遍历方式：键找值（keySet）

public class A02_MapDemo2 {
    public static void main(String[] args) {
        //Map集合的第一种遍历方式

        

        //1.创建Map集合的对象
        Map map = new HashMap<>();

        //2.添加元素
        map.put("伊志平","小空女");
        map.put("郭靖","穆念慈");
        map.put("来来来","哈哈哈");

        //3.通过键找值

        //3.1获取所有的键，把这些键放到一个单列集合当中
        Set keys = map.keySet();
        
        //3.2遍历单列结合，得到每一个键
        for(String key:keys){
            //System.out.println(key);
            //3.3利用Map结合中的键获取对应的值  get
            String value = map.get(key);
            System.out.println(key +" = "+value);
        }



    }
}

课堂练习：

//三个课堂练习
        //
        //练习一：利用键找值的方式遍历map集合，要求: 装着键的单列集合使用增强for的形式进行遍历
        //练习二：利用键找值的方式遍历map集合，要求: 装着键的单列集合使用迭代器的形式进行遍历
        //练习三：利用键找值的方式遍历map集合，要求: 装着键的单列集合使用lambda表达式的形式进行遍历

//2.迭代器
        Iterator it = keys.iterator();

        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }

        //3.forEach遍历
        keys.forEach(new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //Lambda表达式改进
        keys.forEach( s-> System.out.println(s));

3.2第二种遍历方式：键值对（entrySet）
Entry：键值对对象

public class A03_MapDemo3 {
   

    public static void main(String[] args) {
        //Map集合的第二种遍历方式

        //三个课堂练习

        //1.创建Map集合的对象
        Map map = new HashMap<>();

        //2.添加元素
        //键：任务的外号
        //值：人物的名字
        map.put("标枪选手", "马超");
        map.put("人物挂件", "明世隐");
        map.put("驯龙骑士", "你好");

        //3.Map集合的第二种遍历方式
        //通过键值对对象进行遍历
        //3.1通过一个方法获取所有的键值对对象，返回一个Set集合
        Set> entries = map.entrySet();
        //3.2遍历entries这个集合，去得到里面的每一个键值对象
        for (Map.Entry entry : entries) {
            //3.3利用entry调用get方法获取键和值
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }

       
}

课堂练习：

//三个课堂练习
//通过键值对对象进行遍历map集合，要求: 装着键值对对象的单列集合使用增强for的形式进行遍历
//通过键值对对象进行遍历map集合，要求: 装着键值对对象的单列集合使用迭代器的形式进行遍历
//通过键值对对象进行遍历map集合，要求: 装着键值对对象的单列集合使用lambda的形式进行遍历
 //2.迭代器
        System.out.println("===========================");
        Iterator> it= entries.iterator();
        while(it.hasNext()){
            Map.Entry str = it.next();
            System.out.println(str.getKey()+"="+str.getValue());
        }

        //3.forEach遍历
        entries.forEach(new Consumer>() {
            @Override
            public void accept(Map.Entry stringStringEntry) {
                System.out.println(stringStringEntry.getKey()+"="+stringStringEntry.getValue());
            }
        });

        //4.Lambda表达式
        entries.forEach(stringStringEntry ->
                System.out.println(stringStringEntry.getKey()+"="+stringStringEntry.getValue()));
    }

3.3第三种遍历方式：Lambda表达式（forEach）

示例代码：

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class A04_MapDemo4 {
    public static void main(String[] args) {
        //Map集合的第三种遍历方式

        //1.创建Map集合的对象
        Map map = new HashMap<>();

        //2.添加元素
        map.put("鲁迅","这句话是我说的");
        map.put("曹操","不可能绝对不可能");
        map.put("刘备","接着奏乐接着舞");

        //3.利用lambda表达式进行遍历
        //底层：
        //forEach其实就是利用第二种方式进行遍历，依次得到每一个键和值
        //再调用accept方法
        map.forEach(new BiConsumer() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key+"="+value);
            }
        });

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

        //Lambda表达式
        map.forEach((String key, String value)-> {
                System.out.println(key+"="+value);
            }
        );

        //Lambda简化
        map.forEach(( key,  value)-> System.out.println(key+"="+value));
    }
}

二、HsahMap集合

1、HashMap的特点

2、HashMap的底层原理

HashMap首先还是会创建一个默认长度为16，默认加载因子为0.75的数组；
然后再利用put方式，就可以添加数据了，put方法的底层会先创建一个Entry对象，Entry对象里面记录的就是要添加的键和值，然后利用键来计算哈希值，跟值无关，然后再计算出元素在数组中应存储的位置的索引，如果该位置为null，直接添加，如果该位置不为null，它会调用equals方法比较键的属性值，如果键的值相同，那么元素就会被覆盖；如果比较完后不一样，则会添加新的Entry对象；

JDK8，如果计算出来的索引相同，且键不一致，那么就会直接挂在当前值的下面；
此外，当链表长度超过8，且数组长度大于等于64的时候，链表就会自动转成红黑树

3、小结

4、HashMap练习

4.1存储学生对象并遍历

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

public class A05_HashMapDemo1 {
    public static void main(String[] args) {
        /*
        需求: 创建一个HashMap集合，键是学生对象(student)，值是籍贤(String)。
        存储三个键值对元素，并遍历
        要求:同姓名，同年龄认为是同一个学生
        梭心点:
        HashMap的键位置如果存傲的是自定义对象，需要重写hashCode和equals方法。
         */

        //1.创建HashMap的对象
        HashMap hm = new HashMap<>();

        //2.创建HashMap的对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("wangwu", 25);
        Student s4 = new Student("wangwu", 25);

        //3.添加元素
        hm.put(s1, "江苏");
        hm.put(s2, "浙江");
        hm.put(s3, "福建");
        hm.put(s4, "山东");

        //4.遍历集合
        Set keys = hm.keySet();
        for (Student key : keys) {
            String value = hm.get(key);
            System.out.println(key + "=" + value);
        }

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

        Set> entries = hm.entrySet();
        for (Map.Entry entry : entries) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }

        System.out.println("----------------------------");
        hm.forEach(( student,  s) -> System.out.println(student+"="+s));

    }
}

4.2Map集合案例-统计投票人数

package com.yaqi.a01mymap;

import java.util.*;

public class A06_HashMapDemo2 {
    public static void main(String[] args) {
        /*
        某个班级80名学生。现在需要组成秋游活动。
        班长提供了四个景点依次是《A、B、C、D) ，
        每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多
         */
        //1.需要先让同学们投票
        //定义一个数组，存储4个景点
        String[] arr = {"A", "B", "C", "D"};
        //利用随机数模拟80个同学的投票，并把票数的结果存储起来
        ArrayList list = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            int index = r.nextInt(arr.length);
            list.add(arr[index]);
        }
        //2.如果要统计的东西比较多，不方便使用计数器思想
        //我们可以定义map集合，利用集合进行统计。
        HashMap hm = new HashMap<>();
        for (String name : list) {
            //判断当前景点在Map集合当中是否存在
            if (hm.containsKey(name)) {
                //存在
                //先获取当前景点已经被投票的次数
                int count = hm.get(name);
                //表示当前景点又被投了一次
                count++;
                //把新的次数再次添加到集合当中
                hm.put(name, count);
            } else {
                //不存在
                hm.put(name, 1);
            }
        }

        System.out.println(hm);

        //3.求最大值
        int max = 0;
        Set> entries = hm.entrySet();
        for (Map.Entry entry : entries) {
            int count = entry.getValue();
            if(count>max){
                max = count;
            }
        }
        System.out.println(max);
        //4.判断哪个景点的次数跟最大值一样，如果一样打印出来
        for (Map.Entry entry : entries) {
            int count = entry.getValue();
            if(count==max){
                System.out.println(entry.getKey());
            }
        }
    }
}

三、LinkedHashMap

代码：

import java.util.LinkedHashMap;

public class A01_LinkedHashMapDemo1 {
    public static void main(String[] args) {
        /*
        LinkedHashMap:
        由键决定:
        有序、不重复、无素引。
        有序:
        保证存储和取出的顺序一致
        原理:
        底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
         */

        //1.创建集合
        LinkedHashMap lhm = new LinkedHashMap<>();
        //2.添加元素
        lhm.put("c",789);
        lhm.put("b",456);
        lhm.put("a",123);
        lhm.put("a",111);

        //3.打印集合
        System.out.println(lhm);

    }
}

四、TreeMap

1、练习TreeMap基本应用

示例代码：（Integer、Double 默认情况下都是按照升序排列的）

（String 按照字母在ASCII码表中对应的数字升序排列 abcdefg…）

TreeMap集合: 基本应用
 需求1:
      键:整数表示id
      值: 字符串表示商晶名称
      要求1: 按照id的升序排列
      要求2: 按照id的降序排列

TreeMap集合: 基本应用
    需求2:
    键:学生对象
    值: 籍贯
    要求:按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。


import java.util.TreeMap;

public class A02_TreeMapDemo2 {
    public static void main(String[] args) {
        /*
        TreeMap集合: 基本应用
            需求2:
            键:学生对象
            值: 籍贯
            要求:按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。
         */

        //1.创建集合
        TreeMap tm = new TreeMap<>();

        //2.创建三个学生对象
        Student s1 = new Student("zhangsan",23);
        Student s2=new Student("lisi",24);
        Student s3 = new Student("wnagwu",25);

        //3.添加元素
        tm.put(s1,"武汉");
        tm.put(s2,"天津");
        tm.put(s3,"北京");

        //4.打印集合
        System.out.println(tm);
    }
}

2、练习统计个数

需求:
   字符串“aababcabcdabcde”
   请统计宁符串中每一个字符出现的次数，并按照以下格式输出
   输出结果:
       a(5) b (4) c (3) d (2) e(1)
   新的统计思想: 利用map集合进行统计
   如果题目中没有要求对结果进行排序，默认使用HashmMap
   如果题目中要求对结果进行排序，请使用TreeMap

   键:表示要统计的内容
   值:表示次数

import java.util.StringJoiner;
import java.util.TreeMap;

public class A03_TreeMapDemo3 {
    public static void main(String[] args) {
        /*
        需求:
           字符串“aababcabcdabcde”
           请统计宁符串中每一个字符出现的次数，并按照以下格式输出
           输出结果:
               a(5) b (4) c (3) d (2) e(1)
           新的统计思想: 利用map集合进行统计
           如果题目中没有要求对结果进行排序，默认使用HashmMap
           如果题目中要求对结果进行排序，请使用TreeMap

           键:表示要统计的内容
           值:表示次数
         */

        //1.定义字符串
        String s = "aababcabcdabcde";

        //2.创建集合
        TreeMap tm = new TreeMap<>();


        //3.遍历字符串得到里面的每一个字符
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            //拿着c到集合中判断是否存在
            //存在，表示当前字符又出现了一次
            //不存在，表示当前字符是第一次出现
            if(tm.containsKey(c)){
                //存在
                //先把已经出现的次数拿出来
                int count = tm.get(c);
                //当前字符又出现了一次
                count++;
                //把自增之后的结果再添加到集合当中
                tm.put(c,count);
            }else{
                //不存在
                tm.put(c,1);
            }
        }

        //4.打印集合
        //a(5) b(4) c(3) d(2) e(1)
        //System.out.println(tm);

        //字符串拼接
        //StringBuilder sb = new StringBuilder();
        //tm.forEach(( key, value)-> sb.append(key).append("(").append(")");

        StringJoiner sj = new StringJoiner("","","");
        tm.forEach(( key, value)-> sj.add(key+"").add("(").add(value+"").add(")"));

        System.out.println(sj);
    }
}

遍历集合，并按照指定的格式进行拼接

StringBuilder
StringJoiner

//4.打印集合
        //a(5) b(4) c(3) d(2) e(1)
        //System.out.println(tm);

        //字符串拼接
        //StringBuilder sb = new StringBuilder();
        //tm.forEach(( key, value)-> sb.append(key).append("(").append(")");

        StringJoiner sj = new StringJoiner("","","");
        tm.forEach(( key, value)-> sj.add(key+"").add("(").add(value+"").add(")"));

        System.out.println(sj);

3、小结

五、原码解析

1、HashMap的底层原理（一）

1.1源码中的类型介绍

⬆：表示该方式是父类或者接口中的方法，后面就标记了父类或接口的名称，我们可以理解为这个方法是重写的父类里面的方法；

➡：继承于Xxxx哪个类

f：表示这是HashMap的属性

I：接口

C：类

1.2HashMap中的每一个元素是什么？

在HashMap中每一个元素其实都是一个Node对象：

next：表示记录下一个节点的地址值

红黑树：红黑树中的节点为TreeNode

哈希表数组名为Table，默认长度为16

扩容因子：

最大容量：

2、HashMap的底层原理（二）

2.1看源码前的准备工作

数组（table）中的键值对对象是分情况讨论的：

数组下面挂的是链表
数组下面挂的是红黑树

2.2创建对象、第一种情况：添加元素（添加第一个元素，即数组位置为null）底层原理

刚开始用空参构造创建对象时，底层什么都没有，table也不存在，就是个null

当使用put方法，添加元素后，这个时候数组才存在

put方法：

putVal方法：

扩容机制：

2.3第二种情况：添加其他元素（数组位置不为null）底层原理

2.4为什么hashcode值要与数组长度-1做一次“与”运算？【★】

答：为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间。一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ (n - 1) & hash”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。

取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）”，并且采用二进制位操作 &，相对于%能够提高运算效率。

总结： a % b 操作等于 a & ( b - 1 ) (前提是b等于2的n次幂)

2.5 第三种情况：添加元素（数组位置不为null，键重复，元素覆盖）

步骤可见2.4

3、TreeMap中的底层源码（一）

TreeMap的底层为红黑树

3.1为什么这里的默认颜色为BLACK？

提高代码的阅读性，红黑树内部还存在调整过程，统一调整成红色。

3.2TreeMap中每一个节点的内部属性

3.3TreeMap类中的成员变量以及构造器

1.TreeMap中每一个节点的内部属性
K key;                   //键
V value;               //值
Entry left;       //左子节点
Entry right;       //右子节点
Entry parent;       //父节点
boolean color;           //节点的颜色

2.TreeMap类中中要知道的一些成员变量
public class TreeMap{

    //比较器对象
    private final Comparator comparator;

   //根节点
    private transient Entry root;

   //集合的长度
    private transient int size = 0;

3.空参构造
   //空参构造就是没有传递比较器对象
   public TreeMap() {
        comparator = null;
    }



4.带参构造
   //带参构造就是传递了比较器对象。
   public TreeMap(Comparator comparator) {
        this.comparator = comparator;
    }

put：添加元素
5.添加元素
   public V put(K key, V value) {
        return put(key, value, true);
    }

参数一：键
参数二：值
参数三：当键重复的时候，是否需要覆盖值
       true：覆盖
       false：不覆盖

   private V put(K key, V value, boolean replaceOld) {
       //获取根节点的地址值，赋值给局部变量t
        Entry t = root;
       //判断根节点是否为null
       //如果为null，表示当前是第一次添加，会把当前要添加的元素，当做根节点
       //如果不为null，表示当前不是第一次添加，跳过这个判断继续执行下面的代码
        if (t == null) {
           //方法的底层，会创建一个Entry对象，把他当做根节点
            addEntryToEmptyMap(key, value);
           //表示此时没有覆盖任何的元素
            return null;
        }
       //表示两个元素的键比较之后的结果
        int cmp;
       //表示当前要添加节点的父节点
        Entry parent;

       //表示当前的比较规则
       //如果我们是采取默认的自然排序，那么此时comparator记录的是null，cpr记录的也是null
       //如果我们是采取比较去排序方式，那么此时comparator记录的是就是比较器
        Comparator cpr = comparator;
       //表示判断当前是否有比较器对象
       //如果传递了比较器对象，就执行if里面的代码，此时以比较器的规则为准
       //如果没有传递比较器对象，就执行else里面的代码，此时以自然排序的规则为准
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else {
                    V oldValue = t.value;
                    if (replaceOld || oldValue == null) {
                        t.value = value;
                    }
                    return oldValue;
                }
            } while (t != null);
        } else {
           //把键进行强转，强转成Comparable类型的
           //要求：键必须要实现Comparable接口，如果没有实现这个接口
           //此时在强转的时候，就会报错。
            Comparable k = (Comparable) key;
            do {
               //把根节点当做当前节点的父节点
                parent = t;
               //调用compareTo方法，比较根节点和当前要添加节点的大小关系
                cmp = k.compareTo(t.key);

                if (cmp < 0)
                   //如果比较的结果为负数
                   //那么继续到根节点的左边去找
                    t = t.left;
                else if (cmp > 0)
                   //如果比较的结果为正数
                   //那么继续到根节点的右边去找
                    t = t.right;
                else {
                   //如果比较的结果为0，会覆盖
                    V oldValue = t.value;
                    if (replaceOld || oldValue == null) {
                        t.value = value;
                    }
                    return oldValue;
                }
            } while (t != null);
        }
       //就会把当前节点按照指定的规则进行添加
        addEntry(key, value, parent, cmp < 0);
        return null;
    }



   private void addEntry(K key, V value, Entry parent, boolean addToLeft) {
        Entry e = new Entry<>(key, value, parent);
        if (addToLeft)
            parent.left = e;
        else
            parent.right = e;
       //添加完毕之后，需要按照红黑树的规则进行调整
        fixAfterInsertion(e);
        size++;
        modCount++;
    }


红黑树规则：
   private void fixAfterInsertion(Entry x) {
       //因为红黑树的节点默认就是红色的
        x.color = RED;
       //按照红黑规则进行调整

       //parentOf:获取x的父节点
       //parentOf(parentOf(x)):获取x的爷爷节点
       //leftOf:获取左子节点
        while (x != null && x != root && x.parent.color == RED) {


           //判断当前节点的父节点是爷爷节点的左子节点还是右子节点
           //目的：为了获取当前节点的叔叔节点
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
               //表示当前节点的父节点是爷爷节点的左子节点
               //那么下面就可以用rightOf获取到当前节点的叔叔节点
                Entry y = rightOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                   //叔叔节点为红色的处理方案

                   //把父节点设置为黑色
                    setColor(parentOf(x), BLACK);
                   //把叔叔节点设置为黑色
                    setColor(y, BLACK);
                   //把爷爷节点设置为红色
                    setColor(parentOf(parentOf(x)), RED);

                   //把爷爷节点设置为当前节点
                    x = parentOf(parentOf(x));
                } else {

                   //叔叔节点为黑色的处理方案


                   //表示判断当前节点是否为父节点的右子节点
                    if (x == rightOf(parentOf(x))) {

                       //表示当前节点是父节点的右子节点
                        x = parentOf(x);
                       //左旋
                        rotateLeft(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {
               //表示当前节点的父节点是爷爷节点的右子节点
               //那么下面就可以用leftOf获取到当前节点的叔叔节点
                Entry y = leftOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == leftOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateRight(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }

       //把根节点设置为黑色
        root.color = BLACK;
    }

3.4面试小问题

6.课堂思考问题：
6.1TreeMap添加元素的时候，键是否需要重写hashCode和equals方法？
此时是不需要重写的。hashCode和equals方法与HashMap的键有关！

6.2HashMap是哈希表结构的，JDK8开始由数组，链表，红黑树组成的。
既然有红黑树，HashMap的键是否需要实现Compareable接口或者传递比较器对象呢？
不需要的。
因为在HashMap的底层，默认是利用哈希值的大小关系来创建红黑树的

6.3TreeMap和HashMap谁的效率更高？
如果是最坏情况，添加了8个元素，这8个元素形成了链表，此时TreeMap的效率要更高
但是这种情况出现的几率非常的少。
一般而言，还是HashMap的效率要更高。

6.4你觉得在Map集合中，java会提供一个如果键重复了，不会覆盖的put方法呢？
此时putIfAbsent本身不重要。
传递一个思想：
   代码中的逻辑都有两面性，如果我们只知道了其中的A面，而且代码中还发现了有变量可以控制两面性的发生。
   那么该逻辑一定会有B面。

   习惯：
       boolean类型的变量控制，一般只有AB两面，因为boolean只有两个值
       int类型的变量控制，一般至少有三面，因为int可以取多个值。

6.5三种双列集合，以后如何选择？
   HashMap LinkedHashMap TreeMap

   默认：HashMap（效率最高）
   如果要保证存取有序：LinkedHashMap
   如果要进行排序：TreeMap

六、可变参数

代码：

1、普通示例



    public static class ArgsDemo1 {
        public static void main(String[] args) {
           /*
            假如需要定义一个方法求和，该方法可以灵活的完成如下需求：
            计算2个数据的和
            计算3个数据的和
            计算4个数据的和
            计算n个数据的和
           */

            System.out.println(getSum(10,20));
            System.out.println(getSum(10,20,30));
            System.out.println(getSum(10,20,30,40));


        }


        //计算2个数据的和
        public static int getSum(int a, int b) {
            return a + b;
        }

        //计算3个数据的和
        public static int getSum(int a, int b, int c) {
            return a + b + c;
        }

        //计算4个数据的和
        public static int getSum(int a, int b, int c, int d) {
            return a + b + c + d;
        }


    }
}

2、数组使用示例

public class ArgsDemo2 {
    public static void main(String[] args) {
        //计算n个数据的和
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int sum = getSum(arr);
        System.out.println(sum);



    }


    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i : arr) {
            sum = sum + i;
        }
        return sum;
    }

3、JDK5-可变参数

public class ArgsDemo3 {
    public static void main(String[] args) {
        //JDK5
        //可变参数
        //方法形参的个数是可以发生变化的，0 1 2 3 ...
        //格式：属性类型...名字
        //int...args

        int sum = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(sum);
    }

    //底层：
    //可变参数底层就是一个数组
    //只不过不需要我们自己创建了，Java会帮我们创建好
    public static int getSum(int...args){
        //System.out.println(args);//[I@119d7047
        int sum = 0;
        for (int i : args) {
            sum = sum + i;
        }
        return sum;
    }
}

4、可变参数小细节

public class ArgsDemo4 {
    public static void main(String[] args) {
        //可变参数的小细节：
        //1.在方法的形参中最多只能写一个可变参数
        //可变参数，理解为一个大胖子，有多少吃多少

        //2.在方法的形参当中，如果出了可变参数以外，还有其他的形参，那么可变参数要写在最后

        getSum(1,2,3,4,5,6,7,8,9,10);
        
    }
    
    public static int getSum( int a,int...args) {
        return 0;
    }
}

5、小结

七、Collections

1、addAll() 批量添加元素

import java.util.ArrayList;
import java.util.Collections;

public class CollectionsDemo1 {
    public static void main(String[] args) {
      /*
        public static  boolean addAll(Collection c, T... elements)        批量添加元素
        public static void shuffle(List list)                                打乱List集合元素的顺序
     */



        //addAll  批量添加元素
        //1.创建集合对象
        ArrayList list = new ArrayList<>();
        //2.批量添加元素
        Collections.addAll(list,"abc","bcd","qwer","df","asdf","zxcv","1234","qwer");
        //3.打印集合
        System.out.println(list);

       

    }
}

2、shuffle() 打乱List集合元素的顺序

 //shuffle 打乱
        Collections.shuffle(list);

        System.out.println(list);

3、其它方法

package com.yaqi.a07mycollections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class CollectionsDemo2 {
    public static void main(String[] args) {
      /*
        public static  void sort(List list)                       排序
        public static  void sort(List list, Comparator c)      根据指定的规则进行排序
        public static  int binarySearch (List list,  T key)       以二分查找法查找元素
        public static  void copy(List dest, List src)          拷贝集合中的元素
        public static  int fill (List list,  T obj)               使用指定的元素填充集合
        public static  void max/min(Collection coll)              根据默认的自然排序获取最大/小值
        public static  void swap(List list, int i, int j)         交换集合中指定位置的元素
     */


        System.out.println("-------------sort默认规则--------------------------");
        //默认规则，需要重写Comparable接口compareTo方法。Integer已经实现，按照从小打大的顺序排列
        //如果是自定义对象，需要自己指定规则
        ArrayList list1 = new ArrayList<>();
        Collections.addAll(list1, 10, 1, 2, 4, 8, 5, 9, 6, 7, 3);
        Collections.sort(list1);
        System.out.println(list1);


        System.out.println("-------------sort自己指定规则规则--------------------------");
        Collections.sort(list1, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(list1);

        Collections.sort(list1, (o1, o2) -> o2 - o1);
        System.out.println(list1);

        System.out.println("-------------binarySearch--------------------------");
        //需要元素有序
        ArrayList list2 = new ArrayList<>();
        Collections.addAll(list2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(Collections.binarySearch(list2, 9));
        System.out.println(Collections.binarySearch(list2, 1));
        System.out.println(Collections.binarySearch(list2, 20));

        System.out.println("-------------copy--------------------------");
        //把list3中的元素拷贝到list4中
        //会覆盖原来的元素
        //注意点：如果list3的长度 > list4的长度，方法会报错
        ArrayList list3 = new ArrayList<>();
        ArrayList list4 = new ArrayList<>();
        Collections.addAll(list3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.addAll(list4, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
        Collections.copy(list4, list3);
        System.out.println(list3);
        System.out.println(list4);

        System.out.println("-------------fill--------------------------");
        //把集合中现有的所有数据，都修改为指定数据
        ArrayList list5 = new ArrayList<>();
        Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.fill(list5, 100);
        System.out.println(list5);

        System.out.println("-------------max/min--------------------------");
        //求最大值或者最小值
        ArrayList list6 = new ArrayList<>();
        Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(Collections.max(list6));
        System.out.println(Collections.min(list6));

        System.out.println("-------------max/min指定规则--------------------------");
        // String中默认是按照字母的abcdefg顺序进行排列的
        // 现在我要求最长的字符串
        // 默认的规则无法满足，可以自己指定规则
        // 求指定规则的最大值或者最小值
        ArrayList list7 = new ArrayList<>();
        Collections.addAll(list7, "a","aa","aaa","aaaa");
        System.out.println(Collections.max(list7, new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        }));

        System.out.println("-------------swap--------------------------");
        ArrayList list8 = new ArrayList<>();
        Collections.addAll(list8, 1, 2, 3);
        Collections.swap(list8,0,2);
        System.out.println(list8);



    }
}

八、综合练习

1、自动点名器

 班级里有N个学生，学生属性:姓名，年龄，性别。
        实现随机点名器。

import java.util.ArrayList;
import java.util.Collections;

public class Test1 {
    public static void main(String[] args) {
       /* 班级里有N个学生，学生属性:姓名，年龄，性别。
        实现随机点名器。*/


        //1.定义集合
        ArrayList list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list,"范闲","范建","范统","杜子腾","杜琦燕","宋合泛","侯笼藤","朱益群","朱穆朗玛峰","袁明媛");
        //3.随机点名
       /* Random r = new Random();
        int index = r.nextInt(list.size());
        String name = list.get(index);
        System.out.println(name);*/

        //打乱
        Collections.shuffle(list);

        String name = list.get(0);
        System.out.println(name);


    }
}

2、自动点名器2（概率——随机面）


import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Test2 {
    public static void main(String[] args) {
       /* 班级里有N个学生
        要求：
        70%的概率随机到男生
        30%的概率随机到女生

        "范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰",
        "杜琦燕","袁明媛","李猜","田蜜蜜",
        */


        //1.创建集合
        ArrayList list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list,1,1,1,1,1,1,1);
        Collections.addAll(list,0,0,0);
        //3.打乱集合中的数据
        Collections.shuffle(list);
        //4.从list集合中随机抽取0或者1
        Random r = new Random();
        int index = r.nextInt(list.size());
        int number = list.get(index);
        System.out.println(number);
        //5.创建两个集合分别存储男生和女生的名字
        ArrayList boyList = new ArrayList<>();
        ArrayList girlList = new ArrayList<>();

        Collections.addAll(boyList,"范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰");
        Collections.addAll(girlList,"杜琦燕","袁明媛","李猜","田蜜蜜");

        //6.判断此时是从boyList里面抽取还是从girlList里面抽取
        if(number == 1){
            //boyList
            int boyIndex = r.nextInt(boyList.size());
            String name = boyList.get(boyIndex);
            System.out.println(name);
        }else{
            //girlList
            int girlIndex = r.nextInt(girlList.size());
            String name = girlList.get(girlIndex);
            System.out.println(name);
        }


    }
}

3、自动点名器3（不会重复且会循环点名——辅助列表）

package com.yaqi.a08test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Test3 {
    public static void main(String[] args) {
       /* 班级里有5个学生
        要求：
        被点到的学生不会再被点到。
        但是如果班级中所有的学生都点完了，需要重新开启第二轮点名。*/


        //1.定义集合
        ArrayList list1 = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list1, "范闲", "范建", "范统", "杜子腾", "杜琦燕", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰", "袁明媛");
        //创建一个临时的集合，用来存已经被点到学生的名字
        ArrayList list2 = new ArrayList<>();
        //外循环：表示轮数
        for (int i = 1; i <= 10; i++) {
            System.out.println("=========第" + i + "轮点名开始了======================");
            //3.获取集合的长度
            int count = list1.size();
            //4.随机点名
            Random r = new Random();
            //内循环：每一轮中随机循环抽取的过程
            for (int j = 0; j < count; j++) {
                int index = r.nextInt(list1.size());
                String name = list1.remove(index);
                list2.add(name);
                System.out.println(name);
            }
            //此时表示一轮点名结束
            //list1 空了 list2 10个学生的名字
            list1.addAll(list2);
            list2.clear();

        }


    }
}

4、自动点名器4（权重）

微服务技术

2、Map集合案例——省和市

 需求
        定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
        添加完毕后，遍历结果格式如下：
                江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
                湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
                河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市

import java.util.*;

public class Test4 {
    public static void main(String[] args) {
       /* 需求
        定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
        添加完毕后，遍历结果格式如下：
                江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
                湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
                河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市*/


        //1.创建Map集合
        HashMap> hm = new HashMap<>();

        //2.创建单列集合存储市
        ArrayList city1 = new ArrayList<>();
        city1.add("南京市");
        city1.add("扬州市");
        city1.add("苏州市");
        city1.add("无锡市");
        city1.add("常州市");

        ArrayList city2 = new ArrayList<>();
        city2.add("武汉市");
        city2.add("孝感市");
        city2.add("十堰市");
        city2.add("宜昌市");
        city2.add("鄂州市");

        ArrayList city3 = new ArrayList<>();
        city3.add("石家庄市");
        city3.add("唐山市");
        city3.add("邢台市");
        city3.add("保定市");
        city3.add("张家口市");

        //3.把省份和多个市添加到map集合
        hm.put("江苏省",city1);
        hm.put("湖北省",city2);
        hm.put("河北省",city3);

        Set>> entries = hm.entrySet();
        for (Map.Entry> entry : entries) {
            //entry依次表示每一个键值对对象
            String key = entry.getKey();
            ArrayList value = entry.getValue();
            StringJoiner sj = new StringJoiner(", ","","");
            for (String city : value) {
                sj.add(city);
            }

            System.out.println(key + " = " + sj);

        }

    }
}

你可能感兴趣的:(Java黑马,java,开发语言)

华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
学习JavaEE的日子 Day32 线程池 A 北枝学习JavaEE 学习 java-ee java 线程池
Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shiro java java 安全开发语言
请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？大龄下岗程序员 mysql java mysql spring
Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb 前端 ajax elementui java 前端框架
P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
枚举使用笔记万变不离其宗_8 项目笔记笔记
1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
Python dict字符串转json对象，小数精度丢失问题朝如青丝暮成雪 json python
一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
java实体中返回前端的double类型四舍五入（格式化）婲落ヽ紅顏誶 java
根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java 数据结构开发语言
在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
Java学习笔记01 .wsy. 日常 java 学习笔记
1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
Java回溯知识点（含面试大厂题和源码）一成码农 java 面试开发语言
回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
Azkaban各种类型的Job编写 __元昊__
一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
java基础相关面试题详细总结。。。。。96 java 开发语言
1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记 javascript 开发语言 ecmascript
日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法杰哥在此 Java系列 java jvm 算法面试
Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
COMP315 JavaScript Cloud Computing for E Commerce zhuyu0206girl javascript 开发语言 ecmascript
Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
JSON与AJAX：网页交互的利器入冉心 json ajax 前端
在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
程序员开发技术整理 laizhixue 学习前端框架
前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
javascript的数据类型及转换田小田txt
一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
java线程之Lock的使用 dimdark
目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
第六届蓝桥杯大赛软件赛省赛Java 大学C组题解爱跑步的程序员~ 刷题蓝桥杯省赛
文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
Java学习笔记04：Java_数组 JasonYangQ Java java
文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
【设计模式】Java 设计模式之桥接模式（Bridge）新手村长 Java 设计模式设计模式 java 桥接模式
桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
基于SSM+Vue企业销售培训系统企业人才培训系统企业课程培训管理系统企业文化培训班系统Java 计算机程序老哥
作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
java selenium 元素点击不了马达马达达 selenium 测试工具
最近做了一个页面爬取，很有意思被机缘巧合下解决了。这个元素很奇怪，用xpath可以定位元素，但是就是click()不了。试过了网上搜的一些办法：//尝试一WebElementa_tag=driver.findElement(By.xpath("xxx"));a_tag.click();//点击不了，卡住//尝试二WebDriverWaitwait=newWebDriverWait(driver,1
【Java初阶（三）】方法的使用 PU-YUHAN Java从入门到精通 java 开发语言递归方法
❣博主主页:33的博客❣▶文章专栏分类:Java从入门到精通◀我的代码仓库:33的代码仓库目录1.前言2.方法的概念2.1方法定义2.2实参和形参的关系3.方法的重载3.1方法重载的概念4.递归4.1递归的概念4.2递归过程分析4.3递归练习5.总结1.前言在前面的学习中，我们已经学习了Java的部分知识，包括数据类型与变量，运算符，分支与循环以及输入和输出这些基础知识，我们继续对Java的学习进
解析XML文件的几种方式？人生在勤，不索何获 xml
在Java中解析XML文件可以通过多种方式完成，其中最常用的有DOM（DocumentObjectModel）、SAX（SimpleAPIforXML）和StAX（StreamingAPIforXML）。每种方式有其特点和适用场景。1.DOM解析DOM解析是一种将整个XML文档加载到内存中，构造成一个树形结构，然后你可以很方便地访问任何数据节点的方法。这种方法适用于需要频繁读写操作的场景。impo
javascript实现SM2加密解密人生在勤，不索何获 javascript 前端 jquery
前提JavaWeb环境前端代码window.sm2=function(t){functioni(e){if(r[e])returnr[e].exports;varn=r[e]={i:e,l:!1,exports:{}};returnt[e].call(n.exports,n,n.exports,i),n.l=!0,n.exports}varr={};returni.m=t,i.c=r,i.d=fu
Vue：为什么要使用v-cloak 刻刻帝的海角 vue.js 前端 javascript
Vue.js是一种流行的JavaScript框架，它使我们能够构建交互性强大的用户界面。在Vue.js中，v-cloak是一个指令，用于解决在页面加载时出现的闪烁问题。本文将介绍如何使用v-cloak及代码来优化Vue.js应用程序的渲染效果。引言当我们使用Vue.js构建应用程序时，有时会遇到一个问题：在页面加载时，由于Vue.js需要一定的时间来解析和渲染模板，会导致页面上显示出未经处理的Mu
Github 2024-03-26 开源项目日报 Top10 老孙正经胡说 github 开源 Github趋势分析开源项目 Python Golang
根据GithubTrendings的统计，今日(2024-03-26统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Python项目3TypeScript项目3JupyterNotebook项目2C++项目1GDScript项目1Lua项目1Solidity项目1OpenInterpreter:本地代码运行和自然语言界面创建周期：254天开发语言：Python协议
SQL的各种连接查询 xieke90 UNION ALL UNION 外连接内连接 JOIN
一、内连接概念：内连接就是使用比较运算符根据每个表共有的列的值匹配两个表中的行。内连接（join 或者inner join ） SQL语法： select * fron
java编程思想--复用类百合不是茶 java 继承代理组合 final类
复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书一:组合语法:就是将对象的引用放到新类中即可代码: package com.wj.reuse; /** * * @author Administrator 组
[开源与生态系统]国产CPU的生态系统 comsci cpu
计算机要从娃娃抓起...而孩子最喜欢玩游戏.... 要让国产CPU在国内市场形成自己的生态系统和产业链,国家和企业就不能够忘记游戏这个非常关键的环节.... 投入一些资金和资源,人力和政策,让游
JVM内存区域划分Eden Space、Survivor Space、Tenured Gen，Perm Gen解释商人shang jvm内存
jvm区域总体分两类，heap区和非heap区。heap区又分：Eden Space（伊甸园）、Survivor Space(幸存者区)、Tenured Gen（老年代-养老区）。非heap区又分：Code Cache(代码缓存区)、Perm Gen（永久代）、Jvm Stack(java虚拟机栈)、Local Method Statck(本地方法栈)。 HotSpot虚拟机GC算法采用分代收
页面上调用 QQ oloz qq
<A href="tencent://message/?uin=707321921&Site=有事Q我&Menu=yes"> <img style="border:0px;" src=http://wpa.qq.com/pa?p=1:707321921:1></a>
一些问题文强chu 问题
1.eclipse 导出 doc 出现“The Javadoc command does not exist.” javadoc command 选择 jdk/bin/javadoc.exe 2.tomcate 配置 web 项目 ..... SQL:3.mysql * 必须得放前面否则 select&nbs
生活没有安全感小桔子生活孤独安全感
圈子好小，身边朋友没几个，交心的更是少之又少。在深圳，除了男朋友，没几个亲密的人。不知不觉男朋友成了唯一的依靠，毫不夸张的说，业余生活的全部。现在感情好，也很幸福的。但是说不准难免人心会变嘛，不发生什么大家都乐融融，发生什么很难处理。我想说如果不幸被分手(无论原因如何)，生活难免变化很大，在深圳，我没交心的朋友。明
php 基础语法 aichenglong php 基本语法
1 .1 php变量必须以$开头 <?php $a=” b”; echo ?> 1 .2 php基本数据库类型 Integer float/double Boolean string 1 .3 复合数据类型数组array和对象 object 1 .4 特殊数据类型 null 资源类型(resource) $co
mybatis tools 配置详解 AILIKES mybatis
MyBatis Generator中文文档 MyBatis Generator中文文档地址： http://generator.sturgeon.mopaas.com/ 该中文文档由于尽可能和原文内容一致，所以有些地方如果不熟悉，看中文版的文档的也会有一定的障碍，所以本章根据该中文文档以及实际应用，使用通俗的语言来讲解详细的配置。本文使用Markdown进行编辑，但是博客显示效
继承与多态的探讨百合不是茶 JAVA面向对象继承对象
继承 extends 多态继承是面向对象最经常使用的特征之一：继承语法是通过继承发、基类的域和方法 //继承就是从现有的类中生成一个新的类，这个新类拥有现有类的所有extends是使用继承的关键字：在A类中定义属性和方法； class A{ //定义属性 int age； //定义方法 public void go
JS的undefined与null的实例 bijian1013 JavaScript JavaScript
<form name="theform" id="theform"> </form> <script language="javascript"> var a alert(typeof(b)); //这里提示undefined if(theform.datas
TDD实践（一） bijian1013 java 敏捷 TDD
一.TDD概述 TDD：测试驱动开发，它的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。
[Maven学习笔记十]Maven Profile与资源文件过滤器 bit1129 maven
什么是Maven Profile Maven Profile的含义是针对编译打包环境和编译打包目的配置定制，可以在不同的环境上选择相应的配置，例如DB信息，可以根据是为开发环境编译打包，还是为生产环境编译打包，动态的选择正确的DB配置信息 Profile的激活机制 1.Profile可以手工激活，比如在Intellij Idea的Maven Project视图中可以选择一个P
【Hive八】Hive用户自定义生成表函数(UDTF) bit1129 hive
1. 什么是UDTF UDTF，是User Defined Table-Generating Functions，一眼看上去，貌似是用户自定义生成表函数，这个生成表不应该理解为生成了一个HQL Table，貌似更应该理解为生成了类似关系表的二维行数据集 2. 如何实现UDTF 继承org.apache.hadoop.hive.ql.udf.generic
tfs restful api 加auth 2.0认计 ronin47
　　目前思考如何给tfs的ngx-tfs api增加安全性。有如下两点：　　一是基于客户端的ip设置。这个比较容易实现。　　二是基于OAuth2.0认证，这个需要lua，实现起来相对于一来说，有些难度。　　现在重点介绍第二种方法实现思路。　　前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGe
jdk环境变量配置 byalias java jdk
进行java开发，首先要安装jdk，安装了jdk后还要进行环境变量配置： 1、下载jdk（http://java.sun.com/javase/downloads/index.jsp），我下载的版本是：jdk-7u79-windows-x64.exe 2、安装jdk-7u79-windows-x64.exe 3、配置环境变量：右击"计算机"-->&quo
《代码大全》表驱动法-Table Driven Approach-2 bylijinnan java
package com.ljn.base; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.uti
SQL 数值四舍五入小数点后保留2位 chicony 四舍五入
1.round() 函数是四舍五入用，第一个参数是我们要被操作的数据，第二个参数是设置我们四舍五入之后小数点后显示几位。 2.numeric 函数的2个参数，第一个表示数据长度，第二个参数表示小数点后位数。例如：　　select cast(round(12.5,2) as numeric(5,2))
c++运算符重载 CrazyMizzz C++
一、加+，减-，乘*，除/ 的运算符重载 Rational operator*(const Rational &x) const{ return Rational(x.a * this->a); } 在这里只写乘法的，加减除的写法类似二、<<输出,>>输入的运算符重载 &nb
hive DDL语法汇总 daizj hive 修改列 DDL 修改表
hive DDL语法汇总１、对表重命名 hive> ALTER TABLE table_name RENAME TO new_table_name; 2、修改表备注 hive> ALTER TABLE table_name SET TBLPROPERTIES ('comment' = new_comm
jbox使用说明 dcj3sjt126com Web
参考网址：http://www.kudystudio.com/jbox/jbox-demo.html jBox v2.3 beta [ 点击下载] 技术交流QQGroup：172543951 100521167 [2011-11-11] jBox v2.3 正式版 - [调整&修复] IE6下有iframe或页面有active、applet控件
UISegmentedControl 开发笔记 dcj3sjt126com
// typedef NS_ENUM(NSInteger, UISegmentedControlStyle) { // UISegmentedControlStylePlain, // large plain &
Slick生成表映射文件 ekian scala
Scala添加SLICK进行数据库操作，需在sbt文件上添加slick-codegen包 "com.typesafe.slick" %% "slick-codegen" % slickVersion 因为我是连接SQL Server数据库，还需添加slick-extensions，jtds包 "com.typesa
ES-TEST gengzg test
package com.MarkNum; import java.io.IOException; import java.util.Date; import java.util.HashMap; import java.util.Map; import javax.servlet.ServletException; import javax.servlet.annotation
为何外键不再推荐使用 hugh.wang mysql DB
表的关联，是一种逻辑关系，并不需要进行物理上的“硬关联”，而且你所期望的关联，其实只是其数据上存在一定的联系而已，而这种联系实际上是在设计之初就定义好的固有逻辑。在业务代码中实现的时候，只要按照设计之初的这种固有关联逻辑来处理数据即可，并不需要在数据库层面进行“硬关联”，因为在数据库层面通过使用外键的方式进行“硬关联”，会带来很多额外的资源消耗来进行一致性和完整性校验，即使很多时候我们并不
领域驱动设计 julyflame VO DAO 设计模式 DTO po
概念： VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对
单例设计模式 hm4123660 java Singleton 单例设计模式懒汉式饿汉式
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。 &nb
logback zhb8015 log logback
一、logback的介绍 Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个改良版本。此外logback-class
整合Kafka到Spark Streaming——代码示例和挑战 Stark_Summer spark storm zookeeper PARALLELISM processing
作者Michael G. Noll是瑞士的一位工程师和研究员，效力于Verisign，是Verisign实验室的大规模数据分析基础设施（基础Hadoop）的技术主管。本文，Michael详细的演示了如何将Kafka整合到Spark Streaming中。期间， Michael还提到了将Kafka整合到 Spark Streaming中的一些现状，非常值得阅读，虽然有一些信息在Spark 1.2版
spring-master-slave-commondao 王新春 DAO spring dataSource slave master
互联网的web项目，都有个特点：请求的并发量高，其中请求最耗时的db操作，又是系统优化的重中之重。为此，往往搭建 db的一主多从库的数据库架构。作为web的DAO层，要保证针对主库进行写操作，对多个从库进行读操作。当然在一些请求中，为了避免主从复制的延迟导致的数据不一致性，部分的读操作也要到主库上。（这种需求一般通过业务垂直分开，比如下单业务的代码所部署的机器，读去应该也要从主库读取数

集合进阶（双列集合、HashMap、LinkedHashMap、TreeMap、Collections）

一、双列集合

1、双列集合的特点

2、双列集合的常见API

3、Map的遍历方式

3.1第一种遍历方式：键找值（keySet）

3.2第二种遍历方式：键值对（entrySet） Entry：键值对对象

3.3第三种遍历方式：Lambda表达式（forEach）

二、HsahMap集合

1、HashMap的特点

2、HashMap的底层原理

3、小结

4、HashMap练习

4.1存储学生对象并遍历

4.2Map集合案例-统计投票人数

三、LinkedHashMap

四、TreeMap

1、练习TreeMap基本应用

2、练习统计个数

3、小结

五、原码解析

1、HashMap的底层原理（一）

1.1源码中的类型介绍

1.2HashMap中的每一个元素是什么？

2、HashMap的底层原理（二）

2.1看源码前的准备工作

2.2创建对象、第一种情况：添加元素（添加第一个元素，即数组位置为null）底层原理

2.3第二种情况：添加其他元素（数组位置不为null）底层原理

2.4为什么hashcode值要与数组长度-1做一次“与”运算？【★】

2.5 第三种情况：添加元素（数组位置不为null，键重复，元素覆盖）

3、TreeMap中的底层源码（一）

3.1为什么这里的默认颜色为BLACK？

3.2TreeMap中每一个节点的内部属性

3.3TreeMap类中的成员变量以及构造器

3.4面试小问题

六、可变参数

1、普通示例

2、数组使用示例

3、JDK5-可变参数

4、可变参数小细节

5、小结

七、Collections

1、addAll() 批量添加元素

2、shuffle() 打乱List集合元素的顺序

3、其它方法

八、综合练习

1、自动点名器

2、自动点名器2（概率——随机面）

3、自动点名器3（不会重复且会循环点名——辅助列表）

4、自动点名器4（权重）

2、Map集合案例——省和市

你可能感兴趣的:(Java黑马,java,开发语言)

3.2第二种遍历方式：键值对（entrySet）
Entry：键值对对象