Java学习笔记===》20.集合总结

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量62 收藏
点赞数
分类专栏： 学习笔记 文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59318477/article/details/131154253
版权

集合总结

一、可变参数

1.什么是可变参数

假如需要定义一个方法求和，该方法可以灵活的完成以下需求：

计算（1/2/3/4 …/n）个数据的和

public class ArgsTest01 {
    public static void main(String[] args) {

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

    }

    public static int getSum(int...args){
        int sum = 0;
        for (int i : args) {
            sum = sum + i;
        }
        return sum;
    }
}

2.可变参数的作用以及细节

①可变参数在本质上其实就是一个数组

②在方法的形参中最多只能写一个可变参数

③如果在方法中，除了可变参数还有其他的形参，那么可变参数要写在最后面

④可变参数的作用就实在形参中接受多个数据

⑤格式：数据类型 . . . 参数名称

二、集合的工具类Collections

1.什么是Collections

①Collections是定义在java.util.collections的一个工具类

②作用：Collections不是集合，而是集合的工具类

2.Collectioms常用的API

方法名称说明
public static < T > boolean addAll （Collection< T > c , T … elements）批量添加元素
public static void shuffle ( List < ? > list)打乱List集合元素的顺序
public static < T > void sort (List < T > list)排序
public static < T > void sort (List < T > list，Compartor < T > c)根据指定的规则进行排序
public static < T > int binarySearch(List< T > list , T key)以二分查找法查找元素
public static < T > void copy（List < T > list , List < T > src）拷贝集合中的元素
public static < T > void fill（List< T > list,T obj）使用指定的元素天机集合
public static < T > void max/min （Collection < T > coll）根据默认的自然排序获取最大/小值
public static < T > void swap (List <?> list, int i , int j)交换集合中指定位置的元素
import java.util.ArrayList;
import java.util.Collections;

public class CollectionsTest01 {
    public static void main(String[] args) {
/*
方法名称说明
public static < T > boolean addAll （Collection< T > c , T ... elements）          批量添加元素
public static void shuffle ( List < ? > list)                                     打乱List集合元素的顺序
public static < T > void sort (List < T > list)                                   排序
public static < T > void sort (List < T > list，Compartor < T > c)                根据指定的规则进行排序
public static < T >  int binarySearch(List< T > list , T key)                     以二分查找法查找元素
public static < T >  void  copy（List < T > list , List < T > src）                拷贝集合中的元素
public static < T > int fill（List< T > list,T obj）                               使用指定的元素填充集合
public static < T >  void max/min  （Collection < T > coll）                       根据默认的自然排序获取最大/小值
public static < T >  void swap (List  <?> list,  int i ,  int j)                  交换集合中指定位置的元素
 */

        //创建集合
        ArrayList<String> list = new ArrayList<>();

        //1.public static < T > boolean addAll （Collection< T > c , T ... elements）      批量添加元素
        Collections.addAll(list,"abc","bcd","qwer","df","asdf","zxcv","1234","qwer");
        System.out.println(list);   //[abc, bcd, qwer, df, asdf, zxcv, 1234, qwer]

        //2.public static void shuffle ( List < ? > list)     打乱List集合元素的顺序
        Collections.shuffle(list);
        System.out.println(list);   //[bcd, df, 1234, qwer, abc, qwer, zxcv, asdf]

        //3.public static < T > void sort (List < T > list)       排序
        Collections.sort(list);
        System.out.println(list);   //[1234, abc, asdf, bcd, df, qwer, qwer, zxcv]

        //4.public static < T > void sort (List < T > list，Compartor < T > c)     根据指定的规则进行排序
        Collections.sort(list, ( o1,  o2)-> {
                if (o1.length()<o2.length()){
                    return -1;
                } else if (o1.length() == o2.length()) {
                    return 0;
                }
                return 1;
        });
        //打印集合
        System.out.println(list);   //[df, abc, bcd, 1234, asdf, qwer, qwer, zxcv]

        //5.public static < T >  int binarySearch(List< T > list , T key)      以二分查找法查找元素
        int binarySearch = Collections.binarySearch(list, "qwer");
        System.out.println(binarySearch);     //5  返回元素所在的索引

        //6.public static < T >  void  copy（List < T > list , List < T > src）    拷贝集合中的元素
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"00","00","00","00","00","00","00","00");
        Collections.copy(list2,list);
        System.out.println(list);   //[df, abc, bcd, 1234, asdf, qwer, qwer, zxcv]
        System.out.println(list2);  //[df, abc, bcd, 1234, asdf, qwer, qwer, zxcv]

