JavaEE入门级别最全教程3--初学者必看

Posted J哥.

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JavaEE入门级别最全教程3--初学者必看相关的知识,希望对你有一定的参考价值。

​​​​​​接JavaEE入门级别最全教程1--初学者必看​​​​​​​

接JavaEE入门级别最全教程2--初学者必看

一、包装类和常用类

1.1 常用类(聚合函数)

1.1.1 Math

概念: 是一个数学类,这个类中封装了很多用来做数学计算的方法。当我们需要使用到数学计算的时候,要能够想到这个类。这个类中有很多封装好的数学公式,而且

,都是静态方法,方便调用。

1.1.2 常用静态类

属性描述
PI圆周率3.14159265358979323846
E自然对象2.7182818284590452354

1.1.3 常用方法

方法参数描述
absint/long/float/double计算一个数字的绝对值
max(int,int)/(long,long)/(float,float)/(double,double)计算两个数的最大值
min(int,int)/(long,long)/(float,float)/(double,double)计算两个数的最小值
roundfloat/double计算一个数的四舍五入
floorfloat/double计算一个数的向下取整
ceilfloat/double计算一个数的向上取整
pow(double,double)计算一个数的指定次幂
sqrtdouble计算一个数的平方根
random-获取(0,1)范围内的浮点型随机数

1.1.4实例代码

 package com.laity.basicSyntax.day6.aCommonClasses;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day6.aCommonClasses
  * @date Date : 2021年12月04日 0:23
  * @Description: 常用类Math的使用
  */
 public class MathUsage 
     public static void main(String[] args) 
         mathRandom();
         //
     
 ​
     /**
      * 关于Math类常用的属性和方法
      */
     public static void MathMethod() 
         // 1.关于Math的属性
         System.out.println(Math.PI);
         System.out.println(Math.E);
 ​
         // 2.常用方法
         // 2.1 求绝对值
         System.out.println(Math.abs(-10));
         int[] array = 1, 2, 3, 4, 5;
         // 2.2 求最大值
         System.out.println(Math.max(array[1], array[3]));
         // 2.3 求最小值
         System.out.println(Math.min(array[1], array[3]));
         // 2.4 四舍五入
         System.out.println(Math.round(3.1));
         // 2.5 向上取整
         Math.ceil(3.14);   // 找到第一个比3.14大的整数
         // 2.6 向下取整
         Math.floor(3.14);  // 找到第一个比3.14小的整数
         // 2.7 指定次幂
         System.out.println(Math.pow(3, 3));
         // 2.8 计算平方根
         System.out.println(Math.sqrt(2));  // 根号几
         // 2.9 计算一个数的3次方根
         System.out.println(Math.pow(27, 1.0 / 3.0));
         // 3.0 随机数 0-1 ---> float
         System.out.println(Math.random());
     
 ​
     public static void mathRandom() 
         for (int i = 0; i < 10; i++) 
             System.out.println(Math.random());
         
         // 生成0-100 的整型随机数
         for (int i = 0; i < 10; i++) 
             System.out.println((int) (Math.random() * 100));
         
         // 拓展需求 50-100
         for (int i = 0; i < 10; i++) 
             System.out.println((int)(Math.random() * 50 + 50));
         
     
 

1.2 常用类Random

1.2.1 概念

是一个专门负责产生随机数的类。在java中,random类在 java.util 包中。在使用之前,需要先导包。

  • 其实,随机数的产生,是一个由固定的随机数算法的。带入一个随机数种子,能够生成一个随机数列表。但是由于算法是固定的,因此会有一个“BUG”:比如

  • 随机数的种子相同,则生成的随机数列也是完全相同。

1.2.2 常用方法

方法参数描述
Random通过将系统时间作为随机数种子,实例化一个Random对象
Randomint通过一个指定的随机数种子,实例化一个Random对象
nexIntint生成一个[0, bounds) 范围内的整型随机数
nextInt生成一个int范围内的随机数
nextFloat生成一个[0,1) 范围内的float类型的随机数
nextDouble生成一个[0,1) 范围内的double类型的随机数
nextBoolean随机生成一个boolean类型数值

