JAVA基础

发表于： 2020年10月18日 2023年1月13日
分类： JAVA

JAVA虚拟机
JAVA原反补
JAVA常量优化机制
JAVA取余
JAVA++ 和 --
JAVA短路与(&&)和短路或(||)
JAVA逻辑运算符
JAVA位运算符
JAVA键盘录入
JAVA循环
JAVA代码优化
JAVA void方法
JAVA 重载
JAVA数组
JAVA中的内存分配
JAVA 动态静态数组
JAVA数组异常
JAVA参数传递
JAVA引用数据类型：
JAVA代码块
JAVA 抽象
JAVA接口
JAVA 包
四种权限修饰符
修饰符
JAVA内部类
JAVA Eclipse 快捷键
JAVA断点调试
JAVA API
equals和==
Scanner类
String类
String中的方法
String 字符串操作方法
String类的转换功能
JAVA StringBuffer
Arrays类的概述和方法使用
包装类
String和int类型相互转换
正则
正则1：
预定义字符
数量词
split
给定字符串中的数字排序
正则的替换功能replaceAll
正则表达式的分组功能
pattern 和 matcher
Math常用方法
Random类概述
System类的概述及方法
BigInteger类的概述和方法使用
BigDecimal类的概述和方法使用
Date类的概述和方法使用
SimpleDateFormat类实现日期和字符串的相互转换
你来到这个世界多少天案例
Calendar类的概述和获取日期的方法
Calendar类的add()和set()方法
如何获取任意年份是平年还是闰年
集合的由来及集合继承体系图

JAVA虚拟机
JAVA原反补
JAVA常量优化机制
JAVA取余
JAVA++ 和 --
JAVA短路与(&&)和短路或(||)
JAVA逻辑运算符
JAVA位运算符
JAVA键盘录入
JAVA循环
JAVA代码优化
JAVA void方法
JAVA 重载
JAVA数组
JAVA中的内存分配
JAVA 动态静态数组
JAVA数组异常
JAVA参数传递
JAVA引用数据类型：
JAVA代码块
JAVA 抽象
JAVA接口
JAVA 包
四种权限修饰符
修饰符
JAVA内部类
JAVA Eclipse 快捷键
JAVA断点调试
JAVA API
equals和==
Scanner类
String类
String中的方法
String 字符串操作方法
String类的转换功能
JAVA StringBuffer
Arrays类的概述和方法使用
包装类
String和int类型相互转换
正则
正则1：
预定义字符
数量词
split
给定字符串中的数字排序
正则的替换功能replaceAll
正则表达式的分组功能
pattern 和 matcher
Math常用方法
Random类概述
System类的概述及方法
BigInteger类的概述和方法使用
BigDecimal类的概述和方法使用
Date类的概述和方法使用
SimpleDateFormat类实现日期和字符串的相互转换
你来到这个世界多少天案例
Calendar类的概述和获取日期的方法
Calendar类的add()和set()方法
如何获取任意年份是平年还是闰年
集合的由来及集合继承体系图

JAVA虚拟机

虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机有自己完善的硬体架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。JVM屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。

JAVA原反补

JAVA常量优化机制

给一个变量赋值，如果等于号的右边是常量的表达式并且没有一个变量，那么就会在编译阶段计算该表达式的结果，然后判断该表达式的结果是否在左边类型所表示范围内，如果在，那么就赋值成功，如果不在，那么就赋值失败。但是注意如果一旦有变量参与表达式，那么就不会有编译期间的常量优化机制

JAVA取余

JAVA++ 和 --

JAVA短路与(&&)和短路或(||)

JAVA逻辑运算符

JAVA位运算符

JAVA键盘录入

JAVA循环

JAVA代码优化

JAVA void方法

JAVA 重载

JAVA数组

JAVA中的内存分配

JAVA 动态静态数组

JAVA数组异常

JAVA参数传递

JAVA引用数据类型：

数组、类、接口

JAVA代码块

静态代码块优先于主方法执行，也就优先于所有方法。

JAVA 抽象

当无法描述一个类的方法时，就把类和方法定义为抽象的，由子类强制重写方法。

抽象方法必须存在于抽象类中

JAVA接口

interface 接口中可以定义方法，接口中的方法都是抽象的。

实例化需要父类引用指向子类对象

die i = new er();

接口中的成员变量都是public static final 公开静态常量

接口所有方法都是公开的

JAVA 包

四种权限修饰符

修饰符

外部类不能用私有也不可以用protected 因为protected是受保护的对其它类相当于私有

当一个类中所有的方法都是静态的我们把这个类中的构造方法私有

JAVA内部类

如果内部类被私有，只能通过类定义方法调用

匿名内部类框里代表inter接口的子类对象，调用子类对象的方法直接大括号后加.方法()

JAVA面向对象

JAVA Eclipse 快捷键

JAVA断点调试

功能类似单步向下

功能类似于单步步入

JAVA API

equals和==

Scanner类

String类

引用数据类型进堆 String类型进常量池 class进方法区方法进栈

String中的方法

模拟登陆

String 字符串操作方法

public class Demo5_StringMethod {

public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
String s = "woaiheima";
s.substring(4); //substr会产生一个新的字符串，需要新的引用接收
System.out.println(s);

}

private static void demo4() {
String s1 = "heimawudi";
String s2 = s1.substring(5);//从指定位置开始截取字符串，默认到字符串结尾
System.out.println(s2);

String s3 = s1.substring(0,5);//从指定位置开始截取字符串，截取到指定位置左闭右开区间
System.out.println(s3);
}

private static void demo3() {
String s1 = "woaiheima";
int index = s1.indexOf('a',3);//从指定位置开始向后查找给出的字符
System.out.println(index);

int index1 = s1.lastIndexOf('a');//从后向前找，第一次出现的字符
System.out.println(index1);

int index2 =s1.lastIndexOf('a',7);//从指定位置向前找
System.out.println(index2);
}

private static void demo2() {
String s1 = "heima";
int index = s1.indexOf("h");//参数接收的是int类型的，传递char类型的会自动类型提升
System.out.println(index);
int index1 = s1.indexOf("v"); //如果不存在返回-1
System.out.println(index1);
int index2 = s1.indexOf("ma"); //获取字符串中第一个字符出现的位置
System.out.println(index2);
int index3 = s1.indexOf("ia"); //找不到返回-1
System.out.println(index3);
}

private static void demo1() {
String s1 = "heima";
System.out.println(s1.length());
String s2 = "你要减肥，造吗？";
System.out.println(s2.length());//lenth()是一个方法，获取的是每一个字符的个数

char c =s2.charAt(2); //根据索引获取对应位置的字符
System.out.println(c);
char d =s2.charAt(21); //tringIndexOutOfBoundsException字符串索引越界异常
System.out.println(d);
}

}

String类的转换功能