        //7.public static < T > void  fill（List< T > list,T obj）   使用指定的元素填充集合
        Collections.fill(list2,"222");
        System.out.println(list2);  //[222, 222, 222, 222, 222, 222, 222, 222]

        //8.public static < T >  void max/min  （Collection < T > coll）     根据默认的自然排序获取最大/小值
        String max = Collections.max(list);
        System.out.println(max);        //zxcv

        //public static < T >  void swap (List  <?> list,  int i ,  int j)     交换集合中指定位置的元素
        System.out.println(list);   //[df, abc, bcd, 1234, asdf, qwer, qwer, zxcv]
        Collections.swap(list,3,6); //交换3索引和6索引上元素的位置
        System.out.println(list);   //[df, abc, bcd, qwer, asdf, qwer, 1234, zxcv]
    }
}

三、综合练习

（1）需求：班级里有N个学生，实现随机点名

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

public class Test01 {
    public static void main(String[] args) {
        //需求：班级里有N个学生，实现随机点名

        //1.创建集合并添加元素
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"范闲","范建","范统","杜子腾","杜琦燕","宋合泛","侯笼藤","朱益群","朱穆朗玛峰","袁明媛");

        //2.随机点名
        Random r = new Random();
        int index = r.nextInt(list.size());

        String name = list.get(index);

        System.out.println(name);

        //第二种随即方法
        Collections.shuffle(list);
        System.out.println(list.get(0));
    }
}

（2）需求：班级里有N个学生，要求：70%的概率随机到男生，30%的概率随机到女生

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

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

        //1.创建集合并添加元素
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,1,1,1,1,1,1,0,0,0);
        //2.打乱顺序
        Collections.shuffle(list);
        //3.从list集合中随机抽取0或1
        Random r = new Random();
        int index = r.nextInt(list.size());
        int number = list.get(index);
        
        //4.创建两个集合分别存储男生和女生,并添加数据
        ArrayList<String> boyList = new ArrayList<>();
        ArrayList<String> girlList = new ArrayList<>();
        Collections.addAll(boyList,"范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰");
        Collections.addAll(girlList,"袁明媛","杜琦燕","李猜","田蜜蜜");

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

（3）需求：班级里有N个学生，要求：被点到的学生不会被再次点到，如果班级里所有的学生都点过了，需要重新开启第二轮点名

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

public class Test03 {
    public static void main(String[] args) {
        /*（3）需求：班级里有N个学生，要求：被点到的学生不会被再次点到，如果班级里所有的学生都点过了，需要重新开启第二轮点名 */
        //1.创建集合并添加元素
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "范闲", "范建", "范统", "杜子腾", "杜琦燕", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰", "袁明媛");

        //创建新集合存储被删除的元素，用来开始第二轮点名
        ArrayList<String> temp = new ArrayList<>();

        //外循环表示点名的轮数
        for (int i = 0; i < 10; i++) {
            System.out.println("=====第" + i + 1 + "轮=====");
            //2.随机点名
            //获取集合的长度
            int count = list.size();
            for (int j = 0; j < count; j++) {
                Random r = new Random();
                int index = r.nextInt(list.size());
                String name = list.remove(index);
                System.out.println(name);
                temp.add(name);
            }
            //代码到这里，表示第一轮点名已经结束，
            list.addAll(temp);
            temp.clear();
        }
    }
}

（4）

（5） 需求

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