1.2.3 代码实例

 package com.laity.basicSyntax.day6.bRandom;
 ​
 import java.util.Random;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day6.bRandom
  * @date Date : 2021年12月04日 0:57
  * @Description: Random关键字
  */
 public class RandomUsage 
     public static void main(String[] args) 
         randomSeed();
     
 ​
     /**
      * 带有种子的随机数
      */
     private static void randomSeed()
         // 1. 通过一个随机数种子,实例化一个Random对象
         Random random = new Random(1);
         // 2. 生成10个100范围内的随机数
         for (int i = 0; i < 10; i++) 
             System.out.print(random.nextInt(100)+",");
         
         System.out.println();
         for (int i = 0; i < 10; i++) 
             System.out.print(random.nextInt(100)+",");
         
     
     /**
      * random 普通方法
      * nanotime 系统时间 以nanotime为种子
      */
     private static void randomBasic()
         // 1. 实例化一个对象
         Random random = new Random();
         // 2. 使用Random中的方法,生成随机数
         // random.nextInt();              // 生成int范围内的随机数[-2^31, 2^31-1]
         // random.nextInt(3);       // 生成 [0, bound) 范围内的随机数
         // random.nextBoolean();          // 随机生成一个boolean类型数值
         // random.nextDouble();           // 生成一个[0,1) 范围内的double类型的随机数
         // random.nextFloat();            // 生成一个[0,1) 范围内的float类型的随机数
         // 3. 需求:生成20个[0, 100) 范围内的随机数
         for (int i = 0; i < 20; i++) 
             System.out.println(random.nextInt(100));
         
         // 4. 需求:生成20个[50, 100) 范围内的随机数
         System.out.println(random.nextInt(50) + 50);
     
 

1.3 常用类BigInteger、BigDecimal

1.3.1 概念

这两个类都是用来表示数字的类,BigInteger表示整型数字,、BigDecimal表示浮点型数字。这两个类,可以用来描述非常、非常、非常大的数字。例如

整数,long是最大的表示范围,但是即便是long型,也有它表示不了的情况。、BigInteger就是可以表示任意大小的数字。

BigInteger:表示整型数字,不限范围。

BigDecimal:表示浮点型,不限范围,不限小数点后面的数字。

1.3.2 常用方法

 package com.laity.basicSyntax.day6.cBigIntegerClasses;
 ​
 import java.math.BigInteger;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day6.cBigIntegerClasses
  * @date Date : 2021年12月04日 1:45
  * @Description: BigInteger 与 BigDecimal的使用
  */
 public class BigIntegerUsage 
     public static void main(String[] args) 
         // 实例化一个BigInteger对象:描述相当大的数字
         BigInteger biginteger = new BigInteger("1111111111111111111111111111111111111111111111111111111111111111111111");
         BigInteger biginteger1 = new BigInteger("2222222222222222222222222222222222222222222222222222222222222222222222");
         System.out.println(biginteger);
         System.out.println(biginteger1);
         // 四则运算
         System.out.println(biginteger1.add(biginteger));  // 加
         System.out.println(biginteger1.subtract(biginteger));  // 减法
         System.out.println(biginteger1.multiply(biginteger));  // 乘法
         System.out.println(biginteger1.divide(biginteger));   // 除法
         // 除法 保留商和余数,商存在结果的数组的第0位,余数存在结果的数组的第一位
         BigInteger[] bigIntegers = biginteger1.divideAndRemainder(biginteger);
         System.out.println(bigIntegers[0]);
         System.out.println(bigIntegers[1]);
     
 
 // 将BigInteger转型成为其他的基本数据类型的数据
 // 也可以转字符串  toString()
 ​
 // BigDecimal 是一样的

1.4 常用类Date

1.4.1 概念

是一个用来描述时间、日期的类。在java.util包中!!!