import com.heima.bean.Person;
public class Demo6_StringMethod {
public static void main(String[] args) {
//demo1();
//demo2();
//demo3();
String s1 ="hEimA";
String s2 = "chengxuYuAN";

String s3 = s1.toLowerCase(); //将字符串所有字符转化为小写
String s4 = s2.toUpperCase(); //将字符串所有的字符转化为大写
System.out.println(s3);
System.out.println(s4);
System.out.println(s3+s4); //用加号"+"拼接字符串更强大，可以用字符串与任意类型相加
System.out.println(s3.concat(s4)); //concat方法调用的和传入的都必须是字符串

}
private static void demo3() {
char[] arr = {'a','b','c'};
String s = String.valueOf(arr);
System.out.println(s);

String s1 = String.valueOf(100);
System.out.println(s1); //将100转化为字符串

Person p =new Person("张三",23);
System.out.println(p);
String s3 = String.valueOf(p);//调用的是对象的toString方法
System.out.println(s3);
}
private static void demo2() {
String s ="heima";
char[] arr =s.toCharArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]+ " ");
}
}
private static void demo1() {
String s1 = "abc";
byte[] arr =s1.getBytes();
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
String s2 = "你好你好";
byte[] arr1 =s2.getBytes();
for (int i = 0; i < arr1.length; i++) { //编码过程，将我们看得懂的转化为机器看得懂的
System.out.print(arr1[i]+" ");//gbk编码一个字占两个字节中文第一个字节肯定是负数
}
}
}

public class Test4 {
//将一个字符串首字母转化为大写，其他小写
// 链式编程只要保证每次调用方法返回的是对象，就可以继续调用由于字符串属于引用数据类型，所以字符串.方法相当于对象.方法
public static void main(String[] args) {
String s = "woaiheimaNIaiMa";
String s1 = s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());
System.out.println(s1);
}

}

public class Test5 {
public static void main(String[] agrs){
/*把数组中的数据按照指定格式拼接成一个字符串
int[] arr = {1,2,3}
输出
"[1,2,3]"*/
int[] arr = {1,2,3};
System.out.println(arr.length);
String s = "["; //定义一个字符串用来与数据中元素拼接
for (int i = 0; i < arr.length; i++) {
if(i == arr.length -1){
s = s+arr[i]+"]";
}else{
s = s+arr[i]+",";
}

}
System.out.println(s);
}
}

import java.util.Scanner;

public class Test6 {
/* 将字符串反转 abc 换为 cba
1.通过键盘录入获取字符串
2.将字符串转换为字符数组
3.倒着遍历字符数组，并再次拼接成字符串*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //创建键盘录入对象
System.out.println("请输入一个字符串：");
String line =sc.nextLine(); //将键盘录入字符串存储在line

char[] arr = line.toCharArray(); //将字符串转化为字符数组
String s = "";
for (int i = arr.length-1; i >=0; i--) {//创建遍历字符数组
s = s+arr[i]; //拼接字符串
}
System.out.println(s);
}

}

public class Test7 {
// 统计大串中小串出现的次数

public static void main(String[] args) {
String max = "woaiheima,heimazuiniubi"; //定义大串
String min = "ma"; //定义小串

int count = 0; //定义计数器
int index =0; //定义索引
while((index = max.indexOf(min))!= -1){ //定义循环，判断小串是否在大串中出现第一次小串出现后，返回第一次出现的索引并与-1比较不相等进入循环体，计数器加1
count++;
max = max.substring(index + min.length());//将大串截断，截取第一次出现小串后不包含第一次小串的所有字符赋值给循环条件相当于一直减少大串的长度，一直找小串第一次出现
}
System.out.println(count);
}

}

JAVA StringBuffer

构造函数

public class Dome1_StringBuffer {

public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
System.out.println(sb.length()); //容器中的字符个数，实际值
System.out.println(sb.capacity()); //容器的初始容量，理论值

StringBuffer sb1 = new StringBuffer(10);
System.out.println(sb1.length());
System.out.println(sb1.capacity());

StringBuffer sb2 = new StringBuffer("heima");
System.out.println(sb2.length()); //实际字符的个数
System.out.println(sb2.capacity()); //为什么是21 21是字符串的length+初始容量

}

}

添加功能

public class Dome2_StringBuffer {
//StringBuffer 是字符串缓冲区，当new的时候是在堆内存创建了一个对象，底层是一个长度为16的数组
//当调用添加的方法时，不会重新创建对象，在不断向原缓冲区添加字符
public static void main(String[] args) {
// demo1();
StringBuffer sb = new StringBuffer("1234");
sb.insert(3, "heima"); //在指定位置添加元素，如果没有指定位置的索引就会报索引越界异常
System.out.println(sb);
}

private static void demo1() {
StringBuffer sb = new StringBuffer();//其实四个引用指向的是同一个对象
System.out.println(sb.toString());
StringBuffer sb1 = sb.append(true);
System.out.println(sb1.toString());
StringBuffer sb2 = sb.append("heima");
System.out.println(sb2.toString());
StringBuffer sb3 = sb.append(100);
System.out.println(sb3.toString());
System.out.println("-----------------------");
System.out.println(sb.toString());//被重写了toString方法,显示的是对象中的属性值
System.out.println(sb1.toString());
System.out.println(sb2.toString());
System.out.println(sb3.toString());
}

}

删除

public class Demo3_StringBuffer {

public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//sb.deleteCharAt(5); //当缓冲区索引上没有元素的时候就会爆字符串越界异常

sb.append("heima");
//sb.deleteCharAt(4);
//sb.delete(0, 2); //ima 包含头不包含尾

sb.delete(0, sb.length()); //清空缓冲区
System.out.println(sb);

}

}

替换和反转

public class Dome4_StringBuffer {

public static void main(String[] args) {
StringBuffer sb = new StringBuffer("heima");
sb.replace(0, 3, "bai");
System.out.println(sb);

sb.reverse();
System.out.println(sb);

}

}

截取功能

public class Dome5_StringBuffer {
//substring函数
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("woaiheima");
String s = sb.substring(4);
System.out.println(s); //截取从索引到末尾
String s1 = sb.substring(4,7);
System.out.println(s1);
}

}

String和StringBuffer互相转化

public class Dome6_StringBuffer {

public static void main(String[] args) {
// demo1();
StringBuffer sb = new StringBuffer("heima");
String s1 = new String(sb);//通过构造将StringBuffer转换为String

System.out.println(s1);
System.out.println(sb.toString()); //通过toString方法将StringBuffer转换为String

String s2 = sb.substring(0,sb.length());//通过截取转化

}

private static void demo1() {
StringBuffer sb = new StringBuffer("heima"); //通过构造方法将字符串转化为StringBuffer对象
System.out.println(sb);
StringBuffer sb1 = new StringBuffer();
sb1.append("heima");
System.out.println(sb1);//通过append方法将字符串转化为StringBuffer对象
}

}

数组转化为字符串

public class Test1 {
public static void main(String[] args) {
// 将数组拼接为字符串 int[] arr = {1,2,3}; "[1,2,3]"
int[] arr = {1,2,3};
System.out.println(array2String(arr));

}
public static String array2String(int[] arr){
StringBuffer sb = new StringBuffer();
sb.append("[");//将左中括号添加到缓冲区
for (int i = 0; i < arr.length; i++) {//遍历数组
//sb.append(arr[i]+", "); //这样做没有右中括号
if(i==arr.length-1){
sb.append(arr[i]).append("]");
}else{
sb.append(arr[i]).append(", ");//这样不会生成新的对象省内存
}
}
return sb.toString();
}
}

字符串反转

import java.util.Scanner;

public class Test2 {
public static void main (String[] args){
System.out.println("请输入字符串");
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();

/*StringBuffer sb = new StringBuffer(line);//将字符串转化为StringBuffer对象
sb.reverse();
System.out.println(sb);*/
System.out.println(revString(line));
}
public static String revString(String line){
StringBuffer sb = new StringBuffer(line);
sb.reverse();

return sb.toString();

}
}

