2021 JAVA学习记录笔记(更新学习中)
·
第一章：“HelloWorld"
- 梦的开始:
1.编写:
我们将Java代码编写在".java"的源文件中
2.编译 :
javac.exe命令编译我们的java源文件。格式为:javac 源文件名.java
3.运行 :
java.exe命令解释运行我们的字节码文件。格式为:java 类名。
4.在一个java源文件当中可以声明多个class。但·是，只能最多有一个类声明为public的。
而且声明为public的类的类名必须与源文件的文件名相同。
5.每一行执行语句都以";"结束
6.编译的过程: 编译过程中,会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。
以.class为后缀的就是字节码文件。
//类名必须与文件名一致
public class HelloChina{
//main（）方法如同JAVA程序的大门,一个程序只能有一个main方法,且方法是固定的。
public static void main(String[] args){
//arguments:参数 (是可以变化的,不是固定的)
// main(String a[])这是唯一两个可以改变的地方。
System.out.println("Hello,World!");
//ln代表行的意思,加上ln,输出的结果会自动换行
//去掉ln的话不会自动换行
}
}
class admin {
}
class sun{
}
}
1.1.0转义符的用法：
\n 相当于回车
System.out.println("Hello,Word!\n");
\t 相当于Tab键盘
System.out.println("Hello,Word!\t");
1.1.2.Java中的注释类型:
- 单行注释:
//单行注释:
- 多行注释
"/*
内容
*/
- 文档注释(Java特有)
/**
@author 指定Java程序的作者
@version 指定源文件的版本
*/
注释内容可以被JDK提供的工具javadoc所解析,生成一套以网页文件形式体现该程序的文档说明。
使用方法:javadoc -d myhello -author -version HelloJava.java(文件名)
就会出现这个文件。
3.注释的好处：
- 对所写的程序进行解释说明,方便自己,方便别人。
- 调试所写的代码
- 多行注释不可以嵌套使用
比如说代码中有一行出错了,在前面加一个//就可以过滤掉那一行代码
很明显这一行少了一个分号,过滤掉即可。
第二章：JAVA的基本语法
2.1 关键字和保留字:
关键字的定义和特点:
定义:被Java语言赋予了特殊的含义，用做专门用途的字串符(单词)
特点:关键字中所有的字母均为小写。
保留字(reserved word)
定义:现有Java版本尚未使用，但以后的版本可能作为关键字使用。
自己命名标识符时要避免使用这些保留字。 goto、const
2.2 标识符(identifier):
标识符的使用:
1.标识符：凡是可以自己起名字的地方都叫标识符
比如：类名，变量名，方法名，接口名，包名…
2.标识符的命名规则：----> 如果不遵守如下的规则，编译则不会通过，要严格遵守。
1.由26个英文字母大小写，0-9，_或 $ 组成
2.数字不可以开头。
3.不可以使用关键字和保留字，但能包含关键字和保留字。
4.Java中严格区分大小写，长度无限制。
5.标识符不能包含空格。
3.Java中的名称和命名规范 : ----> 如果不遵守如下规范,编译也可以通过。建议大家遵守。
包名:多单词组成时所有字母都小写：boooooooy
类名、接口名:多单词组成时，所有单词的首字母大写:XyyYyyZzz（大驼峰命名法）
变量名、方法名:多单词组成时，第一个单词首字母小写， 第二个单词开始每个单词首字母大写：xxxYyyZzz(小驼峰命名法)
常量名:所有字母都大写。多个单词时每个单词用下划线连接:XXX_YYY_ZZZ
4.注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
2.3 变量
变量的使用
java的定义变量的格式: 数据类型 变量名 = 变量值;
变量的概念：
内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值。
变量的作用：
用于在内存中保存数据
使用变量注意：
①.Java中每个变量必须先声明，后使用
②使用变量名来访问这块区域的数据
③变量的作用域:其定义所在的一对{}内
它（变量== ）在它的有效使用范围内使用才有效，超出这个范围就出 现报错，这个范围就叫它的作用域。顾名思义就是 “能起作用的地方”。
④同一个作用域内，不能定义重复的变量。
class VariableTest
{
public static void main(String[] args) {
//变量的定义
int myAge = 18;
//变量的使用
System.out.println(myAge);
//编译错误:使用myNumber之前并未定义过myNumber
//System.out.println(myNumber);
//变量的声明
int myNumber
//编译错误：使用myNumber之前并未赋值过myNumber
//System.out.println(myNumber);
//变量的赋值
myNumber = 1001
System.out.println(myNumber);
}
}
2.3.1 变量的分类-按数据类型
2.3.2 Java常用数据类型：
| 数据类型 | 举例 |
|---|---|
| int（整型） | 用于存储整数，例如，学生人数、某公司的员工编号、一年的天数、一天的小时数等 |
| double（双精度浮点型） | 用于存储带有小数的数字，例如，商品的价格、员工工资等 |
| char（字符型） | 用于存储单个字符，例如，性别“男”或"女"、成绩"优"或"良"等 |
| String（字符串型） | 用于存储一串字符，例如，员工姓名、产品型号等 |
各个数据类型的使用:
①整型 : byte \ short \ int \ long
class VariableTest1
{
public static void main(String[] args) {
/整型: byte \ short \ int \ long
//① byte范围: -128~127
byte b1 = 12;
byte b2 = -128;
//若 b2 =128;/编译不通过
System.out.println(b1);
System.out.println(b2);
/② 声明long型变量，必须以"l"或"L"结尾
/③ 通常定义整形变量时，使用int类型。
//代码
short s1 = 128;
int i1 = 1234;
long l1= 34123412511231L;
System.out.println(l1);
浮点型：float (4字节) \ double (8字节)
/2.浮点型: float(4字节) \ double(8字节)
/①浮点型，标识带小数点的数值
/② float表示数值的范围比long还大
//代码
double d1 =123.3;
System.out.println(d1 + 1);
/③ 定义float类型变量时,变量要以"f"或"F"结尾
//代码
float f1 = 12.3F;
System.out.println(f1);
/④ 通常,定义浮点型变量时,使用double型。
③字符型: char (1字符=2字节)
3.字符型: char (1字符=2字节)
/① 定义char型变量.通常使用一对' ',内部只能写一个字符
//代码
char c1 ='a';
char c2 ='学';
char c3 ='习';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
/② 表示方式：1.声明一个字符 2.转义字符 3.直接用 Unicode 值来表示字符型常量
//代码
char c5 ='\n';//换行符
c5 = '\t'; //制表符,相当于Table
System.out.print("hello"+ c5);
System.out.println("world");
char c6 = '\u0043';//Unicode字符集
System.out.println(c6);
char也可以作为数字和int型进行计算:
char c = 'a';//a:97 A:65 b:98 B:66 以此类推
int nume = 10;
String str = "hello";
System.out.println(c+nume+str);
//输出结果为:107hello
④布尔型:boolean
/4.布尔型:boolean
/① 只能取两个值之一:true、false
/② 常常在条件判断、循环结构中使用
//代码
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
//if语句
if(isMarried) {
System.out.println("你就不能参加\"单身\"party了！\n很遗憾");// "\"可以作为转义符用
}else {
System.out.println("你就可以多谈谈女朋友！");
}
//关系运算符 boolean
boolean a = 2 > 1;
System.out.println(a);
boolean b = ( 3 + 40 % 6 ) > (9 / 2 * 3);
//输出结果
System.out.println("7是否大于12："+b);
}
}
⑤字符串型:String
- String类型变量的使用
1.String属于引用数据类型,翻译为：字符串
2.声明String类型变量时，使用一对 " "
3.String可以和8种基本数据类型变量作运算，且运算只能是连接运算:+
4.运算的结果仍然是String类型
class StringTest5{
public static void main(String [] agrs) {
String s1 ="Hello World!";
System.out.println(s1);
String s2 = "a";
String s3 = "" ;
//**********************
int number = 1001 ;
String numberStr = "学号:";
String info = numberStr + number ;// + ： 连接运算
boolean b1 =true;
String info1 = info + b1;//+ : 连接运算
System.out.println(info);
}
}
如何判断是否是连接运算
看前面是否带有String,若带有String的基本都属于连接运算
2.4 运算符
2.4.1 运算符之一:算数运算符
| 运算符 | 说明 | 举例 |
|---|---|---|
| + | 加法运算符,求操作数的和 | 5 + 3等于8 |
| - | 加法运算符,求操作数的差 | 5 - 3等于2 |
| * | 乘法运算符,求操作数的乘积 | 5 * 3 等于15 |
| / | 除法运算符,求操作数的商 | 6 / 3等于2 |
| % | 取余运算符,求操作数相除的余数 | 5%2等于2 |
| (++)前 | 先增加1,然后再运算 | ++i |
| 后(++) | 先运算，然后增加1 | i++ |
| 前(- -) | 先减1，然后再运算 | –i |
| 后(- -) | 先运算，然后再减1 | i– |
使用方法:
/除号: /
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1);//结果为2
int result2 = num1 / num2 * num2;
System.out.println(result2);//结果为10
double result3 = num1 / num2;
System.out.println(result3);
double result4 =num1 / (num2+ 0.0);
//可以将int类型的结果转化为小数点，得出2.4
System.out.println(result4);
double result5 =(double)num1 / num2;
/ %:取余运算
/结果的符号与被模数的符号相同
/开发中,经常使用%来判断能否被除尽的情况
int m1 =12 ;//被模数
int n1 = 5;
System.out.println("m1 % n1 =" + m1 % n1);
//(前)++:先自增1，然后再运算
//(后)++:先运算，然后再自增1
int a1 =10;
int b1 = ++a1;
System.out.println("a1 =" + a1 +",b1 = "+b1);// 11,11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 =" + a2 +",b2 = "+b2);// 11,10
//注意点:
//如果要给short +1
short s1 = 10;
//s1 = s1 +1 ;//编译失败
//s1 = (short)(s1+1);//正确的，强转类型转换
s1++;//自增1不会改变本身变量的数据类型
System.out.println(s1);
//问题
//如果是byte自增加1会发生什么(byte的字节的最大值为-128-127)
byte s2 =127;
int s22 = s2++;
System.out.println(s2);//会输出 -128
//(前)--先自减1，然后再运算
//(后)--:先运算，然后再自减1
int s3 =127;
s3++;
System.out.println(s3);
}
}
算三位数的整数的个十百位数:
int qian = num/1000 % 10 ;千
int bai = num / 100 % 10;百
int shi = num % 10 /10 ;//int shi = num / 10 % 10;十
int ge = num % 10;个
2.4.2 自动转换与强制类型转换
自动类型转换:
定义：
当容量小的数据类型与容量大的数据类型运算时，结果自动会提升为容量大的类型。
byte --> short --> int --> long --> float --> double
结论:
* 1.类型要兼容 比如小数和整数 字符串和整数不兼容
* 2.目标类型要大于源类型 左边(大) = 右边(小)
* 例如double > int
//自动类型转换(左大右小)
int a = 10 ;
double b;
b = a ;
强制类型转换:自动类型提升运算的逆运算。
①需要使用强转符:()
②注意点:强制类型转换,可能导致精度损失
③类型要兼容
④目标类型小于源类型 左边(小) = 右边(大)
//强制类型转换
char cccc;
int dddd = 5;
cccc = (char)dddd;
//强制类型转换
float ccccc;
double ddddd =5 ;
ccccc = (float)ddddd ;
//精度损失举例1
double d1 =12.3;
int i11 =(int)d1 ;//截断操作(四舍五入)
System.out.println(i11);
//没有精度损失
long l11 =123;
short s2 = (short)l1;
精度损失举例2
//byte容量为-128---127
int i22 = 128;
byte c = (byte)i22;
//会输出为-128
System.out.println(c);
2.4.3 运算符之二:赋值运算符
符号:"="
扩展赋值运算符: +=,-=,*=,/=,%=
//赋值符号：=
int i1 =10;
int j1 =10;
int i2,j2;
//连续赋值
i2 = j2 = 10;
int i3 = 10,j3 = 20;
//用的不熟悉的话用普通的赋值就行。
"+="符号的用法:
int num1 =10;
num1 +=2; //num1 = num1 + 2;在本身变量之上加上一个数。
System.out.println(num1); //12
short s1 =10 ;
//s1 = s1 +2 ; //编译失败,正确解答s1 =(short)(s1+2);
s1 +=2;//不会改变本身变量的数据类型(推荐)
System.out.println(s1);
练习1:
int m =2;
int n =3;
n *=m++; //m=3 n=6
练习2:
int n1=10;
n1 +=(n1++) + (++n1);//=32
"="和”==“的区别
①“=”是赋值运算符,即把右边的值赋给"=“左边的变量，比如int num =20；
②”=="则是算数运算符,两者不一致
2.4.1 运算符之三:比较运算符
符号:, != ,> ,< ,>= ,<=, instanceof
① 比较运算符的结果都是boolean型，要么就是true要么就是false。
② 比较运算符"==“不能误写为”="
public static void main(String[] agrs) {
int j =10;
int i =20;
System.out.println(i == j);//false
}
2.4.1 运算符之四:逻辑运算符
| 运算符 | 汉语名称 | 表达式 | 说明 |
|---|---|---|---|
| && | 与、并且 | 条件1&&条件2 | 两个条件同时为真，则结果为真；两个条件有一个为假，则结果为假 |
| 两条竖线 | 或、或者 | 条件1"两条竖线"条件2 | 两个条件有一个为真,则结果为真；两个条件同时为假，则结果为假 |
| ! | 非 | ！条件 | 条件为真时，则结果为假；条件为假时，结果为真 |
符号:& , && , | , || (或者), ！, ^
说明:逻辑运算符操作的都是boolean类型的变量
区分 & 与 &&(逻辑并且):
//相同点:& 与 &&的运算结果相同
//相同点2:当符号左边是true时，他们二者都会执行符号右边的运算。
//不同点:当符号左边是flase时，&继续执行符号右边的运算。&&(并且)不再执行符号右边运算。
##开发中，我们优先使用&&
boolean b1 = true ;
b1 = false;
int num1 =10;
if(b1 &(num1++ > 0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}
System.out.println("num1=" +num1);
boolean b2 = true ;
b2 = false ;
int num2 =10;
if(b2 &&(num2++ > 0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}
System.out.println("num2=" +num2);
区分: | 与 ||(逻辑或者):
//区分: | 与 ||(逻辑或者)
//相同点1:| 与 || 的运算结果相同
//相同点2：当符号左边是false时，两者都会执行符号右边的运算
//不同点:当符号左边是true时，|继续执行符号右边的运算，而||不会执行右边的运算
##开发时，我们优先使用||
boolean b3 = true ;
b3 = true ;
int num3 =10;
if(b3 |(num3++ > 0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}
System.out.println("num3=" +num3);
boolean b4 = true ;
b4 = true ;
int num4 =10;
if(b4 ||(num4++ > 0)) {
System.out.println("我现在在北京");
}else {
System.out.println("我现在在南京");
}
System.out.println("num3=" +num4);
第三章: 流程控制语句
3.0 输入语句
使用步骤
①在Java源代码中引入Scanner类,写法如下：
import java.util.Scanner//导包
②在类里面实例化Scanner类,写法如下:
Scanner input = new Scanner (System.in);//input是可变的。
③调用next()或nextInt()方法接受用户输入的内容
int stb = int.nextInt();//整型
String name = input.next();//字符串
Double asd = input.nextDouble();//小数点型
例子:
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
//实例化类
Scanner input = new Scanner(System.in);
System.out.println("请输入你的数字:");
int num = input.nextInt();//整型
3.1 流程控制语句-if选择结构
3.1.1 if 基本选择结构
语法格式:if(条件){代码块}
简要:使用于"如果XX就XX“的情况
案例:
如果小明考了一百分,妈妈给他奖励一块手表
int score = input.nextInt();//从控制台输入小明的成绩
if (score == 100){
//条件
System.out.println("妈妈奖励了他一块手表");//输出语句
}
3.1.2 if-else选择结构
语法格式:if(条件1) {代码块1 }else{ 代码块2 }
简要 :使用于“如果XXX就XXX，否则XXX”的情况
案例:
如果小明考了九十分以上,妈妈给他奖励一块手表，否则什么都不给
int score = input.nextInt();//从控制台输入小明的成绩
if (score > 90){
//条件
System.out.println("妈妈奖励他一块手表");
}else{
//否则
System.out.println("什么都不给");
}
3.1.3 多重if-else选择结构
语法格式:if(条件1) {代码块1} else if (条件2) {代码块2} else if(条件3){代码块3} else {代码块4}
简要:使用于:"如果XXX就XXX，否则如果XXX，就XXX，否则XXX”的情况下。
案列:
年龄的各个阶段
int age = input.nextInt();//从控制台输入
if(age < 0){
System.out.println("您输入的格式非法");
}else if(age < 18){
System.out.println("青少年时期");
}else if(age <35){
System.out.println("青壮年时期");
}else if(age <60){
System.out.println("中年时期");
}else if(age <120){
System.out.println("老年时期")
}else{
System.out.println("您是要升仙啊？");
}
3.1.4 多重if嵌套语句
语法格式:
if(条件1) {
if(条件2) {
//代码块1
}else {
//代码块2
}
}else {
if(条件3) {
//代码块3
}else {
//代码块4
}
}
案例:
编写程序:由键盘输入三个整数分别存入变量num1、num2、num3、
对它们进行排序(使用if-else if -else )，并且从小到大输出
import java.util.Scanner;
public class IfTest{
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数:");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数:");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数:");
int num3 = scanner.nextInt();
if(num1 >= num2){
//num1比num2大
if(num3 >= num1){
//num3比num1大
System.out.println(num2+","+num1+","+num3);//从小到大排序
}else if(num3 <= num2) {
//如果num2比num3大
System.out.println(num2+","+num3+","+num1);//从小到大排序
}
}else {
if(num3 >= num2) {
System.out.println(num1+","+num2+","+num3);
}else if(num3 <= num1) {
System.out.println(num3+","+num1+","+num2);
}else {
System.out.println(num1+","+num3+","+num2);
}
}
}//main
}//class
小知识:
当 if-else 执行语句只有一行的话,对应的 { } 是可以省略的但是不建议大家使用。如下，可以与上边对比一下。
if(num1 >= num2) {
//num1比num2大
if(num3 >= num1)//num3比num1大
System.out.println(num2+","+num1+","+num3);//输出语句只有一行
else if(num3 <= num2) //如果num2比num3大
System.out.println(num2+","+num3+","+num1);//输出语句只有一行
}else {
if(num3 >= num2)
System.out.println(num1+","+num2+","+num3);//输出语句只有一行
else if(num3 <= num1)
System.out.println(num3+","+num1+","+num2);//输出语句只有一行
else
System.out.println(num1+","+num3+","+num2);//输出语句只有一行
}
3.2 流程控制语句- switch-case选择结构
3.2.1 switch选择结构
语法格式:
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
...
default: //相当于if-else结构中的else.
/注:default结构是可选的，而且位置是灵活的!
执行语句n;
//break;
}
简述:
根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
break关键字的简述:
表示一旦执行到此关键字，就跳出switch-case结构。break关键字是可选的。
省略break的后果:
case后面的不再进行条件判断，会直接执行后面所有case块中 代码，直到遇到break结束。所以在编写switch的时候若无特殊情况切记要加"break";
3.2.2 switch选择结构的注意事项
- switch选择结构的条件只能是等值的判断
- switch结构中的表达式，只能是如下的6种数据类型之一： byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
- case 之后只能声明常量。不能声明范围。
- 如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
3.3 流程控制语句-while循环结构
选择结构的四个要素:
① 初始化条件 ② 循环条件 —>是boolean类型 ③ 循环体 ④ 迭代条件 说明：通常情况下，循环结束都是因为②中循环条件返回false了。
3.2.1 while循环结构
语法结构:
①
while(②){
③;
④;
}
-执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
注意:
写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
案例:
用while循环打印50份试卷
int count =1;
while(count <= 50){
//条件
system.out.println("打印第"+count+"份试卷");
count++;
}
3.2.2 do-while循环结构
简述:
先执行，之后再判断循环条件
语法结构:
①
do{
③;
④;
}while(②);
-执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
说明：
- do-while循环至少会执行一次循环体
- 开发中，使用for和while更多一些。较少使用do-while
- 数组循环比遍历通常用for循环
- 触发条件复杂的用while循环
案例:
经过几天的学习，老师给小明一道测试题，让他上机编写程序完成，然后老师检查是否合格，如果不合格，则继续编写。
String answer = "";//标识是否合格
do{
System.out.println("上机编写程序！");
System.out.print("合格了吗?(y/n)");
answer = input.next();
System.out.println("");
}while(!"y".equals(answer));
System.out.println("恭喜你通过了测试！");
3.4 细说break和continue
| 使用范围 | 循环中的作用（不同点） | 相同点 | |
|---|---|---|---|
| break | switch-case 循环结构中 | 结束当前循环 | 关键字后面不能声明执行语句 |
| continue | continue | (结束本次循环)跳出本次循环,进入下一次循环 | 关键字后面不能声明执行语句 |
第四章 :String类型的介绍与扩展提升
4.1 字符串的创建
使用String对象储存单位(三种方法):
①String a1 ="小明";
②String a2 = new String(); //new个对象--但本身为空值
③String a3 = new String("小红"); //创建对象的同时,给它赋值。
问题1:
4.2 获取字符串的长度
格式:字符串.length()//返回值是int数据类型 ;
例:定义一个123456的变量，获取它的长度
String pwd1 = "1234567";//密码长度为7位
如何获取长度:pwd1.length();
int length1 = pwd1.length();
System.out.println(length);
if(length1！=6){
//如果密码长度不等于6
System.out.println("密码长度必须为6位数!")
}
4.3 获取字符串的长度
格式::字符串.equlas(); 对比的是两个字符串的值
简述：比较两个字符串的值是否相同，返回boolean类型的值。
------- 如果相同,则返回true;否则返回flase;
例子:
输入用户名和密码,如果用户名等于小明,并且密码等于123，提示登录成功。
Scanner input = new Scanner(System.in);//实例化
String uname,pwd;//设置变量
System.out.println("请输入用户名:");
uname = input.next();
System.out.println("请输入密码:");
pwd = input.next();
if(uname.equals("小明")&&pwd.euqals("123")){
//做比较
System.out.println("登录成功!");
}
问题：如果用"=="会发生什么？
例子:boolean b2 = pwd1 == pwd2;
System.out.println(b2);
答:并不会报错,运行出来的结果为false
不同点:一个对比的是值，一个对比的内存地址。
"=="对比内存地址: 内存地址的话基本上是不会一致的。
4.4 字符串的忽略大小写
格式：字符串.equalsIgnoreCase(字符串/比较值) ;
简述:忽略大小写比较 字符串1和字符串2。如果都相同,则返回ture;否则返回false
例:
系统规定，登录时不考虑用户名的大小写问题，该如何实现登录?
Scanner input = new Scanner(System.in);//实例化
String uname,pwd;//设置变量
System.out.println("请输入用户名:");
uname = input.next();
System.out.println("请输入密码:");
pwd = input.next();
if(uname.equalsIgnoreCase("XiaoMing")&&pwd.euqalsIgnoreCase("123")){
//做比较
System.out.println("登录成功!");
}
4.5 字符串的大小写转换
格式:字符串.toUpperCase();//转换字符串中英文字母为大写
例:输入一个字母转换为大写
System.out.println("请输入一个字符串:");
String s1 = input.next();//aaa
System.out.println("转换之前:"+s1);
String daxie = s1.toUpperCase();//返回值是String类型
System.out.println("转换之后:"+daxie);
格式:字符串.toLowerCase();.//转换字符串中的英文字母为小写
例:输入一个字母转换为小写
System.out.println("请输入一个字符串:");
String s2 = input.next();//AAA
System.out.println("转换之前:"+s2);
s2.toLowerCase();
String xiaoxie = s2.toLowerCase();
System.out.println("转换小写以后是:"+xiaoxie);
实例:两者结合同样可以实现忽略大小写实现登录
if(uname.toLowerCase().equals(("Jack").toLowerCase())&&pwd.toUpperCase().equals(("1234567").touUpperCase())){
System.out.printl("登录成功！");
}else{
System.oput.print("用户名或密码不匹配,登录失败！")
}
4.6 字符串的拼接
格式:字符串.concat();或者直接使用"+"运算符
简述:将两个值进行拼接输出，返回值的数据类型是String
String s1 = "Hello";
String s2 = "World";
①System.out.println("s1+s2");
利用+号,进行连接。
②String s3 = s1.concat (s2); //返回值的数据类型为String
System.out.println(s3);
利用concat。
例:输出以下代码,并使用拼接
int sqlScore = 80; //SQL成绩
int javaScore =80; //Java成绩
double htmlScore = 80.5; //HTML成绩
//成绩单
String scoreSheet = "SQL:"+sqlScore+"Java:"+javaScore+"HTML:"+htmlScore;
//打印成绩单
System.out.println("********成绩单********");
System.out.println(scoreSheet);
//*************第二种方法****************
String scoreSheet2 = ("********成绩单********\n");
String concatTest = scoreSheet2.concat(scoreSheet);
4.7 字符串的提取与查询
分析:
判断Java的文件名是否合法,关键是判断它是不是以".java"结尾的;
判断邮箱是否合法.至少要检查邮箱名中是否包含字符"@“和” .",并检查"@“是否
在”."之前。
要解决这样的问题就要使用String类提供的提取和搜索字符串的方法。
根据不同的情况,可以选用不同的提取和搜索字符串的方法。
字符串下标的获取:indexOf()方法
简述:该方法是获取某个指定的字符或字符串的位置，如果没有找到则返回-1。
String a = "快去学习";
int index = a.indexOf("快");
System.out,println(index);
返回值是:2
最后出现字符串下标位置的获取:lastIndexOf()方法
简述:该方法用于出现两个"快去"的情况下，如:“快去学习快去”
单纯的使用index Of（）是不行的，它会优先获取最先出现"快去"的下标位置
需要使用lastIndexOf()方法获取最后出现字符串"快去"的下标位置。
String b = "快去学习快去";
int index = b.lastIndexOf("快去");
System.out.println(index);
返回值是:4
字符串的提取:substring(int idex)方法
简述:获取要提取的字符串
例:获取444656840@qq.com里面的"@qq.com"
String qq = "[email protected]";
String sub1 = qq.substring(9);
字符串的提取②:substring(int beginindex , int endindex)方法
简述:提取位置
beginindex和endindex终止位置之间的字符串部分
注意点：对于开始位置beginindex,Java是基于首字符为0处理的,
但是对于终止位置endindex,Java是基于首字符为1处理的。
例:要提取"快去学习快去"中的学习。
String s = "快去学习快去";
String study = s.substring(2,4);
返回值:"学习"
4.8 字符串的去空
格式:字符串.trim()方法
简述:顾名思义,可以忽略字符串前后的空格
例:
String s1 = " 1234 5 6 ";
System.out.println(s1);//未去空格前
String qukong = s1.trim();
System.out.println(qukong);//只能去除前面和后面的空格，中间的空格不能去空
4.9 字符串的拆分
格式:字符串.split();
例:使用拆分打印以下格式。
String words = "长亭外 古道边 芳草碧连天 晚风扶 柳笛声残 夕阳西下";
String [] printword = new String [30];//接受数组
Ststem.out.println("***原歌词格式***\n"+words);
System.out.println("\n**拆分后歌词格式***");
printword = words.split(" ")//按照空格进行拆分
for(int i=0;i<printword.length;i++){
Ststem.out.println(printword[i]);// 打印输出
}
②格式:字符串.split(regex,limit);//limit的意思是你想从第几个字符串拆分
String [] array2 = s2.split(" ",1);//从第一个字符串拆分//结果为hello world int a b c;
for(int i=0;i<array2.length;i++){
//从第二个字符串拆分//结果为hello
// world int a b c;
System.out.println(array2[i]);
}
第五章 数组的使用
简述:
数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的 方式对这些数据进行统一管理。
数组的相关概念:
- 标识符: 数组的名称
- 数组元素: 数组中存放的数据(数组的长度)
- 数组下标（角标）: 为了正确得到数组的元素，为他们设置的编号，可以看做为数组内存的大小。数组的下标从0开始。
- 元素类型: 数据类型
数组的特点：
- 数组是序排列的
- 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
- 创建数组对象会在内存中开辟一整块连续的空间
- 数组的长度一旦确定，就不能修改。
5.1 一维数组的使用
代码的使用:
int num;//声明
num = 10;//初始化
int id = 1001;//声明 + 初始化
int[] ids;//声明
// 静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{
1001,1002,1003,1004};
//动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
int[] arr4 = {
1,2,3,4,5};//类型推断
总结:
"①静态初始化的格式"
数组类型 [] 数组名 = {
值1，值2，值3....,值n};
数据类型 [] 数组名 = new 数据类型 {
值1，值2，值3....,值n};
"②动态初始化的格式"
数组类型 [] 数组名 = new 数据类型[数据长度];
数组名 = new 数据类型 [数据长度];
常见的错误方式:
//int[] arr1 = new int[]; //未加元素
//int[5] arr2 = new int[5];//设置了两个元素
//int[] arr3 = new int[3]{1,2,3};//动态静态重叠了
5.2 一维数组元素的引用
通过角标的方式调用：
//数组的角标（或索引从0开始的，到数组的长度-1结束。
names[0] = "王波波";
names[1] = "李湘赫";
names[2] = "周杰伦";
names[3] = "王心怡";
names[4] = "L X Y" ;//charAt(0)
5.3 数组的属性
数组的属性:length
int [] num = new int [] {
8,4,2,1,23,344};
System.out.println(num.length);//5
说明： 数组一旦初始化，其长度就是确定的。name.length 数组长度一旦确定，就不可修改。
5.4 输出数组里面的值
//循环输出
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
5.5 一维数组元素的默认初始化值
| 数据类型 | 初始值 |
|---|---|
| int | 0 |
| double | 0.0 |
| char | 0或’\u0000’，而非’0’ |
| String | null |
| boolean | False |
5.6 针对于数值型的数组：
找到数组中的平均数:
int num = 0;
for (int i = 0; i < arr.length; i++) {
num += arr[i];
}
System.out.println("数组的平均数为：" + (num / arr.length));
求总和：
int num1 = 0;
for (int i = 0; i < arr.length; i++) {
num1 += arr[i];
}
System.out.println("数组的总和为：" + num1);
5.7 数组之冒泡排序：
//冒泡排序
public class MaoPao {
public static void main(String[] args) {
int [] array = {
10,1,35,61,89,36,55};
int temp;//设置一个临时的变量，类似于托盘的东西。
for(int i=0 ; i<array.length-1;i++) {
//总共循环了6回
for(int j=0;j<array.length-1-i;j++) {
//每一回比较了多少次 6 5 4 3 2 1
if(array[j]>array[j+1]) {
//升序
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
//输出数组验证是否冒泡
for(int i=0 ; i<array.length;i++) {
System.out.print(array[i]+" ");
}
}
}
5.8 数组的排序之快速排序(使用Array类):
Arrays.sort(循环数组的名字);
for(int i=0; i<数组的长度;i++){
//升序
System.out.println(数组[]+"");
}
Arrays.sort(数组的名字);
for(int i =数组的长度-1;i>=0;i--){
//降序
System.out.println(数组[]+"");
}
5.9 数组的常见异常
1.数组角标越界异常：
ArrayIndexOutOfBoundsException
int[] arr = new int[]{
1,2,3,4,5};
for(int i = 0;i <= arr.length;i++){
//<=换为<
System.out.println(arr[i]);
}
System.out.println(arr[-2]);//下标从0开始并没有-2
System.out.println("hello");
2.空指针异常：
NullPointerException
"情况①"
int[] arr1 = new int[]{
1,2,3};
arr1 = null;
System.out.println(arr1[0]);
"情况②"
String[] arr3 = new String[]{
"AA","BB","CC"};
arr3[0] = null;
System.out.println(arr3[0].toString());
提示: 一旦程序出现异常，未处理时，就终止执行。
x.0 一些小知识点 :
x.1 随机数:
公式:
公式 ：[a,b] ： (int)(Math.random() * (b - a + 1 )) + a
//比如说你想获得一个[1,10]的随机数
//按照公式,这样运算:Math.random()*(10-1+1)+a
//但仅仅是这样是不行的,我们需要获得一个整数类型的随机数
因此我们需要一个强转: (int)(Math.random() * (10-1+1)) + a
x.2 数组如何求大小值
公式:
int max = 数组[0] //设置一个空的最大值的数组
int min = 数组[0] //设置一个空的最小值的数组
for(int i=0;i<数组的长度;i++){
if(max<数组[]){
max=数组[];//最大值
}if(min >数组[]){
min=数组[];//最小值
}
}//for循环外面输出
System.out.prinlnt("最大值为"+max);
System.out.prinlnt("最小值为"+min);
代码:
public static void main(String[] args) {
int [] num = new int [] {
8,4,2,1,23,344};// 静态
int max = num[0]; //设置一个空的数组
int min = num[0] ; //设置一个空的数组
for(int i = 0; i<num.length;i++) {
if(max<num[i]) {
max=num[i];//最大值
}if(min > num[i]) {
min = num[i];//最小值
}
}//for循环外面输出
System.out.prinlnt("最大值为"+max);
System.out.prinlnt("最小值为"+min);
}
x.2 插入缺失的数组
代码:
public static void main(String[] args) {
int [] score = new int [6];
score[0]=99;
score[1]=85;
score[2]=82;
score[3]=63;
score[4]=60;
//数组输出
for(int i=0;i<score.length;i++) {
System.out.print(score[i]+" ");
}
//利用下标把漏掉的第二位(1)学生的成绩加进去
for (int i = score.length-1;i>=0;i--) {
score[i] = score[i-1];
if (i==1) {
score [i] = 88;
break;
}
}
for(int i=0;i<score.length;i++) {
System.out.print(score[i]+" ");
}
}
x.3 数组的降序与升序
公式:
Arrays.sort(循环数组的名字);
for(int i=0; i<数组的长度;i++){
//升序
System.out.println(数组[]+"");
}
Arrays.sort(数组的名字);
for(int i =数组的长度-1;i>=0;i--){
//降序
System.out.println(数组[]+"");
}
案例:
原字符序列: a c u b e p f z
升序排序后: a b c e f p u z
逆序输出为: z u p f e c b a
代码:
Scanner scanner = new Scanner(System.in);
char [] eng = new char [] {
'a','c','u','b','e','p','f','z'};
System.out.println("原字符序列:");
for(int i=0;i<eng.length;i++) {
//原字符
System.out.print(eng[i]+"");
}System.out.println();//回车
Arrays.sort(eng);
System.out.println("升序排列:");
for(int i =0;i<eng.length;i++) {
//升序
System.out.print(eng[i]+ "");
}System.out.println();//回车
Arrays.sort(eng);
System.out.println("降序排列:");
for (int i = eng.length-1;i>=0;i--) {
//降序
System.out.print(eng[i]+"");
}
}
x.4 正直角倒直角的例题
正直角:
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//这是 循环1
System.out.println("请输入直角三角形的行数");
int hang = scanner.nextInt();
for (int i = 1; i <=hang; i++) {
//声明变量，行 i
//循环2
for (int j = 1; j <= i; j++) {
//声明变量，列 j
System.out.print("*");//打印输出
}
System.out.println(); //换行作用
}
}
倒直角:
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入直角三角形的行数");
int hang = scanner.nextInt();
//循环1
for(int i=1 ; i <= hang; i ++) {
//行数
//循环2
for(int j= hang; j >= i;j--) {
//输出*
System.out.print("*");//打印输出
}System.out.println();//换行作用
}
}