import java.util.*;
public class Test05 {
    public static void main(String[] args) {



        //1.创建双列集合Map并添加元素
        HashMap<String,ArrayList<String>> hm = new HashMap();
        //2.创建单列结合存储市的信息
        ArrayList<String> city1 = new ArrayList<>();
        Collections.addAll(city1,"南京市","扬州市","苏州市","无锡市","常州市");

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

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


        hm.put("江苏省",city1);
        hm.put("湖北省",city2);
        hm.put("河北省",city3);


        Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();
        for (Map.Entry<String, ArrayList<String>> entry : entries) {
            String key = entry.getKey();
            ArrayList<String> value = entry.getValue();
            StringJoiner sj = new StringJoiner(",","","");
            for (String city : value) {
                sj.add(city);
            }
            System.out.println(key+"<===>"+sj);
        }

    }
}

五、阶段练习：斗地主小游戏

（1）思路：

=》准备牌=》洗牌===》发牌===》排序

①版本1：在控制台简单输出

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;

public class game {

    static ArrayList<String> list = new ArrayList<>();

    static {
        //准备牌
        String[] color = {"♠", "♥", "♦", "♣"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2", "", "", ""};
        for (String c : color) {
            for (String n : number) {
                list.add(c + n);
            }
        }
        list.add("大王");
        list.add("小王");
    }

    public game() {
        //洗牌
        Collections.shuffle(list);


        //发牌
        //准备四个集合
        ArrayList<String> dipai = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();

        //遍历集合得到每一张牌
        for (int i = 0; i < list.size(); i++) {
            if (i <= 2) {
                dipai.add(list.get(i));
                continue;
            }
            if (i % 3 == 0) {
                player1.add(list.get(i));
            } else if (i % 3 == 1) {
                player2.add(list.get(i));
            } else {
                player3.add(list.get(i));
            }
        }
        //看牌
        look("刚脑壳",player1);
        look("大帅比",player2);
        look("蛋筒",player3);

    }
    public  void look(String name,ArrayList<String> list) {
        System.out.print(name + "： ");
        for (String poker : list) {
            System.out.print(poker);

        }
        System.out.println();
    }
}
//测试类
public class App {
    public static void main(String[] args) {
        //控制台版本的三个步骤：准备牌、洗牌、发牌

        new game();
    }
}


运行结果：
刚脑壳： ♣Q♠6♠大王♠♦2♠K♥7♠9♣♥4♦6♥6♠8♦4♠Q♥K♠5♥2♦K♥J
大帅比： ♣2♦9♥5♥10♣9♦8♣5♦A♦3♦7♦♣10♠2♠J♥9♦♥Q♣J♣A♥8♠A
蛋筒： 小王♦5♣6♥♣7♦♣8♥3♦Q♠10♣♣4♣♠7♦J♥♥A♣K♠♠4♣3

②版本二：给扑克牌进行排序

两种排序方式：

​ 方式一：利用序号进行排序

​ 方式二：给每一张牌计算价值

注意：

①如果原始数据的规律比较复杂，我们可以先手动让每一个数据跟唯一的序号产生对应的关系

②序号就是数字，规律比较简单，后续的所有操作，我们以序号为主

③当我们需要操作原始数据的时候，再通过序号找到原始数据即可

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class game {
    static HashMap<Integer,String> hm = new HashMap<>();
    static  ArrayList<Integer> list = new ArrayList<>();


    static {
        //准备牌
        int serialNumber = 1;
        String[] color = {"♠", "♥", "♦", "♣"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        for (String n : number) {
            for (String c : color) {
                hm.put(serialNumber,c+n);
                serialNumber++;
                list.add(serialNumber);
            }
        }
        hm.put(serialNumber,"小王");
        list.add(serialNumber);
        serialNumber++;
        hm.put(serialNumber,"大王");
        list.add(serialNumber);

    }
        public game(){
            //洗牌
            Collections.shuffle(list);


            //发牌
            TreeSet<Integer>diapi = new TreeSet();
            TreeSet<Integer>player1 = new TreeSet();
            TreeSet<Integer>player2 = new TreeSet();
            TreeSet<Integer>player3 = new TreeSet();

            for (int i = 0; i < list.size(); i++) {
                if(i<=2){
                    diapi.add(list.get(i));
                    continue;
                }
                if (i % 3 == 0){
                    player1.add(list.get(i));
                } else if (i % 3 == 1) {
                    player2.add(list.get(i));
                }else{
                    player3.add(list.get(i));
                }
            }

            //看牌
            lookPoker("底牌",diapi);
            lookPoker("刚脑阔",player1);
            lookPoker("蛋筒",player2);
            lookPoker("大帅比",player3);
        }
    
    public void lookPoker(String name,TreeSet<Integer>ts){
        System.out.print(name+": ");
        for (int serialNumber : ts) {
            System.out.print(hm.get(serialNumber)+" ");
        }
        System.out.println();
    }
}

③版本3：第二种排序方式

利用双列集合给扑克牌指定价值

package banben3;

import java.util.*;

public class game {
    static ArrayList<String> list = new ArrayList<>();

    static HashMap<String,Integer> hm = new HashMap();

    static {
        //准备牌
        String[] color = {"♠", "♥", "♦", "♣"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        for (String c : color) {
            for (String n : number) {
                list.add(c + n);
            }
        }
        list.add(" 大王");
        list.add(" 小王");
    }

    public game() {
        //洗牌
        Collections.shuffle(list);


        //发牌
        //准备四个集合
        ArrayList<String> dipai = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();

        //遍历集合得到每一张牌
        for (int i = 0; i < list.size(); i++) {
            if (i <= 2) {
                dipai.add(list.get(i));
                continue;
            }
            if (i % 3 == 0) {
                player1.add(list.get(i));
            } else if (i % 3 == 1) {
                player2.add(list.get(i));
            } else {
                player3.add(list.get(i));
            }
        }
        //指定牌的价值
        //牌上的数字到Map集合中判断是否存在
        //不存在获取，本身的数字就是价值
        //存在，获取价值
        hm.put("J",11);
        hm.put("Q",12);
        hm.put("K",13);
        hm.put("A",14);
        hm.put("2",15);
        hm.put("小王",16);
        hm.put("大王",17);

        //排序
        order(dipai);
        order(player1);
        order(player2);
        order(player3);

        //看牌
        look("底牌",dipai);
        look("刚脑壳",player1);
        look("大帅比",player2);
        look("蛋筒",player3);



    }
    public void order(ArrayList<String> list){
        Collections.sort(list, ( o1,  o2) ->{
                //计算o1的花色和价值
                String color1 = o1.substring(0);
                int value1 = getValue(o1);
                //计算o1的花色和价值
                String color2 = o1.substring(0);
                int value2 = getValue(o2);

                //比较o1和o2的价值，
                int i = value1 - value2;
                //如果价值一样按花色排序
                return i == 0 ? color1.compareTo(color2) : i;
            }
        );
    }

    public int getValue(String poker){
        //获取数字
        String number = poker.substring(1);
        //拿着数字到map集合中判断是否存在
        //如果存在直接获取价值
        if(hm.containsKey(number)){
            return  hm.get(number);
        }else{
            //如果不存在直接类型转换
            return  Integer.parseInt(number);
        }
    }
    public  void look(String name,ArrayList<String> list) {
        System.out.print(name + "： ");
        for (String poker : list) {
            System.out.print(poker);

        }
        System.out.println();
    }
}

//测试类
package banben3;

public class App {
    public static void main(String[] args) {
        new game();
    }
}

//运行结果：
底牌： ♣10♠Q♠2
刚脑壳： ♦3♦4♠5♠6♠7♣7♥8♣9♠9♦10♥10♥J♣K♣A♠A♦A♥A
大帅比： ♣3♠4♥5♣8♠8♦8♥9♠10♠J♦J♥Q♦K♥K♠K♣2 小王 大王
蛋筒： ♥3♠3♣4♥4♦5♣5♦6♣6♥6♥7♦7♦9♣J♣Q♦Q♦2♥2
kinbow_0923
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合——java学习笔记
longwanhu的博客
04-29 1527
集合，又称容器，用于存储对象（集合的元素），且长度可变，具体可以是集合类的对象，也可以是集合接口的对象（多态）。 Collection接口 collection接口的动态方法 创建对象：Collection<类型实参> col = new ArrayList<>(); //多态 引用对象的方法 col.add(元素) == 添加元素到集合，成功则返回true col.remove(元素) == 删除集合中的元素，成功则返回true col.clear; == 清空集合中的元素
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
Java学习笔记
Piglett的博客
12-30 958
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java学习笔记十七——集合类详细总结各自对比
Pandafz的博客
10-12 3910
一、Java集合介绍
Collection集合 --java学习笔记
m0_71386740的博客
03-29 1325
常见List系列集合—— ArrayList、LinkdList：有序、可重复、有索引运行结果。
Java学习笔记——集合
m0_53127728的博客
03-14 1673
集合的概念 概念 在java.util包中，可以存放对象的容器 集合中只能存放对象 集合中存放的是多个对象的引用，对象本身还是存放在堆内存中 集合中可以存放不同类型、不限数量【size():int】的数据类型的数据，如果不使用泛型约束存储数据的类型，则默认Object 数组和集合的比较 数组 集合 定长 变长存储数据的容器，容量可以动态改变 不是面向对象的 弥补了数组的缺陷，比数组更灵活 存放简单类型和引用类型的数据 存放的都是对象的引用 无法判断存储的元素个数，length
java学习笔记11--集合总结
GarfieldEr007的专栏
03-22 1180
java学习笔记系列: java学习笔记10--泛型总结  java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 java学习笔记6--类的继承、Object类 java学习笔记5--类的方法  java学习笔记4--对象的初始化与回收 java学习笔记3--类与对象的基础  java学习笔记
Java 集合学习笔记：HashMap - 迭代器
灵台方寸山斜月三星洞
12-24 1893
，current 才有几率非 null。如果该Spliterator为ORDERED，则操作将按遇到顺序对下一个元素执行。，则按遇到顺序执行操作。之前或中间，应该总是返回相同的结果。作为其他几个可拆分迭代器的基类，实现了公用的方法。，直到所有元素都处理完毕或该操作抛出异常。注意：是按哈希表拆分，并不理会桶中结点的个数。，8个特性每个特性占一位，可以组合。如果存在剩余元素，则对其执行给定操作。算出来的元素个数，肯定是不准确的。，无法实例化，所以只能作为其他类的。尝试拆分，如果可拆分，创建一个新的。
Java 集合学习笔记：ArrayList
灵台方寸山斜月三星洞
10-03 3654
ArrayList 是 List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是非线程安全的。）List的数组实现。因为底层数据解构是数组，所以特点是连续内存空间，根据索引操作。优势在读，频繁写操作相对吃亏。有两个性能消耗点：2.1. 插入/删除时，当前元素之后的所有元素需要整体平移。2.2. 空间不足时的反复自动扩容。
《Java面向对象程序设计》学习笔记
weixin_45940369的博客
07-31 8077
备考某学校的 817程序设计Java 专业课，在学习耿祥义老师的《Java面向对象程序设计（第3版）-微课视频版》。 发一些自己的学习笔记到专栏（一篇文章对应书上一章），可能不会及时更新，见谅。 笔记可能有错误，看看就得，现在懒得浓缩精炼了，以后再说吧🧐
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 500
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
jiaowenjie的专栏
08-06 269
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 489
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 567
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
时光不等人：java每日一练
m0_67187271的博客
08-05 1045
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Servlet(2)
xjdkxnhcoskxbco的博客
08-04 787
这个注解可以用来修饰一个Servlet类，可以简化配置，替代Web.xml中 的servlet配置。
Spring事务
最新发布
c1tenj2的博客
08-07 382
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
java selenium 设置代理，允许在其他环境中使用不同的IP访问
huanghm88的专栏
08-05 482
此代码以Chrome浏览器为例，如果你使用其他浏览器，你需要相应地调整代码。另外，你需要下载适用于你的操作系统的Chrome浏览器驱动，并将路径替换为。在Java Selenium中设置代理可以使用。替换为其他环境中要访问的IP地址。替换为实际的代理IP和端口，并将。
【SpringBoot】数据验证之分组校验
Jacker
08-05 359
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
Java学习笔记：面向对象与集合框架详解
在Java学习笔记中，首先介绍了面向对象的基础，包括集合框架和Oracle数据库编程。集合框架是Java中处理对象集合的重要工具，包括ArrayList、LinkedList、HashMap等数据结构。Oracle编程部分则强调了Oracle数据库的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值