1.4.2 常用方法

 package com.laity.basicSyntax.day6.dDateClasses;
 ​
 import java.util.Date;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day6.dDateClasses
  * @date Date : 2021年12月04日 2:03
  * @Description: Date
  */
 public class DateUsage 
     public static void main(String[] args) 
         // 1.实例化一个Date对象
         Date date = new Date();
         System.out.println(date);  // 获取当前时间 :Sat Dec 04 02:06:37 CST 2021
         System.out.println(date.getTime());  // 获取时间戳  1970-1-1 00:00:00:000 时间开始计算 到现在的毫秒
         System.out.println(date.getTime()/1000/60/60/24/365);  // 51年
         System.out.println(date.getDate());  // 获取日期
         System.out.println(date.getClass());
         // 设置时间戳
         date.setTime(123123114L);
         System.out.println(date);
         // 比较两个时间
         Date date1 = new Date(2132341413123L);
         System.out.println(date1);
         // date在date1之前 true
         System.out.println(date.before(date1));
     
 

1.5 常用类SimpleDateFormat

1.5.1 概念

是一个用来格式化时间的类。使用这个类,一般有两种操作

  • 将一个Date对象,转变成指定格式的时间字符串。

  • 将一个指定格式的字符串,转变成Date对象。

1.5.2 常用时间格式

在时间格式中,有几个常见的时间占位符。

占位符描述
y表示年。常用yyyy 表示长年份。 yy表示短年份。
M表示月。常用MM表示两个占位符,如果月份不够两位,往前补0.
d表示日。常用dd 表示两个占位符,如果日期不够两位,往前补0.
H表示时。24小时制,常用HH表示两个占位符,如果不够两位,补0.
h表示时。12小时制,常用hh 表示两个占位符,如果不够两位,补0.
m表示分。常用mm表示两个占位符,如果不够两位,补0
s表示秒。常用 ss 表示两个占位符,如果不够两位,补0.
S表示毫秒。常用SSS 表示三个占位符,如果毫秒不够三位,往前补0.

1.5.3 常用方法

 package com.laity.basicSyntax.day6.dDateClasses;
 ​
 import java.text.SimpleDateFormat;
 import java.util.Date;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day6.dDateClasses
  * @date Date : 2021年12月04日 2:31
  * @Description: SimpleDateFormat 格式化时间类
  */
 public class SimpleDateFormatUsage 
     public static void main(String[] args) 
         stringToDate();
     
 ​
     /**
      * 将日期对象,格式化为指定格式的字符串
      */
     public static void dateToString()
         Date date = new Date();
         // 格式化的字符串
         String format = "yyyy年MM月dd日 HH:mm:ss";
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
         // System.out.println(simpleDateFormat);
         String s = simpleDateFormat.format(date);
         System.out.println(s);
     
 ​
     /**
      * 将一个指定格式的字符串,转变为一个日期对象
      */
     public static void stringToDate()
         Date date = new Date();
         String format = "2021年12月04日 02:43:55";
         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
         Date parse = SimpleDateFormat.parse(format);
         System.out.println(parse);
     
 

2.1 包装类

2.1.1 概念

包装类,就是在基本数据类型的基础上,做一层包装。每一个包装类的内部都维护了一个对应的基本数据类型的属性,用来存储管理一个基本数据类型的数据。

包装类是一种引用数据类型,使用包装类,可以使得基本数据类型数据有着引用类型的特征。例如,可以存储在集合中。同时,包装类还添加了若干个特殊的方法。

2.1.2 基本数据类型对应的包装类型

基本数据类型包装类型
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

2.1.3 装箱拆箱

手动装箱/手动拆箱

2.1.4 手动装箱

概念: 由基本数据类型,完成向对应的包装类型进行转换。

方式1:可以通过每一个包装类的构造方法来完成。在每一个包装类的构造方法中,都有一个与之对应的基本数据类型作为参数的重载方法,此时,直接将需要包装起来的基本数据类型,写到构造方法的参数中即可完成装箱。

     /**
      * 完成手动的装箱
      * 由基本数据类型向引用数据类型的转换
      * 通过包装类的构造方法
      */
     public static void boxing() 
         // 1. byte -> Byte
         Byte num1 = new Byte((byte) 10);
         // 2. short -> Short
         Short num2 = new Short((short) 10);
         // 3. int -> Integer
         Integer num3 = new Integer(10);
         // 4. long -> Long
         Long num4 = new Long(10);
         // 5. float -> Float
         Float num5 = new Float(3.14f);
         // 6. double -> Double
         Double num6 = new Double(3.14);
         // 7. char -> Character
         Character num7 = new Character('a');
         // 8. boolean -> Boolean
         Boolean num8 = new Boolean(false);
     