StringBuffer 和 StringBuilder区别

String 和StringBuffer分别当作参数传递

public class Dome7_StringBuffer {
//基本数据类型值传递不改变其值
// 引用数据类型值传递，改变其值
// String虽然是引用数据类型，但是他当作参数产地时和基本数据类型是一样的

public static void main(String[] args) {
String s ="heima";
System.out.println(s);
change(s);
System.out.println(s);

StringBuffer sb = new StringBuffer();
sb.append("heima");
change(sb);
System.out.println(sb);
}

public static void change(String s) {

s += "itcast";
}

public static void change(StringBuffer sb) {
sb.append("itcast");

}

}

数组高级冒泡排序

public class Demo1_Array {

public static void main(String[] args) {
int[] arr = {11,43,21,1,88};
bubbleSort(arr);
print(arr);
}
public static void bubbleSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {//外循环只需要比较arr.length-1次
for (int j = 0; j < arr.length-1-i; j++) {//-1为了防止索引越界
if(arr[j]>arr[j+1]){
int temp =arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
public static void print(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]+" ");
}
}
}

数组高级选择排序

public class Demo1_Array {

public static void main(String[] args) {
int[] arr = {11,43,21,1,88};
//bubbleSort(arr);
selectSort(arr);
print(arr);
}

//冒泡排序
public static void bubbleSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {//外循环只需要比较arr.length-1次
for (int j = 0; j < arr.length-1-i; j++) {//-1为了防止索引越界
if(arr[j]>arr[j+1]){
/*int temp =arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;*/
swap(arr,i,j+1);
}
}
}
}
//打印数组
public static void print(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]+" ");
}
}
//选择排序
public static void selectSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j < arr.length; j++) {
if(arr[i]>arr[j]){
swap(arr,i,j);
}
}
}
}
// 换位操作如果某个方法只针对本类使用，不想让其他类使用可以定义为private
private static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

二分法

二分查找的前提是元素有序

public class Demo2_Array {

public static void main(String[] args) {
int[] arr ={11,22,33,44,55,66,77};
System.out.println(getIndex(arr, 22));
System.out.println(getIndex(arr, 11));
System.out.println(getIndex(arr, 77));
System.out.println(getIndex(arr, 79));
}
//二分查找
/*1.返回值类型为索引 int
2.参数列表int[] arr,int value*/
public static int getIndex(int[] arr,int value){
int min = 0;
int max = arr.length-1;
int mid = (min+max)/2;

while(arr[mid]!=value){ //当中间值不等于要找的值，就开始循环查找
if(arr[mid]<value){ 当中间值小于要找的值="" min="mid" +="" 1;="" 最小的索引改变="" }else="" if(arr[mid]="">value){ //当中间值大于了要找的值
max = mid - 1; //最大的索引改变
}

mid = (min+max)/2; //无论最大还是最小改变，主键索引都会改变

if(min>max){ //如果最小索引大于了最大索引，就没必要找返回-1
return -1;
}
}

return mid;
}
}

Arrays类的概述和方法使用

toString方法：数组转字符串

sort方法：排序

binarySearch：二分法查找值

import java.util.Arrays;

public class Demo3_Arrays {

public static void main(String[] args) {
int[] arr ={33,22,11,44,55,66};
System.out.println(Arrays.toString(arr));//数组转字符串

Arrays.sort(arr);
System.out.println(Arrays.toString(arr));//排序

int[] arr1 = {11,22,55,44,55,66,77};
System.out.println(Arrays.binarySearch(arr1, 55));
System.out.println(Arrays.binarySearch(arr1, 12));
}

}

包装类

public class Demo2_Integer {
//integer 构造方法传入一个int类参数或int字符串
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);

Integer i1 = new Integer(100);
System.out.println(i1);

Integer i2 = new Integer(100);
System.out.println(i2);
}

}

String和int类型相互转换

public class Demo3_Integer {
//基本数据类型有八种，其中七种都有paresxxx的方法，可以将这七种的字符串表现形式转换为基本数据类型
//char的包装类里没有paresxxx方法
// 字符串到字符的转换通过toCharArray就可以将字符串转化为字符数组
public static void main(String[] args) {

//int---->String
int i =100;
String s1 = i+""; //推荐用

String s2 = String.valueOf(i);//推荐用

Integer i2 = new Integer(i);
String s3 = i2.toString();

String s4 = Integer.toString(i);
System.out.println(s3);

// String--->int

String s = "200";
Integer i3 = new Integer(s);
int i4 = i3.intValue(); //Integer 转换成int

int i5 =Integer.parseInt(s); //将String转换为int 推荐
}

}

自动装箱和拆箱

public class Demo4_JDK5 {

public static void main(String[] args) {

int x = 100;
Integer i1 = new Integer(x);

int y = i1.intValue();

Integer i2 = 100;//自动装箱将基本数据类型转换为对象
int z = i2 + 200; //自动拆箱，把对象转换为基本数据类型
System.out.println(z);

Integer i3 = null; //底层i3调用intValue，但是i3是null null调用方法就会出现空指针异常
int a = i3+100;
System.out.println(a);
}

}

正则

校验qq

public class Demo1_Regex {
public static void main(String[] args){
System.out.println(checkQQ("12345"));

String regex = "[1-9]\\d{4,14}";
System.out.println("0121278".matches(regex));
}
/*
* 需求：检验qq号
* 1：要求必须是5-15位数字
* 2：0不能开头
* 3：必须都是数字
* 4：检验qq：
* 1，明确返回值为boolean
* 2，明确参数列表为String qq
* */
public static boolean checkQQ(String qq){
boolean flag = true; //如果校验qq不符合要求，就把flag置为false，如果符合要求直接返回
if(qq.length()>=5&&qq.length()<=15){
if(!qq.startsWith("0")){
char[] arr = qq.toCharArray();//将字符串转化为字符数组
for(int i = 0;i<arr.length;i++){
char ch = arr[i]; //记录每一个字符
if(!(ch>='0'&&ch<='9')){ //不是数字
flag = false;
break;
}
}
}else{
flag = false; //以0开头不符合qq标准
}
}else{
flag = false; //长度不符合
}

return flag;

}
}

正则1：

