2021 JAVA学习记录笔记(更新学习中)

·

第一章：“HelloWorld"

1. 梦的开始:
   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中的注释类型:

1. 单行注释:

//单行注释:

2. 多行注释

"/*
内容
*/

3. 文档注释(Java特有)

/**
@author 指定Java程序的作者
@version 指定源文件的版本
*/
注释内容可以被JDK提供的工具javadoc所解析,生成一套以网页文件形式体现该程序的文档说明。
使用方法:javadoc -d myhello -author -version HelloJava.java(文件名)
就会出现这个文件。

3.注释的好处：

1. 对所写的程序进行解释说明,方便自己,方便别人。
2. 调试所写的代码
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 = "444656840@qq.com";
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();//换行作用
			
	}	
 
		}