方法2:可以通过包装类的静态方法 valueOf() 完成装箱。每一个包装类中,都有一个静态方法 valueOf(),这个方法的参数是包装类型对应的基本数据类型的参数。直接将需要包装起来的基本数据类型的数据,写到这个方法的参数中,即可完成对这个基本数据类型的装箱。

     /**
      * 第二种手动装箱 valueOf()
      */
     public static void boxing2()
         Byte num1 = Byte.valueOf((byte) 10);
         Short num2 = Short.valueOf((short) 10);
         Integer num3 = Integer.valueOf(10);
         Long num4 = Long.valueOf(10L);
         Float num5 = Float.valueOf(3.14F);
         Double num6 = Double.valueOf(3.14);
         Character num7 = Character.valueOf('a');
         Boolean num8 = Boolean.valueOf(true);
     

2.1.5 手动拆箱

概念:由包装类型,完成向对应的基本数据类型进行转换。

方式:使用每一个包装类型对象的 xxxValue 可以实现。这里的 xxx 就是需要转型的基本数据类型。例如,如果需要转型为int类型,则直接调用intValue 即可。

     /**
      * 完成手动的拆箱
      * 包装类型转基本数据类型
      */
     public static void unboxing() 
         Byte num1 = Byte.valueOf((byte) 10);
         byte n1 = num1.byteValue();
 ​
         Short num2 = Short.valueOf((short) 10);
         short n2 = num2.shortValue();
 ​
         Integer num3 = Integer.valueOf(10);
         int n3 = num3.intValue();
 ​
         Long num4 = Long.valueOf(10L);
         long n4 = num4.longValue();
 ​
         Float num5 = Float.valueOf(3.14F);
         float n5 = num5.floatValue();
 ​
         Double num6 = Double.valueOf(3.14);
         double n6 = num6.doubleValue();
 ​
         Character num7 = Character.valueOf('a');
         char n7 = num7.charValue();
 ​
         Boolean num8 = Boolean.valueOf(true);
         boolean n8 = num8.booleanValue();
     

备注:某些包装类对象,除了可以拆箱成对应的基本数据类型的数据之外。还可以将包装起来的数字转成其它的基本数据类型的数据。例如,Integer,除了有 intVlaue 之外,还有 byteValue 等方法。其实,就是将包装起来的int数据,强行转成byte类型返回结果。

2.1.6 自动装箱拆箱

概念:所谓的自动装箱和拆箱,指的是在进行装箱和拆箱的时候,不用再使用上面的方法完成装箱和拆箱的操作。在JDK1.5之后,装箱和拆箱是可以自动完成的!

只需要一个赋值语句。

方式:没有什么特殊的语句,直接去进行赋值即可。

 // 自动装箱:由一个基本数据类型,到对应的包装类型的转换。只需要一个赋值语句即可完成。
 Integer i1 = 10;
 // 自动拆箱:由一个包装类型
 int a = i1;

注意:既然有自动的装箱和拆箱,为什么还要掌握手动的装箱和拆箱。因为,在有些情况下,自动的装箱和拆箱是不能使用的。

示例:如果在一个类的重载方法中,有两个方法的参数类型,一个是基本数据类型,一个是对应的包装类型。此时,将无法使用自动装箱和拆箱。必须通过手动的装箱和拆箱完成对应的方法调用。

 package com.laity.basicSyntax.day7.ePackageClasses;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day7.ePackageClasses
  * @date Date : 2021年12月08日 23:14
  * @Description: 手动装箱和拆箱的使用场景
  */
 public class Boxing2 
     public static void main(String[] args) 
         test(10);
         // 只能手动装箱
         test(Integer.valueOf(10));
     
 ​
     public static void test(int a) 
         System.out.println("test(int a) 方法被调用了");
     
 ​
     public static void test(Integer a) 
         System.out.println("test(Integer a) 被调用了");
     
 

2.1.7 享元原则

概念:是程序设计的一个基本原则。当我们需要在程序中频繁的用到一些元数据的时候,此时,我们可以提前将这些元数据准备好,当需要的时候,直接拿过来使用即可。使用完成之后,也不进行销毁,以便下次继续使用。