public class Demo2_Regex {

public static void main(String[] args) {
// demo1();
// demo2();
// demo3();
// demo4();
// demo5();
// demo6();
String regex = "[a-z&&[^m-p]]"; //a-z和除了m-p的交集也就是a-l q-z
System.out.println("m".matches(regex));
System.out.println("q".matches(regex));

}

private static void demo6() {
String regex = "[a-z&&[^def]]";
System.out.println("a".matches(regex));
System.out.println("1".matches(regex));
System.out.println("d".matches(regex));
}

private static void demo5() {
String regex = "[a-z&&[def]]"; //a-z和def 的交际相当于[def]
System.out.println("d".matches(regex));
System.out.println("a".matches(regex));
}

private static void demo4() {
String regex = "[a-d[m-p]]";
System.out.println("a".matches(regex));
System.out.println("n".matches(regex));
System.out.println("z".matches(regex));
}

private static void demo3() {
String regex = "[a-zA-Z]";//包含头包含尾
System.out.println("a".matches(regex));
}

private static void demo2() {
String regex = "[^abc]"; //除了abc以外的字符
System.out.println("a".matches(regex));
System.out.println("1".matches(regex));
System.out.println("10".matches(regex)); //10代表的是1 和 0 是两个字符
}

private static void demo1() {
String regex = "[abc]"; //中括号代表单个字符代表a字符或b字符或c字符
System.out.println("a".matches(regex));
System.out.println("v".matches(regex));
System.out.println("1".matches(regex));
}

}

预定义字符

public class Demo3_Regex {

public static void main(String[] args) {
/* 预定义字符
* .任何字符
* \d 数字：[0-9]
* \D 非数字: [^0-9]
* \s 空白字符：[ \t\n\x0B\f\r] \t table \n 换行 \x0B 垂直table \f翻页 \r 回车
* \S 非空白字符： [^\s]
* \w 单词字符： [a-zA-Z_0-9]
* \W 非单词字符： [^\w]
* */
// demo1();
// demo2();
// demo3();
// demo4();
// demo5();
// demo6();
String regex = "\\W";
System.out.println("1".matches(regex));
System.out.println("?".matches(regex));

}

private static void demo6() {
String regex = "\\w";
System.out.println("1".matches(regex));
System.out.println(" ".matches(regex));
}

private static void demo5() {
String regex = "\\S";
System.out.println("1".matches(regex));
System.out.println(" ".matches(regex));
}

private static void demo4() {
String regex = "\\s";
System.out.println(" ".matches(regex));
System.out.println("1".matches(regex));
System.out.println(" ".matches(regex));//table算一个空格
}

private static void demo3() {
String regex = "[^0-9]";
System.out.println("1".matches(regex));
System.out.println("a".matches(regex));
}

private static void demo2() {
String regex = "\\d"; //反斜线代表转义字符，如果需要反斜线这个符号，需要\\d
System.out.println("1".matches(regex));
System.out.println("a".matches(regex));
}

private static void demo1() {
String regex = "..."; //几个点代表几个字符
System.out.println("a".matches(regex));
System.out.println("121".matches(regex));
}

}

数量词

public class Demo4_Regex {

public static void main(String[] args) {
/*数量词
* X? X,一次或一次也没有,不能只出现不存在的
* X* X零或多次
* X+ X，一次或多次
* X{n} X恰好n次
* X{n,} X至少n次
* X{n,m} 至少n次，但不能超过m次
* */
// demo1();
// demo2();
String regex = "[abc]+";
System.out.println("aaaaaaaa".matches(regex));
System.out.println("v".matches(regex));
System.out.println("".matches(regex));
}

private static void demo2() {
String regex = "[abc]*";
System.out.println("aaa".matches(regex));
System.out.println("v".matches(regex));
System.out.println("".matches(regex));
}

private static void demo1() {
String regex = "[abc]?";
System.out.println("a".matches(regex));
System.out.println("v".matches(regex));
System.out.println("".matches(regex));
}

}

正则表达式的分割split

public class Demo5_Regex {
public static void main(String[] args) {
String s = "金三胖.郭美美.李dayone";
String[] arr = s.split("\\."); //点代表任意字符用.这个当字符时需要用\\转义
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}

给定字符串中的数字排序

public class Test1 {
public static void main(String[] args) {
/*字符串 "91 27 46 38 99" 实现从小到大输出给定字符串中的数字排序
1.将字符串切割为字符串数组
2.将字符串转换为数字并将其储存在一个等长度的int数组中
3.排序后的结果遍历并拼接成一个字符串*/

String s = "91 27 46 38 99";
String[] arr = s.split(" ");//1.将字符串切割为字符串数组
int[] arr1 = new int[arr.length];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = Integer.parseInt(arr[i]);
}
//排序
Arrays.sort(arr);

//将排序后结果遍历并拼接成字符串
/*String str = "";
for (int i = 0; i < arr1.length; i++) {
if(i == arr.length-1){
str = str+arr[i];
}else{
str = str+arr[i]+" ";
}
}
System.out.println(str);*/
StringBuilder sb = new StringBuilder(); //更节约内存
for (int i = 0; i < arr1.length; i++) {
if(i == arr.length-1){
sb.append(arr[i]);
}else{
sb.append(arr[i]+" ");
}
}
System.out.println(sb.toString());
}
}

正则的替换功能replaceAll

public class Demo6_Regex {
//正则表达式的替换功能 replaceAll方法
public static void main(String[] args) {
String s = "wo1ai2heima";
String regex = "\\d"; //\\d代表任意数字

String s1 = s.replaceAll(regex, " ");
System.out.println(s1);
}

}

正则表达式的分组功能

