Java-SE基础
2023-04-13 20:09:59 0 举报
AI智能生成
Java SE(Standard Edition)是Java平台的核心,它提供了开发和运行Java应用程序所需的基本功能。Java SE包括了Java语言的基础特性,如面向对象编程、异常处理、多线程、集合框架等。此外,Java SE还提供了一套丰富的API,用于访问操作系统、网络、文件系统等资源。Java SE的跨平台特性使得开发者可以在不同的操作系统和硬件平台上编写和运行相同的代码。Java SE广泛应用于企业级应用、桌面应用、移动应用等领域,是学习Java编程的基础。
作者其他创作
大纲/内容
Java的环境
Java的介绍
java发展
三个平台
版本
javase
javame
javaee
java的火
面向对象
开源
跨平台
Java语言本质上是不能跨平台的,真正实现跨平台的是JVM,也就是Java虚拟机。
子主题
jdk(Java Development Kit)
Java开发工具
java.exe 运行java程序
javac.exe编译java程序
jre(Java Runtime Environment)
:java运行环境
:java运行环境
虚拟机jvm(Java Virtual Machine)
核心类库(Java提供的 写代码用的一些好用的工具)
dos
dos命令
常用命令
盘符名称+冒号
E:Enter 打开E盘
dir
查看当前路径下内容
cd 目录
进入单级目录
cd..
回退到上一级目录
cd 目录1\目录2\
进入多级目录
cd\
回退到盘符目录
cls
清屏
exit
退出
环境变量
为什么要配置环境变量?
要想在任何目录下都打开指定软件,就可以把软件的路径配置到环境变量中
右击 我的电脑 选择属性 选择高级系统设置
高级-环境变量
选择系统变量的Path 编辑
运行Java文件注意事项
运行步骤:
1.把.java文件 编译 .class文件 虚拟机只认识class文件
执行命令 javac HelloWorld.java
2.注意java运行的时候,不用写.class后缀
执行命令 java HelloWorld
程序解释:
public: 让文件的名字和类名一致
class 类:class的后面要跟一个类名
main 主要的 主方法(main方法):程序的入口
System.out.println 在窗口中打印内容 ,打印双引号里的内容
System.out.println("hello1111");
规范:
一个左大括号开始
就要一个右大括号结束,右大括号 要和左大括号这行代码的最左侧对齐
左大括号敲完后,回车换行,换行后要缩进再敲代码
规则:
所有的符号都要是英文的
注意大小写
java代码每行结束都要有分号 ,遇到大括号除外
idea
创建项目(工程)
层级关系
project - module(模块) - package(包) - class(类)
- project中可以创建多个module
- module中可以创建多个package
- package中可以创建多个class
- module中可以创建多个package
- package中可以创建多个class
图
快捷输入
psvm或者main 等提示出来按回车 生成main方法
sout 快速生成输出语句
alt+enter 提示如何解决当前错误
快捷键
ctrl+d 向下复制一行
ctrl+y 删除一行
ctrl+/ 单行注释
ctrl+shift+/ 多行注释
alt+shift + 上/下 上下移动代码
shift+回车 在下面 开始新的一行
ctrl+alt+回车 在上面 开始新的一行
ctrl+alt+L 格式化代码
注意
打开idea 用工程作为根目录,不要打开一堆其它和工程无关的东西
类名包名修改
快捷键 shift+f6
工程名 模块名写错 直接删除 重新创建
一定要注意: 模块是工程的下一级一定要注意: 模块是工程的下一级
Java基本语法
程序的基本组成
注释(非必须)
单行注释
//
多行注释
/* 写注释*/
关键字
java提供了一些有特殊用途的单词,有特殊的含义java提供了一些有特殊用途的单词,有特殊的含义
例:
- public 让类名和文件名一致
- class 类 后面要跟类名
- static 静态的
- void 方法没有返回值
- public 让类名和文件名一致
- class 类 后面要跟类名
- static 静态的
- void 方法没有返回值
数据
字面量
概念
就是数据在代码中的表示, 我坐公交花了5元钱 这个5就是字面量
字面量是指由字母,数字等构成的字符串或者数值,它只能作为右值出现,
(右值是指等号右边的值,如:int a=123这里的a为左值,123为右值。)
(右值是指等号右边的值,如:int a=123这里的a为左值,123为右值。)
int a = 10; //a为变量,10为字面量
字面量 有如下:
整数 字面量
浮点数 字面量 (小数)
布尔 字面量 真或者假 true(真) 、false(假)
字符串 字面量 "" 写在双引号里的内容
字符 字面量 '' 单引号里是字符 里面有且只有一个字符串
空 null
常量
概念
有些数据可以在程序使用之前预先设定并在整个运行过程中没有变化,这称为常量。
final int b = 10; //b为常量,10为字面量
static str = "Hello World"; //str为变量,Hello World为字面量
整数 10
小数 3.14
布尔 true
字符 'a'
字符串 "aaaa"
空 null
变量
概念
好比一个容器,储存着会发生变化的数据.
定义格式
数据类型 变量的名字=变量具体的数值;
int age=12; //int 这里是整数的意思
数据类型
存储单位
1PB = 1024TB
1TB = 1024GB;
1GB = 1024MB;
1MB = 1024KB;
1KB = 1024b;
一字节 = 8bit 比特位 010101
基本类型
数据类型的作用
四类八种类型
四类八种
四类
整数
byte(1字节)
short
**int(4字节)**
long(8字节)
浮点数
float(4字节)
**double(8字节)**
布尔
boolean
字符
char
八种
引用类型(综合类型)
String 字符串
数组
定义
动态
动态初始化
格式
数据类型[] 数组名 = new 数据类型[数组长度];
静态
静态初始化
初始化的时候 给出数据 但是不给长度
完整格式: 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
简化格式: 数据类型[] 数组名 = {数据1,数据2,数据3...};
静态省略
注意:动态和静态初始化完后,数组的长度就已经确定了,无法改变
使用
索引
获取
获取数组里的数据
根据索引获取
获取数组元素 arr[index] , index是索引的意思 索引从0开始
数组不同类型的默认值
整数 0
小数 0.0
char 空 '\0' 或者 '\u0000'
boolean false
String[] 引用类型 null(表示空 什么都没有)
修改
内存
java内存结构
一个数组内存
两个数组内存
两个指向一个内存
数组的内存存储
方法区 存着加载进来的 字节码文件的内容, 包含的类的所有信息
栈 ,方法如果运行 就会加载进栈, 运行完后 出栈
堆 在创建数组(对象)的时候,会在堆中创建
遇到异常
空指针
引用类型的变量 可以赋值为null.
索引越界
遍历
arr.length可以获取数组长度
求最值
求和
基本查找
反转
二维数组
二维数组动态初始化
格式
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组,可以存放多少个一维数组
n表示每一个一维数组,可以存放多少个元素
代码
静态初始化
//二维数组静态初始化 格式
int[][] arr = new int[][]{ {11,22,33},{44,55,66},{77,88,99} };
//二维数组静态初始化 简写格式
int[][] arr1 = {{11,22,33},{44,55,66},{77,88,99}};
遍历二维数组
public class Demo04 {
public static void main(String[] args) {
//二维数组静态初始化 格式
int[][] arr = new int[][]{{11, 22, 33}, {44, 55, 66}, {77, 88, 99}};
//二维数组静态初始化 简写格式
//int[][] arr1 = {{11, 22, 33}, {44, 55, 66}, {77, 88, 99}};
//二维数组的遍历
for (int i = 0; i < arr.length; i++) {
//arr[i]是一维数组 对其再次遍历
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
多维数组的概念
类
接口
关于变量注意
在一条语句可以定义多个变量
要求是同一个类型,多个变量逗号分开,后面的变量的的类型可以省略
例:
int a = 10, b = 20,c = 30;
System.out.println(a);
System.out.println(b);
System.out.println(c);
int a = 10, b = 20,c = 30;
System.out.println(a);
System.out.println(b);
System.out.println(c);
1.在同一范围内 不能重复定义同名变量
2.变量在大括号范围内 有效
2.变量在大括号范围内 有效
例:
没有赋值的变量不能使用
定义long加L float加f
一个整数 默认是int类型
一个小数 默认是double类型
一个小数 默认是double类型
long a = 1000000000000L;
float b = 3.14f;
float b = 3.14f;
类型转换
隐式类型转换
运算中的隐式转换
比int小
比int大
隐式转换
取值范围小的数据, 给取值范围大的类型赋值, 可以直接赋值,会自动转换取值范围小的数据, 给取值范围大的类型赋值, 可以直接赋值,会自动转换
类型范围 byte<short=char<int<long<float<double
当运算的时候 ,所有参与运算的变量的类型都小于等于int的范围时候,那么会先全部提升为int类型运算,结果也是int类型
当运算的时候 如果出现大于int类型范围的数据,那么所有的数据全部提升为最大的那个类型,结果也是最大的那个类型
强制类型转换
强制转换
一个大范围类型的变量,赋值给小范围类型的变量 需要强制转换
强转值不变
强制值改变
小数取整
强制转换语法:
目标数据类型 变量名 = (目标数据类型)字面量或者变量;
注意事项
常量优化
字面量优化机制
byte c = 10+20;为什么不报错?
- byte d = 10+20 在编译阶段 就会得到 byte d = 30; 判断右侧的值 是否在类型的范围内,如果不在 就报错
- byte d = 10+20 在编译阶段 就会得到 byte d = 30; 判断右侧的值 是否在类型的范围内,如果不在 就报错
boolean不参与
标识符
标识符: 一些起名字的符号
规则
1 数字、字母、下划线、$ , 数字不能开头
2 不能和关键字重复
符号
基本符号
{}
[]
()
.
;
""
,,
空格
运算符号
算术运算符
算术运算符
+
加
"+"情况
数字相加
字符串相加
字符相加
-
减
*
乘
在代码中,如果有小数参与计算,结果有可能不准确的。
/
除
%
取模、取余
数值拆分公式总结
个位:数值 % 10
十位:数值 / 10 %10
百位:数值 / 100 % 10
千位:数值 / 1000 % 10
十位:数值 / 10 %10
百位:数值 / 100 % 10
千位:数值 / 1000 % 10
算术运算符总结
除法注意事项
取模符号
char和整数的转换
ASCII编码
字符串连接符
打印的时候拼接变量
字符串和其它类型变量 拼接用+号
例:
int age = 10;
System.out.println("我今年" + age + "岁了"); //我今年10岁了
int age = 10;
System.out.println("我今年" + age + "岁了"); //我今年10岁了
自增自减运算符
++和--只能操作变量
++和-- 无论是放在变量的前边还是后边,单独写一行结果是一样的
++在变量前: 先对该变量做自增(++)或者自减(--),然后再拿变量参与操作
++在变量后: 先将该变量原本的值,取出来参与操作,随后再进行自增(++),自减(--)。
赋值运算符
基本赋值
=
复合赋值
+= -= *= /= %= 扩展赋值运算符(复合赋值运算符)
扩展赋值运算符底层会自带强转功能
比较运算符
关系运算符
a==b,判断a和b的值是否相等,成立为true,不成立为false
a!=b,判断a和b的值是否不相等,成立为true,不成立为false
a>b,判断a是否大于b,成立为true,不成立为false
a>=b,判断a是否大于等于b,成立为true,不成立为false
a<b,判断a是否小于b,成立为true,不成立为false
a<=b,判断a是否小于等于b,成立为true,不成立为false
逻辑运算符
普通逻辑
&(与) : 并且, 遇false则false, 只有符号左右两边同时为true, 结果才为true.
|(或) : 或者, 遇true则true, 只有符号左边两边同时为false, 结果才为false
!(非) : 取反
^(异或) : 相同为false, 不同为true. 不常用 了解
短路逻辑
&和&& 结果一样,但&&效率高,左侧如果是false 右侧就不运算了,结果就是false
|和|| 结果一样,但||效率高,左侧如果是true 右侧就不运算了,结果就是true
三元运算符
关系表达式?表达式1:表达式2
位运算符
计算机如何存储二进制
进制(理解)
任意进制转10进制
10进制转任意进制
8421法(掌握)
所有运算都是用补码运算
正数原码 反码 补码 相同
负数算补码 :原码 取反(不包括符号位) 然后 +1
位运算
& | ^ ~ 注意 都是2进制的运算
true 是1 false是0
5&0
5|2
^ 相同为0 不同为1
~
位移运算
00000000 00000000 00000000 00000101
<< 向左移位 右侧补0 移动几位就是乘以2的几次方
>> 向右移位 左侧补符号位 移动几位就是除以2的几次方
>>> 无符号向右移位 左侧补0 很少用
同一个数 对另一个数异或2次 还是原数
5^3^3 = 5
5^3^5 = 3
结构型语句
顺序结构
选择结构
if
if格式1
案例
if格式2
案例
if格式3
案例
switch
基本语法:
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
…
default:
语句体n+1;
break;
}
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
…
default:
语句体n+1;
break;
}
执行过程
1. 首先计算表达式的值。
2. 依次和case后面的值进行比较,如果有对应的值,就会执行相应的语句
在执行的过程中,遇到break就会结束。
3. 如果所有的case后面的值和表达式的值都不匹配
就会执行default里面的语句体,然后程序结束掉。
2. 依次和case后面的值进行比较,如果有对应的值,就会执行相应的语句
在执行的过程中,遇到break就会结束。
3. 如果所有的case后面的值和表达式的值都不匹配
就会执行default里面的语句体,然后程序结束掉。
注意
case后的值不能重复
case后面只能跟字面量(常量), 不能跟变量
switch后的小括号内的表达式的值,
只能是byte、short、int、char enum (枚举) String 类型
只能是byte、short、int、char enum (枚举) String 类型
记住最常用的只有int和String
case语句的上下顺序 可以自己调整 包括default也没有强制放到最后,
一般不这么做,default 可以不写 ,
一般不这么做,default 可以不写 ,
default的位置
case穿透
当case后的语句体下面的break没有写的时候,
代码会继续向下执行,并且不再判断匹配,
直到遇到下一个break才停止,或者switch语句全部执行完。
(对default也适用)
代码会继续向下执行,并且不再判断匹配,
直到遇到下一个break才停止,或者switch语句全部执行完。
(对default也适用)
switch和if
switch 写的语句 都能用if替换
switch 只能判断 表达式和case后的值
是否相等,if可以完成更多逻辑
是否相等,if可以完成更多逻辑
if(a>5&& a<=19) 这个用switch无法完成
switch 在条件多的时候 比if效率高
经验: 大于5条就用switch
经验: 大于5条就用switch
switch底层可以根据数据,直接找到要执行的那条case语句
循环结构
for
格式
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;(重复做的事情)
}
案例
案例打印3个HelloWorld
案例打印1-5
案例打印5-1
案例打印55-66
案例打印10以内偶数
案例打印 1 4 7 10 13 ...
案例打印 11 22 33 44 55 ...
案例打印水仙花数
案例求水仙花数的和
案例求水仙花数的个数
while
格式
初始化语句;
while(条件判断语句) {
循环体语句;
条件控制语句;
}
案例珠穆朗玛峰
do while
格式
do{
循环体语句;
条件控制语句;
}while(条件控制语句);
循环体语句;
条件控制语句;
}while(条件控制语句);
案例 dowhile的应用
三者循环区别
循环小结
1 明确循环次数 一般用for 比如1到100
2 不明确次数 用while 比如珠峰案例
3 do while 用的很少
4 死循环 while用的最多
while(true){
System.out.println("aaaaa");
}
System.out.println("aaaaa");
}
死循环
案例:死循环用法
循环中断
continue(继续)
break(打断 中断)
break(打断 中断)
continue
continue 只能用在循环中,while、for、dowhile都可以
循环中遇到continue ,当前循环中的这一轮结束,continue后面的代码不执行,开始循环中的下一轮
break (打断 停止)
循环中遇到break,直接结束整个循环
带标号中断
用变量的方式结束循环(掌握)
import java.util.Scanner;
public class D20{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
//定义一个变量 表示循环是否在执行
boolean isRun = true;
while(isRun){
System.out.println("请输入星期几");
int day = sc.nextInt();
switch(day){
case 0:
System.out.println("88 下次见");
//把isRun置为false 让循环结束
isRun = false;
break;
case 1:
System.out.println("游泳");
break;
case 2:
System.out.println("跑步");
break;
default:
System.out.println("输入错误");
break;
}
}
}
}
public class D20{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
//定义一个变量 表示循环是否在执行
boolean isRun = true;
while(isRun){
System.out.println("请输入星期几");
int day = sc.nextInt();
switch(day){
case 0:
System.out.println("88 下次见");
//把isRun置为false 让循环结束
isRun = false;
break;
case 1:
System.out.println("游泳");
break;
case 2:
System.out.println("跑步");
break;
default:
System.out.println("输入错误");
break;
}
}
}
}
循环嵌套
案例 打印正方形
案例打印三角形
案例打印99乘法表
方法(函数)
方法的定义格式
概念: 一段独立功能的代码,组织成为一个整体,可以通过调用的形式执行
定义格式
public static void 方法名 (){
方法体
}
//public static 是固定的 void稍后会讲
//方法名 按照小驼峰的规范
调用方式
方法名();
注意
方法之间是平级的,不能嵌套定义(不能在一个方法内部定义另外一个方法)
栈
后进先出 的一种结构
进栈(压栈) 出栈(弹栈)
方法的作用
方法的使用
无参无返回值
带参数的方法
格式
public static void 方法名 ( 参数 ) { … … }
public static void 方法名 ( 数据类型 变量名 ) { … … }
调用格式
方法名 ( 参数 ) ;
方法名 ( 变量名/常量值 ) ;
形参: 形式参数 定义方法的时候 写的参数
实参: 实际参数 方法调用的时候 实际传的值
实参: 实际参数 方法调用的时候 实际传的值
参数传递的两种情况
参数传递基本数据类型
byte short char int float long boolean
参数传递引用数据类型
String、 数组
返回值
方法返回值
void 表示没有返回值,如果有返回值,把void改为要返回的数据的类型
返回值是返回到调用方法的位置
方法的注意事项
方法的重载
重载
同一个类中,定义多个方法,这些方法的名字相同,参数不同
参数不同指的是(类型,个数,顺序)
参数不同指的是(类型,个数,顺序)
重载的好处
引用类型参数传递
内存中方法调用过程
面向对象
封装
面向对象介绍
成员变量和局部变量
成员变量 类中方法外
存在堆里,对象被回收,才会消失
局部变量 方法内部定义的变量(包括方法的参数)
在栈里,方法调用结束,就消失了
封装(面向对象三大特性之一)
封装 继承 多态 面向对象三大特性
隐藏实现细节,提供了公共的访问方式
提高的代码安全性和复用性
常见表现形式
把代码提取到一个方法里 ,对功能的封装
把属性和方法 写到一个类里,完成对一类事物的封装
类
类:有属性和行为
类的定义
成员变量 和 成员方法
成员变量: 定义在类中,方法的外面 ,用来描述类的属性
成员方法:和之前定义方法一样 去掉了static ,用来描述类的行为
基础语法代码
定义一个类Student,有成员变量name和age 有成员方法study和play
代码
public class Student {
//成员变量 ---属性
String name; //名字
int age;//年龄
//成员方法 ----行为
public void study() {
System.out.println("xxx在学习");
}
public void play() {
System.out.println("xxx在打球");
}
}
对象
语法
创建对象的格式:
类名 对象名 = new 类名();
调用成员变量的格式:
对象名.成员变量名
调用成员方法的格式:
对象名.成员方法名();
类名 对象名 = new 类名();
调用成员变量的格式:
对象名.成员变量名
调用成员方法的格式:
对象名.成员方法名();
代码
// 创建一个学生对象
//创建对象的时候 会给成员变量初始一个默认值 整数0 小数0.0 boolean false String null
Student stu01 = new Student();
//打印对象 会打印出对象的地址
System.out.println(stu01); //com.heima.test2.Student @ b4c966a
//获取成员变量的值 当前获取的是之前创建对象的时候 初始的默认值
System.out.println(stu01.name); //null
System.out.println(stu01.age); //0
//给成员变量赋值
stu01.name = "张三";
stu01.age = 20;
//再次获取成员变量的值
System.out.println(stu01.name); //张三
System.out.println(stu01.age); //20
//调用成员方法 对象名.成员方法名();
stu01.study();
stu01.play();
注意
注意:对象打印出来 的是地址
用类创建对象时,会给成员变量初始化,每种类型的成员变量的初始化默认值和数组动态初始化一样
用类创建对象时,会给成员变量初始化,每种类型的成员变量的初始化默认值和数组动态初始化一样
整数0 小数0.0 boolean false String null
权限修饰符
private 私有的(掌握)
public 公有的
private 关键字 可以修饰成员变量和成员方法
被private修饰的成员变量或者成员方法,只能本类中被使用
如果需要访问被private修饰的变量,一般会提供公共的get、set方法
this
当成员方法里的局部变量和成员变量重名的时候,直接使用的变量是局部变量,那么this直接调用的是成员变量
用在成员方法执行的时候,哪个对象调用的成员方法,this就是哪个对象
当直接使用成员变量或者调用成员方法时,如果不写this,默认就是有this
查看一个方法在哪里被调用过的快捷键
Alt+F7
构造方法(构造器)
格式
方法名和类名相同
不能有返回值,也就不能有返回值类型 void也不能写
public 构造方法的名字(){
}
作用
给成员变量初始化值
注意(重点)
如果不写构造,java会默认提供一个无参的构造方法,如果自己写了一个有参数的构造方法,那么java就不会再提供无参的构造方法了,
需要自己把有参无参的构造都写出来
总结一下
1.什么是构造器?
答:构造器其实是一种特殊的方法,但是这个方法没有返回值类型,方法名必须和类名相 同。
2.构造器什么时候执行?
答:new 对象就是在执行构造方法; 注意 是堆里先创建好了对象 然后才执行的构造方法
3.构造方法的应用场景是什么?
答:在创建对象时,可以用构造方法给成员变量赋值
4.构造方法有哪些注意事项?
1)在设计一个类时,如果不写构造器,Java会自动生成一个无参数构造器。
2)一定定义了有参数构造器,Java就不再提供空参数构造器,此时建议自己加一个无参数构造器。
容易出的问题
在构造方法里 一定不要忘记 初始化成员变量
一个标准的javabean
alt+insert 快捷键
成员变量私有化
给成员 变量提供公共的get和set方法
提供空的构造, 根据需求提供有参数的构造
导包注意点
1跨包使用类,需要导包
2如果需要使用不同的包中,名字相同的类,只能有一个类导包,其余的需要写全路径(包名.类名)
3尽量不要自己写的类和java提供的重名
继承
多态
Java类库
Scanner
键盘录入
1. 导包 Scanner 写在类的上面
import java.util.Scanner;
2. 创建对象 sc是一个变量名 这个可以理解为 有键盘输入功能的工具
Scanner sc = new Scanner(System.in);
3. 录入字符串
String s01 = sc.next();//等待键盘录入 字符串
nextInt
Random
nextInt
1-100随机数
获取随机数
//1导包
import java.util.Random;
//2 创建Random对象
Random r = new Random();
//3 获取随机数
//int num = r.nextInt(10); //获取的是0到9的随机数
import java.util.Random;
//2 创建Random对象
Random r = new Random();
//3 获取随机数
//int num = r.nextInt(10); //获取的是0到9的随机数
//int num = r.nextInt(11); //获取的是0到10的随机数
//System.out.println(num);
int num = r.nextInt(41)+20; //获取 20到60的随机数 20+ (0到40的随机数)
System.out.println(num);
//a到b的随机数 a + r.nextInt(b-a+1)//int num = r.nextInt(11); //获取的是0到10的随机数
//System.out.println(num);
int num = r.nextInt(41)+20; //获取 20到60的随机数 20+ (0到40的随机数)
System.out.println(num);
//a到b的随机数 a + r.nextInt(b-a+1)
//System.out.println(num);
int num = r.nextInt(41)+20; //获取 20到60的随机数 20+ (0到40的随机数)
System.out.println(num);
//a到b的随机数 a + r.nextInt(b-a+1)//int num = r.nextInt(11); //获取的是0到10的随机数
//System.out.println(num);
int num = r.nextInt(41)+20; //获取 20到60的随机数 20+ (0到40的随机数)
System.out.println(num);
//a到b的随机数 a + r.nextInt(b-a+1)
String
String类的特点
- 字符串不可变,它们的值在创建后不能被更改
- 虽然 String 的值是不可变的,但是它们可以被共享
- 字符串效果上相当于字符数组( char[] ),但是底层原理是字节数组( byte[] )
Sting的构造方法
常用的构造方法
public String()
创建一个空白字符串对象,不含有任何内容
String s1 = new String();
System.out.println("s1:" + s1);
new String()
public String(char[] chs)
根据字符数组的内容,来创建字符串对象
char[] chs = {'a', 'b', 'c'};
String s2 = new String(chs);
System.out.println("s2:" + s2);
new String(字符数组)
public String(byte[] bys)
根据字节数组的内容,来创建字符串对象
byte[] bys = {97, 98, 99};
String s3 = new String(bys);
System.out.println("s3:" + s3);
new String(byte数组)
String s = “abc”;
直接赋值
直接赋值的方式创建字符串对象,内容就是abc
String s4 = "abc";
System.out.println("s4:" + s4);
创建字符串对象两种方式的区别
通过构造方法创建
通过 new 创建的字符串对象,每一次 new 都会申请一个内存空间,虽然内容相同,但是地址值不同
直接赋值方式创建
以“”方式给出的字符串,只要字符序列相同(顺序和大小写),无论在程序代码中出现几次,JVM 都只会建立一个 String 对象,并在字符串池中维护
String的方法
equals
字符串的比较
==号的作用
- 比较基本数据类型:比较的是具体的值
- 比较引用数据类型:比较的是对象地址值
equals方法的作用
public boolean equals(String s)
比较两个字符串内容是否相同、区分大小写
equalsIgnoreCase(比较的时候忽略大小写)
toUpperCase(转大写)
toLowerCase(转小写))
例
案例1登录
equalsIgnoreCase
toCharArray
字符串的遍历
toCharArrray() 转为字符数组
charAt(int index) 获取index位置的字符
ctrl + alt + V 自动生成左边的接受变量
length() 获取长度
案例3遍历
案例4 统计个数
案例2遍历
substring
subString截取
截取的索引从beginIndex开始 到endIndex-1 结束
substring(int beginIndex,int endIndex);
只有beginIndex的时候,就从beginIndex一直截取到字符串结束
substring(int beginIndex)
substring(int beginIndex,int endIndex);
只有beginIndex的时候,就从beginIndex一直截取到字符串结束
substring(int beginIndex)
案例 :手机号屏蔽
public static void main(String[] args) {
// 统计一个字符串中 大写字母和小写字母 先打印大写 然后是小写
String s = "sf2J@3jSs%4DkaF^5lG(f";
String daxie = "";
String xiaoxie = "";
//获取字符串对应的字符数组
char[] chars = s.toCharArray();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if (c >= 'A' && c <= 'Z') {
daxie += c; //如果是大写 就都拼接到daxie中
} else if (c >= 'a' && c <= 'z') {
xiaoxie+=c; //如果是小写 就都拼接到xiaoxie中
}
}
System.out.println(daxie+xiaoxie);
}
案例5 手机号变****
replace
replace字符串替换
案例6 替换脏话
split
split切割字符串
案例7 封装数据
判断开头和结尾
startsWith() 以什么开头
endsWith() 以什么结尾
contains() 包含
StringBuilder
作用
StringBuilder 可以看成是一个容器,创建之后里面的内容是可变的。
当我们在拼接字符串和反转字符串的时候会使用到
当我们在拼接字符串和反转字符串的时候会使用到
构造方法
public StringBuilder() : 创建一个空白可变字符串对象,不含有任何内容
public StringBuilder(String str) : 根据字符串的内容,来创建可变字符串对象
public StringBuilder(String str) : 根据字符串的内容,来创建可变字符串对象
方法
append
添加内容
length
获取长度
delete
deleteCharAt
reverse
反转
toString
StringBuilder和String的转换
转为String类型
StringBuilder的原理
案例1:倒序打印字符串
案例2:指定格式遍历字符串
ArrayList
集合作用
一种容器,用来存储数据的。集合的大小可变
ArrayList是集合中最常用的一种,ArrayList是泛型类,泛型: 可以约束存储的数据类型
ArrayList是集合中最常用的一种,ArrayList是泛型类,泛型: 可以约束存储的数据类型
构造方法
ArrayList常用方法名
public boolean add(E e)
将指定的元素添加到此集合的末尾
public void add(int index,E element)
在此集合中的指定位置插入指定的元素
public E get(int index)
返回指定索引处的元素
public int size()
返回集合中的元素的个数
public E remove(int index)
删除指定索引处的元素,返回被删除的元素
public boolean remove(Object o)
删除指定的元素,返回删除是否成功
public E set(int index,E element)
修改指定索引处的元素,返回被修改的元素
成员方法
增
创建集合
添加元素
添加元素
删
两种删除方式
- 根据索引删除返回的是被删除的元素
- 根据数据删除 返回的是删除是否成功
删除案例
改
查
集合存对象
注意: <>是泛型 用来限制集合里添加的数据的类型
- <>里写要添加的数据的类型的类名 所以只能是引用类型
- <>里写要添加的数据的类型的类名 所以只能是引用类型
案例练习
学生管理系统菜单编写
学生类编写
查询全部学生
添加学生
添加学生学号重复处理
修改学生信息
修改学生不存在处理
删除学生
删除学生不存在处理
条件查询学生信息
0 条评论
下一页