包装类中的享元:将常用到的基本数据类型对应的包装类对象,预先存储起来。当使用到这些基本数据类型对应的包装类对象的时候,可以直接拿过来使用,不用再实例化新的对象了。

示例:Integer 类中,将[ -128, 127]范围内的数字对应的包装类对象预先存到了一个 Integer.cache 数组中,每当我们用到这个范围内的数字的时候,可以直接从这个数组中获取到元素。如果用到了不在这个范围内的数字,再去进行新的包装类对象的实例化。这样,不用频繁的开辟空间、销毁空间,节省CPU资源。

 package com.laity.basicSyntax.day7.ePackageClasses;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day7.ePackageClasses
  * @date Date : 2021年12月08日 23:54
  * @Description: 装箱中的享元原则
  */
 public class Boxing3 
     public static void main(String[] args) 
         Integer i1 = new Integer(10);
         Integer i2 = new Integer(10);
 ​
         System.out.println(i1 == i2);       // 比的是地址     false
         System.out.println(i1.equals(i2));  // 比的是value   true
 ​
         Integer i3 = Integer.valueOf(10);
         Integer i4 = Integer.valueOf(10);
         System.out.println(i3 == i4);   // true
         System.out.println(i3.equals(i4));
 ​
         Integer i5 = Integer.valueOf(200);
         Integer i6 = Integer.valueOf(200);
         System.out.println(i5 == i6);   // false
     
 

二、字符串

2.1 字符串的简介

2.2 字符串与基本数据类型的转换

2.2.1 基本数据类型转型字符串类型

概念:基本数据类型,转成字符串,希望得到的结果是这个数值转成字符串的样式。其实,就是直接给这个数值添加上双引号。

方式一:可以利用字符串拼接运算符完成。当加号两端有任意一方是字符串的时候,此时都会自动的把另一方也转成字符串,完成字符串的拼接,所以,当需要把一个基本数据类型的数据转成字符串的时候,只需在另一端拼接上一个空的字符串即可。

 int a = 10;
 String str = a + "";

[推荐使用] 方式二:使用字符串的静态方法 valueOf 完成

 String str = String.valueOf(10);

方式三:借助包装类的实例方法 toString 方法

 String str = Integer.valueOf(10).toString();

方法四:借助包装类的静态方法 toString 方法

 String str = Integer.toString(10);

2.2.2 字符串类型转型基本数据类型

概念:字符串类型转基本数据类型,其实就是解析出这个字符串中的内容,转型成对应的基本数据类型的表示。

注意事项一:基本数据类型转字符串肯定是没有问题的,但是由字符串转基本数据类型的时候,可能会出现问题,字符串中的内容,不一定能够转成希望转换的基本数据类型。

注意事项二:对于整数而言,字符串中如果出现了其他的非数字的字符,都会导致转整型失败,即便是小数点,也不可以转。这里并没有转成浮点数字,再转整数的过程。

方式一:使用包装类的静态方法 valueOf() 方法。

Integer num = Integer.valueOf("123");

方式二:使用包装类的静态方法 parsexxx 方法。这里的xxx就是要转换的基本数据类型。

 int num = Integer.parseInt("123");

注意:如果希望直接转成基本数据类型;推荐使用方式二 ,如果希望转成包装类型,推荐使用方式一。

字符串类型,没有类似于上面的方式,可以直接转成字符串类型。如果一个字符串,要转成字符,需要使用字符串的一个实例方法 charAt() 方法。使用这个方法,获取字符串中的指定下标位的字符。

2.2.3 字符串中常用的静态方法

