java的基础学习day06
-2019年7月5日
复习
数组（容器）—元素类型支持基本数据类型与引用数据类型；–
定义格式–java的内存—（二分查找（前提：有序；缺点：1必须有序、
2、查找的数在前面））排序（冒泡排序、选择排序）
–**-––-–--------------------
数组的应用
时间复杂度：核心代码执行的次数
二分查找（n(数组长度)/2`x=1 x = log2n O(log2n)）
冒泡、选择（（n数组长度）*（n-1）= n`2-n）
Arrays.sort()----O(n*logn)
空间复杂度
在代码执行过程中额外开辟的空间，是对一个算法在运行过程中临时
占用储存空间大小的量度；
二分查找、冒泡、选择---- O（1）
-–------–--------–**---------*
关于扩容–数组定义完成之后长度永远不变；
所谓扩容事实上就是数组的复制，将旧数组内容复制进入更长的
新数组之中；
数组的复制格式：
(原数组，起始下标，新数组，起始下标，原数组长度)
System.arraycopy(a,0,a1,0,a.length);
数组扩容演示：
public class QWQ{public static void mian(String[]args){
//创建一个数组；
int[] a = {5,6,9,8,7;}
//创建一个新数组,并复制
int [] a1 = new int[a.length*2];
//(原数组，起始下标，新数组，起始下标，原数组长度)
System.arraycopy(a,0,a1,0,a.length);
System.out.println(Arrays.toString(a));
数组值的覆盖：
a = Arrays.copyOf(a,arr.length*2);扩容两倍
数组的缩容，同理；
a = Arrays.copyOf(a,arr.length-3);
–--------------–-------–-----**–
二维数组
定义：数组元素是一维数组的数组；从字面意思可以理解为储存一维数组的
容器，深层理解为储存一维数组地址的容器；
格式：
1、数据类型[][]数组名 = new 数据类型[二维数组长度（一维数组的个数）][每个一维数组的长度]；
class QWQ{public static void main(String[] args){
//定义数组
int a = new int[2] [3];
}}
格式2、数据类型[][]数组名 = new 数组类型[数组个数][]
int[][]a =new int[4][];
a[0] = new int[]{1,2};
a[1]=new int [5];
a[2]= new int [3];
格式3、数据类型[][]数组名={{},{},{},{},{}};
int [] []a = {{1,2},{5,6},{7,9},{88,48}};
如果[]在数据类型的后面，就会跟随这个数据类型取修饰，
例如 int i[],[]a 则等于 int i[];int[][]a;
–--**–-------–----–––---**-–*
二维数组的基本应用
遍历二维数组
class QWQ{public static void main(String[] args){
定义二维数组
int [] [] a = {{1,2,3},{4,6},{7,8,9}};
for(int i = 0;i<a.length;i++){控制一维数组
for(int j =0; j<a[i].length){
System.out.print(a[i][j]);
} System.out.println();}
}}
增强for循环遍历
for(int[] i :a){所有一维数组
遍历每个一维数组元素
for(int j:i){System.out.println(j)}
System.out.println(); }
—**–------**–-------------**----
java的方法
特性 提高代码的复用性；
对重复且有效的代码进行抽取，这种抽取的形式是方法
方法的格式
修饰符 方法返回值类型 方法名（参数类型 参数名...）{
方法体；
return 返回值；
}
修饰符：public static
方法的返回值类型：要提前给定返回值类型，返回值是什么
数据类型，这块就是什么类型。 如果没有返回值类型，这块的类型
就是void；
方法名：就是标识符
参数列表：参数类型以及参数个数和阐述顺序；
方法体：抽取的代码；
ruturn：返回结果值；
java中，方法不允许嵌套；
方法的调用
单独调用 方法名（参数值）
注意：1、方法被调用才能执行
2、方法调用时必须在main方法中进行
3、返回值类型和参数列表必须提前确定
4、没有返回值的方法只能单独调用
5、考虑参数所有可能取值范围
6、方法的抽取形式不固定，根据个人经验
演示
public static void printXing(int m,int n){
for(int a =0;a<m;a++){
for(int i =0 ;i<n;i++){
System.out.print("*");}
System.out.println();
} }}
System.out.println(sum(5, 6));
//输出
//赋值调用
int result = sum(5, 6);
public static void XX(int 参数){
代码块
}
public static 数据类型 XX(int 参数){
return 代码块；
}
return的功能：1、用于把方法结果值进行返回。
2、用于结束方法。
//////////////////////////////////////////////////////////
判断一个整数是否是奇数
两个明确 --返回值类型（boolean）参数列表（int n）
public static boolean jiShu(int n){
//先考虑不正常范围
if(n<0){System.out.println("输入有误");
//结束方法
return false;}
//正常范围---判断是否能被2整除
if(n%2!=0){return true; }
//其他数据的范围
return false；
}
判断一个整数是否是质数
public static boolean zhiShu(int i){
//考虑不正常范围
if(m<2){return false;}
//考虑正常范围，操作循环
for(int i=2;i<m/2;i++ ){
//判断是够能被整除
if(m%i == 0){return false;}
}
return true;
}
-----------–------—------------
方法的重载
在一个类中，出现了方法名一致，参数列表不一致的方法
方法签名：方法名和参数列表共同作用
根据方法签名来进行区分方
调用重载方法时，有精确匹配的方法，先精确匹配；
如果重载方法没有提供精确匹配，则进行相对精确匹配。
如果提供了多个相对精确的重载方法，且没有精确匹配方法，
则无法调用方法；
//求和方法
方法签名为 sum(int ,int )
public static int sum(int i,int j){
return i+j;
}
方法签名为 (int , double )
public static double sum(int i , double j){
return i+j;
}
方法签名为 (double ,double )
public static double sum(double i,double j){
return i+j;
}
要点：所有的方法执行在栈中
class QWQ{public static void main(String[] args){
int i = 1;
//实参—实际赋予参数的值
m(i);
System.out.println(i);
}
//形参–用于接收的参数
public static void m(int i){
i++
System.out.println(i);
}
}}
方法的传值：
如果传入的实参是基本类型，就是值的拷贝。
如果参数是引用数据类型，就是地址值的拷贝；
方法中拿到拷贝过来的地址值，找到堆内存改变了元素
就会对原堆空间进行影响；如果没有找到原堆内存，就不会
有任何影响；
则main方法内 b(a[0])的值为 10；
public static void b(int [] a){
a[0]=10;
}
如果方法中拿到拷贝过来的地址值，如果找到的不是原堆空间
做任何操作都不会影响原堆空间；
public static void mn(int[] a){
a = new int [4];
arr[0]=10;
}
------------------------------*-
方法的递归：
方法执行过程中调用本方法
假如一个方法 sum 是求递进之和；
sum（3）= 1+2+3
3+sum(2)
2+sum(1)=1
public static int sum(int n ){
//结束标志
if（n == 1）return 1;
return n+sum(n-1);
}
递归求阶乘
public static int sum(int n ){
//结束标志
if（n == 1）return 1;
return n*sum(n-1);
}
如果数值稍大可能会出现栈内存溢出错误；