Java组队学习Task02

最新推荐文章于 2024-09-23 15:50:28 发布
最新推荐文章于 2024-09-23 15:50:28 发布
阅读量159 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chigusakawada/article/details/118766717
版权
本文详细介绍了Java中的基础数据类型，包括整数、浮点、布尔和字符类型，以及它们的取值范围和默认值。此外，还讨论了引用类型、变量声明、常量、自动类型转换和强制类型转换的规则。接着，讲解了Java的注解，如@Deprecated、@Override和@FunctionalInterface，以及元注解的作用。最后，深入探讨了泛型的概念，包括泛型类、泛型方法和泛型接口，以及类型通配符的使用。
摘要由CSDN通过智能技术生成

1.基础数据类型和变量

所谓变量就是申请内存还存储值，即创建变量时需要申请内存空间。内存管理系统根据该变量的数据类型来分配存储空间，而分配给特定变量的存储空间只能存储该变量。

因此，可以通过定义不同的数据类型的变量即可存储如整数、浮点数、布尔变量等数据。

ava 的两大数据类型:

  1. 内置数据类型
  2. 引用数据类型

1.1内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

1.整数类型

byte8位最小值是 -128（-2^7）最大值是 127（2^7-1）默认值是 0
short16位最小值是 -32768（-2^15）最大值是 32767（2^15 - 1）默认值是 0
int32位最小值是 -2,147,483,648（-2^31）最大值是 2,147,483,647（2^31 - 1）默认值是 0
long63位最小值是 -9,223,372,036,854,775,808（-2^63）最大值是 9,223,372,036,854,775,807（2^63 -1）默认值是 0

2.浮点型

float32位最小值是1.4E-45最大值是 3.4028235E38默认值是 0.0f
double64位最小值是4.9E-324最大值是 1.7976931348623157E308默认值是 0.0d

3.布尔型

boolean1位truefalse默认值false

4.字符型

char16位最小值\u0000（十进制等效值为 0）最大值是 \uffff（即为 65535)默认值空

代码实例

 

public class PrimitiveTypeTest {

    static boolean bool;
    static byte by;
    static char ch;
    static double d;
    static float f;
    static int i;
    static long l;
    static short sh;
    static String str;

    public static void main(String[] args){
        // byte
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
        System.out.println("包装类：java.lang.Byte");
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();

        // short
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
        System.out.println("包装类：java.lang.Short");
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println();

        // int
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
        System.out.println("包装类：java.lang.Integer");
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println();

        // long
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
        System.out.println("包装类：java.lang.Long");
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println();

        // float
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
        System.out.println("包装类：java.lang.Float");
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println();

        // double
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
        System.out.println("包装类：java.lang.Double");
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println();

        // char
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
        System.out.println("包装类：java.lang.Character");
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
        System.out.println("最小值：Character.MIN_VALUE="
                + (int) Character.MIN_VALUE);
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
        System.out.println("最大值：Character.MAX_VALUE="
                + (int) Character.MAX_VALUE);

        // default value
        Test();
    }

    public static void Test(){

        // default value
        System.out.println("Bool :" + bool);
        System.out.println("Byte :" + by);
        System.out.println("Character:" + ch);
        System.out.println("Double :" + d);
        System.out.println("Float :" + f);
        System.out.println("Integer :" + i);
        System.out.println("Long :" + l);
        System.out.println("Short :" + sh);
        System.out.println("String :" + str);
    }
}

引用类型

  • 在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，变量一旦声明后，类型就不能被改变了。
  • 对象、数组都是引用数据类型。
  • 所有引用类型的默认值都是null
  • 一个引用变量可以用来引用任何与之兼容的类型

Java常量

常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

1. 不能对boolean类型进行类型转换。

2. 不能把对象类型转换成不相关类的对象。

3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

4. 转换过程中可能导致溢出或损失精度，例如：

int i =128;   
byte b = (byte)i;

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。

5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

(int)23.7 == 23;        
(int)-45.89f == -45

强制类型转换

1. 条件是转换的数据类型必须是兼容的。

2. 格式：(type)value type是要强制类型转换后的数据类型 实例：

public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

隐含强制类型转换

1、 整数的默认类型是 int。

2. 小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。

1.2Java变量类型

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

Java语言支持的变量类型有：

  • 类变量：独立于方法之外的变量，用 static 修饰。
  • 实例变量：独立于方法之外的变量，不过没有 static 修饰。
  • 局部变量：类的方法中的变量。
