【三】狂神Java笔记-基础语法

JAVA流程控制

Scanner对象

导入包：java.util.Scanner
基本用法：Scanner s = new Scanner(Syatem.in);
//右边new创建一个对象，通过Syatem.in接受用户的输入并将它封装成Scanner对象

接受用户输入：

输入空格就会停止

next（）和nextLine（）的区别

也可以这样写，不需要加if的判断：

接收到一个浮点数据：f = scanner.nextFloat()；
接收到一个整型数据：i = scanenr.nextInt()；

String s = scanner.nextLine();
s.equals("hwllo");  //判断接收的字符与hello是否一样，少用==来判断字符串

if(布尔表达式){
	表达式;
}else if{
	表达式;
}else if{
	表达式;
}else{
	表达式;
}

if也可以嵌套，就是if里面可以有if

//JDK7开始可以比较字符串: 'A'
switch(expression){
	case value://语句
	break;
	case value://语句
	break;
	default:
	//语句
}

hashCode :可以理解为每个数据都被赋予一个身份证,然后就用这个身份证去找你要的数据

循环结构

• while循环
• do…while循环——会至少执行一次
• for循环

do{
	//代码语句
}while(布尔表达式)；

for(初始化;条件表达式;迭代){
	//代码表达式
}

快捷 100.for

//输出换行
System.out.print("\n");
System.out.println();

增强for循环 循环数组和集合

int[] numbers = {10,20,30,40,50};
for(int x:numbers){
	System.out.println(x);
}
//===========等效效果=====================
for (int i = 0;i<5;i++){
	System.out.println(x);
}

break； //循环中强行跳出
continue；  //直接进入下一次循环，后面的内容不执行

Java的方法

1. 定义和调用
2. 方法的重载
3. 命令行传参
4. 可变参数
5. 递归

System.out.println();//System是类；out是输出对象；println()是方法

• 方法在main方法外自己创建；
• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用
• 原则：一个方法只完成一个功能

//写一个加法的方法
public static int add(int a,int b){
	return a+b;
}

方法包含一个方法头和一个方法体
修饰符：可选，告诉编译器如恶化调用该方法。定义了该方法的访问类型
返回值类型：没有返回值用void
方法名：实际名称
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。
方法体：包含的具体语句，定义该方法的功能。

修饰符 返回值 方法名（参数类型 参数名）{
	//方法体、
	return 返回值;
}

方法的调用
调用方法：对象名.方法名
Java支持两种调用方法，根据方法是否有返回值来选择
当方法返回以恶告知对方的时候，方法调用通常被当作一个值。
如果方法返回值时void，方法调用一定是一条语句。

值传递和引用传递

方法的重载

就是在一个类中，有相同的函数名称，但是 形参类型不同 的函数

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

规则：

方法名称必须相同
参数列表比哦徐不同（个数、类型、参数排列顺序不同等)
方法的返回类型可以相同也可以不同
仅仅返回值不同不足以成为方法的重载

方法名称相同时，编译器会自动去匹配

命令行传参

可变参数

• 在方法声明中，在指定参数类型后加一个省略号
• 一个方法中只能指定一个可变参数，必须是方法的最后一个参数。任何普通的参数必须在它之前声名。

 public void text(int x,int... i){  //可变参数必须放最后面
	//代码块
}

递归

A方法调用A方法

数组

数组描述的是 相同类型 的若干个数据，按照一定的先后次序排列组合而成。

数组的声名创建
首先必须声名数组的变量，才能在程序中使用数组。语法如下：

dataType[] arrayRefVar;  // 首选的方法，在类型后面加[]

dataTye arrayRefVar[];  //效果相同，但不是首选方法,在变量名后面加[]

Java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

打个比方就是：平时定义我们只能一个个定义，用到数组就是现在我们有了一个箱子，可以同时定义同类型的很多个数值。
没赋值就是默认值String为null，数值为0
获取数组的长度：arrays.length / nums.length

静态初始化：

int[] a = {1,2,3,4,5,6,7,8,9};  //静态初始化：创建 + 赋值
Man[] mans = {new Man(),new Man()};

int[] b = new int[10];  //动态初始化,包含默认初始化，没有定义则为默认值
b[0] = 10;

Arrays类

Array类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用。
以字符串的形式表示出来：Arrays.toString();
数组进行升序排序：Array.sort(a);
填充：Array.fill(a,2,4,0); //数组中2-4用0填充，左闭右开区间
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分法查找法操作。

优化

稀疏数组

当一个数组中大部分有相同的数值，可以用稀疏数组来保存该数据。

创建一个二维数组：

int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始数组
for (int[] ints : array1){
	for (intanInt : ints){
	System.out.print(anInt + "\t");
	}
	System.out.println();
}

转换为稀疏数组：

//获取有效值的个数
int sum = 0;
for (int i = 0;i < 11;i++){
	for(int j = 0;j < 11;j++){
	if (array1[i][j] != 0){   //将原始数组中不是0的数累计
		sum++;
		}
	}
}
System.out.println("有效值的个数："+sum);

//创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;

//遍历二维数组，将非零的值，存放在稀疏数组中
int count = 0;
for (int i = 0;i < array1.length;i++){
	for (int j = 0;j < array[i].length;j++){
		if (array1[i][j] != 0){
			count++;
			array2[count][0] = i;
			array2[count][1] = j;
			array2[count][2] = array1[i][j];
			}
		}
	}
	
//输出稀疏数组
System.out.println("稀疏数组");
for(int i = 0;i < array2.length;i++){
	System.out.println(array2[i][0]+"\t"
		+array2[i][1]+"\t"
		+array2[i][2]+"\t");
}

//还原稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for(int i = 1;i < array2.length;i++){
	array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
System.out.println("输出还原的数组：");
for (int[] ints : array1){
	for (intanInt : ints){
	System.out.print(anInt + "\t");
	}
	System.out.println();
}

//输出稀疏数组
11  11  2
1   2   1
2   3   2