需求：使用 SSH 框架的 Java web 项目想要和第三方公司集成 CAS 单点登录，接入到第三方的 OA 系统中，（在网上查阅一些资料，基本都是 CSDN 的帖子，尝试添加过滤器的方案未能实现（问题在过滤后跳转这块未能解决））向社区大佬们求助，有做过这方面的，或者总结过这方面的给个链接什么的非常感谢

StringBuffer类String类是在所有开发项目开发之中一定会使用的一个功能类，并且这个类拥有如下功能每个字符串的常量都属于一个String类匿名对象，并且不能修改；String类有两个常量池：静态常量池、运行常量池；String类对象实例化建议直接使用赋值的形式完成，这样可以直接将对象保存在对象池中方便下次重用；虽然String类很好用，但是我们发现它也有弊端，就是内容不允许频繁修改，所以为了解决问题，我们提供了StringBuffer类StringBuffer 并不像String类那样拥有两种实例化方法，必须要想普通方法一样调用方法，这个时候可以考虑一下方法构造方法：public StringBuffer();数据追加：public StringBuffer append(数据类型、变量)，相当于字符串中的“+”操作；构造方法：public StringBuffer(String str)，相当于初始化范例：观察String与StringBuffer对比 String类对象引用传递public class JavaAPIDemo { public static void main(String[] args) { // TODO Auto-generated method stub String str ="hello"; change(str); System.out.println(str); } public static void change(String temp) { temp+="word"; } }str内的值没有发生改变StringBuffer类对象引用传递public class JavaAPIDemo { public static void main(String[] args) { // TODO Auto-generated method stub StringBuffer buf =new StringBuffer("Hello "); change(buf); System.out.println(buf); } public static void change(StringBuffer temp) { temp.append("World"); } }buf内的值发生了改变 由此可见String内的值不能改变，StringBuffer内的值可以改变，这就是两这最主要的区别实际上大部分的情况下，很少会出现有字符串内容的改变，这种改变指的并不是针对静态常量池的改变； 范例：分析一下已有问题public class JavaAPIDemo { public static void main(String[] args) { String strA="www.baidu.com"; String strB="www."+"baidu."+"com"; System.out.println(strA==strB); } }在这个时候strB对象里面的内容并不是真正改变，或者更严格的将，对于现在的strB当程序编译的时候就相当于下面形式buf.append("www.").append("baidu.").append("com");也就是说所有的”+“在我们编译后都变为了StringBuffer中的append（）方法，并且在程序中String类对象和StringBuffer类对象本来就可以互相转换String类对象变为StringBuferr可以依靠StringBuffer类构造方法或者使用append()方法所以类的对象都可以通过toString（）方法将其变为String类型在StringBuffer类里面除了可以支持字符串内容修改之外，实际上也添加了很多String所不具有的方法插入数据：public StringBuffer insert(int offest,boolean b);public class JavaAPIDemo { public static void main(String[] args) { StringBuffer buf=new StringBuffer(); buf.append(".com").insert(0,"www.").insert(4, "baidu"); System.out.println(buf); } }删除指定范围的数据：public StringBuffer delete(int start,int end);public class JavaAPIDemo { public static void main(String[] args) { StringBuffer buf=new StringBuffer(); buf.append("Hello World!").delete(6, 12); System.out.println(buf); } }-字符串内容反转：public StringBuffer reverse();public class JavaAPIDemo { public static void main(String[] args) { StringBuffer buf=new StringBuffer(); buf.append("Hello World!"); System.out.println(buf.reverse()); } }实际上与StringBuffer类还有一个类似的功能类：StringBuilder类，这个类是在JDK1.5之后提供的，该类中提供的方法与StringBuffer类相同，区别在于StringBuffer类中的方法属于线程安全的，全都使用了synchronized关键字进行标注，而StringBuilder类属于非线程安全的面试题：请解释String、StringBuffer、StringBuilder的主要区别？String类是字符串的首选类型，其最大的特点是内容不允许修改；StringBuffer与StringBuilder类的内容允许修改；StringBuffer是在JDK1.0的时候提供的，属于线程安全操作，而StringBuilder是在JDK1.5的时候提供的不是线程安全操作

是否是因为gsjbcd4.jar中的 org.postgresql.ds.common.BaseDataSource getUrl为private 导致与springboot2.6.3中org.springframework.boot.jdbc.DataSourceBuilderPostgresDataSourceProperties BaseDataSource::getUrl 报错

1、UserAgent的简介      User Agent即用户代理，简称为UA，是一种特殊的字符串头，会使得服务器能够识别客户使用的操作系统、版本、CPU 类型、浏览器版本、浏览器渲染引擎、浏览器语言、浏览器插件等等，是不感觉很厉害的样子，通过这个串头，我们就可以进行获得很多的信息，从而进行相关业务的处理。      在server抓包的时候，会经常碰到直接使用wget或者curl被服务器拒绝的状况，这时候只需要通过增加一个user-agent串头进行模拟就可以通过了。2、查看User Agent的方法2.1 通过js获取      在浏览器地址栏中输入以下代码navigator.userAgent      或者window.navigator.userAgent      进行获取相关信息，获取后的信息会是这个样子的:'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/xxx (KHTML, like Gecko) Chrome/xxx Safari/xxx'2.2 通过Chrome开发者模式获取      打开chrome开发者模式（快捷键是F12），或者在网页上右键选择检查（快捷键是Ctrl+Shift+I），在Network栏中找到需要查询的请求，在Headers的最后可以看到User-Agent的相关信息了。这种方法可以通过模拟机型，在选择模拟的设备机型后，找到相应的请求就可以找到这类机型所对应的User-Agent信息了。3、User-Agent的应用3.1 User-Agent在js中的应用      其中判断是否是微信环境，通常我们会通过window.navigator.userAgent获取User-Agent串头后进行转小写，然后通过正则匹配/MicroMessenger/i是否为'micromessenger'来判断是否是微信内部浏览器从而判断是否是微信环境，这里如果不加window的话Android机可能会判断不了是否是微信，所以还是加上比较保险。function isWX() { var ua = window.navigator.userAgent.toLowerCase(); if (ua.match(/MicroMessenger/i) == 'micromessenger') { return true; } else { return false; }} 3.2 User-Agent在java中的应用       通常我们会通过reques请求中获取header中的user-Agent元素，然后进行转小写，在获取到信息之后，我们就可以通过这个User-Agent串头信息来进行环境判断了，其中包含micromessenger则为微信内部浏览器标识，即微信内部环境，在微信内部环境又包括小程序和企微，我们通过判断User-Agent串头信息是否包含wxwork元素来判断是否为企微环境，通过判断User-Agent串头信息是否包含miniprogram来判断是否为小程序环境下。String userAgent = request.getHeader("user-agent").toLowerCase();if (userAgent.indexOf("micromessenger") < 0) {// 非微信 return true;} else{ if (userAgent.indexOf("wxwork") > 0) { // 企业微信客户端 return true; }else if(userAgent.indexOf("miniprogram") > 0){//小程序下 return true; }}以上就是User-Agent的相关应用和总结。

1、pom的简介         pom是Project Object Model的简称，即项目对象模型。它是Maven项目中的XML配置文件。张什么样呢？就是这样的：pom.xml。主要作用是管理源代码、版本信息、配置文件信息、开发者的信息和角色信息、项目授权、url、继承和项目使用的依赖管理等等，一个Maven项目必须包含pom.xml配置文件。 其中各个pom依赖只是为了聚合工程或传递依赖用的。2、Maven项目打包类型        maven项目的打包类型有三种：pom、jar、war。会通过packing标签来进行标识，默认是jar类型，具体如下：       pom表示父类型都为pom类型。       jar表示内部调用或者是作服务使用。       war表示需要部署的项目。2.1 jar类型介绍 2.1.1 扩展名为.jar（Java Application Archive简写）的文件，其中包含Java类的普通库、资源（resources）、辅助文件（auxiliary files）等。 2.1.2 jar包是java打的包，一般只包括一些编译后class文件和一些部署文件。 2.1.3 jar包通常是开发时要引用通用类，打成包便于存放管理。 2.1.4 常用于内部、接口、服务部署等。 2.2 war类型 2.2.1 扩展名为.war（Web Application Archive）的文件，包含全部Web应用程序。        2.2.2 war包可以理解为javaweb打的包，是一个web模块，包括写的代码编译成的class文件，依赖的包，配置文件，所有的网站页面，包括html，jsp等等。一个war包即为一个web项目，里面是项目的所有东西。 2.2.3 war包需要发布到一个容器里面，比如Tomcat需要将war包放置到它的webapps目录下，启动Tomcat就可以自动解压到你的web目录。         2.2.4 war类型是Sun公司提出的一种Web应用程序格式，与jar类型类似，也是许多文件的一个压缩包。这个包中的文件按一定目录结构来组织：通常其根目录下包含有Html和Jsp文件或者包含这两种文件的目录，另外还会有一个WEB-INF目录，这个目录很重要。通常在WEB-INF目录下有一个web.xml文件和一个classes目录，web.xml是这个应用的配置文件，而classes目录下则包含编译好的Servlet类和Jsp或Servlet所依赖的其它类（JavaBean）。 2.3 pom类型2.3.1 项目中使用maven进行模块管理时，每个模块下对应都会有一个pom文件，因为pom文件中维护了各模块之间的依赖和继承关系。          2.3.2 使用maven进行模块划分管理时，一般都会有一个父级项目，pom文件除了GAV(groupId, artifactId, version)是必须要配置的，另一个重要的属性就是packaging打包类型，所有的父级项目的packaging都为pom（可以到pom.xml文件里面进行手动配置），packaging默认是jar类型，如果不作配置，maven会将该项目打成jar包。 3.Maven项目的多模块        Maven项目的多模块（multi-modules）项目，也被称为聚合项目，通常由一个父模块和若干个子模块构成。其中，父模块必须以pom打包类型，通过标签标识出所有下属的子模块。其中的每个module，都是另外一个Maven项目，并且子类项目的packaging值只能是war或者jar。父模块的POM示例如下：pom test-one test-two test-three 以上就是Maven项目的知识点的简单归纳汇总。

一、 关键字和保留字关键字（keyword）的定义和特点定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）特点：关键字中所有字母都为小写根据分类：数据类型：Boolean、int、long、short、byte、float、double、char、class、interface流程控制：if、else、do、while、for、Switch、case、default、break、continue、return、try、catch、finally修饰符：  public、protected、private、final、void、static、abstract、transient、synchronized、volatile、native动作：package、import、throw 、throws、extends、implements、this、supper、instanceof、new保留字：Java保留字：现有Java版本尚未使用，以后可能会作为关键字使用。命名【标识符】时要避免使用这些保留字goto、const二、标识符什么是标识符Java对各种变量，方法和类等要素命名时使用的字符串序列称为标识符技巧：凡是自己可以 起名字的地方都叫标识符定义合法标识符规则由26个英文字母大小写，0-9，_或$组成数字不能包含空格不可以使用关键字和保留字，但能包含关键字个保留字Java中严格区分大小写，长度无限制Java 中名称命名规范包名：多单词组成时所有字母都小写：xxxxyyyy类名：接口名：多单词组成时，所有单词首字母读大写 ： XxxYyy变量名：方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz常量名:所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_AAA注意点：注意1：在起名字时，为了提高阅读性，要尽量有意义注意2：Java采用Unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用三、变量变量的声明与使用变量的概念： 内存中的一个存储区域该区域的数据可以在同一类型范围内不断变化变量是程序中最基本的存储的单位。包含变量类型  变量名和存储的值变量的作用：用于在内存中保存的数使用变量的注意：Java中每个变量必须先声明，后使用使用变量名来访问这块区域的数据变量的作用域：其定义所在的一对{}内变量只有在其作用域才有效同一个作用域内，不能定义重名的变量声明变量：语法：数据类型  变量名称 int   var；变量的赋值：var =10；声明和赋值变量语法：数据类型  变量名 =初始值int var =10；补充：变量的分类  按声明的位置的不同在方法体外，类体内声明的变量称为成员变量在方法体内，声明的变量称为局部变量所有变量：成员变量、局部变量成员变量和局部变量的区别：成员变量：实例变量（不以static修饰）；类变量（以static修饰）局部变量：形参（方法、构造器中定义的变量）；方法局部变量（在方法内定*义）；代码块局部变量（在代码块内定义）注意:二者在初始值方面的异同异:局部变量除形参外，都需要显式初始化同： 都有生命周期基本数据类型变量的分类  按数据类型对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。数据类型包括：基本数据类型和引用数据类型基本数据类型：数值型（整数类型：byte、short、int、long；浮点类型：float、double）、字符型char、布尔型boolean引用数据类型：类class、接口interface、数组 【】整数类型：byte、short、int、longJava各整数类型有固定的表数范围和字段长度，不受OS的影响，以保证Java程序的可移植性。Java的整型常量默认为int型，声明long型常量须后加“l”或‘L’Java程序中变量通常声明为int 型，除非不足以表示较大的数，才使用longbit 计算机中的最小存储单位，byte计算机中基本存储单位下面一个小练习：class VariableTest1 {    public static void main(String[] args) {        //整型：byte（1字节=8bit）  short（2字节）  int（4字节）  long（8字节）        //byte 范围： -128~127         byte b1 = 12;        byte b2 = -128;        //b2=128 编译不通过        System.out.println(b1);        System.out.println(b2);// ② 声明long型变量，必须以“1”或“L”结尾        short s1 = 128;        int i1 = 12345;        long l1 = 345678586;        System.out.println(l1);    }}浮点类型：float 、double 与整数类型类似，Java浮点类型也有固定的表数范围和字段长度，不受具体的操作系统影响。浮点型常量有两种表示形式：十进制数形式：如：5.12 512.0f 0.512 (必须有小数点）科学计数法形式：如：5.12e2 512E2 100E-2float ：单精度，尾数可以精确到7有效数字。很多情况下，精度很难满足需求。double ：双精度，精度是float 的两倍。通常采用此类型。Java的浮点型常量默认为double 型，声明float 型常量，须后加“ f ”或“ F ” 字符类型：charchar 型数据用来表示通常意义上的“字符”（2字节）Java中所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。字符型变量的三种形式：字符常量是用单引号（‘’）括起来的单个字符、例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;Java中还可以使用转义字符‘ / ’ 来将其后字符转变为特殊字符型常量 。例如：char c3 = ‘\n’;‘\n’ 表示换行符直接使用Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如： \u000a 表示\n。char类型是可以进行运算的。因为它都对应有Unicode码。小练习：编程就需要多动手，看会了理解了还需要多多动手class VariableTest1 {    public static void main(String[] args) {         double d1 = 12.3;        System.out.println(d1 + 1);         //定义float类型变量时，变量要以"f" 或"F"结尾        float f1 = 12.3f;        System.out.println(f1);         //② 通常，定义浮点型变量时，使用double变量        //3. 字符型：char(1字符=2字节)        //① 定义char型变量，通常使用一对''        char c1='a';        System.out.println(c1);         char c2 = '1';        char c3 = '中';        char c4 = '&';        System.out.println(c2);        System.out.println(c3);        System.out.println(c4);         //② 表示方式：1.声明一个字符；2.转义字符；3.直接使用Unicode值来表示字符型常量        char c5='\n';//换行符        c5='\t';//制表符        System.out.println("hello"+c5);        System.out.println("world");         char c6= '\u0123';        System.out.println(c6);        char c7 = '\u0043';        System.out.println(c7);    }}布尔类型： Boolean Boolean 类型用来判断逻辑条件，一般用于程序流程控制：if 条件控制语句while 循环控制语句do-while 循环控制语句for 循环控制语句boolean类型数据只允许取值true 和 false ，这点和C语言 不同。Java虚拟机中没有任何供Boolean值专用的字节码指令，Java语言表达所操作的Boolean 值，在编译之后都使用Java虚拟机中的int 类型数据类型代替：true 用1 表示，false 用0表示。代码示例：class VariableTest2 {    public static void main(String[] args) {//4. 布尔型：boolean//① 只能取两个值之一：true . false//② 常常在条件判断. 循环结构中使用        boolean bb1 = true;        System.out.println(bb1);         boolean isMarried=false;        if(isMarried){            System.out.println("禁止入内！");        }else {            System.out.println("可以参观！");        }    }}基本数据类型转换自动类型转换：容量小的类型自动转换为容量大的数据类型，数据类型按容量大小排序为：有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再 进行计算。byte、short、char之间不会相互转换，他们三者在计算时首先转换为int类型。boolean类型不能与其它数据类型运算。当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为 字符串(String)类型。  代码示例：class VariableTest3{    public static void main(String[] args) {        byte b1=2;        int i1=129;         int i2=b1+i1;        long l3=b1+i1;        System.out.println(i2);        System.out.println(l3);         float f = b1 + i1;        System.out.println(f);//***************特别的**************************        char c1 = 'a'; //字符’a‘对应的数字是97        int i3=10;        int i4 = c1 + i3;        System.out.println(i4);    }}字符串类型：StringString不是基本数据类型，属于引用数据类型使用方式与基本数据类型一致。例如：String str= “abcd”;一个字符串可以串接另一个字符串，也可以直接串接其它类型的数据。代码示例：String类型变量的使用1. String属于引用数据类型2. 声明String类型变量时，使用一对""3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算；+4. 运算的结果依然是String类型class  StringTest{    public static void main(String[] args) {        String s1="hello";        System.out.println(s1);        String s2 = "a";        String s3 = "";// char c = ''; //编译不通过//*******************************        int number = 1001;        String numberStr = "学号:";        String info = numberStr + number; //连接运算        boolean b1 = true;        String info1 = info + true;        System.out.println(info1);    }}练习：String str1 = 4; //判断对错：noString str2 = 3.5f + “”; //判断str2对错：yesSystem.out.println(str2); //输出：”3.5”System.out.println(3+4+“Hello!”); //输出：7Hello!System.out.println(“Hello!”+3+4); //输出：Hello!34System.out.println(‘a’+1+“Hello!”); //输出：98Hello!System.out.println(“Hello”+‘a’+1); //输出：Helloa1强制类型转换自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换 符：()，但可能造成精度降低或溢出,格外要注意。通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成 基本类型。如：String a = “43”; inti= Integer.parseInt(a);boolean 类型不可以转换为其它的数据类型。练习：判断是否能通过编译short s = 5;s = s-2; //判断：nobyte b = 3;b = b + 4;//判断：nob = (byte)(b+4);//判断：yeschar c = ‘a’;int i = 5;float d = .314F;double result = c+i+d; //判断：yesbyte b = 5;short s = 3;short t = s + b;//判断：no————————————————版权声明：本文为CSDN博主「Serendipity的人」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/m0_57448314/article/details/126239827

一、栈相关基础概念① 先进先入。不是所有进完才可以出，入的同时也可以出。②用数组实现栈：入栈和出栈的时间复杂度是O(1)③用单链表实现栈：头插法： 入栈和出栈 O(1)尾插法：入栈和出栈 O(n)所以用单链表实现栈时一定要头入头出。④方法  push、peek、pop、size、empty二、队列相关基础概念① 队尾进，队头出。底层是个双向链表。②Queue是个接口，在实例化时必须实例化LinkedList的对象。        Queue<Integer> q = new LinkedList<>();③用单链表实现队列  ok④ 用数组实现队列 。必须使用循环数组。后面3.6有代码实现逻辑。④方法  offer、poll、peek、size、isEmpty三、OJ题3.1 不可能的出栈顺序核心：入的时候同时可以出3.2 中缀表达式中缀转后缀：按照自己的理解，从左往右加括号，先乘除后加减。再逐步将运算符移到括号后，移                        掉所有的(),就是rug计算中缀表达式的值：遇见数字入栈，遇到运算符就从栈出两个元素。先出的放在运算符的后面，后出栈的放在运算符前面。将计算结果再入栈。3.3 括号匹配 OJ链接：20. 有效的括号 - 力扣（LeetCode）实现代码：class Solution {    public boolean isValid(String s) {        Stack<Character> stack = new Stack<>();        for(int i = 0 ;i<s.length();i++){            char ch = s.charAt(i);            // 遇见左括号就入栈，注意是单引号            if(ch == '[' || ch == '{' || ch == '('){                stack.push(ch);            }else{                // 否则，就与栈顶元素进行比较                // 如果栈是空的，并且遇见的是右括号，直接返回false                // 判断栈空 不能使用stack==null                if(stack.isEmpty()){                    return false;                }else{                    char peek = stack.pop();                    if( (peek == '[' && ch == ']') || (peek == '{' && ch == '}') || (peek == '(' && ch ==')')){                        continue;                    }else{                        return false;                    }                }            }        }        if(stack.isEmpty()){            return true;        }else{            return false;        }    }}3.4 逆波兰表达式求值 OJ链接：150. 逆波兰表达式求值 - 力扣（LeetCode）实现代码：class Solution {     public int evalRPN(String[] tokens) {        Stack<Integer> stack = new Stack<>();        HashSet<String> set = new HashSet<>();        set.add("+");        set.add("-");        set.add("*");        set.add("/");        for(String str:tokens){            // 如果遇见的是不是运算符，是数字，就入栈            if(!set.contains(str)){                stack.push(Integer.parseInt(str));            }else{                // 遇见运算符，就弹出两个数字                int back = stack.pop();                int front = stack.pop();                HashMap<String,Integer> hashMap = new HashMap<>();                hashMap.put("+",front+back);                hashMap.put("-",front-back);                hashMap.put("*",front*back);                //  注意：back有可能为 0                 if(back != 0){                    hashMap.put("/",front/back);                }//计算结果，将结果入栈                int result = hashMap.get(str);                stack.push(result);            }        }        return stack.peek();    }}3.5 出栈入栈次序匹配 OJ链接：栈的压入、弹出序列_牛客题霸_牛客网 (nowcoder.com) 解题思路：要点1：定义一个pos，记录popA数组中元素的位置。要点2：遍历pushA，依次将pushA中的元素入栈，判断栈顶元素和popA中的元素是否相同，相同就出栈，并观察popA中的下一个元素是否和新栈顶元素相等。如果不相等，入栈pushA的下一个元素实现代码：import java.util.*;import java.util.ArrayList; public class Solution {    public boolean IsPopOrder(int [] pushA,int [] popA) {        Stack<Integer> stack1 = new Stack();        int pos = 0;        for(int i=0;i<pushA.length;i++){            stack1.push(pushA[i]);            while(!stack1.isEmpty() && stack1.peek() == popA[pos]){                stack1.pop();                pos++;            }        }        if(stack1.empty()){            return true;        }        return false;    }}3.6 循环队列 OJ链接：622. 设计循环队列 - 力扣（LeetCode）​ 解题思路：要点1：为了区分队列空和满，约定：        rear指向数组最后一个元素的下一个位置，下一次添加数据，可以直接往rear位置上放        front == rear 队列空        rear的下一个元素是front，队列满了。（rear+1）%elem.length要点2：返回队列顶部元素，返回front所在位置元素，front向前移。为了保证front可以从3移到1，front=（front+1）%elem.length要点3：返回队列最后一个元素。如果rear=0，返回elem[elem.length-1].如果rear不为0，就返回elem[rear-1]实现代码：class MyCircularQueue {     private int[] elem;    private int front;    private int rear;     public MyCircularQueue(int k) {        elem = new int[k+1];    }        public boolean enQueue(int value) {        if(isFull()){            return false;        }        if(isEmpty()){            elem[0] = value;            front = 0;            rear = 1;            return true;        }        elem[rear] = value;        rear = (rear+1) % elem.length;        return true;    }        public boolean deQueue() {        if(isEmpty()){            return false;        }        front = (front+1) % elem.length;        return true;    }        public int Front() {        if(isEmpty()){            return -1;        }        return elem[front];     }        public int Rear() {        if(isEmpty()){            return -1;        }        if(rear == 0){            return elem[elem.length-1];        }        return elem[rear-1];     }        public boolean isEmpty() {        return rear == front;     }        public boolean isFull() {        if((rear+1)%elem.length == front){            return true;        }        return false;     }}3.7 用队列实现栈 OJ链接：225. 用队列实现栈 - 力扣（LeetCode）解题思路：要点1：有两个队列要点2：第一次放push数据时，默认放到队列1中要点3：添加元素时，添加到不为空的队列中，这样才能保证顺序要点4：出栈—》获得栈顶元素—》栈后入先出—》弹出最后一个入栈的元素因此，需要找出最后一个入队列的元素。将队列的前n-1个元素，放到另外一个队列中，剩下的就是最后一个入队列的元素实现代码：class MyStack {     private Queue<Integer> qu1;    private Queue<Integer> qu2;     public MyStack() {        qu1 = new LinkedList<>();        qu2 = new LinkedList<>();    }        public void push(int x) {        // 如果队列2是空的，就往队列1里面放。原因：只有放在不为空的队列中顺序才不会乱        if(qu2.isEmpty()){            qu1.offer(x);        }else{            qu2.offer(x);        }            }        public int pop() {        if(empty()){            return -1;        }        if(qu1.isEmpty()){            // 队列2不为空，队列先进先出，将队列前size-1个元素放到队列1中，剩下的最后一个元素就是最后入队列的，也就是栈的第一个元素，将其返回            int size = qu2.size();            while(size > 1){                qu1.offer(qu2.poll());                size--;            }            int result = qu2.poll();            return result;        }        if(qu2.isEmpty()){            int size = qu1.size();            while(size > 1){                qu2.offer(qu1.poll());                size--;            }            int result = qu1.poll();            return result;        }        return -1;    }    public int top() {        if(empty()){            return -1;        }        if(qu1.isEmpty()){            int size = qu2.size();            while(size > 1){                qu1.offer(qu2.poll());                size--;            }            int result = qu2.poll();            qu1.offer(result);            return result;        }        if(qu2.isEmpty()){            int size = qu1.size();            while(size > 1){                qu2.offer(qu1.poll());                size--;            }            int result = qu1.poll();            qu2.offer(result);            return result;        }        return -1;     }        public boolean empty() {        return qu1.isEmpty()&&qu2.isEmpty();    }}3.8 用栈实现队列 OJ链接：232. 用栈实现队列 - 力扣（LeetCode）​ 解题思路：要点1：有两个栈。存数据都存到栈1中，取数据都从栈2中取。要点2：取数据时，如果栈2是空的，就把栈1中的元素全放到栈2中。再从栈2中取。实现代码：class MyQueue {    private Stack<Integer> stack1;    private Stack<Integer> stack2;    public MyQueue() {        stack1 = new Stack();        stack2 = new Stack();    }        public void push(int x) {        stack1.push(x);    }        public int pop() {        if(empty()){            return -1;        }        if(stack2.empty()){            while(!stack1.empty()){                stack2.push(stack1.pop());            }        }        return stack2.pop();    }        public int peek() {        if(empty()){            return -1;        }        if(stack2.empty()){            while(!stack1.empty()){                stack2.push(stack1.pop());            }        }        return stack2.peek();     }        public boolean empty() {        return stack1.empty()&&stack2.empty();     }}3.9 最小栈 OJ链接：155. 最小栈 - 力扣（LeetCode） 解题思路：要点1：创建两个栈。一个栈存放所有的元素，另外一个栈存放栈中最小的元素要点2：第一次push数据，数据存放在两个栈中要点3：之后存放数据，该数据小于等于最小栈的栈顶元素，才能存放到最小栈和stack中。否则，就只能存放到stack中实现代码：class MinStack {    public Stack<Integer> stack;    public Stack<Integer> minStack;     public MinStack() {        stack = new Stack();        minStack = new Stack();    }        public void push(int val) {        // 如果第一次放元素，往stack和minStack里都放        if(stack.empty() && minStack.empty()){            stack.push(val);            minStack.push(val);            return;        }        // 如果存放的数据比minStack元素小，该元素同时放到两个栈中        if(val <= minStack.peek()){            stack.push(val);            minStack.push(val);            return;        }else{            // 否则，就只往stack中放            stack.push(val);            return;        }    }        public void pop() {        int peek = stack.pop();        if(peek == minStack.peek()){            minStack.pop();        }    }        public int top() {        if(stack.empty()){            return -1;        }        return stack.peek();     }        public int getMin() {        if(minStack.empty()){            return -1;        }        return minStack.peek();     }}————————————————版权声明：本文为CSDN博主「刘减减」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/weixin_44258092/article/details/126240946

如何判断一个整型数字是不是对称数字(用纯C语言实现)比如输入是1569651是一个对称数字，而25则不是一个对称数字。有两种判断方法：1. 将输入的数字分解成一个个数字，然后进行判断。2. 将数字的高地位进行互换，然后判断互换后的数与原来的数是否相等。 方法一：数字分解法 1 /*将input输入，输出为一个output数组和input的位数*/ 2 int decompose(int input, int* output) 3 { 4 int* decomposeResult = output; 5 int count = 0, temp = input; 6 7 while(1) 8 { 9 int quotient = temp / 10;10 int remainder = temp % 10;11 if((quotient != 0) || ((quotient == 0) && (remainder != 0)))12 {13 decomposeResult[count] = remainder;14 temp = quotient;15 count ++;16 }17 else 18 break;19 }20 return count;21 }1 /*判断是否是对称数字*/ 2 bool isSymmetryDecompose(const int* input, int count) 3 { 4 for(int i = 0; i < count /2 ; i++) 5 { 6 if(input[i] != input[count - i - 1]) 7 { 8 return false; 9 }10 }11 return true;12 }方法二：数值高地位互换比较法 1 /*输入数字高地位互换，输出为互换后的结果*/ 2 int highAndLowSwap(int input) 3 { 4 int temp = input, swap = 0; 5 /*将输入的地位按顺序换成输出的高位，比如输入为12345，那么输出为54321*/ 6 while(temp) 7 { 8 swap = swap * 10 + temp %10; 9 temp = temp / 10;10 }11 12 return swap;13 }/*判断两个数字是否相等，相等则是对称数字，否则不是对称数字*/ bool isSymmetryHighAndLowSwap(int input, int inputSwap) { if(input == inputSwap) return true; else return false; } 测试代码： 1 void main() 2 { 3 int input = 123060321; 4 int decomposeResult[32], swapResult; 5 int count = 0; 6 bool isSymDecomp = false, isSymSwap = false; 7 8 count = decompose(input, decomposeResult); 9 isSymDecomp = isSymmetryDecompose(decomposeResult, count);10 swapResult = highAndLowSwap(input);11 isSymSwap = isSymmetryHighAndLowSwap(input, swapResult);12 13 if(isSymDecomp)14 printf("Is a symmetry number, judge by decompose method!\n");15 else 16 printf("Not a symmetry number, judge by decompose method!\n");17 18 printf("\n");19 20 if(isSymSwap)21 printf("Is a symmetry number, judge by swap method!\n");22 else 23 printf("Not a symmetry number, judge by swap method!\n");24 25 printf("\n");26 27 printf("Please print enter to continue ...\n");28 getchar();29 } 源码下载：http://download.csdn.net/detail/hudaliquan/9765114转载于:https://www.cnblogs.com/Keven-Lee/p/6473308.html相关资源：用数学方式判断一个数是否为对称数_java判断对称数-Java文档类...

opK问题输入数组arr，找出其中最大的k个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最大的4个数字是5、6、7、8。示例一： 输入：arr = [3,2,1], k = 2 输出：[3,2]或者[2,3]示例二： 输入：arr = [0,1,2,1], k = 1 输出：[2]解决方法1：先将这个数组排成降序，输出前K个数字即可！注意1.如果排升序，就建立大根堆2.如果排降序，接建立小根堆//交换函数void Swap(int* x, int* y){    int tmp = *x;    *x = *y;    *y = tmp;}//堆的向下调整（小堆）void AdjustDown(int* a, int n, int parent){    //child记录左右孩子中值较小的孩子的下标    int child = 2 * parent + 1;//先默认其左孩子的值较小    while (child < n)    {        if (child + 1 < n&&a[child + 1] < a[child])//右孩子存在并且右孩子比左孩子还小        {            child++;//较小的孩子改为右孩子        }        if (a[child] < a[parent])//左右孩子中较小孩子的值比父结点还小        {            //将父结点与较小的子结点交换            Swap(&a[child], &a[parent]);            //继续向下进行调整            parent = child;            child = 2 * parent + 1;        }        else//已成堆        {            break;        }    }}int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize){    *returnSize = k;    int i = 0;    //建小堆    for (i = (arrSize - 1 - 1) / 2; i >= 0; i--)    {        AdjustDown(arr, arrSize, i);    }    //排降序    int end = arrSize - 1;    while (end > 0)    {        Swap(&arr[0], &arr[end]);        AdjustDown(arr, end, 0);        end--;    }    //将最大的k个数存入数组    int* retArr = (int*)malloc(sizeof(int)*k);    for (i = 0; i < k; i++)    {        retArr[i] = arr[i];    }    return retArr;//返回最大的k个数}时间复杂度: O(N+NlogN) 空间复杂度：O(N)解决方法2：将数组建成一个大堆，取K次堆顶的数据就可以了。细节：每次拿走堆顶的数据后，需要将堆顶的数据和最后一个数据进行交换，然后重新建堆！//交换函数void Swap(int* x, int* y){    int tmp = *x;    *x = *y;    *y = tmp;}//堆的向下调整（大堆）void AdjustDown(int* a, int n, int parent){    //child记录左右孩子中值较大的孩子的下标    int child = 2 * parent + 1;//先默认其左孩子的值较大    while (child < n)    {        if (child + 1 < n&&a[child + 1] > a[child])//右孩子存在并且右孩子比左孩子还大        {            child++;//较大的孩子改为右孩子        }        if (a[child] > a[parent])//左右孩子中较大孩子的值比父结点还大        {            //将父结点与较大的子结点交换            Swap(&a[child], &a[parent]);            //继续向下进行调整            parent = child;            child = 2 * parent + 1;        }        else//已成堆        {            break;        }    }}int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize){    *returnSize = k;    int i = 0;    //建大堆    for (i = (arrSize - 1 - 1) / 2; i >= 0; i--)    {        AdjustDown(arr, arrSize, i);    }    //将最大的k个数存入数组    int* retArr = (int*)malloc(sizeof(int)*k);    int end = arrSize - 1;    for (i = 0; i < k; i++)    {        retArr[i] = arr[0];//取堆顶数据        Swap(&arr[0], &arr[end]);//交换堆顶数据与最后一个数据        //进行一次向下调整，不把最后一个数据看作待调整的数据，所以待调整数据为end=arrSize-1        AdjustDown(arr, end, 0);        end--;//最后一个数据的下标改变    }    return retArr;//返回最大的k个数}时间复杂度: O(N+klogN) 空间复杂度：O(N)弊端：如果待待续的数字有100亿个，那么存储100亿个整数究竟需要多大的内存空间？让咱们来大概估算一下： 我们知道1KB=1024byte，1MB=1024KB，1GB=1024MB，于是可以得出1GB大概有230个字节，也就是说1GB大概等于10亿个字节。 存储100亿个整型需要400亿个字节，所以存储100亿个整型数据需要40G左右的内存空间。前面两种算法的空间复杂度均为O(N)，并不适合用于这种海量数据处理。基于上述问题，我们重新建立一种新的解决方法！解决方法3：1.先将前K个数据建立小堆 2.将数组剩下的N-K个数字依次和堆顶的数据比较，如果大于堆顶的数据，进行替换，然后向下调整，使其仍为小堆。//交换函数void Swap(int* x, int* y){    int tmp = *x;    *x = *y;    *y = tmp;}//堆的向下调整（小堆）void AdjustDown(int* a, int n, int parent){    //child记录左右孩子中值较小的孩子的下标    int child = 2 * parent + 1;//先默认其左孩子的值较小    while (child < n)    {        if (child + 1 < n&&a[child + 1] < a[child])//右孩子存在并且右孩子比左孩子还小        {            child++;//较小的孩子改为右孩子        }        if (a[child] < a[parent])//左右孩子中较小孩子的值比父结点还小        {            //将父结点与较小的子结点交换            Swap(&a[child], &a[parent]);            //继续向下进行调整            parent = child;            child = 2 * parent + 1;        }        else//已成堆        {            break;        }    }}int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize){    *returnSize = k;    if (k == 0)        return NULL;    //用数组的前K个数建小堆    int i = 0;    int* retArr = (int*)malloc(sizeof(int)*k);    for (i = 0; i < k; i++)    {        retArr[i] = arr[i];    }    for (i = (k - 1 - 1) / 2; i >= 0; i--)    {        AdjustDown(retArr, k, i);    }    //剩下的N-k个数依次与堆顶数据比较    for (i = k; i < arrSize; i++)    {        if (arr[i]>retArr[0])        {            retArr[0] = arr[i];//堆顶数据替换        }        AdjustDown(retArr, k, 0);//进行一次向下调整    }    return retArr;//返回最大的k个数}————————————————版权声明：本文为CSDN博主「XG_JieJie」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/jiejiezuishuai/article/details/126245957

2022年CSP-J1 CSP-S1 第1轮初赛 报名指南​​​​​​2022年CSP-J1 CSP-S1 第1轮初赛 报名指南_dllglvzhenfeng的博客-CSDN博客【教程】图文详解 CSP-J/S 第一轮报名流程（附备考建议）【教程】图文详解 CSP-J/S 第一轮报名流程（附备考建议）CSP J/S你真的报名成功了吗？报名步骤详解速看！CSP J/S你真的报名成功了吗？报名步骤详解速看！ - 知乎0.CSP-J初赛集训第0课——进制转换0.CSP-J初赛集训第0课——进制转换_哔哩哔哩_bilibili1.CSP-J初赛集训第1课——计算机中的数据大小1.CSP-J初赛集训第1课——计算机中的数据大小_哔哩哔哩_bilibili2.CSP-J初赛集训第2课 原码反码与补码2.CSP-J初赛集训第2课 原码反码与补码_哔哩哔哩_bilibili3.CSP-J初赛集训第3课 进制转换 原码反码补码 近十年真题汇总3.CSP-J初赛集训第3课 进制转换 原码反码补码 近十年真题汇总_哔哩哔哩_bilibili4.CSP-J初赛集训第4课——栈和队列初识4.CSP-J初赛集训第4课——栈和队列初识_哔哩哔哩_bilibili5.CSP-J初赛集训—栈的近20年真题讲解5.CSP-J初赛集训—栈的近20年真题讲解_哔哩哔哩_bilibili6.CSP-J初赛集训——循环队列 真题讲解6.CSP-J初赛集训——循环队列 真题讲解_哔哩哔哩_bilibili7.CSP-J初赛集训第5课 数据结构 树的基本概念介绍 树和二叉树 小白一听就会7.CSP-J初赛集训第5课 数据结构 树的基本概念介绍 树和二叉树 小白一听就会_哔哩哔哩_bilibili8.CSP-J初赛集训 关于树的计算真题 二叉树的计算 CSP noip8.CSP-J初赛集训 关于树的计算真题 二叉树的计算 CSP noip_哔哩哔哩_bilibili9.CSP-J初赛集训第6课 二叉树的遍历 小白入门必好学9.CSP-J初赛集训第6课 二叉树的遍历 小白入门必好学_哔哩哔哩_bilibili10.CSP-J初赛集训 二叉树的遍历 历年真题讲解10.CSP-J初赛集训 二叉树的遍历 历年真题讲解_哔哩哔哩_bilibili11.CSP-J初赛集训第6课 图的基本概念介绍11.CSP-J初赛集训第6课 图的基本概念介绍_哔哩哔哩_bilibili12.CSP-J初赛集训 关于图的历年真题讲解12.CSP-J初赛集训 关于图的历年真题讲解_哔哩哔哩_bilibili13.CSP-J初赛集训第7课_排列和组合13.CSP-J初赛集训第7课_排列和组合_哔哩哔哩_bilibili14.CSP-J初赛排列和组合历年真题114.CSP-J初赛排列和组合历年真题1_哔哩哔哩_bilibili15.CSP-J初赛排列和组合历年真题215.CSP-J初赛排列和组合历年真题2_哔哩哔哩_bilibili16.CSP-J初赛排列和组合历年真题3​​​​​​16.CSP-J初赛排列和组合历年真题3_哔哩哔哩_bilibili17.CSP-J初赛数学问题历年真题17.CSP-J初赛数学问题历年真题_哔哩哔哩_bilibili信奥学习规划 信息学竞赛之路(2022.07.31)信奥学习规划 信息学竞赛之路(2022.07.31)_dllglvzhenfeng的博客-CSDN博客Scratch -＞ C++画图-＞信奥（C++）学习导航Scratch -＞ C++画图-＞信奥（C++）学习导航_dllglvzhenfeng的博客-CSDN博客【NOI2022】PV「什么是信息学精神？」【NOI2022】PV「什么是信息学精神？」_dllglvzhenfeng的博客-CSDN博客高含金量国际计算机编程竞赛高含金量国际计算机编程竞赛_dllglvzhenfeng的博客-CSDN博客_计算机编程大赛【国际竞赛-计算机篇】2022年高含金量的计算机竞赛有哪些【国际竞赛-计算机篇】2022年高含金量的计算机竞赛有哪些_dllglvzhenfeng的博客-CSDN博客Kaggle学习Kaggle学习_dllglvzhenfeng的博客-CSDN博客Scratch -＞ C++画图-＞信奥（C++）学习导航Scratch -＞ C++画图-＞信奥（C++）学习导航_dllglvzhenfeng的博客-CSDN博客USACO资料集（2022.07.22）USACO资料集（2022.07.22）_dllglvzhenfeng的博客-CSDN博客【信息学奥赛】2021 CSP-J 初赛真题解析【信息学奥赛】2021 CSP-J 初赛真题解析_哔哩哔哩_bilibili【合集】信息学奥赛 2020 CSP-J 初赛真题解析【合集】信息学奥赛 2020 CSP-J 初赛真题解析_哔哩哔哩_bilibili【合集】信息学奥赛 2019 CSP-J 初赛真题解析【合集】信息学奥赛 2019 CSP-J 初赛真题解析_哔哩哔哩_bilibiliCSP-J初赛集训（因特网概述）CSP-J初赛集训（因特网概述）_哔哩哔哩_bilibili信奥（CSP-J/S初赛）公益讲座精选系列之考点和重点信奥（CSP-J/S初赛）公益讲座精选系列之考点和重点_哔哩哔哩_bilibili信奥集训营【CSP-J专题集训、案例全、历年真题讲解、值得收藏】信奥集训营【CSP-J专题集训、案例全、历年真题讲解、值得收藏】_哔哩哔哩_bilibili初赛大题选讲——信奥（CSP-J/S初赛）公益讲座精选系列初赛大题选讲——信奥（CSP-J/S初赛）公益讲座精选系列_哔哩哔哩_bilibili2022csp-j初赛模拟day082022csp-j初赛模拟day08_哔哩哔哩_bilibili2022csp-j初赛模拟day092022csp-j初赛模拟day09_哔哩哔哩_bilibili2021CSP-J第一轮认证分析与吐槽2021CSP-J第一轮认证分析与吐槽_哔哩哔哩_bilibili名师教你学 - NOIP 信息学奥赛 CSP-J 刷题班名师教你学 - NOIP 信息学奥赛 CSP-J 刷题班_哔哩哔哩_bilibili聊聊2021年csp-j初赛的事儿聊聊2021年csp-j初赛的事儿_哔哩哔哩_bilibiliCSP-J初赛知识点：其它进制CSP-J初赛知识点：其它进制_哔哩哔哩_bilibili信息学奥赛CSP-J：链表专题信息学奥赛CSP-J：链表专题_哔哩哔哩_bilibili2023计算机考研专业课参考书目（408）2023计算机考研专业课参考书目（408）_dllglvzhenfeng的博客-CSDN博客_计算机408参考教材计算机考研 机试书籍及相关的资料计算机考研 机试书籍及相关的资料_dllglvzhenfeng的博客-CSDN博客2023年 计算机考研 资料集（2022.02.03）2023年 计算机考研 资料集（2022.02.03）_dllglvzhenfeng的博客-CSDN博客动画学信奥 漫画学算法 CSP-J入门级 （一）、计算机基础与编程环境（依据「NOI大纲」）动画学信奥 漫画学算法 CSP-J入门级 （一）、计算机基础与编程环境（依据「NOI大纲」）_dllglvzhenfeng的博客-CSDN博客_cspj考试大纲动画学信奥 漫画学算法 CSP-J入门级 （二）、C++程序设计 数据结构（依据「NOI大纲」）动画学信奥 漫画学算法 CSP-J入门级 （二）、C++程序设计 数据结构（依据「NOI大纲」）_dllglvzhenfeng的博客-CSDN博客_csp-j 数据结构动画学信奥 漫画学算法 CSP-J入门级 （三）、算法（依据「NOI大纲」）动画学信奥 漫画学算法 CSP-J入门级 （三）、算法（依据「NOI大纲」）_dllglvzhenfeng的博客-CSDN博客————————————————版权声明：本文为CSDN博主「dllglvzhenfeng」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/dllglvzhenfeng/article/details/126253377

Arrays类Arrays类是Java中用来操作数组的模块他的使用方法是在Java类中使用import java.util.Arrays进行导入，并使用Arrays.方法（）进行调用方法！Arrays类的fill方法fill方法有两种用途！第一种就是填充数组，将数组中的全部元素转换为所输入的元素第二种就是替换数组元素，将数组中某个元素进行单个替换用fill方法填充数组在初始化一个数组之后，如果没有给数组的元素赋值，那么这个数组中的元素默认是为0的，那么我们一个个进行赋值又会略显麻烦，会堆积代码！所以我们就需要用到fill方法进行填充，但是这么做会让全部元素变成同一个数值！import java.util.Arrays; //这里导入Arrays类public class Fill{public static void main(String[] args){int[] mylist = new int[5]; //这里创建一个名称为mylist的数组，数组的元素个个数为5Arrays.fill(mylist,3); //为数组填充3，格式为fill(列表,数值)for(int x:mylist){System.out.println(x);} //通过for each来遍历数组元素}}上面的for each在以前的文章中介绍过！用fill方法替换数组元素在给元素赋值完或者是填充完元素之后，如果想对某个元素进行修改，那么我们就要重新赋值或者是替换元素，但是重新赋值会增加代码，让代码显得更繁琐，所以Arrays类中提供了替换元素的方法fill！import java.util.Arrays;public class Fill{public static void main(String[] args){int[] mylist = {1,2,3,4};Arrays.fill(mylist, 1,2,4);for(int x:mylist){System.out.println(x);}} //这是一个特殊的格式Arrays.fill(列表名称,空格正向索引,反向索引,改变的数值）1}这里的正反向索引指向的一定要是同一个元素！Arrays类的复制数组方法在Java程序的使用过程中，有时候会需要一个含有相同或者是部分相同元素的数组，但是重新创建数组的话就会增加代码长度，减少代码可读性，那么我们就可以使用到复制数组或者是部分数组的方法！用copyOf复制数组☄️copyOf方法提供了多种重载的方法，用以复制数组，增加代码可读性。该方法不受数组长度的限制，若超出，则多处部分为0！import java.util.Arrays;public class Fill{public static void main(String[] args){int[] mylist = {1,2,3,4};int[] justlist = Arrays.copyOf(mylist,4); //将复制后的数组赋值给justlist//格式Arrays.copyOf(列表,复制后的长度)for(int x:justlist){System.out.println(x);}System.out.println(mylist);System.out.println(justlist); //这里输出两个数组的内存空间进行检查} //这是一个特殊的格式Arrays.fill(列表名称,空格正向索引,反向索引,改变的数值）1}解：从以上结果可以看出赋值成功了，并且内存空间不同（下面我会解释为什么要输出内存空间）用copyOfRange方法复制部分数组有时候在编辑代码的时候只需要中间一部分代码，但是copyOf方法只能复制以前面部分为开头的元素，而不能直接复制中间的代码，为了解决这一个问题，这个类提供了另一个方法copyOfRange方法（中文意思：选择复制）利用这个方法就可以解决这一个问题！import java.util.Arrays;public class Fill{public static void main(String[] args){int[] mylist = {1,2,3,4};int[] justlist = Arrays.copyOfRange(mylist,1,3);//Arrays类的方法使用形式Arrays.copyOfRange(列表,第一个索引位置,第二个索引位置)for(int x:justlist){System.out.println(x);}}}注：在末尾有问题解答！Arrays类对数组进行排序在代码编译过程中，有时候会需要用到有序的一组数组才能进行更好的操作，但是我们重新进行编译会增加代码数量，所以我们要对代码进行排序，Java中提供了sort方法对数组的元素进行升序排序！用sort方法进行升序排序在Java编译过程中，有顺序的数组会让你的编译更加方便，使得你自己以及其他参与编译的人更加清楚，尤其是适合那些大基数的数组更为适用和实用！import java.util.Arrays;public class Fill{public static void main(String[] args){    int[] mylist = {1,7,33,4};    Arrays.sort(mylist);    //方式为Arrays.sort(列表)    for(int x:mylist){        System.out.println(x);    }}}问题解答为什么要在fill方法中加空格：因为不加空格就会使他执行不正确，无法达到效果为什么要输出内存空间吗：如果在同一个内存空间，一个数组改变之后另一个也会随之改变，会影响后续程序执行copyOfRange方法如果超出索引最大限度会怎么样：如果超出，则超出部分默认为0！为什么有些要方法要创建新数组有些不用：因为有些方法是对一个数组进行改变，有些是要重新创建数组！————————————————版权声明：本文为CSDN博主「Code Writers」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/m0_71905144/article/details/126250825

1.try-catch异常处理说明1.Java提供try和catch块来处理异常，try块用于包含可能出错的代码。catch块用于处理try块中发出的异常。可以根据需要在程序中有一个或多个try-catch块2.基本语法try{    //可疑代码    //将一场生成对应的异常对象，传递给catch块}catch{    //对异常的处理}2.try-catch异常处理细节1.如果异常发生了，则异常后面的代码不会执行，直接进入到catch块2.如果异常没有发生，则顺序执行try的代码块，不会进入到catch。3.如果希望不管是否发生异常，都执行某段代码，则使用如下代码-finally{}示例01package com.demo.trycatch;/** * @version 1.0 * @auther Demo龙 */public class TrycatchDetial {    public static void main(String[] args) {        //1.如果异常发生了，则异常后面的代码不会执行，直接进入到catch块        //ctrl+alt+t        try {            String ch="kkk";            int a=Integer.parseInt(ch);            System.out.println("number"+a);        } catch (NumberFormatException e) {            System.out.println("异常信息："+e.getMessage());        }        System.out.println("程序继续运行");        // > 2.如果异常没有发生，则顺序执行try的代码块，不会进入到catch。        try {            String ch="556";            int a=Integer.parseInt(ch);            System.out.println("number="+a);        } catch (NumberFormatException e) {            System.out.println("异常信息："+e.getMessage());        }        System.out.println("程序继续运行02");        //> 3.如果希望不管是否发生异常，都执行某段代码，则使用如下代码-finally{}        try {            String ch="Demo龙";            int a=Integer.parseInt(ch);            System.out.println("number="+a);        } catch (NumberFormatException e) {            System.out.println("异常信息："+e.getMessage());        } finally {            System.out.println("finally被执行");        }    }}测试结果014.可以有多个catch语句，捕获不同的异常（进行不同的业务处理），要求父类异常在后，子类异常在前，如果发生异常，只会匹配一个catch。5.try-finally配合使用，这种用法相当于没有捕获异常，程序会直接退出，但会执行finally业务逻辑示例02package com.demo.trycatch;/** * @version 1.0 * @auther Demo龙 */public class TrycatchDetial02 {    //4.可以有多个catch语句，捕获不同的异常（进行不同的业务处理），    // 要求父类异常在后，子类异常在前，如果发生异常，只会匹配一个catch。    public static void main(String[] args) {        try {            Person person = new Person();            person=null;            System.out.println("name="+person.getName());//空指针异常            int n1=9;            int n2=0;            int num=n1/n2;//数学异常            //1.try代码块可能有多个异常            //2.可以使用多个catch分别捕获不同的异常，相应处理            //3.要求子类异常写在前面，父类异常写在后面        }catch (NullPointerException e){            System.out.println("空指针异常："+e.getMessage());        } catch (ArithmeticException c){            System.out.println("算数异常："+c.getMessage());        } catch (Exception e) {            System.out.println("异常情况："+e.getMessage());        } finally {            System.out.println("finally代码块被执行");        }        System.out.println("程序继续运行。");        //5.try-finally配合使用，这种用法相当于没有捕获异常，        // 程序会直接退出，但会执行finally业务逻辑        System.out.println("try-finally细节测试");        try {            int m1=9;            int m2=3;            System.out.println("m1/m2="+m1/m2);        } finally {            System.out.println("执行finally代码块02");        }        try {            int m1=9;            int m2=0;            System.out.println("m1/m2="+m1/m2);        } finally {            System.out.println("执行finally代码块01");        }    }}class Person{    private String name="demo龙";    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}————————————————版权声明：本文为CSDN博主「Demo龙」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/qq_59708493/article/details/125011256

首先来了解桶排序将数组分成若干类  分这个类的条件  我们自己决定这里我们用的是 每隔5个数分为一类如20~24  25~29 30~34...数组中的元素满足这样的条件就会被放在相应的桶中如: 23会被放在20~24的桶中假设我们有这样一个数组int arr[15] = { 34,36,31,78,65,32,33,34,89,90,91,67,52,71,77};我们决定桶的数量 为确保数组中的元素都能如桶   一般设定为  :原数组中的最大值-最小值+1 想判断当前数组元素应该入哪个桶  我们这里的条件是:当前元素的值-最小值/5   为他要入的桶的下标如  最小元素20 当前元素40  那么他要进去的桶的下标为 (40-20)/5=4我们这里所谓的桶  其实就是一个哈希数组 这里用的是链式存储法 (每一个元素都是一个链表的头)如相应的桶  就是 把元素添加到哈希数组的相应下标上的链表上去  在这里我们添加用的是链表插入的方式  直接根据节点的值将节点插入到相应的位置   完成排序 之后我们只需要 遍历哈希数组并遍历哈希数组元素  吧 哈希数组中的元素都放回到原数组中去这样就实现了桶排序桶排序完整代码如下#include<iostream>using namespace std;#define  jiange 5struct List{    int id;    List* pNext;}; void Insert(List*&pHead,int value){    List* pTemp=new List;    pTemp->id = value;    pTemp->pNext = NULL;    //链表中没有节点    if (pHead == NULL)    {        pHead = pTemp;        return;    }    //链表中的头节点比当前节点的值大      //头插入    if (pTemp->id < pHead->id)    {        pTemp->pNext=pHead;        pHead = pTemp;        return;    }    //链表的头的值比当前要插入的节点的值小    //遍历链表  找到要插在谁的后面            List* pMark = pHead;        while (pMark->pNext != NULL)        {            if (pMark->pNext->id > pTemp->id)            {                pTemp->pNext = pMark->pNext;                pMark->pNext = pTemp;                return;            }            pMark = pMark->pNext;        }        //遍历到最后一个节点  都没找到比当前节点大的节点  插在最后        pMark->pNext = pTemp;         }void BuckeSort(int arr[],int nLen){    int begin = arr[0];    int end =arr[0];    //参数校验    if (arr == NULL || nLen <= 10)    {        return;    }    //找到最大值和最小值确定桶的数量    for (int i = 0; i < nLen; i++)    {        if (arr[i] < begin)            begin = arr[i];        if (arr[i] > end)            end = arr[i];    }    int nBucketCount =  end -begin + 1;    //开辟空间    List** Hash = new List*[nBucketCount];    ::memset(Hash, 0, sizeof(List*)* nBucketCount);    //遍历数组入桶    for (int i = 0; i < nLen; i++)    {        //入桶函数        Insert(Hash[(arr[i]-begin)/jiange], arr[i]);    }    //出桶     int j = 0;    for (int i = 0; i < nBucketCount; i++)    {                while (Hash[i])        {            List* pDel = Hash[i];            Hash[i] = Hash[i]->pNext;             arr[j++] =pDel->id;            delete pDel;            pDel = NULL;                                }    }    delete Hash;    Hash = NULL;       } int main(){    int arr[15] = { 34,36,31,78,65,32,33,34,89,90,91,67,52,71,77};    BuckeSort(arr, 15);    for (int val : arr)    {        cout << val << " ";    }    return 0;}基数排序:可以看做是桶排序的另一种优化  只不过 他的如桶条件变了 而且需要额外创建一个记录链表的尾的哈希数组;  用于添加节点尾入  头出思想:先把数组中的元素根据个位入桶出桶放入原数组在把数组中的元素根据十位入桶出桶放入原数组...直到把数组中的元素根据  数组中的最大的元素的最高位  入桶出桶放入原数组   结束这样一来  数组自己就排序好了基数排序:代码如下#include<iostream>using namespace std;#define  jiange 5struct List{    int id;    List* pNext;}; void AddNode(List*& pHead, List*& pEnd ,int value){    List* pTemp = new List;    pTemp->id = value;    pTemp->pNext = NULL;    //链表中没有节点    if (pHead == NULL)    {        pHead = pTemp;            }    //链表有节点      //尾插入    else     {        pEnd->pNext = pTemp;     }                  pEnd = pTemp;      }void RadixSort(int arr[], int nLen){        //参数校验    if (arr == NULL || nLen <= 10)    {        return;    }    //找到最大值    int max = arr[0];    for (int i = 0; i < nLen; i++)    {        if (arr[i] > max)        {            max = arr[i];        }    }    int base = 1;        //创建桶中链表的头节点数组    List** pHeadarr = new List * [10];    //创建桶中链表的尾节点数组    List** pEndarr = new List * [10];    ::memset(pHeadarr, 0, sizeof(List*) * 10);    ::memset(pEndarr, 0, sizeof(List*) * 10);    while (max / base != 0)    {        //arr的元素放入桶中        for (int i = 0; i < nLen; i++)        {                        //链表尾部添加            AddNode(pHeadarr[arr[i] / base % 10], pEndarr[arr[i] / base % 10], arr[i]);        }        //出桶        int j = 0;        for (int i = 0; i < 10; i++)        {            while (pHeadarr[i])            {                List* pDel = pHeadarr[i];                                pHeadarr[i] = pHeadarr[i]->pNext;                                    arr[j++] = pDel->id;                delete pDel;                pDel = NULL;            }        }        base *= 10;     }       } int main(){    int arr[15] = { 34,36,31,78,65,32,33,34,89,90,91,67,52,71,77 };    RadixSort(arr, 15);    for (int val : arr)    {        cout << val << " ";    }    return 0;————————————————版权声明：本文为CSDN博主「van9527」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/van9527/article/details/126232966

【功能模块】使用AR502H时，前一年买的串口读取没反应，后来买的一批都可以正常读取，把老批次的系统升级了也不行。C++版本的app在两个批次都可以，JAVA的app在老批次不行。老批次与新批次的差异：老一批的系统是V200R020C00SPC100，新的一批系统是V200R020C10SPC100，都升级成了V200R020C10SPC100，还是不行双工切换的结果返回也正常，就是串口没反应【操作步骤&问题现象】1、2、【截图信息】【日志信息】（可选，上传日志内容或者附件）

1：在开始本项目讲解之前和大家简单的了解了解java吧Java是由斯坦福大学网络公司于1995年开发的一门高级变成语言是一种面向互联网的编程语言 javga具有着某种魔力和吸引力同时也可以在web浏览器中运行 这些java程序被称为java小程序 applet随着java在web方向的不断发展和成熟后台开发出了：java  go  node.js2：Java技术体系平台分为： JavaSE(Java Standard Edition)标准版       JavaEE(Java Enterprise Edition)企业版       Java ME(Java Micro Edition)小型版3：特性包括易学  分布式 健壮 安全 开源 解释型语言等特点项目介绍：现在电商对我们生活可以说是息息相关 大家都会有把自己喜欢的东西添加到购物车的习惯那么用java算法是怎么实现的购物车添加、删除、更新等操作的呢？？？先给大家看看源码：Shopcar类：import mianxiangduixiang.demo.Goods;import java.util.Scanner;import java.util.SortedMap;public class ShopCarTest {    public static void main(String[] args) {                        mianxiangduixiang.demo.Goods[] shopCar=new mianxiangduixiang.demo.Goods[1000];        while (true) {            System.out.println();            System.out.println("==================================================================");            System.out.println("请您选择如下命令进行操作：");            System.out.println("添加商品到购物车 a");            System.out.println("查看购物车商品 q");            System.out.println("修改购物车商品数量 u");            System.out.println("结算购物车商品金额 p");            System.out.println("结束程序 end");            Scanner sc=new Scanner(System.in);            System.out.println("请输入您的命令：");            System.out.println();            String command=sc.next();            switch (command){                case "add":                    //添加商品到购物车                    addGoods(shopCar,sc);                    break;                case "query":                                        queryGoods(shopCar);                    break;                case "update":                                        updateGoods(shopCar,sc);                    break;                case "pay":                                        payGoods(shopCar);                    break;                case "end":                                        System.exit(0);                    break;                default:                    System.out.println("无此功能！！！");            }        }    }      public static void payGoods(Goods[] shopCar){        System.out.println("您现在购物车的信息为：");        queryGoods(shopCar);        double money=0;        for (int i = 0; i < shopCar.length; i++) {            Goods g=shopCar[i];            if (g!=null){                money+=(g.buyNumber*g.price);            }else {                break;            }        }        System.out.println("您购买商品的总金额为："+money+"元");    }         public static void updateGoods(Goods[] shopCar,Scanner sc) {               System.out.println("请输入您要修改的商品id：");        int id=sc.nextInt();        Goods g=getGoodsByid(shopCar,id);        if (g==null){            System.out.println("抱歉，购物车中无此商品信息，请重新输入！！！");            updateGoods(shopCar, sc);        }else {            System.out.println("请输入"+g.name+"要修改的数量：");            int buyNumber=sc.nextInt();            g.buyNumber=buyNumber;            System.out.println("修改成功！！！");        }    }        public static Goods getGoodsByid(Goods[] shopCar,int id){        for (int i = 0; i < shopCar.length; i++) {            Goods g=shopCar[i];            if (g != null) {                                if (g.id == id) {                    return g;                }            }else {                //System.out.println("您还未添加此商品！！！");                return null;            }        }        return null;    }        public static void queryGoods(Goods[] shopCar) {        System.out.println("===========================查看商品信息=========================");        System.out.println("商品编号\t\t\t商品名称\t\t\t商品价格\t\t\t商品数量");        for (int i = 0; i < shopCar.length; i++) {            Goods g=shopCar[i];            if (g != null) {                System.out.println(g.id+"\t\t\t\t"+g.name+"\t\t\t\t"+g.price+"\t\t\t\t"+g.buyNumber);            }else {                break;            }        }    }       public static void addGoods(Goods[] shopCar,Scanner sc) {        //1.录入用户输入的商品信息        System.out.println("请您输入商品的编号（不可重复）：");        int id=sc.nextInt();        System.out.println("请您输入商品名称：");        String name=sc.next();        System.out.println("请您输入商品价格：");        double price=sc.nextDouble();        System.out.println("请输入商品数量：");        int buyNumber=sc.nextInt();               Goods g=new Goods();        g.id=id;        g.name=name;        g.price=price;        g.buyNumber=buyNumber;                for (int i = 0; i < shopCar.length; i++) {                        if (shopCar[i] == null) {                shopCar[i]=g;                break;            }        }        System.out.println("您的商品"+g.name+"已参加至购物车!!!");    }}Goods类：package mianxiangduixiang.demo;public class Goods {    public int id;    public String name;    public double price;    public int buyNumber;}思路：创建一个商品定义一个购物车的类定义一个商品类，用于创建后期创建商品对象定义一个购物车对象：用数组表示代表商品数组对象，可以存1000个搭建操作架构查看购物车商品修改购物车商品数量结算购物车商品金额结束程序//定义一个方法，进行求和变量累加求出金额 定义一个方法，修改购物车商品数量让用户输入要修改的商品id，根据id查询出要修改的商品对象（定义一个方法，查询要修改的对象）定义一个方法，可以查询出要修改的商品对象,返回商品对象判断此商品id是我们要找的定义一个方法，查看购物车商品信息，并展示出来定义一个方法，添加商品到购物车把这个商品购买信息封装成一个商品信息把这个商品对象添加到购物车数组中去找出这个数组空的地方存入说明此位置没有元素存入，把商品信息存入即可存入之后就跳出循环，无需继续遍历查询结果截图： 这次的项目开发其实按照一个有序的逻辑思路来开发的话是不难的 难在思维上的理解和概念的熟悉与否 相信很多小伙伴都看懂了 有问题下方留言哦