public class Demo7_Regex {
public static void main(String[] args) {
// demo1();

// demo2();
//按照叠词切割
// demo3();

/*我...我...要...要..学...学...习..习.
* */
String s = "我...我...要...要..学...学...习..习.";
String s1 = s.replaceAll("\\.+", "");
String s2 = s1.replaceAll("(.)\\1+", "$1");//$1 代表第一个组内的元素

System.out.println(s2);
}
private static void demo3() {
String s = "sdqqfgkkkhjppppk1";
String regex = "(.)\\1+";//+代表出现一次或多次
String[] arr =s.split(regex);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
private static void demo2() {
String regex ="(..)\\1";
System.out.println("死啦死啦".matches(regex));
}
private static void demo1() {
String regex = "(.)\\3(.)\\2"; //\\1代表第一组又出现一次 \\2代表第二组又出现一次
System.out.println("快快乐乐".matches(regex));
System.out.println("快乐乐".matches(regex));
}
}

pattern 和 matcher

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo8_Regex {

public static void main(String[] args) {
//pattern 和 matcher

//demo1();
//需求：把一个字符串中的手机号获取出来
String s ="手机号码是18878627367，曾用过18827783920";
String regex = "1[3578]\\d{9}";//手机号码的正则表达式
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
/*boolean b = m.find();
String s1 = m.group();
System.out.println(b);
System.out.println(s1);*/
while(m.find())
System.out.println(m.group());
}

private static void demo1() {
Pattern p = Pattern.compile("a*b"); //获取到正则表达式
Matcher m = p.matcher("aaaaab"); //获取匹配器
boolean b = m.matches(); //看是否能匹配，匹配就返回true

System.out.println(b);

System.out.println("aaab".matches("a*b")); //等价于上述代码
}

}

Math常用方法

public class Demo1_Math {

public static void main(String[] args) {
//math 类
System.out.println(Math.PI); //Π
System.out.println(Math.abs(-10)); //取绝对值

System.out.println(Math.ceil(-12.3));//ceil天花板获取向上一个整数但是结果是一个double值
System.out.println(Math.ceil(12.3));

System.out.println(Math.floor(-12.3));//floor地板获取向下一个整数结果也是一个double

System.out.println(Math.max(1, 2)); //比较最大值
System.out.println(Math.min(1, 2)); //比较最小值
//前面的数是底数，后面的数是指数
System.out.println(Math.pow(2, 3));
//生成0.0-1.0之间的随机数包括0.0不包括1.0
System.out.println(Math.random());
//四舍五入方法
System.out.println(Math.round(12.3f));
System.out.println(Math.round(12.01));
//开平方
System.out.println(Math.sqrt(4));
System.out.println(Math.sqrt(2));

}

}

Random类概述

import java.util.Random;
public class Demo2_Random {
public static void main(String []args){
// demo1();

// demo2();

Random r = new Random();
/*int x = r.nextInt();
System.out.println(x);*/
for (int i = 0; i < 10; i++) {
System.out.println(r.nextInt(100));//生成0到n范围的整数，包含0不包含n
}

}
private static void demo2() {
//根据种子计算随机数
Random r1 = new Random(1000);
int a = r1.nextInt();
int b = r1.nextInt();

System.out.println(a);
System.out.println(b);
}
private static void demo1() {
Random r = new Random();
/*int x = r.nextInt();
System.out.println(x);*/
for (int i = 0; i < 10; i++) {
System.out.println(r.nextInt());//空参构造
}
}
}

System类的概述及方法

public class Demo3_System {
public static void main(String[] args) {
//System类所有的成员方法都是静态的，无构造方法，构造方法被私有化
// demo1();
// demo2();
//计算方法运行所用的时间
// demo3();

int[] src = {11,22,33,44,55};
int[] dest = new int[8];
System.arraycopy(src, 0/*从源数组开始的位置*/, dest, 0/*接收数组开始的位置*/, src.length);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
}
private static void demo3() {
long start = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
System.out.println("*");
}
//获取当前时间的毫秒值
long end = System.currentTimeMillis();

System.out.println(end - start);
}
private static void demo2() {
//停止java虚拟机
System.exit(0);
System.out.println("11");
}
private static void demo1() {
for (int i = 0; i < 100; i++) {
new Demo();
//运行垃圾回收器
System.gc();
}
}

}
//在一个源文件中不允许定义两个用public修饰的类
class Demo{
@Override
public void finalize() {
System.out.println("垃圾被清扫了");

}
}

BigInteger类的概述和方法使用

import java.math.BigInteger;
public class Demo4_BigInteger {
public static void main(String[] args) {
//用于放置更大的整数
// long num = 1234567890987654321234L;
// String s = "1234567890987654321234";
BigInteger bi1 = new BigInteger("100");
BigInteger bi2 = new BigInteger("2");
//加法
System.out.println(bi1.add(bi2));
//减法
System.out.println(bi1.subtract(bi2));
//乘法
System.out.println(bi1.multiply(bi2));
//除法
System.out.println(bi1.divide(bi2));

BigInteger[] arr =bi1.divideAndRemainder(bi2);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}

BigDecimal类的概述和方法使用

import java.math.BigDecimal;

public class Demo5_BigDecimal {

public static void main(String[] args) {
//更精确的存储小数
// System.out.println(2.0-1.1);
//这种方式在开发中不推荐，因为不够精确
/*BigDecimal bd1 = new BigDecimal(2.0);
BigDecimal bd2 = new BigDecimal(1.1);

System.out.println(bd1.subtract(bd2));*/

//通过构造中传入字符串的方式，开发时推荐使用
// demo1();

//这种方式在开发中推荐
BigDecimal bd1 = BigDecimal.valueOf(2.0);
BigDecimal bd2 = BigDecimal.valueOf(1.1);

System.out.println(bd1.subtract(bd2));

}

private static void demo1() {
BigDecimal bd1 = new BigDecimal("2.0");
BigDecimal bd2 = new BigDecimal("1.1");

System.out.println(bd1.subtract(bd2));
}

}

Date类的概述和方法使用

import java.util.Date;

public class Demo6_Date {

public static void main(String[] args) {
//Date类是util包下的
// demo1();
// demo2();

Date d1 = new Date();
d1.setTime(1000);//设置毫秒值改变时间对象
System.out.println(d1);

}

private static void demo2() {
Date d1 = new Date();
System.out.println(d1.getTime());//获取当前时间毫秒
System.out.println(System.currentTimeMillis());//通过系统类方法获取当前时间毫秒值
}

private static void demo1() {
Date d1 = new Date();//空参代表当前时间
System.out.println(d1);

Date d2 = new Date(0);//0代表1970年1月1日
System.out.println(d2);
}

}

SimpleDateFormat类实现日期和字符串的相互转换

import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class Demo7_SimpleDateFromat {

public static void main(String[] args) throws ParseException {
// demo1();
String str ="2000年08月08日 08:08:09";
//将时间字符串转换为日期对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
Date d = sdf.parse(str);
System.out.println(d);
}

private static void demo1() {
Date d = new Date();//获取当前时间对象
//创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
System.out.println(sdf.format(d));
}

}

你来到这个世界多少天案例

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test2 {

/*
* 你来到这个世界多少天
*
* 第一步：将生日字符串和今天字符串存储在String类型的变量中
*
* 第二步：定义日期格式化对象
*
* 第三步：将日期字符串转换成日期对象
*
* 第四步：通过日期对象获取时间毫秒值
*
* 第五步：将两个时间毫秒值相减除以1000再除以60再除以60再除以24最后得到天数
*
* */
public static void main(String[] args) throws ParseException {
// * 第一步：将生日字符串和今天字符串存储在String类型的变量中
String birthday = "1996年12月21日";
String today = "2020年10月15日";

// * 第二步：定义日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");

// 第三步：将日期字符串转换成日期对象
Date d1 = sdf.parse(birthday);
Date d2 = sdf.parse(today);

// 第四步：通过日期对象获取时间毫秒值
long time = d2.getTime() -d1.getTime();

// 第五步：将两个时间毫秒值相减除以1000再除以60再除以60再除以24最后得到天数
System.out.println(time/1000 /60 /60 /24 );

}

}

Calendar类的概述和获取日期的方法

import java.util.Calendar;

public class Demo8_Calendar {
//Calendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换
public static void main(String[] args) {
Calendar c = Calendar.getInstance(); //父类引用指向子类对象
// System.out.println(c);
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get((Calendar.MARCH))+1);//月份是从0开始的
System.out.println(c.get(Calendar.DAY_OF_MONTH));
System.out.println(c.get(Calendar.DAY_OF_WEEK));//周日是第一天所以往后推一天
System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"
+c.get(Calendar.DAY_OF_MONTH)+"日"+getWeek(c.get(Calendar.DAY_OF_WEEK)));

}
//将星期存储表中进行查表
public static String getWeek(int week){
String[] arr ={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return arr[week];
}
/*月份如果前面是个位数字前面补0
1.返回类型为String类型
2.参数列表，int num*/
public static String getNum(int num){
if(num>9){
return ""+num;
}
return "0"+num;
}
}

