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 常用方法
| 方法 | 参数 | 描述 |
|---|---|---|
| abs | int/long/float/double | 计算一个数字的绝对值 |
| max | (int,int)/(long,long)/(float,float)/(double,double) | 计算两个数的最大值 |
| min | (int,int)/(long,long)/(float,float)/(double,double) | 计算两个数的最小值 |
| round | float/double | 计算一个数的四舍五入 |
| floor | float/double | 计算一个数的向下取整 |
| ceil | float/double | 计算一个数的向上取整 |
| pow | (double,double) | 计算一个数的指定次幂 |
| sqrt | double | 计算一个数的平方根 |
| 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对象 |
| Random | int | 通过一个指定的随机数种子，实例化一个Random对象 |
| nexInt | int | 生成一个[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 基本数据类型对应的包装类型
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
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 字符串中常用的静态方法
| 返回值 | 方法 | 描述 |
|---|---|---|
| String | join() | 将若干个字符串拼接到一起，在拼接的时候，元素与元素之间以指定的分隔符进行分隔。 |
| String | format() | 以指定的格式，进行字符串的格式化 |
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--初学者必看的主要内容，如果未能解决你的问题，请参考以下文章