java学习笔记4 （SE篇）
1，什么是方法？
列子：
2，方法的定义
语法：
public static void method(){
//public(修饰符) static(修饰符) void(返回值类型) method(方法名) (参数类型 参数名1，参数类型 参数名1) {
//方法体
//}
}
3，方法的调用
4，可变参数
jdk1.5开始，java支持传递同类型的可变参数给一个方法，在方法生明中，在指定参数类型后加一个省略号（...）
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，普通参数必须在她之前声明。
语法
public static void printMax(int... numbers){
方法体
}
5,递归
递归就是自己反复调用自己
列子：
public static void main(String[] args){
System.out.println(f(5));
}
public static int f(int num){
if(num == 1){
return 1;
}else{
return num*f(num-1);
}
}
6，方法的重载
方法的重载要求方法名必须相同，但是方法的参数必须不同，返回类型也可以不同，但仅仅返回类型不同不足以参数重载
二，数组
1，定义数组
//1，定义了一个长度为5的动态数组
int[] array = new int[5];
//2，给数组赋值
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;
//3，数组的下标从[0]开始,而给数组取值赋值都是按下标的值开始
//4，遍历数组
//5，array.length;获取数组的长度
for(int = 0; i = array.length; i++){
System.out.println(array[i]);
}
//定义静态数组
int[] array1 ={1,2,3,4,5}
2，数组的特点
数组是”相同类型“数据的“有序”集合，数组内每一个数据称为”元素“
数组的三个基本特点：
1、长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2、其元素必须是相同类型，不允许出现混合类型。
3、数组类型可以是任何数据类型，包括基本数据类型和引用类型。
列子：
//数组的反转
public class Test1 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int[] reverse = reverse(arr);
for (int i = 0; i < reverse.length ; i++) {
System.out.print(reverse[i]);
}
//数组的反转
}
public static int[] reverse (int[] array){
int[] reve = new int[array.length];
for (int i = 0 ,j = array.length-1; i <array.length ; i++ ,j--) {
reve[j] = array[i];
}
return reve;
}
}
3，数组越界异常
数组越界异常是访问数组超过数组的大小导致
三，二维数组
1，二维数组的定义
//动态二维数组
int[][] array = new int[4][4];
//静态二维数组
int[][] array1 = {{1,2},{3,4}}
//遍历二维数组
public static void main(String[] args) {
int[][] arr = {{1,2},{2,4},{5,6}};
for (int i = 0; i <arr.length ; i++) {
for (int j = 0; j <arr[i].length ; j++) {
System.out.println(arr[i][j]);
}
}
}
四，Arrays工具类
五，基本算法练习
1，冒泡排序
//冒泡排序
//1,比较数组中两个相邻的元素，如果第一个比第二个大，我们就交换它们两的位置
//2,每一次比较都会产生一个最大或者最小的数子
//3,下一轮则可以少一次排序
//4,依次循环直至结束
import java.util.Arrays;
public class Test4 {
public static void main(String[] args) {
int [] array = {1,2,5,3,6,5,7,9,3};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array){
int num = 0;
for (int i = 0; i < array.length-1 ; i++) {
for (int j = 0; j < array.length-1-i ; j++) {
if (array[j+1] < array[j]){ //2,1
num = array[j+1]; //num=2
array[j+1] = array[j]; //j+1 = 1
array[j] = num; //j = 2
}
}
}
}
}
2,稀疏数组
package com.kuang.array;
public class Demo09 {
public static void main(String[] args) {
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始数组
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
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){
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 < array1[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