Calendar类的add()和set()方法

import java.util.Calendar;

public class Demo8_Calendar {
//Calendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换
public static void main(String[] args) {
// demo1();
Calendar c = Calendar.getInstance(); //父类引用指向子类对象
c.add(Calendar.YEAR, 1);//正数就加1 负数减一操作是年就加年写哪个字段对哪个字段操作
c.set(Calendar.YEAR, 1);//修改指定字段
c.set(2000, 7, 8);
System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"
+c.get(Calendar.DAY_OF_MONTH)+"日"+getWeek(c.get(Calendar.DAY_OF_WEEK)));

}
private static void demo1() {
Calendar c = Calendar.getInstance(); //父类引用指向子类对象
// System.out.println(c);
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get((Calendar.MARCH))+1);//月份是从0开始的
System.out.println(c.get(Calendar.DAY_OF_MONTH));
System.out.println(c.get(Calendar.DAY_OF_WEEK));//周日是第一天所以往后推一天
System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"
+c.get(Calendar.DAY_OF_MONTH)+"日"+getWeek(c.get(Calendar.DAY_OF_WEEK)));
}
//将星期存储表中进行查表
public static String getWeek(int week){
String[] arr ={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return arr[week];
}
/*月份如果前面是个位数字前面补0
1.返回类型为String类型
2.参数列表，int num*/
public static String getNum(int num){
if(num>9){
return ""+num;
}
return "0"+num;
}
}

如何获取任意年份是平年还是闰年

import java.util.Calendar;
import java.util.Scanner;

public class Test3 {
/*键盘录入一个年份，判断该年份是闰年还是平年
*
* 1.键盘录入年Scanner
* 2.创建Calendar对象
* 3.通过set方法设置为那一年的3月1日
* 4.将日向前减去1
* 5.判断日是多少天，如果是29天返回true，否则返回false
*/
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("请输入年份，判断年份是闰年还是平年");
// int year = sc.nextInt();
String line = sc.nextLine(); //录入数字字符串
int year = Integer.parseInt(line);//将数字字符串转换为数字
boolean b = getYear(year);
System.out.println(b);
}

private static boolean getYear(int year) {
// 创建Calendar对象
Calendar c = Calendar.getInstance();
// 通过set方法设置为那一年的3月1日
c.set(year, 2, 1);
// 将日向前减去1
c.add(Calendar.DAY_OF_MONTH, -1);
// 判断日是多少天，如果是29天返回true，否则返回false

return c.get(Calendar.DAY_OF_MONTH)==29;
}

}

集合的由来及集合继承体系图

集合只能储存引用数据类型，也可以存基本数据类型，但是会自动装箱变成对象，集合长度是可变的

Collection集合的基本功能测试

import java.util.ArrayList;
import java.util.Collection;

import com.heima.bean.Student;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo2_Collection {
//add方法如果是List集合一直返回true 因为List集合可以存储重复元素
//如果是Set方法存储重复元素时就会返回false
// ArrayList的父类重写toString方法，所以在打印对象的引用的时候，输出的不是object类的toString
public static void main(String[] args) {
// demo1();
Collection c = new ArrayList();//父类引用指向子类对象
c.add("a");
c.add("b");
c.add("c");
c.add("d");

//c.remove("b");//删除指定元素

//c.clear();//清空集合

System.out.println(c.contains("b"));//判断是否包含
System.out.println(c.isEmpty());//判断集合是否为空
System.out.println(c.size());//获取元素个数

System.out.println(c);
}

private static void demo1() {
Collection c = new ArrayList();//父类引用指向子类对象
boolean b1 = c.add("abc");
boolean b2 = c.add(true);//自动装箱 new Boolean(true);
boolean b3 = c.add(100);
boolean b4 = c.add(new Student("张三",23));

System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);

System.out.println(c);
}

}

public class Student {
private String name;
private int age;
public Student() {
super();

}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}

}

集合的遍历之集合转数组遍历

import java.util.ArrayList;
import java.util.Collection;
import com.heima.bean.Student;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo3_Collection {
public static void main(String[] args) {
// demo1();
Collection c = new ArrayList();
c.add(new Student("张三",23));//父类引用指向子类对象 Object obj = new Student("张三",23));
c.add(new Student("李四",23));
c.add(new Student("王五",23));
c.add(new Student("赵六",23));

Object[] arr = c.toArray();//将集合转换成数组
for (int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]);
Student s = (Student)arr[i];//类型向下强转
System.out.println(s.getName()+"..."+s.getAge());
}
}
private static void demo1() {
Collection c = new ArrayList();

c.add("a");
c.add("b");
c.add("c");
c.add("d");

Object[] arr = c.toArray(); //将集合转换成数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}

Collection集合的带All功能测试

import java.util.ArrayList;
import java.util.Collection;

@SuppressWarnings({ "unchecked", "rawtypes" })
public class Demo4_Collection {

public static void main(String[] args) {
// demo1();
// demo2();
// demo3();
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");

Collection c2 = new ArrayList();//alt+shift+r可以一起改名
c2.add("a");
c2.add("b");
//取交集，如果调用的集合c1改变就返回true，如果调用的集合不变即返回false
boolean b = c1.retainAll(c2);//取交集
System.out.println(b);
System.out.println(c1);

}

private static void demo3() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");

Collection c2 = new ArrayList();//alt+shift+r可以一起改名
c2.add("a");
c2.add("b");

boolean b = c1.containsAll(c2);//containsAll 函数用于检测c1是否包含c2
System.out.println(b);
}

private static void demo2() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");

Collection c2 = new ArrayList();//alt+shift+r可以一起改名
c2.add("a");
c2.add("b");

//c1.removeAll(c2);

boolean b = c1.removeAll(c2);//removeAll删除的是交集
System.out.println(b);
System.out.println(c1);
}

private static void demo1() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");

Collection c2 = new ArrayList();//alt+shift+r可以一起改名
c2.add("a");
c2.add("b");
c2.add("c");
c2.add("d");

c1.add(c2);//将c2看成一个对象添加到c1中
c1.addAll(c2);//将c2添加到c1中
System.out.println(c1);
}

}