返回值方法描述
Stringjoin()将若干个字符串拼接到一起,在拼接的时候,元素与元素之间以指定的分隔符进行分隔。
Stringformat()以指定的格式,进行字符串的格式化
 package com.laity.basicSyntax.day7.fString;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day7.fString
  * @date Date : 2021年12月09日 9:55
  * @Description: 字符串的静态方法
  */
 public class StringStaticMethod 
     public static void main(String[] args) 
         // join
         // delimiter 拼接时的分隔符  ""/","/...
         String join = String.join("", "hello", "word", "laity");
         System.out.println(join);
 ​
         // format
         // 以指定的格式,进行字符串的格式化
         String name = "laity";
         int age = 18;
         char gender = '男';
         /**
          * 常见占位符 :%s %d %c %f
          * %ns :凑够n位字符串,如果不够,补空格
          * %nd :凑够n位,如果不够补空格
          * %.nf :保留小数点后面指定位的数字
          */
         System.out.println(String.format("姓名:%s,年龄:%d,性别:%c", name, age, gender));
 ​
         // 格式化打印 手动添加换行
         System.out.printf("姓名:%s,年龄:%d,性别:%c \\n", name, age, gender);
     
 

2.2.4 StringBuffer和StringBuilder类

概念:都是用来操作字符串的类

// StringBuffer与StringBuilder完全一样
 package com.laity.basicSyntax.day7.gStringBuffer;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day7.gStringBuffer
  * @date Date : 2021年12月09日 10:14
  * @Description:
  */
 public class StringBufferUsage 
     public static void main(String[] args) 
         // 构造方法
         // 1.操作一个空字符串的StringBuffer的对象
         StringBuffer sb = new StringBuffer();
         // 2.
         StringBuffer sb1 = new StringBuffer("HELLO");
 ​
         // 3. 增:拼接字符串
         sb1.append("123");
         // 4. 增:指定位置添加
         sb1.insert(3, "2");
         // 5. 删:删除指定范围的数据
         sb1.delete(7,9);
         // 6. 删:删除指定下标的字符
         sb1.deleteCharAt(3);
         // 7. 改:替换指定部分的字符
         sb1.replace(0,4,"laity");
         // 8. 改:替换指定位的字符
         sb1.setCharAt(5,'-');
         System.out.println(sb1);
         // 9. 反转:前后倒置
         sb1.reverse();
     
 

区别

  • StringBuffer是线程安全的

  • StringBuilder是线程不安全的

使用场景:

  • 当处于多线程的环境中,多个线程同时操作这个对象,此时使用StringBuffer。

  • 当没有处于多线程环境中,只有一个线程来操作这个对象,此时使用StringBuilder。

执行效率:StringBuilder > StringBuffer > String

三、泛型

2.1 什么是泛型、为什么用泛型?

 泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?
 ​
 顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),
 ​
 然后在使用/调用时传入具体的类型(类型实参)。
 ​
 泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,
 ​
 操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。

2.2 泛型类

泛型类也就是把泛型定义在类中,这样用户在使用类的时候才把类型给确认下来。

具体的方法就是使用<>加上一个未知数,通常用 K T V 等大写字符表示,事实上只要是个单词就可以。

// 1.解决程序安全问题(要是有错误,编译时期就会报错)
 <大写的字母>
 // 泛型的好处
 1.在集合中,限制存储元素的类型,不用再使用元素的时候,逐个元素进行类型检查。
 2.可以提高代码的可读性。
 3.可以使某些发生在运行时期的错误,提前到编译时期。
 // 泛型的定义方式
 泛型,是定义在一对尖括号中的。在尖括号里面定义一个类型。此时,定义在这一对尖括号中的类型,就是泛型。
     泛型,是一个标识符,遵循大驼峰命名法。
     泛型,一般情况下,不用太长的类型来描述,一般情况下,只需要使用一个字母代替即可。
     如果需要定义多种泛型,直接在尖括号中定义,泛型和泛型之间用逗号隔开。
 ​
 泛型在类中的使用:在类名的后面,紧跟一对尖括号。
     class Dog <T,M>   // 一个或者多个参数

2.3 集合

 // 概念:集合和数组非常类似,是一个数据容器,用来存储引用数据类型的数据。在java中,集合不是泛指某一个类,而是若干个类组成的数据结构的实现。
 // 集合的特点:
 集合类这种框架是高性能的。对基本类集(动态数组、链接表、树和散列表)的实现是高效率的。
 集合类允许不同类型的集合以相同的方式和高度互操作方式工作。
 集合类容易扩散和修改,程序员可以很容易地稍加修改就能满足自己的数据结构需求。
 // 集合和数组的区别
 1.数组是固定长度的,而集合不是固定长度。
 2.数组中可以存储基本数据类型的数据,也可以存储引用数据类型的数据。
 3.集合中只能存储引用数据类型的数据,基本数据类型的数据需要进行装箱,才能存入集合中。
 // java中的集合,大致分为两类,分别是Collection集合和Map集合。
     其中,Collection是单列集合的顶级接口,Map接口是双列集合的顶级接口。

