尚学堂 JAVA DAY11 概念总结

1.冒泡排序算法 《升序排列》

思路1：
数组长度为n,那么要对数组进行n-1次遍历;

step 1---从数组的第一个数开始，两两比较，如果第一个数 > 第二个数，将二者进行交换；
之后拿第二个数与第三个数进行比较，若 第二个数 > 第三个数，将二者进行交换；
依此类推，直到 第n-2个数 和 第n-1个数比较完。

此时，该数组中最大的数将排在数组的最后一个位置。

step 2---重复step1,直到遍历完整个数组。

public class NewArray {
public static void main(String[] args) {
//声明并定义一个无序的数组
int[] scores = new int[15];
for(int i = 0; i < scores.length; i++) {
scores[i] = (int)(Math.random() * 101);
}

//排序前 打印数组
System.out.println("\n==============排序前====================");
for(int score : scores) {
System.out.print(score + " ");
}

//排序进行时 升序排列
int temp = 0;
int counter = 0;
for(int j = 0; j < scores.length - 1; j++) {
for(int i = 0; i < scores.length - 1; i++) {
if(scores[i] > scores[i+1]) {
temp = scores[i];
scores[i] = scores[i+1];
scores[i+1] = temp;
}
}
counter++;
}

//排序后 打印数组
System.out.println("\n==============排序后====================");
for(int score : scores) {
System.out.print(score + " ");
}

System.out.println("\n======================================");
System.out.println("共进行了" + counter + "次比较");
}
}

思路2：
数组长度为n,那么要对数组进行n-1次遍历；

step 1---从数组的第一个数开始，两两比较，交换，直到数组元素的（索引 == 数组长度 - 1 - 第i次）遍历数组结束。

step 2---重复step1，直到数组遍历结束。

public class NewArray {
public static void main(String[] args) {
//声明并定义一个无序的数组
int[] scores = new int[15];
for(int i = 0; i < scores.length; i++) {
scores[i] = (int)(Math.random() * 101);
}

//排序前 打印数组
System.out.println("\n==============排序前====================");
for(int score : scores) {
System.out.print(score + " ");
}

//排序进行时 升序排列

int temp = 0;
int counter = 0;
for(int j = 0; j < scores.length - 1; j++) {
for(int i = 0; i < scores.length - 1 - j; i++) {
if(scores[i] > scores[i+1]) {
temp = scores[i];
scores[i] = scores[i+1];
scores[i+1] = temp;
}
}
counter++;
}

//排序后 打印数组
System.out.println("\n==============排序后====================");
for(int score : scores) {
System.out.print(score + " ");
}

System.out.println("\n======================================");
System.out.println("共进行了" + counter + "次比较");
}
}

View Code
思路3：
数组长度为n,那么要对数组进行n-1次遍历；

step 1---从数组的第一个数开始，两两比较，交换，直到数组元素的（索引 == 数组长度 - 1 - 第i次）遍历数组结束。

step 2---重复step1，直到数组中没有发生元素的交换为止。

public class NewArray {
public static void main(String[] args) {
//声明并定义一个无序的数组
int[] scores = new int[15];
for(int i = 0; i < scores.length; i++) {
scores[i] = (int)(Math.random() * 101);
}

//排序前 打印数组
System.out.println("\n==============排序前====================");
for(int score : scores) {
System.out.print(score + " ");
}

//排序进行时 升序排列
int temp = 0;
int counter = 0;
boolean hasChanged = false;
for(int j = 0; j < scores.length - 1; j++) {
//每一次遍历开始都认为数列无序，数据未发生过交换
hasChanged = false;
for(int i = 0; i < scores.length - 1 - j; i++) {
if(scores[i] > scores[i+1]) {
//只要发生了交换，标志位置为true,表示还需进行下一次比较
hasChanged = true;
temp = scores[i];
scores[i] = scores[i+1];
scores[i+1] = temp;
}
}
counter++;
if(!hasChanged){
break;
}
}

//排序后 打印数组
System.out.println("\n==============排序后====================");
for(int score : scores) {
System.out.print(score + " ");
}

System.out.println("\n======================================");
System.out.println("共进行了" + counter + "次比较");
}
}

2.方法的重载
一个类中可以存在 [方法名相同、功能相同、参数不同（形参类型、形参数量）的 多个方法]。 这叫方法的重载。
如：
Arrays.sort(int[] arr);
Arrays.sort(float[] arr);
Arrays.sort(byte[] arr);
Arrays.sort(double[] arr);
...
顺便学习了Arrays类的使用，以及API文档的查阅
import java.util.Arrays;

public class TestArraysClass {
public static void main(String[] args) {
//声明并定义一个无序的数组
int[] scores = new int[15];
for(int i = 0; i < scores.length; i++) {
scores[i] = (int)(Math.random() * 101);
}

//输出数组
System.out.println(Arrays.toString(scores));

//将数组排序
Arrays.sort(scores);

//输出数组
System.out.println(Arrays.toString(scores));

//查询某个元素
System.out.println(Arrays.binarySearch(scores,4));

//复制一个数组
int[] newScores = Arrays.copyOf(scores,0);

//打印新数组
System.out.println(Arrays.toString(newScores));

}
}

3.可变参数
1)格式：
方法头(类型 ... 参数变量名) {
方法实体
}
2)特点：(要背)
a.只能作为方法的形参；
b.JDK1.5之后提供；
c.可接受八种基本数据类型和数组类型数据；
d.可以接受0个、1个和多个实参；
e.可变参数只能是最后一个参数；
f.定义了可变参数的方法后，不可定义数组为形参的方法；
g.重载的方法包括可变参数 和 确定数量参数的方法时，会优先调用确定数量参数的方法，而
忽略可变参数的方法。

4.main方法如何接收实参？
格式：
java 类名 参数1 参数2 参数3...

5.二维数组
1) 声明格式：
类型[][] 数组名; 或
类型 数组名[][];
2) 分配空间：
new 类型[长度][长度]; ---将二维数组的第一维和第二维都分配空间，使这都有默认值。
或
new 类型[长度][];---仅给二维数组的第一维分配空间，其默认值为null；
3) 动态初始化
数组名[][] = ...;
4) 静态初始化
是将上述三步合而为一。
类型[][] 数组名 = new 类型[][]{{},{},{}...};
或
类型[][] 数组名 = {{},{},{}...};

public class TwoDArray{

public static void main(String[] args) {

//int[][] scores = new int[][]{{80,90,78},{90,80},{0,70}};
int[][] scores = {{80,90,78},{90,80},{0,70}};

/*scores[0] = new int[4];
scores[1] = new int[3];
scores[2] = new int[2];

scores[0][0] = 80;
scores[0][1] = 79;
scores[0][2] = 78;

scores[1][0] = 90;
scores[1][1] = 80;

scores[2][1] = 70;    */

for(int i = 0; i < scores.length; i++) {
for(int j = 0; j < scores[i].length; j++) {
System.out.print(scores[i][j] + " ");
}
System.out.println();
}

}

}