集合的遍历之迭代器遍历

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import com.heima.bean.Student;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo5_Collection {

public static void main(String[] args) {
// demo1();
Collection c1 = new ArrayList();
c1.add(new Student("张三",23));
c1.add(new Student("李四",23));
c1.add(new Student("王五",23));
c1.add(new Student("赵六",23));

//获取迭代器

Iterator it = c1.iterator();
while (it.hasNext()) {

Student s = (Student)it.next();
System.out.println(s.getName()+"..."+s.getAge());
}
}

private static void demo1() {
//迭代就是遍历
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");

//对集合中的元素进行迭代

Iterator it = c1.iterator();//获取迭代器
/*boolean b1 = it.hasNext();//判断集合中是否有元素
Object obj1 = it.next();
System.out.println(b1);
System.out.println(obj1);*/

while (it.hasNext()) {
System.out.println(it.next());

}
}

}

List集合的特有功能概述和测试

import java.util.ArrayList;
import java.util.List;
@SuppressWarnings({ "unchecked", "rawtypes" })
public class Demo1_List {
public static void main(String[] args) {
// demo1();
// demo2();
// demo3();
// demo4();
List list = new ArrayList();//父类引用指向子类对象
list.add("a");
list.add("b");
list.add("c");

list.set(1, "z");
System.out.println(list);//将指定位置元素修改
}
private static void demo4() {
List list = new ArrayList();//父类引用指向子类对象
list.add("a");
list.add("b");
list.add("c");

// Object obj1 = list.get(0);
// System.out.println(obj1);
//通过索引遍历List集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
private static void demo3() {
List list = new ArrayList();//父类引用指向子类对象
list.add(111);
list.add(222);
list.add(333);
list.remove(111);//删除的时候不会自动装箱
System.out.println(list);
}
private static void demo2() {
List list = new ArrayList();//父类引用指向子类对象
list.add("a");
list.add("b");
list.add("c");
list.add("d");

Object obj = list.remove(1);//通过索引删除元素，将删除的元素返回
System.out.println(obj);
System.out.println(list);
}
private static void demo1() {
List list = new ArrayList();//父类引用指向子类对象
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//list.add(1,"e");//如果有索引要注意索引越界异常
list.add(4,"f"); //index<=size并且index>=0都不会报错
System.out.println(list);
}
}

List集合存储学生对象并遍历

import java.util.ArrayList;
import java.util.List;
import com.heima.bean.Student;
@SuppressWarnings({ "unchecked", "rawtypes" })
public class Demo2_List {
//向list集合中存储学生对象
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Student("张三",23));
list.add(new Student("李四",23));
list.add(new Student("王五",23));
list.add(new Student("赵六",23));

for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));//通过索引遍历每一个元素
Student s = (Student)list.get(i);
System.out.println(s.getName()+"..."+s.getAge());
}
}
}

并发修改异常产生的原因及解决方案

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Demo3_List {

@SuppressWarnings({ "unchecked", "rawtypes" })
public static void main(String[] args) {
//有一个集合，判断里面是否有"world"这个元素，如果有添加一个"javaee"元素

List list = new ArrayList();
list.add("a");
list.add("b");
list.add("world");
list.add("c");
list.add("d");
list.add("e");

/*Iterator it = list.iterator(); //获取迭代器
while(it.hasNext()){ //判断集合中是否有元素
String str = (String)it.next(); //向下转型
if("world".equals(str)){
list.add("javaee"); //遍历的同时在增加元素，叫做并发修改
}
}*/
ListIterator lit = list.listIterator();
while(lit.hasNext()){
String str = (String)lit.next(); //向下转型
if("world".equals(str)){
lit.add("javaee");//遍历的同时在增加元素，叫做并发修改
}
}
System.out.println(list);
}
}

数据结构之数组和链表

链表是链式的每个元素只需记住前一个和后一个元素的地址即可

去除ArrayList中重复字符串元素方式

import java.util.ArrayList;
import java.util.Iterator;

@SuppressWarnings({ "unchecked", "rawtypes" })
public class Demo1_ArrayList {
/*需求：ArrayList去除集合中字符串的重复值（字符串的内容相同）
*
* */
public static void main(String[] args) {

/*创建新集合将重复元素去掉
1.明确返回值类型，返回ArrayList
2.明确参数列表，ArrayList

分析
1.创建新集合
2.根据传入的集合（老集合），获取迭代器
3.遍历老集合
4.通过新集合判断是否包含老集合中的元素，如果包含就不添加，如果不包含就添加
*/
ArrayList list = new ArrayList();
list.add("a");
list.add("a");
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
list.add("c");
ArrayList newList = getSingle(list);
System.out.println(newList);

}
public static ArrayList getSingle(ArrayList list){
ArrayList newList = new ArrayList();//创建新集合
Iterator it = list.iterator(); //根据传入的集合（老集合）获取迭代器

while(it.hasNext()){
Object obj = it.next(); //记录每一个元素 next()方法为当前元素
if(!newList.contains(obj)){//如果当前元素不被新list包含则添加到新list
newList.add(obj);
}
}
return newList;
}

}

去除ArrayList中重复自定义对象元素

import java.util.ArrayList;
import java.util.Iterator;

import com.heima.bean.Person;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo2_ArrayList {
/*需求：ArrayList去除集合中自定义对象的重复值（对象的成员变量相同）
* contains方法判断是否包含，底层依赖的是equals方法
* remove方法判断是否删除，底层依赖的是equals方法
* */
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Person("张三",23));
list.add(new Person("张三",23));
list.add(new Person("李四",23));
list.add(new Person("李四",23));

/*ArrayList newList = getSingle(list);//调用方法去除重复
System.out.println(newList);*/
list.remove(new Person("张三",23));
System.out.println(list);

}
public static ArrayList getSingle(ArrayList list){
ArrayList newList = new ArrayList();//创建新集合
Iterator it = list.iterator(); //根据传入的集合（老集合）获取迭代器

while(it.hasNext()){
Object obj = it.next(); //记录每一个元素 next()方法为当前元素
if(!newList.contains(obj)){//如果当前元素不被新list包含则添加到新list
newList.add(obj);
}
}
return newList;
}
}

public class Person {

private String name;
private int age;
public Person() {
super();

}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
Person p = (Person)obj;
return this.name.equals(p.name)&& this.age == p.age;
}

}

LinkedList的特有功能

import java.util.LinkedList;

public class Demo2_LinkedList {

@SuppressWarnings({ "unchecked", "rawtypes" })
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.addFirst("c");//在头加元素
list.addLast("a");//在尾加元素
list.addLast("b");
list.addLast("c");
list.addLast("d");

/*System.out.println(list.removeFirst());//删除头
System.out.println(list.removeLast());//删除尾
System.out.println(list);
System.out.println(list.getFirst());//获取头
System.out.println(list.getLast());//获取尾
*/ System.out.println(list.get(3));
System.out.println(list.size());
System.out.println(list);

}

}

栈和队列数据结构

队列具象化为一根管子所以先进先出

用LinkedList模拟栈数据结构的集合并测试

import java.util.LinkedList;