public class var{
    static int lei_var;    // 类变量
    String str="hello world";  // 实例变量 
    public void test(){
        int local_var =0;  // 局部变量 
    }
}

类变量

  • 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
  • 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
  • 静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
  • 静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
  • 静态变量在第一次被访问时创建，在程序结束时销毁。
  • 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
  • 默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
  • 静态变量可以通过：ClassName.VariableName的方式访问。
  • 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

实例变量

  • 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
  • 当一个对象被实例化之后，每个实例变量的值就跟着确定；
  • 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
  • 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
  • 实例变量可以声明在使用前或者使用后；
  • 访问修饰符可以修饰实例变量；
  • 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
  • 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
  • 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

局部变量

  • 局部变量声明在方法、构造方法或者语句块中；
  • 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
  • 访问修饰符不能用于局部变量；
  • 局部变量只在声明它的方法、构造方法或者语句块中可见；
  • 局部变量是在栈上分配的。
  • 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

2.注解

注解，一种元数据形式，提供有关程序的数据，该数据不属于程序本身。注释对其注释的代码的操作没有直接影响。

注解的语法：

@注解类型名

注释有多种用途，其中包括：

  • 编译前：为编译器提供编译检查的依据，辅助检查代码错误或抑制检查异常。
  • 编译中或发布时：给编译器提供信息生成代码或给其他工具提供信息生成文档等。
  • 运行时：在运行过程中提供信息给解释器，辅助程序执行。
  • 注解经常和反射结合起来用，多用于框架中。

2.1内置的注解

@Deprecated

这个元素是用来标记过时的元素，想必大家在日常开发中经常碰到。编译器在编译阶段遇到这个注解时会发出提醒警告，告诉开发者正在调用一个过时的元素比如过时的方法、过时的类、过时的成员变量。

public class Hero {

    @Deprecated
    public void say(){
        System.out.println("Noting has to say!");
    }


    public void speak(){
        System.out.println("I have a dream!");
    }


}

@Override

  • 加在方法前

  • 表示重写（覆盖）父类的方法；

  • 如果重写（覆盖）有错误，则报错。

  • 因此重写父类方法，请加上@Override注解。

class Parent {
    String name;
    public Parent(){}
    public Parent(String name)
    {
        this.name = name;
    }
    public void sayHello()
    {
        System.out.println("你好，我是" + name )；
    }
}

public class Child extends Parent
{
    String name;
    public Child{}
    @Override
    public void sayHello(String str)
    {
        //这里会报错
        super.sayHello();
        System.out.println("Hello,im Datawhale");
    }
}

/**
本段代码则不会提示错误

public class Child extends Parent
{
    String name;
    public Child{}
    @Override
    public void sayHello()
    {
        super.sayHello();
        System.out.println("Hello,im Datawhale");
    }
}
**/

@SuppressWarnings

阻止警告的意思。之前说过调用被 @Deprecated 注解的方法后，编译器会警告提醒，而有时候开发者会忽略这种警告，他们可以在调用的地方通过 @SuppressWarnings 达到目的。

@SuppressWarnings("deprecation")
public void test1(){
    Hero hero = new Hero();
    hero.say();
    hero.speak();
}

@SafeVarargs

参数安全类型注解。它的目的是提醒开发者不要用参数做一些不安全的操作,它的存在会阻止编译器产生 unchecked 这样的警告。它是在 Java 1.7 的版本中加入的。

@SafeVarargs // Not actually safe!
    static void m(List<String>... stringLists) {
    Object[] array = stringLists;
    List<Integer> tmpList = Arrays.asList(42);
    array[0] = tmpList; // Semantically invalid, but compiles without warnings
    String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
}

上面的代码中，编译阶段不会报错，但是运行时会抛出 ClassCastException 这个异常，所以它虽然告诉开发者要妥善处理，但是开发者自己还是搞砸了。

@FunctionalInterface

函数式接口注解，这个是 Java 1.8 版本引入的新特性。函数式编程很火，所以 Java 8 也及时添加了这个特性。

函数式接口 (Functional Interface) 就是一个具有一个方法的普通接口。

比如

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

我们进行线程开发中常用的 Runnable 就是一个典型的函数式接口，上面源码可以看到它就被 @FunctionalInterface 注解。

