01
1.了解JavaSE课程内容
2.Java发展史
JDK 1.2
JDK 5.0
JDK 7.0
3.Java语言平台
JavaSE 标准版
JavaEE 企业级开发
JavaME Android取代
4.JDK、JRE、JVM
JVM java虚拟机
JRE java运行环境,包含JVM
JDK java开发工具,包含JRE
5.Java语言的跨平台性
一次编译，到处运行
注意事项：代码中不能出现相应系统命令
6.常见dos命令
打开控制台
win + R -- cmd
开始--附件--命令提示符
开始--搜索--cmd
shift + 鼠标右键 （当前目录命令提示符）
常见dos命令
相应的盘符+ ： 盘符切换
cd 路径 路径的更改
cd 全路径 路径的更改
cd .. 回退一级
cd ..\.. 回退多级
cd \ 回退根目录
md 文件夹名 新建文件夹
rd 文件夹名 删除文件夹（必须是空的）
cls 清屏
exit cmd退出
7.下载安装JDK
删除JDK
通过控制面板
软件管家
8.HelloWorld案例
public class HelloWorld {
public static void main (String[] args) {
System.out.println("HelloWorld")；
}
}
Java语言编译
命令：javac 文件名.java
Java语言运行
命令：java 类名
9.HelloWorld案例常见问题
* 大小写
Java语言是一门严格区分大小写的计算机语言
* 标点符号
英文半角输入
* 执行语句要写在方法体中
* 文件名和类名一致
* 括号成对出现
* 文件名 --- 见名知意
10.Java环境变量
配置
计算机---属性---高级系统设置---环境变量---系统变量---新建---JAVA_HOME
JAVA_HOME ：D:\develop\Java\jdk1.7.0_80（JDK安装路径）
path：%JAVA_HOME%\bin;(在path里最前面追加)
11.注释
定义：解释说明
分类：
单行注释： //
特点：可以嵌套
多行注释：/*注释内容*/
特点：不可以嵌套
文档注释：/**注释内容*/
12.关键字
定义：被Java语言赋予特定含义的单词.
特点：
1.全部小写
2.在部分高级编辑器中关键字颜色高亮显示
3.关键字不能用于类名
13.常量
常量：在程序的执行过程中，其值不可以发生改变的量
常量分类：
A:字符串常量 "HelloWorld"
B:整數常量 12,-23
C:小数常量 12.23
D:字符常量 'a','0'
E:布尔常量 true,false
F:空常量 null(后面讲)
14.变量
变量的定义格式：
数据类型 变量名 = 初始化值;
15.数据类型的分类
数据类型：Java是一种强类型语言，针对每一种数据都给出了明确的数据类型。
数据类型分类：
A:基本数据类型
B:引用数据类型(类,接口,数组)
基本数据类型：4类8种
A:整數 占用字节数
byte 1 -128 --- 127
short 2
int 4
long 8
B:浮点数
float 4
double 8
C:字符
char 2
D:布尔
boolean 1
注意：
A:整数默认是int类型,浮点数默认是double类型
B:定义long类型数据的时候，要加L或者l，建议加L
定义float类型数据的时候，要加F或者f，建议加F
变量定义的注意事项：
A:变量未赋值,不能直接使用
B:变量只在它所属的范围内有效
变量属于它所在的那对大括号
C:一行上可以定义多个变量，但是不建议
16.标识符
标识符：就是用来给包,类,方法,变量等起名字的符号
组成规则：
A:unicode字符
数字字符,英文大小写字母,汉字(不建议使用汉字)
B:下划线 _
C:美元符 $
注意事项：
A:不能以数字开头
B:不能是java中的关键字
常见命名规则：
A:基本要求
见名知意
B:常见的命名
a:包（其实就是文件夹，用于对类进行管理）
全部小写,多级包.隔开
举例：com, com.itheima
b:类
一个单词首字母大写
举例：Student,Car
多个单词每个单词的首字母大写
举例：HelloWorld
c:方法和变量
一个单词首字母小写
举例：age,show()
多个单词组成从第二个单词开始每个单词的首字母大写
举例：maxAge,getAge()
17.类型转换
+:这是一个运算符，用于做加法运算的。
我们在做运算的时候，一般要求参与运算的数据的类型必须一致。
类型转换：
隐式转换
强制转换
隐式转换：
byte,short,char -- int -- long -- float -- double
强制转换：
目标类型 变量名 = (目标类型) (被转换的数据);
建议：数据做运算，结果应该是什么类型，就用什么类型接收，不要随意转换类型，否则会有精度的损失。
02
1:eclipse基本使用
A:创建Java项目：
点击File或者在最左侧空白处，选择Java项目，在界面中写一个项目名称，然后Finish即可。
B:创建包：展开项目，在源包src下建立一个包com.itheima
C:创建类：在com.ithiema包下建立一个类HelloWorld
在界面中写一个类名：HelloWorld，然后finish即可。
D:编写代码
在HelloWorld类写main方法，在main方法中写一条输出语句：我是黑马程序员，我骄傲，我自豪。
E:编译
自动编译，在保存的那一刻帮你做好了
F:运行
选择要运行的文件或者在要运行的文件内容中
右键 -- Run as - Java Application即可
2:eclipse基本配置
A:行号的显示和隐藏
显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。
隐藏：把上面的动作再做一次。
B:字体大小及颜色
a:Java代码区域的字体大小和颜色：
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java -- Java Edit Text Font
b:控制台
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
c:其他文件
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font
C:窗体给弄乱了，怎么办?
window -- Perspective -- Reset Perspective
D:控制台找不到了，怎么办?
Window--Show View—Console
3:eclipse快捷键
内容辅助键：alt+/
A:main方法
main,然后alt+/,回车
B:输出语句
syso,然后alt+/,回车
快捷键：
A:注释
单行 选中内容,ctrl+/,再来一次就是取消注释
多行 选中内容,ctrl+shift+/,取消注释 ctrl+shift+\
B:格式化
ctrl+shift+f
右键 -- Source -- Format
4:eclipse删除和导入项目
A:删除项目
选中项目 – 右键 – 删除
从项目区域中删除
从硬盘上删除
B:导入项目
在项目区域右键找到import
找到General，展开，并找到
Existing Projects into Workspace
点击next,然后选择你要导入的项目
注意：这里选择的是项目名称
5.运算符
运算符：就是用于对常量和变量进行操作的符号
表达式：用运算符连接起来的符合java语法的式子。不同的运算符连接的表达式是不同类型的表达式。
举例：a，b
a + b
运算符分类：
算术运算符
赋值运算符
关系运算符
逻辑运算符
三元运算符
6.算术运算符：
+，-，*，/，%，++，--
+，-，*，/的基本使用
%:用于获取两个数据相除时候的余数
/:用于获取两个数据相除时候的商
+:做加法运算
字符参与加法运算，其实是拿字符在计算机中存储的数据值来参与运算的
'A' 65
'a' 97
'0' 48
字符串参与加法运算，其实做的不是加法运算，而是字符串的拼接
++,--:自增自减,用于对变量加1或者1
++,--既可以用在变量的后面，也可以用在变量的前面。
单独使用的时候，++或者--放在变量的前面或者后面，结果一样。
参与其它操作的时候：
++在后面，先拿变量做操作，然后变量在++
++在前面，先变量++，然后再哪变量做操作
7.赋值运算符：
基本的赋值运算符：=
扩展的赋值运算符：+=,-=,*=,/=,...
8.关系运算符：
==,!=,>,>=,<,<=
关系运算符的结果是boolean类型。
注意事项：
千万不要把==写成=
9.逻辑运算符
逻辑运算符：用于连接关系表达式
&,|,^,!
&&,||
&:有false则false
|:有true则true
^:相同则false,不同则true。举例:情侣关系。(男女)
!:true则false,false则true
&和&的结果一样
||和|的结果一样
&&和&的区别：
&&有短路效果,左边为false,右边不执行。
&左边无论是什么，右边都会执行。
||和|的区别：
||有短路效果,左边为true,右边不执行。
|左边无论是什么，右边都会执行。
10.三元运算符：
关系表达式?表达式1:表达式2
执行流程：
A:计算关系表达式的值,看是true还是false
B:如果是true,表达式1就是结果
如果是false,表达式2就是结果
11.Scanner类
为了提高程序的灵活性，我们就把数据改进为键盘录入。
如何实现键盘录入数据呢？目前我们只能使用JDK提供的类Scanner。
如何使用Scanner获取键盘录入数据呢？如下的步骤，大家目前只能记住
使用步骤：
A:导包
import java.util.Scanner;
在一个类中顺序：package > import > class
B:创建键盘录入对象
Scanner sc = new Scanner(System.in);
C:接收数据
int i = sc.nextInt();
03
1.if语句的第一种格式
/*
* if语句有三种格式。
*
* if语句格式1：
* if(关系表达式) {
* 语句体;
* }
*
* 执行流程：
* A:首先判断关系表达式看其结果是true还是false
* B:如果是true,就执行语句体
* C:如果是false,就不执行语句体
*/
2.if语句的第二种格式
/*
* if语句格式2：
* if(关系表达式) {
* 语句体1;
* }else {
* 语句体2;
* }
*
* 执行流程：
* A:判断关系表达式的值是true还是false
* B:如果是true，就执行语句体1
* C:如果是false，就执行语句体2
*/
3.if语句的第三种格式
/*
* if语句格式3：
* if(关系表达式1) {
* 语句体1;
* }else if(关系表达式2) {
* 语句体2;
* }else if(关系表达式3) {
* 语句体3;
* }
* ...
* else {
* 语句体n+1;
* }
*
* 执行流程：
* A:首先判断关系表达式1看其结果是true还是false
* B:如果是true，就执行语句体1
* 如果是false，就继续进行关系表达式2的判断看其结果是true还是false
* C:如果是true，就执行语句体2
* 如果是false，就继续进行关系表达式...的判断看其结果是true还是false
* ...
* D:如果没有一个为true的，就执行语句体n+1
4.if语句三种格式的应用场景
*
* if语句的三种格式：
* 第一种格式适合做一种情况的判断
* 第二种格式适合做二种情况的判断
* 第三种格式适合做多种情况的判断
*/
5.键盘录入对象的步骤
* A:看到键盘录入，我们就应该想到键盘录入的三步骤
* 导包，创建对象，接收数据
* 导包：
* A:手动导包
* import java.util.Scanner;
* B:鼠标点击红色叉叉，自动生成
* C:快捷键(推荐)
* ctrl+shift+o
6.switch语句
/*
* switch语句格式：
* switch(表达式) {
* case 值1:
* 语句体1;
* break;
* case 值2:
* 语句体2;
* break;
* ...
* default:
* 语句体n+1;
* break;
* }
* 格式解释：
* 表达式:byte,short,int,char
* JDK5以后可以是枚举
* JDK7以后可以是字符串
* case:就是要和表达式进行比较的值
* break:表示中断,结束的意思。
* default:表示所有的情况都不匹配的时候，就执行语句体n+1。和if语句的else相似。
* 执行流程：
* A:计算出表达式的值
* B:拿计算出来的值和case后面的值依次比较，一旦有对应的值，就执行该处的语句，在执行过程中，遇到 break，就结束。
* C:如果所有的case都不匹配，就会执行default控制的语句，然后结束。
7.for循环语句
* for循环语句格式：
* for(初始化语句;判断条件语句;控制条件语句) {
* 循环体语句;
* }
*
* 执行流程：
* A:执行初始化语句
* B:执行判断条件语句，看结果是true还是false
* 如果是true，就继续执行
* 如果是false，就结束循环
* C:执行循环体语句
* D:执行控制条件语句
* E:回到B继续
8.while循环语句
/*
* while循环语句的基本格式：
* while(判断条件语句) {
* 循环体语句;
* }
* 扩展格式：
* 初始化语句;
* while(判断条件语句) {
* 循环体语句;
* 控制条件语句;
* }
*
* 回顾for循环的语句格式：
* for(初始化语句;判断条件语句;控制条件语句) {
* 循环体语句;
* }
*/
9.do...while循环
/*
* do...while循环的基本格式：
* do {
* 循环体语句;
* }while(判断条件语句);
* 扩展格式：
* 初始化语句;
* do {
* 循环体语句;
* 控制条件语句;
* }while(判断条件语句);
* 执行流程：
* A:执行初始化语句;
* B:执行循环体语句;
* C:执行控制条件语句;
* D:执行判断条件语句，看是true还是false
* 如果是true，回到B继续
* 如果是false，就结束
10.三种循环的区别和应用场景
/*
* 三种循环的区别：
* A:do...while至少执行一次循环体
* B:for,while循环先判断条件是否成立，然后决定是否执行循环体
*
* for和while的小区别：
* for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。
* 如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。
*
* 循环的使用推荐：
* for -- while -- do...while
*/
11.循环跳转语句 break
/*
* break:中断的意思
* 使用场景：
* A:switch语句中
* B:循环中
* 注意：
* 离开使用场景是没有意义的。
* 作用：
* 跳出循环，让循环提前结束
*/
12.循环跳转语句 continue
/*
* continue:继续的意思
* 使用场景：
* 循环中
* 注意：
* 离开使用场景是没有意义的
* 作用：
* 结束一次循环，继续下一次的循环
* 区别：
* break:退出循环
* continue:结束一次循环，继续下一次的循环
*/
04
1.Random产生随机数
/*
* Random:用于产生随机数
*
* 使用步骤：
* A:导包
* import java.util.Random;
* B:创建对象
* Random r = new Random();
* C:获取随机数
* int number = r.nextInt(10);
* 获取数据的范围：[0,10) 包括0,不包括10
*/
2.数组的简介&动态初始化的格式
/*
* 数组：存储同一种数据类型的多个元素的容器。
*
* 定义格式：
* A:数据类型[] 数组名; (推荐的方式)
* B:数据类型 数组名[];
*
* 举例:
* int[] arr; 定义了一个int类型的数组,数组名是arr
* int arr[]; 定义了一个int类型的变量,变量名是arr数组
*
* 数组初始化：
* A:所谓的初始化,就是为数组开辟内存空间,并为数组中的每个元素赋予初始值
* B:我们有两种方式可以实现数组的初始化
* a:动态初始化 只给出长度,由系统给出初始化值
* b:静态初始化 给出初始化值,由系统决定长度
*
* 动态初始化：
* 数据类型[] 数组名 = new 数据类型[数组长度];
*/
3.数组的静态初始化
/*
* 静态初始化的格式：
* 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
*
* 举例：
* int[] arr = new int[]{1,2,3};
*
* 简化格式：
* 数据类型[] 数组名 = {元素1,元素2,元素3,...};
* int[] arr = {1,2,3};
*/
4.两个常见异常
/*
* 两个常见小问题：
* ArrayIndexOutOfBoundsException:数组索引越界异常
* 产生的原因：我们访问了不存在的索引
*
* NullPointerException:空指针异常
* 产生的原因：数组已经不在指向堆内存的数据了，你还使用数组名去访问元素
*/
5.二维数组的格式和初始化(理解)
/*
* 二维数组：其实就是元素为一维数组的数组。
*
* 定义格式：
* A:数据类型[][] 数组名; (推荐的方式)
* B:数据类型 数组名[][];
* C:数据类型[] 数组名[];
* 初始化：
* A:动态初始化
* 数据类型[][] 数组名 = new 数据类型[m][n];
* m表示的是二维数组中一维数组的个数
* n表示的是一维数组中的元素个数
* B:静态初始化
* 数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
* 简化格式：
* 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
*
* 二维数组名配合索引可以获取到每一个一维数组。
* 每一个一维数组配合索引名可以获取到数组中的元素。
*
* 假如我有一个二维数组：arr。
* 我要从中获取一维数组：arr[索引]
* 我要从中获取二维数组的元素：arr[索引][索引]
*/
05
1.方法的概述和定义格式
/*
* 方法：其实就是完成特定功能的代码块
*
* 定义格式：
* 修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
* 方法体;
* return 返回值;
* }
* 格式解释：
* A:修饰符 目前记住public static
* B:返回值类型 用于限定返回值的数据类型
* C:方法名 为了方便我们调用方法的名字
* D:参数类型 用于限定调用方法时传入的数据的类型
* E:参数名 用于接收调用方法时传入的数据的变量
* F:方法体 完成功能的代码
* G:return 结束方法,并且把返回值带给调用者
*
* 写一个方法有两个明确：
* A:返回值类型 明确功能结果的数据类型
* B:参数列表 明确有几个参数，以及参数的数据类型
2.方法的调用
/*
* 方法的调用：(有明确返回值的方法调用)
* A:单独调用,没有意义
* B:输出调用,有意义,但是不够好,因为我可能需要拿结果进行进一步的操作
* C:赋值调用,推荐方式
*/
*
* 如果一个方法没有明确的返回值类型，也不能把返回值类型的地方空出来，应该写void表示该方法无返回值类型。
*
* 方法调用：(void修饰的方法的调用)
* 只能单独调用
*
*/
3.方法的重载
/*
* 方法重载：在同一个类中，出现了方法名相同的情况。
* 方法重载的特点：
* 方法名相同，参数列表不同。与返回值无关。
* 参数列表不同：
* 参数的个数不同
* 参数对应的数据类型不同
*
* 注意：
* 在调用方法的时候，java虚拟机会通过参数列表的不同来区分同名的方法。
*/
4.方法的形式参数和实际参数
/*
* 方法的参数如果是基本数据类型：形式参数的改变不影响实际参数。
*
* 形式参数：用于接收实际参数的变量
* 实际参数：实际参与运算的变量
*/
/*
* 如果参数是引用数据类型：
* 形式参数的改变直接影响实际参数
*/06
1.面向对象思想的概述
/*
* 面向对象思想：
* 面向对象是基于面向过程的编程思想。
*
* 面向过程：强调的是每一个功能的步骤
* 面向对象：强调的是对象，然后由对象去调用功能
*
* 面向对象的思想特点：
* A:是一种更符合我们思考习惯的思想
* B:可以将复杂的事情简单化
* C:将我们从执行者变成了指挥者
*
* 举例：
* 买电脑：
* 面向过程：我要买电脑--我要明确买电脑的意义--上网查对应的参数信息--去中关村买电脑--讨价还价--买回电脑
* 面向对象：我要买电脑--班长去给我买电脑--买回电脑
* 洗衣服：
* 面向过程：把衣服脱下来--找一个盆--放点洗衣粉--加点水--浸泡10分钟--揉一揉--清洗衣服--拧干--晾起来
* 面向对象：把衣服脱下来--打开全自动洗衣机--扔衣服--按钮--晾起来
*/
2.类及其成员的解释说明
/*
* 我们学习编程语言，其实就是为了把现实世界的事物模拟出来，实现信息化。
*
* 我们是如何表示现实世界的事物的呢?
* A:属性 就是事物的描述信息
* B:行为 就是事物能够做什么
* 举例：学生
*
* Java语言最基本的单位是类，所以，我们在后面的学习过程中，是通过类来体现现实世界事物的。
*
* 类：是一组相关的属性和行为的集合
* 对象：就是该事物的具体体现
* 举例：
* 类 学生
* 对象 班长
*/
3.类及其成员的定义
/*
* 类的定义：
* 类是用来描述现实世界的事物的
*
* 事物：
* 属性 事物的描述信息
* 行为 事物能够做什么
*
* 类是如何和事物进行对应的呢?
* 类：
* 成员变量
* 成员方法
4.成员变量与成员方法
* 成员变量：和我们前面学习过的变量的定义是一样的。
* 位置不同：类中，方法外
* 初始化值：不需要给初始化值
* 成员方法：和我们前面学习过的方法的定义是一样的。
* 去掉static关键字
*/
5.如何创建对象
/*
* Student是一个学生事物描述类，main方法不适合放在它里面。
*
* 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)
* 而我们要想使用一个类的成员，就必须首先拥有该类的对象。
* 我们如何拥有一个类的对象呢?
* 创建对象就可以了?
* 我们如何创建对象呢?
* 格式：类名 对象名 = new 类名();
* 对象如何访问成员呢?
* 成员变量：对象名.变量名
* 成员方法：对象名.方法名(...)
*/
6.成员变量和局部变量的区别
/*
* 成员变量和局部变量的区别：
* A:在类中的位置不同
* 成员变量：类中，方法外
* 局部变量：方法中或者方法声明上(形式参数)
* B:在内存中的位置不同
* 成员变量：堆内存
* 局部变量：栈内存
* C:生命周期不同
* 成员变量：随着对象的创建而存在，随着对象的消失而消失
* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值的问题
* 成员变量：有默认值
* 局部变量：没有默认值。必须先定义，赋值，最后使用
*/
7.private关键字
/*
* 学生类
*
* 通过对象直接访问成员变量，会存在数据安全问题
* 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?
* 能。
* 如何实现呢?
* private关键字
*
* private:
* 是一个修饰符
* 可以修饰成员变量，也可以修饰成员方法
* 被private修饰的成员只能在本类中被访问
*
* 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰
*/
8.this关键字
/*
* 学生类
*
* 起名字我们要求做到见名知意。
* 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。
*
* 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。
*
* 我们有没有办法把局部变量的name赋值给成员变量的name呢?
* 有。
*
* 什么办法呢?
* 用this关键字就可以解决这个问题
*
* this:代表所在类的对象引用
* 方法被哪个对象调用，this就代表那个对象
*
* 使用场景：
* 局部变量隐藏成员变量
*/
9.构造方法的格式和注意事项
/*
* 构造方法：
* 给对象的数据进行初始化
*
* 格式：
* 方法名和类名相同
* 没有返回值类型，连void都不能写
* 没有具体的返回值
*
* 构造方法的注意事项：
* A:如果我们没有给出构造方法，系统将会提供一个默认的无参构造方法供我们使用。
* B:如果我们给出了构造方法，系统将不在提供默认的无参构造方法供我们使用。
* 这个时候，如果我们想使用无参构造方法，就必须自己提供。
* 推荐：自己给无参构造方法
* C:构造方法也是可以重载的
*
*/
10.构造方法的使用
//如何调用构造方法呢?
//通过new关键字调用
//格式：类名 对象名 = new 构造方法(...);
11.类名作为形式参数：其实这里需要的是该类对象。
12.如果方法的返回值是类名：其实返回的是该类的对象
07
常用API的练习过程中体会以下三句话:
* 1.通过new构造方法来创建对象,然后就可以用对象调用成员方法
* 2.方法调用时,要什么数据类型的参数,就给什么数据类型的值
* 3.方法调用时,方法的返回值是什么,就用什么类型的变量来接收
常用API的掌握要求:
* 1.查询api,首先得知道类名,再看该类中有哪些构造方法,用构造方法就可以创建对象,用对象就可以调用成员方法
* 2.记住方法名,理解记忆该方法的功能
* 3.常用api熟悉到在开发中信手拈来
* String:字符串类
- 由多个字符组成的一串数据
- 字符串其本质是一个字符数组
* 构造方法：
- String(String original)
- public String(String original):把字符串数据封装成字符串对象
- public String(char[] value):把字符数组的数据封装成字符串对象
-
public String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象
-
Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。
- 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。
* String类的判断功能：
- public boolean equals(Object obj):比较字符串的内容是否相同
- public boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
- public boolean startsWith(String str):判断字符串对象是否以指定的str开头
- public boolean endsWith(String str):判断字符串对象是否以指定的str结尾
* String类的获取功能：
- public int length():获取字符串的长度，其实也就是字符个数
- public char charAt(int index):获取指定索引处的字符
- public int indexOf(String str):获取str在字符串对象中第一次出现的索引
- public String substring(int start):从start开始截取字符串
- public String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
*案例:
- 遍历字符串(获取字符串中的每一个字符)
- 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
* String类的转换功能：
- public char[] toCharArray():把字符串转换为字符数组
- public String toLowerCase():把字符串转换为小写字符串
- public String toUpperCase():把字符串转换为大写字符串
- 字符串的遍历：
- A:length()加上charAt()
- B:把字符串转换为字符数组，然后遍历数组
*案例:
- 键盘录入一个字符串，把该字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
* 去除字符串两端空格
- public String trim()
* 按照指定符号分割字符串
- public String[] split(String str)
*案例:
-
- 把数组中的数据按照指定个格式拼接成一个字符串
- 举例：int[] arr = {1,2,3};
- 输出结果：[1, 2, 3]
- 把数组中的数据按照指定个格式拼接成一个字符串
-
- 字符串反转
- 举例：键盘录入”abc”
- 输出结果：”cba”
- 字符串反转
08
* StringBuilder:是一个可变的字符串。字符串缓冲区类。
- String和StringBuilder的区别：
- String的内容是固定的。
- StringBuilder的内容是可变的。
* 构造方法：
- public StringBuilder()
* 成员方法：
- public int capacity():返回当前容量
- public int length():返回长度（字符数）
- 容量：理论值
- 长度：实际值
* 添加功能
- public StringBuilder append(任意类型):添加数据，并返回自身对象
* 反转功能
- public StringBuilder reverse()
* StringBuilder和String的相互转换
- StringBuilder -- String
- public String toString():通过toString()就可以实现把StringBuilder转成String
- String -- StringBuilder
- StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder
案例:
- * 把数组拼接成一个字符串
- * 把字符串反转
-
- 判断一个字符串是否是对称字符串
- 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串
- 判断一个字符串是否是对称字符串
快速生成javabean类
* 自动生成构造方法：
- 代码区域右键 -- Source -- Generate Constructors from Superclass... 无参构造方法
- 代码区域右键 -- Source -- Generate Constructor using Fields... 带参构造方法
* 自动生成getXxx()/setXxx():
- 代码区域右键 -- Source -- Generate Getters and Setters...
*案例:
1. 创建一个学生数组，存储三个学生对象并遍历
* 为什么会出现集合类：
- 我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。
- 为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储，
- 就不能是一个基本的变量，而应该是一个容器类型的变量。
- 到目前为止，我们学习过了哪些容器类型的数据呢？StringBuilder,数组。
- StringBuilder的结果只能是一个字符串类型，不一定满足我们的需求。
- 所以，我们目前只能选择数组了，也就是我们前面学习过的对象数组。
- 但是，数组的长度是固定的，适应不了变化的需求，那么，我们该如何选择呢?
- 这个时候，java就提供了集合类供我们使用。
* 集合类的特点：
- 长度可变。
* ArrayList<E>:
-
大小可变数组的实现
-
<E>:是一种特殊的数据类型，泛型。 -
怎么用呢?
在出现E的地方我们使用引用数据类型替换即可 举例：ArrayList<String>,ArrayList<Student>
* 构造方法：
- public ArrayList()
* 添加元素：
- public boolean add(E e):添加元素
- public void add(int index,E element):在指定的索引处添加一个元素
* 获取元素
- public E get(int index):返回指定索引处的元素
* 集合长度
- public int size():返回集合中的元素的个数
* 删除元素
- public boolean remove(Object o):删除指定的元素，返回删除是否成功
- public E remove(int index):删除指定索引处的元素，返回被删除的元素
* 修改元素
- public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
* ArrayList集合的遍历
- 通过size()和get()配合实现的
*案例:
1. 存储字符串并遍历
2. 给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，
将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。
3. 存储自定义对象并遍历
4. 创建一个集合，存储学生对象，学生对象的数据来自于键盘录入，最后，遍历集合
* 集合版的学生管理系统的代码实现
*步骤如下：
A. 定义学生类
B. 学生管理系统的主界面的代码编写
C. 学生管理系统的查看所有学生的代码编写
D. 学生管理系统的添加学生的代码编写
E. 学生管理系统的删除学生的代码编写
F. 学生管理系统的修改学生的代码编写
09
* io流概述
- 可以把数据存储到文件,也可以从文件中读取数据
- 常见应用:
- 文件的复制(U盘拷贝)
- 上次图片(微信图片,QQ空间图片)
- 下载文件(迅雷)
* io流分类
* 输出流(将内存中的数据写出到文件中)
- 写数据--输出流--FileWriter
* FileWriter 的构造方法:
- public FileWriter(String fileName):传递一个文件名称
* 输出流写数据的步骤：
- A:创建输出流对象
- B:调用输出流对象的写数据方法，并刷新缓冲区
- C:释放资源
public class FileWriterDemo {
public static void main(String[] args) throws IOException {
//A:创建输出流对象
FileWriter fw = new FileWriter("d:\\a.txt");
// B:调用输出流对象的写数据方法，并刷新缓冲区
//写一个字符串数据
fw.write("IO流你好");
//数据没有直接写到文件，其实是写到了内存缓冲区
fw.flush();
//C:释放资源: 通知系统释放和该文件相关的资源
fw.close();
}
}
- 相对路径：相对当前项目而言的，在项目的根目录下(a.txt)
- 绝对路径：以盘符开始的路径(d:\a.txt)
* close()和flush()方法的区别：
* flush():刷新缓冲区。流对象还可以继续使用。
* close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
* FileWriter 的成员方法(write()的五个重载方法 ):
- public void write(String str):写一个字符串数据
- public void write(String str,int index,int len):写一个字符串中的一部分数据
- public void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97
- public void write(char[] chs):写一个字符数组数据
- public void write(char[] chs,int index,int len):写一个字符数组的一部分数据
* 实现数据的追加的方法:
- public FileWriter(String fileName, boolean append):
- 方法说明: 根据给定的文件名(fileName)创建FileWriter对象，通过append来指示数据写入位置.如果为 true，则将数据写入文件末尾处,如果为false,则数据从文件起始位置写起
* 输入流(将文件中的数据读入到内存中)
- 读数据--输入流--FileReader
* FileReader 的构造方法:
- public FileReader(String fileName):传递文件名称
* java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)
* 输入流读数据的步骤：
- A:创建输入流对象
- B:调用输入流对象的读数据方法
- C:释放资源
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
//A:创建输入流对象
FileReader fr = new FileReader("FileWriterDemo.java");
//B:调用输入流对象的读数据方法
//int read():一次读取一个字符
/*
//第一次读数据
int ch = fr.read();
System.out.println(ch);
System.out.println((char)ch);
//第二次读数据
ch = fr.read();
System.out.println(ch);
System.out.println((char)ch);
//第三次读数据
ch = fr.read();
System.out.println(ch);
System.out.println((char)ch);
//这是时候，我们发现代码的重复度很高，想用循环改进，但是不知道循环的结束条件是什么
ch = fr.read();
System.out.println(ch);
ch = fr.read();
System.out.println(ch);
//通过测试，我们知道，如果读取数据的返回值是-1的时候，就说明没有数据了，这也是我们循环的结束条件
*/
//故代码最终改造为循环格式:
int ch;
//1:fr.read()
//2:ch=fr.read()
//3:ch != -1
while((ch=fr.read())!=-1) {
//System.out.println(ch);
//System.out.println((char)ch);
System.out.print((char)ch);
}
//C:释放资源
fr.close();
}
}
* 缓冲流
- BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
- BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
* 缓冲流的特殊功能：
- BufferedWriter:
- public void newLine():写一个换行符，这个换行符由系统决定
- BufferedReader:
- public String readLine():一次读取一行数据，但是不读取换行符
* 核心案例代码一:
/*
* 需求：把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中
* 数据源：FileWriterDemo.java -读数据 -FileReader
* 目的地：Copy.java -写数据 -FileWriter
*/
public class CopyFileDemo2 {
public static void main(String[] args) throws IOException {
//创建输入流对象
FileReader fr = new FileReader("FileWriterDemo.java");
//创建输出流对象
FileWriter fw = new FileWriter("Copy.java");
//读写数据
char[] chs = new char[1024];
int len;
while((len=fr.read(chs))!=-1) {
fw.write(chs, 0, len);
}
//释放资源
fw.close();
fr.close();
}
}
* 核心案例代码二:
/*
* 需求：把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中
* 数据源：FileWriterDemo.java -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader
* 目的地：Copy.java -- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
//创建输出缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
//读写数据
String line;
while((line=br.readLine())!=null) {
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
br.close();
}
}
* 核心案例代码三:
/*
* 从文本文件中读取数据到ArrayList集合中，并遍历集合
* 每一行数据作为一个字符串元素
*
* 分析：
* A:创建输入缓冲流对象
* B:创建集合对象
* C:读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中
* D:释放资源
* E:遍历集合
*/
public class FileToArrayListTest {
public static void main(String[] args) throws IOException {
//创建输入缓冲流对象
BufferedReader br = new BufferedReader(new FileReader("array.txt"));
//创建集合对象
ArrayList<String> array = new ArrayList<String>();
//读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中
String line;
while((line=br.readLine())!=null) {
array.add(line);
}
//释放资源
br.close();
//遍历集合
for(int x=0; x<array.size(); x++) {
String s = array.get(x);
System.out.println(s);
}
}
}
扫一扫
126
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