2.3.1 Collection接口

 
package com.laity.basicSyntax.day2.generic;
 ​
 import java.util.ArrayList;
 import java.util.Collection;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day2.generic
  * @date Date : 2021年11月15日 17:35
  * @Description: Collection接口
  */
 public class Demo1 
     public static void main(String[] args) 
         Collection<String> collection = new ArrayList<>();
         Collection<String> temp = new ArrayList<>();
         collection.add("Tom");
         collection.add("Laity");
         collection.add("Lily");
         collection.add("王五");
         collection.add("李明");
         collection.add("Jge");
 ​
         temp.add("张三");
         temp.add("J哥");
         collection.addAll(temp);      // addAll()
         collection.removeAll(temp);   // removeAll()
         collection.remove("Tom");  // 删除指定的名称
         // matches 正则表达式
         collection.removeIf(element -> element.matches("L.*"));  // removeIf 满足条件的进行删除  element是接收变量
         // collection.retainAll(temp);   // retainAll  在 temp出现的元素会被留下 没有被出现的会被删掉
         // collection.clear();  // 清空集合
         // 判断结合是否包含某一元素
         boolean flag = collection.contains("Laity");
         System.out.println("判断结合是否包含某一元素" + flag);
         int size = collection.size();  // 集合中元素的个数
         System.out.println("集合中元素的个数:" + size);
         boolean empty = collection.isEmpty(); // 判断集合是否为空
         System.out.println("判断集合是否为空:" + empty);
         Object[] obj = collection.toArray();   // 集合转数组
         for (Object o : obj) 
             System.out.println("集合转数组(循环遍历):" + o);
         
         // System.out.println(Arrays.toString(obj));
         System.out.println(collection);
     
 

2.3.2 Collection集合的遍历

 package com.laity.basicSyntax.day2.generic;
 ​
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day2.generic
  * @date Date : 2021年11月15日 18:02
  * @Description: 集合的遍历
  */
 public class Demo2 
     public static void main(String[] args) 
         Collection<String> collection = new ArrayList<>();
 ​
         collection.add("Tom");
         collection.add("Laity");
         collection.add("J哥");
         // iterator接口的使用
         Iterator<String> iterator = collection.iterator();// 迭代器对象
         // 通过迭代器遍历这个集合
         while (iterator.hasNext()) 
             String str = iterator.next();// 通过next得到下一个元素
             System.out.println(str);
         
         JDK1_8(collection);
 ​
         // str(collection);
     
 ​
     /**
      * JDK1.8之后的新遍历方法
      *
      * @param collection
      */
     public static void JDK1_8(Collection<String> collection) 
         collection.forEach(element -> System.out.println(element));
     
 ​
     /**
      * 增强的for循环
      *
      * @param collection 被遍历的集合
      */
     public static void str(Collection<String> collection) 
         for (String str : collection) 
             System.out.println(str);
         
     
 

2.3.3 List集合

 package com.laity.basicSyntax.day2.generic;
 ​
 import java.util.ArrayList;
 import java.util.List;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day2.generic
  * @date Date : 2021年11月15日 19:16
  * @Description: List的API(它是Collection的子)
  */
 public class Demo3 
     public static void main(String[] args) 
         List<String> list = new ArrayList();
 ​
         list.add("laity");
         list.add("王宏");
         list.add("王卫");
         list.add("王高");
 ​
         // 在下标为1的位置添加一个元素
         list.add(1, "王五");
         System.out.println(list);
         // 有些方法和Collection的都相同就不做演示了
         // addAll();
         // remove();
         // set() 修改
         list.set(2, "J哥");
         System.out.println(list);
         // replaceAll
         // list.replaceAll(element -> element.concat("aa"));  // 参数是一个接口类型的  concat()字符串的连接 aa 字符串
         // System.out.println(list);
         String s = list.get(0); // 通过get获取指定的元素
         System.out.println(s);
 ​
         int index = list.indexOf("王高"); // indexOf 获取指定元素的下标
         index = list.lastIndexOf("王高"); // 最后出现该元素的下标
         System.out.println(index);
 ​
         List<String> list1 = list.subList(1, 3);  // subList截取元素返回的仍然是List
         System.out.println(list1);
         
     
 