可能有人会疑惑，函数式接口标记有什么用，这个原因是函数式接口可以很容易转换为 Lambda 表达式。

2.2元注解

元注解负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。 @Target, @Retention, @Documented, @Inherited

@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。 　取值(ElementType)有： 　 1.CONSTRUCTOR:用于描述构造器 　　2.FIELD:用于描述域 　　3.LOCAL_VARIABLE:用于描述局部变量 　　4.METHOD:用于描述方法 　　5.PACKAGE:用于描述包 　　6.PARAMETER:用于描述参数 　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

@Retention定义了该Annotation被保留的时间长短：某些Annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）

3.泛型

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型使得代码可以被不同类型的对象重用

3.1泛型类

一个泛型类就是拥有一个或者多个类型变量的类。下面看一个简单例子：

public class test {

    public static class Point<T> {
        private T var;

        public void setVar(T x) {
            this.var = x;
        }

        public T getVar() {
            return this.var;
        }

    }

    public static void main(String[] args){
        Point<Float> p = new Point<Float>() ;
        p.setVar(new Float(100.12f)) ;
        System.out.println(p.getVar());
    }

}

括号里面的T，是形式类型参数，可以随意指定，当类被使用的时候，就会使用具体的实际类型参数。

需要注意的是，泛型类只能用在成员变量上，并且只能使用引用类型。

3.2泛型方法

下面是定义泛型方法的规则：

  • 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前
  • 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
  • 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
  • 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。
public class MethodTest {
	int var = 100;
    String varStr = "Hello Datawhale";
	public <T> T Method(T a) {
		return a;
	}
	public static void main(String[] args) {
		MethodTest t=new MethodTest();
		System.out.println(t.<Integer>Method(t.var));
		System.out.println(t.<String>Method(t.varStr));
	}

3.3泛型接口

class InfoImpl implements Info<String>{   // 定义泛型接口的子类  
    private String var ;                // 定义属性  
    public InfoImpl(String var){        // 通过构造方法设置属性内容  
        this.setVar(var) ;  
    }  
    @Override  
    public void setVar(String var){  
        this.var = var ;  
    }  
    @Override  
    public String getVar(){  
        return this.var ;  
    }  
}  
  
public class GenericsDemo24{  
    public  void main(String arsg[]){  
        InfoImpl i = new InfoImpl("harvic");  
        System.out.println(i.getVar()) ;  
    }  
};

3.4类型通配符

类型通配符一般是在不确定具体参数时候，使用?代替。？表示未知类型，类型参数赋予不确定值，只能用在声明类型、方法参数上，不能用在定义泛型类上。

public class match {
 
  public static void test(List<?> list) {
 
   List<?> list2; 
   list2 = new ArrayList<String>();
   list2 = new ArrayList<Integer>();
   list2 = new ArrayList<Object>();
 
  }
 