@SuppressWarnings({ "unchecked", "rawtypes" })
public class Demo4_LinkedList {
// 用LinkedList模拟栈结构
public static void main(String[] args) {
// demo1();
Stack s = new Stack();

s.in("a");
s.in("b");
s.in("c");
s.in("d");

while(!s.isEmpty()){
System.out.println(s.out());
}
}

private static void demo1() {
LinkedList list = new LinkedList();
list.addLast("a");
list.addLast("b");
list.addLast("c");
list.addLast("d");
while (!list.isEmpty()) {
System.out.println(list.removeLast());
}
}

}

泛型(generic)概述和基本使用

import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;
public class Demo1_Generic {
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<Person>();
/*list.add(110);
list.add(true);*/
list.add(new Person("张三",23));

Iterator<Person> it = list.iterator();
while(it.hasNext()){
// System.out.println(it.next());
Person p = it.next();
// System.out.println(it.next().getName()+"..."+it.next().getAge());//next方法只能调用一次，如果多次调用会将指针向后移动多次
System.out.println(p.getName()+"..."+p.getAge());
}

}
}

泛型的由来

泛型方法的概述和使用

泛型接口的概述和使用

public class Demo4_Generic {
// 泛型接口
// 定义格式 public interface 接口名<泛型类型>
// 泛型接口的使用
public static void main(String[] args) {

}
}
interface Inter<T>{
public void show(T t);
}
/*class Demo implements Inter<String>{ //推荐使用
public void show(String t){
System.out.println(t);
}
}*/
class Demo<T> implements Inter<T>{//没有必要在实现接口的时候给自己的类加泛型
public void show(T t){
System.out.println(t);
}
}

泛型高级之通配符

import java.util.ArrayList;
import com.heima.bean.Person;
import com.heima.bean.Student;
public class Demo5_Generic {
//
public static void main(String[] args) {
// List<?> list = new ArrayList<String>();//当左边不确定接收什么类型时使用通配符？
ArrayList<Person> list1 = new ArrayList<>();
list1.add(new Person("张三",23));
list1.add(new Person("李四",23));
list1.add(new Person("王五",23));

ArrayList<Student> list2 = new ArrayList<>();
list2.add(new Student("赵六",23));
list2.add(new Student("周七",23));

list1.addAll(list2);
System.out.println(list1);

}
}

public class Student extends Person{

public Student() {
super();

}
public Student(String name, int age) {
super(name,age);

}

}

增强for的概述和使用

底层由迭代器实现

import java.util.ArrayList;
import com.heima.bean.Person;
public class Demo1_Foreach {
// 增强for循环依赖迭代器 Iterator
public static void main(String[] args) {
// demo1();
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三",23));
list.add(new Person("李四",23));
list.add(new Person("王五",23));
list.add(new Person("赵六",23));

for (Person person : list) {
System.out.println(person);
}
}
private static void demo1() {
int[] arr = {11,22,33,44,55};
for (int i : arr) {
System.out.println(i);
}
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for (String string : list) {
System.out.println(string);
}
}
}

三种迭代的能否删除

import java.util.ArrayList;
import java.util.Iterator;
import com.heima.bean.Person;
public class Demo1_Foreach {
// 增强for循环依赖迭代器 Iterator
public static void main(String[] args) {
// demo1();
// demo2();
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
//普通for循环删除,索引要减减
/*for (int i = 0; i < list.size(); i++) {
if("b".equals(list.get(i))){
list.remove(i--); //通过索引删除元素
}
}*/
//迭代器删除
Iterator<String> it = list.iterator();
/*while(it.hasNext()){
if("b".equals(it.next())){
// list.remove("b"); //不能用集合的修改方法，迭代过程中如果修改会出现并发修改异常
it.remove();
}
}*/

/*for (Iterator<String> it2 = list.iterator(); it2.hasNext();) {
if("b".equals(it2.next())){
it2.remove();
}

}*/

//增强for循环增强for循环不能删除，只能遍历
for (String string : list) {
if("b".equals(string)){
list.remove("b");
}
}
System.out.println(list);
}
private static void demo2() {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person("张三",23));
list.add(new Person("李四",23));
list.add(new Person("王五",23));
list.add(new Person("赵六",23));

for (Person person : list) {
System.out.println(person);
}
}
private static void demo1() {
int[] arr = {11,22,33,44,55};
for (int i : arr) {
System.out.println(i);
}
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for (String string : list) {
System.out.println(string);
}
}
}

静态导入的概述和使用

只需要看懂，一般不用

可变参数的概述和使用

public class Demo3_ChangeableArgs {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
// print(arr);
print(11,22,33,44);
}
/*public static void print(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}*/
public static void print(int x ,int ... arr){ //可变参数其实是一个数组参数取值为0-无穷大可变参数只能是方法的最后一个参数
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}

Arrays工具类的asList()方法的使用

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Demo4_AsList {
/*数组转化成集合
* 数组转换成集合虽然不能增加或减少元素，但是可以用集合的思想操作数组，也就是说可以使用其他集合中的方法，除去增加和减少的方法*/
public static void main(String[] args) {
// demo1();
// demo2();
//集合转数组，加泛型
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");

String[] arr = list.toArray(new String[1]);//当集合转换数组时，数组的长度如果是小于等于集合的size，转换后的数组长度等于集合的size
//如果数组的长度大于了size，分配的数组长度就和你指定的长度一样

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
private static void demo2() {
// int[] arr = {11,22,33,44,55};
// List list = Arrays.asList(arr);//因为基本数据类型的数组转化为集合，会将整个数组当作一个对象转换
Integer[] arr = {11,22,33,44,55};//将数组转化为集合，数组必须是引用数据类型,基本数据类型需要使用其包装类
List<Integer> list = Arrays.asList(arr);
System.out.println(list);
}
private static void demo1() {
String[] arr = {"a","b","c"};
List<String> list = Arrays.asList(arr);//将数组转化成集合
System.out.println(list);
list.add("e");
System.out.println(list);//java.lang.UnsupportedOperationException不支持修改的异常
}
}

集合嵌套之ArrayList嵌套ArrayList

import java.util.ArrayList;
import com.heima.bean.Person;
public class Demo5_ArrayListArrayList {
/*集合嵌套之ArrayList嵌套ArrayList
案例：
学科分为若干个班级
整个学科为一个大集合
若干个班级分为每一个小集合*/
public static void main(String[] args) {

ArrayList<ArrayList<Person>> list = new ArrayList<>();

ArrayList<Person> first = new ArrayList<>();
first.add(new Person("杨幂",30));
first.add(new Person("李四",31));
first.add(new Person("王五",33));

ArrayList<Person> second = new ArrayList<>();
second.add(new Person("赵六",21));
second.add(new Person("张三",31));
second.add(new Person("陈坤",24));

//将班级添加到学科集合中
list.add(first);
list.add(second);

//遍历学科集合
for (ArrayList<Person> a : list) {
for(Person p : a){
System.out.println(p);
}

}
}
}

pureqh

请尊重作者原创，转载复制请标明出处(●'◡'●) 免责声明：该博客中所发表的文章仅用作学习交流使用，任何人不得用来做违法犯罪活动，出现问题均与本人无关。

142

2024 年 11 月
一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30