方法
方法是语句的集合，它们在一起执行一个功能
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
设计方法时最好保持方法的原子性，即一个方法完成一个功能，这样利于后期的扩展
尽量保证main（）方法的简洁
方法的定义
修饰符 返回值类型 方法名（参数类型 参数名）{
//方法体（方法的功能）
return 返回值;
}
形式参数：用来定义作用的
实际参数：实际调用传递给他的参数
return除了返回结果同时也有终止方法的作用
package com.study.method;
public class MethodDemo1 {
public static void main(String[] args) {
int num= min(1,1);
System.out.println(num);
}
public static int min(int num1,int num2){
int result=0;
if(num1==num2){
System.out.println("num1=num2");
return 0;//终止方法
}
if(num1<num2){
result=num1;
}else {
result=num2;
}
return result;
}
}
//运行结果
num1=num2
0
Java是值传递
方法的重载
重载就是在一个类中，有相同的函数名称，但形参不同的函数
重载的要求：
方法名称必须相同
参数列表必须不同（个数不同或类型不同或参数排列顺序不同等）
方法返回的类型可以相同也可以不同
仅仅返回类型不同不足以成为方法的重载
实现的理论：方法名称相同时，编译器会根据调用方法的参数个数、参数类型、等去逐个匹配，以选择对应的方法，如果匹配失效，那么编译器报错
命令行传参
可变参数
在方法的声明中，在指定参数类型后加一个省略号（…）
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明
package com.study.method;
public class KeBian {
public static void main(String[] args) {
KeBian keBian=new KeBian();//实例化对象
keBian.number(1,2,4,5,3);
keBian.number(new int[]{1,23,4,5,6});//声明数组
}
//可变传参
public void number(int... i){
int j=0;
while (i.length>j){//可以取到i.length
System.out.print(i[j]+" ");
j++;
}
System.out.println();
}}
//运行结果
1 2 4 5 3
1 23 4 5 6
递归
自身调用自己 减少了程序的代码量 但是递归会占用大量的内存，尽量不要使用递归
递归结果包括两个部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法
package com.study.method;
public class DiGui {
public static void main(String[] args) {
System.out.println(number(5));
}
//递归求n！
public static int number(int n){
if(n==1){//边界条件
return 1;
}else {
return n*number(n-1);
}
}
}
//结果 120
Java是栈机制,main（）在底层
数组（相同类型数据的有序集合）
- 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们
- 数组描述的是相同类型的若干个数据按照一定的先后次序排列组合而成
Java使用new操作符来创建数组的语法：
dataType arrayName=new dataType[arraySize];//arraySize必须写
package com.study.arrary;
public class ArraryDemo1 {
public static void main(String[] args) {
int[] a;//声明数组
// int b[];//也可以这么写 但这是c\c++的风格
a=new int[5];//数组中可以存放5个数据
//数组赋值
for (int i=0;i<a.length;i++){
a[i]=i+1;
System.out.print(a[i]+" ");
}
}
}
//运行结果 1 2 3 4 5
内存分析
堆：存放new的对象和数据，可以把所有的线程共享，不会存放别的对象引用（基本类型的具体 数值）
栈：存放基本变量类型和引用对象的变量（引用在堆里面的具体地址）
方法区：可以被所有线程共享包括static和class变量
数组的静态与动态初始化
//静态初始化 创建+赋值
int[] a={1,2,3,4};
//动态初始化 包含默认初始化
int[] b=new int[5];
数组的四个基本特点
长度是确定，数组一旦被创建，大小就是不可以改变的
数组元素类型必须相同，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身就在堆中。
数组边界[0,length-1],越界就会报错
ArrayIndexOutBoundsException 数组下标越界异常
数组的使用
package com.study.arrary;
public class ArrayDemo3 {
public static void main(String[] args) {
int[] array={1,2,3,4,5};
//没有下标 一般用于输出，取不到数组的下标
/* for (int i:array) {
System.out.println(i);
}*/
int[] reverse=reverseArray(array);
for (int i:reverse) {
System.out.print(i+" "); //执行结果 5 4 3 2 1
}
}
//反转数组
public static int[] reverseArray(int[] a){
int[] result=new int[a.length];//result为反转数组,长度和被反转的数组长度相同
for (int i = 0,j=result.length-1; i <a.length ; i++,j--) {
result[j]=a[i];
}
return result;//返回类型为一个数组类型
}
}
多维数组（二维数组）
int[][] array=new int[4][2];
Arrays类
都是static修饰的静态方法，可以直接调用
package com.study.arrary;
import java.util.Arrays;
public class ArraysDemo1 {
public static void main(String[] args) {
//Arrays类
int[] a={1,23,11231,112,123};
System.out.println(a);//[I@1b6d3586
//输出数组
System.out.print(Arrays.toString(a));//[1, 23, 11231, 112, 123]
//数组排序 升序
Arrays.sort(a);
System.out.println(Arrays.toString(a));//[1, 23, 112, 123, 11231]
//数组填充 下标为[1，3)之间的数填充为0 包含1不包含3
Arrays.fill(a,1,3,0);
System.out.println(Arrays.toString(a));//[1, 0, 0, 123, 11231]
}
}
冒泡排序
package com.study.arrary;
import java.util.Arrays;
public class MaoPaoSort {
public static void main(String[] args) {
int[] array={8,11,13,14,5,17};
int[] sort=sort(array);
System.out.println(Arrays.toString(sort));//[5, 8, 11, 13, 14, 17]
}
//冒泡排序
// 比较一组序列中相邻元素的大小，如果后面的元素小于前面的元素则交换他们元素位置
//每一趟比较都会确定一个最大或最小的值
public static int[] sort(int[] array){// [11,8,13,14,17,5] 内层8 11 13 14 5 17
int temp=0;
for (int i = 0; i <array.length-1 ; i++) {
boolean flag=false;//减少没有意义的比较，
for (int j =0; j <array.length-1-i ; j++) {//每次确定了一个最终位置 所以 array.length-1-i
if (array[j]>array[j+1]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
flag=true;
}
}
//如果内层循环中没有进行比较交换位置，则flag依然为false，即表示有序 那么跳出循环
if(flag==false){
break;
}
}
return array;//返回排序好的数组
}
}
稀疏数组
当数组中存在大量的0或相同元素，则采用稀疏数组来保存该数组
稀疏数组的处理方法：
记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
package com.study.arrary;
public class XiShuArray {
//稀疏矩阵
public static void main(String[] args) {
//1.创建一个二维数组
int[][] arr=new int[11][11];
arr[1][2]=1;
arr[2][3]=2;
for (int[] ints:arr) {
for (int ouInt:ints) {
System.out.print(ouInt+"\t");//\t 空格
}
System.out.println();
}
//转换成稀疏数组、
//获取有效值个数
int sum=0;
for (int i = 0; i <arr.length ; i++) {
for (int j = 0; j <arr[i].length ; j++) {
if(arr[i][j]!=0){
sum++;
}
}
}
//创建一个稀疏数组 行 列 有效值
int[][] xiArr=new int[sum+1][3];
//原数组规模
xiArr[0][0]=11;
xiArr[0][1]=11;
xiArr[0][2]=sum;
//遍历二维数组 将非0
int num=0;
for (int i = 0; i <arr.length ; i++) {
for (int j = 0; j <arr[i].length ; j++) {
if(arr[i][j]!=0){
num++;
xiArr[num][0]=i;//存放横坐标
xiArr[num][1]=j;//存放纵坐标
xiArr[num][2]=arr[i][j];//存放数据
}
}
}
//输出稀疏数组
for (int[] xiArray:xiArr) {
for (int xiarr:xiArray) {
System.out.print(xiarr+"\t");
}
System.out.println();
/* 11 11 2
1 2 1
2 3 2 */
}
//还原稀疏数组
//1.读取稀疏数组
int[][] huanArr=new int[xiArr[0][0]][xiArr[0][1]];
//2.元素赋值
for (int i = 1; i <xiArr.length ; i++) {//依次遍历第i组数据，所以是xiArr.length
huanArr[xiArr[i][0]][xiArr[i][1]]=xiArr[i][2];
}// huanArr[行][列]=元素值
for (int[] huArr:huanArr) {
for (int huanarr:huArr) {
System.out.print(huanarr+"\t");
}
System.out.println();
}
}
}
//输出结果
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
11 11 2
1 2 1
2 3 2
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