// List集合的排序
 方法原型: sort()
 package com.laity.basicSyntax.day2.generic;
 ​
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day2.generic
  * @date Date : 2021年11月15日 20:07
  * @Description: List集合的排序
  */
 public class Demo4 
     public static void main(String[] args) 
         List<String> list = new ArrayList<>();
 ​
         list.add("laity");
         list.add("王宏1");
         list.add("王卫11");
         list.add("王高");
 ​
         // list.sort(new MyCompare());
 ​
         // list.sort((e1, e2) -> e1.length() - e2.length()); 从短到长
         list.sort((e1, e2) -> e2.length() - e1.length());   // 从长到短
         list.forEach(ele -> System.out.println(ele));
     
 
 ​
 class MyCompare implements Comparator<String> 
     @Override
     public int compare(String o1, String o2) 
         return o1.length() - o2.length();
     
 

四、正则表达式

每个语言都有

 

 package com.laity.basicSyntax.day8.aRegex;
 ​
 /**
  * @author : Laity
  * @Project: JavaLaity
  * @Package com.laity.basicSyntax.day8.aRegex
  * @date Date : 2021年12月09日 19:32
  * @Description: 正则表达式的语法
  */
 public class RegexSyntax 
     public static void main(String[] args) 
         basicSyntax1();
     
     /**
      * 正则表达式的基础语法规则
      */
     public static void basicSyntax1()
         boolean flag = "hello".matches("hello");
         System.out.println(flag);
     
 
 
matches
 ^   $   a-z A-Z 0-9  \\\\  .  .*  .*?  + 
 ?:前面的一位或者一组字符,连续出现了一次或零次
 +:前面的一位或者一组字符,连续出现了一次或多次
 *:前面的一位或者一组字符,连续出现了任意的次数(包括0次,一次和多次)
 m :前面的一位或者一组字符,连续出现了m次
 m.:前面的一位或者一组字符,连续出现了至少m次,最多不限制
 m, n:前面的一位或者一组字符,连续出现了至少m次,最多n次
     
public static void example() 
         // 1. QQ号码的验证
         System.out.println("1400017254".matches("^[1-9][0-9]5,11"));
         // 2. 验证一个邮箱是否是一个qq邮箱
         System.out.println("1400017254@qq.com".matches("^[1-9]\\\\d5,11@qq\\\\.com"));
         // 3. 验证一个手机号是否是一个手机号
         System.out.println("13434345656".matches("^1[356789]\\\\d9"));
     
   
  /**
      * 切割
      */
     public static void example2() 
         // 可以将一个字符串,按照指定的规则部分,切割成若干段
         String names = "Laity   lily  Kitty  Tom    Lucy";
         // 可以按照空格进行切割
         String[] s = names.split(" +");
         System.out.println(Arrays.toString(s));
     
/**
      * 正则表达式的替换
      */
     public static void replaceTest() 
         // 1.准备一个字符串
         String names = "Laity   lily  Kitty  Tom    Lucy";
         String s = names.replaceAll(" 2,", ",");
         System.out.println(s);
     
         names.replaceFirst()  // 只替换第一个匹配的
     // 需求 : 结果为 132****4545
     public static void replaceTest2() 
         String tip = "13234344545";
         String tp = tip.replaceFirst("(\\\\d3)(\\\\d4)(\\\\d4)", "$1****$3");
         System.out.println(tp);  // 132****4545
     

以上是关于JavaEE入门级别最全教程3--初学者必看的主要内容,如果未能解决你的问题,请参考以下文章

JavaEE入门级别最全教程2--初学者必看

JavaEE入门级别最全教程2--初学者必看

JavaEE入门级别最全教程1--初学者必看

JavaEE入门级别最全教程4--初学者必看

tensorflow新手必看,tensorflow入门教程,tensorflow示例代码

Typora入门:全网最全教程