  public static void main(String[] args) {
   test(new ArrayList<String>());
   test(new ArrayList<Integer>());
  }
 
}

didaida00
关注
专栏目录
Datawhale组队学习之MySQL-task2
一步一个脚印，安静和谐地存在
08-11 316
Datawhale组队学习之MySQL-task2 1. MySQL表数据类型 ---->数据类型定义了列可以存储哪些数据种类。 MySQL表中数据类型有： 1.1，数值类型： MySQL中支持多种整型，其实很大程度上是相同的，只是存储值的大小范围不同而已。 tinyint：占用1个字节，相对于java中的byte smallint：占用2个字节，相对于java中的short int：占用4...
Python基础组队学习
u012729922的博客
07-22 1121
文章目录Python基础组队学习Task1变量、运算符与数据类型及位运算练习题 Python基础组队学习 Task1变量、运算符与数据类型及位运算 is, is not 对比的是两个变量的内存地址 ==, != 对比的是两个变量的值 比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。 对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。 运算符的优先级 一元运算符优于二元运算符。例如3 ** -2等价于3
Java多线程练习（一）：模拟游戏组队
weixin_45145726的博客
06-13 856
编写命令行程序模拟游戏组队： ①每隔1秒有一个玩家进入，并随机加入A或B队。 ②当A、B队人数均达到4人时，倒计时5秒，然后开始游戏。 实现代码： /** * @author xucc * @date 2020/6/8 20:45 */ public class Join { public static void main(String[] args) { String[] s = {"王一","小二","张三", "李四", "王五", "赵六", "小七", "老八"};
java 随机分配到队伍_JAVA问题 关于数组中随机进行分配组队的问题
weixin_32523999的博客
02-13 524
将十二个人先进行抽取4位队长，然后剩余进行每组2个队员的分配。importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;importjava.util.ArrayLi...将十二个人先进行抽取4位队长，然后剩余进行每组2个队员的分配。import java.io.BufferedRe...
java实现根据名单进行随机的小组分组。
Ganxiang
07-19 3144
java实现根据名单进行随机的小组分组。
java 随机分配到队伍_关于java：随机“摇动”一个数组以分配新的随机点
weixin_35829704的博客
02-25 243
我想做的是拿我的阵列硬币[]。 并且基本上将每个硬币重新排列到不同的位置。 这就是我到目前为止所拥有的。 当我这样做时，没有任何反应。 意味着所有的值都保持不变。 除了最后一个。 那个改变了。public void shake(){for (int i = 0; i < coins.length; i++){int index = Coin.RANDOM.nextInt(coins.leng...
比赛组队-Java-2017百度秋招
崔洪振367
05-27 1368
package 百度; import java.util.Scanner; /** * 题目描述： 为活跃公司文化，公司计划组织一场比赛，让员工一展才艺。现有n个员工，欲选出不少于k人组成一支队伍，1＜=n＜ =12,1＜=k＜=n。 * 每个员工有个value值，表示其对队伍水平的贡献，-1000＜=value＜=1000，给出一个矩阵对角线为0的对称矩阵A， * A[i][j]表示i
java自定义线程模型处理方法分享
09-01
例如，在MMORPG或MMOARPG游戏中，通常会有多个特定功能的线程，如主线程、全局同步线程、聊天线程、组队线程、地图线程以及地图消息分发派送线程等。每个线程负责不同的任务，确保游戏逻辑的有序执行和数据的一致性...
Transformer代码完全解读！
Datawhale
09-15 6001
↑↑↑关注后"星标"Datawhale每日干货&每月组队学习，不错过Datawhale干货作者：安晟&闫永强，Datawhale成员本篇正文部分约1...
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
java随机分组
li455854895的博客
01-06 682
java随机分组 最近查看blog看着大家不少把自己工作的总结发上来，大家一起总结学习，所以小弟也把工作的一些经验与总结发上来，希望对新人有些帮助。大家互相交流。 package test; import java.util.ArrayList; import java.util.List; public class Test { public static void main(St...
组队竞赛-Java-牛客模拟三
崔洪振367
05-26 1249
在做笔试中算法题目时，理解题意和解题思路是非常关键。其实此题目知道了解题思路后是非常简单的。 package 模拟三; import java.util.Arrays; import java.util.Scanner; /** * 题目描述：牛牛举办了一次编程比赛,参加比赛的有3*n个选手,每个选手都有一个水平值a_i. * 现在要将这些选手进行组队,一共组成n个队伍,即每个队伍3人.
java 随机分配到队伍_java随机分配
weixin_42497593的博客
02-13 1039
import java.util.*;public class Twentythree_four {public static void main(String[] args) {//创建一个数组int []arr=new int[10000];for(int i=0;i<10000;i++)arr[i]=i;//定义一个集合用来装被分配的对象ArrayList aaa=new ArrayL...
java编程：给你一个班级的名单，随机分成6个组的问题解决办法
01-15 5215
注意：标的名单文件要写在与包名同一级别的目录下，记载src上右击，点新建文件file,把名单复制到此文件中，程序就可以依据一些策略访问这个名单的内容 ArrayList是List（列表），数据是有序的，可以有重复元素 HashSet是Set（集合），数据没有顺序，没有重复元素，元素搜索速度快 package 随机分组; import java.util.ArrayList; impo
微服务--Gateway网关
最新发布
weixin_51933701的博客
09-23 784
Zuul是Spring Cloud早期版本中广泛使用的网关组件，它基于Netflix Zuul构建。Zuul提供了路由、负载均衡、容错、安全性等多种功能，是微服务架构中API网关的常用选择之一。然而，需要注意的是，随着Spring Cloud的发展，Zuul逐渐进入维护模式，Spring Cloud官方推荐使用Spring Cloud Gateway作为替代方案。
JDK17新增语法特性
2201_76124988的博客
09-20 750
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值