标签：作业
IT十八掌大数据第三天
1. 1函数的含义
函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法。
1.2函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句；
return 返回值；
}
返回值的数据类型是由函数运行后的结果决定的
形参：是一个变量，用于存储函数调用时传递给函数的实际参数
实际参数：传递给形式参数的具体数值
return：用于结束函数
返回值 ： 该函数运算后的结果，该结果会返回给调用者。
**
对于函数没有具体返回值的情况，返回值类型使用关键字void表示， 如果该函数中的return语句如果在最后一行可以省略不写。
注意：
函数中只能调用函数，不可以再函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交给调用者处理。
函数在应用时需要明确
定义的函数最后的结果是什么
明确定义该功能的过程中，是否需要未知内容参与运算
定义一个函数实现两个整数相加
class FunctionTest {
public static void main(String [] args){
System.out.println(Sum(2,3));
}
public static int Sum(int a , int b){
return a+b;
}
}
此函数可以实现对Sum的调用
函数的重载
在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可
特点：
与返回值无关，只看参数列表
class FunctionTest {
public static void main(String [] args){
System.out.println(Sum(2,3));
System.out.println(Sum(2,3,4));
}
public static int Sum(int a , int b){ //定义两个参数
return a+b;
}
public static int Sum(int a, int b, int c){ //定义三个参数可以
return a+b+c;
}
}
数组 Array
----------------
概念 ： 同一种类型的数据的集合。（数组就是一个容器）
好处： 可以自动给数组中的 元素 从0开始编号，方便操作这些元素。
格式：
格式1
元素类型[] 数组名 = new 元素类型 [元素个数或者数组长度]
例：
int [] arr =new int [6] //表示的是 该元素为 int型， 元素的长度为6 （结果为有7个元素，因为从0开始）
格式2
元素类型[] 数组名 = new [] { 元素，元素……};
例：
int [] arr =new int []{1，2，3}；
int [] arr= {3,5,7,9};
class ArrayDemo {
public static void main(String[] args) {
int[] arr=new int [6];
int[] arr2=new int[]{1,2,3};
int [] arr3= {3,5,7,9};
System.out.println(arr.length); // 打印数组长度 arr.length是默认的属性
System.out.println(arr2.length);
System.out.println(arr3.length);
}
}
数组在内存中的形式
数组在内存中是连续的
下表从0开始 //访问数组的某个数字时 可以使用arr(下标) 来实现 如[1,2,3,4] arr[0] 即表示该数组的第一个数1.
//数组的长度为 arr[length] 数组中的最大值为arr[length-1]
数组中无arr[length]这个数字，如果访问的话会报错 //ArraIndexOutOfBoundException :数组越界异常
int[] arr=new int [6]; 共三步操作 1-定义一个int型数组2-在内存中开辟一个空间3-将两者关联起来
堆：heap
---------------
object heap
//数组处在堆区
// new建立的实例都处在堆内存中
//因为所有的对象都处在堆区中，所以如果堆设置的过小会放不下对象出现堆栈溢出（一般是栈溢出）
heap overflow 堆溢出
stack overflow 栈溢出
栈 stack
----------------
方法栈
方法栈至少对应一个线程（主线程main函数所在的线程）
栈中每一个方法叫做 一个方法帧 method frame
push stack : 压栈
pop stack :弹栈
java没有指针是指没有显式的指针操作。引用就是指针（变量的名称）
NullPointerException 是空指针异常（RuntimeException）//arr []=null; 属于运行时异常
练习；取数组中的最大值，并封装
class ArrayMax{ //类的名称一定要和文件编译后的名称一样，否则运行会报错。
public static void main(String[] args) {
System.out.println(getMax(new int []{2,5,21,5,7}));
}
public static int getMax (int [] arr){
//从健壮性考虑，应该考虑到arr==null和arr.length 长度为0。
if (arr == null|| arr.length==0){ //短路与先判断大的再判断小的
System.out.println("数组不存在");
return -1; //当为这两种情况时，提示错误，并返回一个-1的结果。
}
int temp =Integer.MIN_VALUE; //Integer.MIN_VALUE是整数型数字的最小值
for (int i=0; i < arr.length ; i++ ){
if (temp < arr[i]){
temp = arr[i] ;
}
}
return temp;
}
}
如果求数组中的最小值，之需要将Temp =Integer.MIN_MALUE换成---> Temp =Integer.MAX.MALUE, temp<arr(i)-->temp>arr(i)即可
对数组进行排序 （从小到大） 思想 迭代数组元素--查找最小值和最小值对应的角标--置换位置--返回数组--封装--调用
class ArraySelectSort{
public static void main(String[] args)
{
outArr(sort(new int []{2,1,6,4,9})); //调用数组
}
public static int[] sort(int[] arr){
if (arr == null|| arr.length == 0){ //排除为null和长度为0的情况
System.out.println("数组不存在");
}
//判断该数字往后的数字中的最小值
for (int i =0;i < arr.length ;i++ ){ //遍历数组中的所有数字
int aa=Integer.MAX_VALUE;
int index = 0 ; //定义角标的初始变量为0
for (int j= i + 1;j < arr.length;j++ ) {//遍历arr[i]数字后面的所有数字，求其中的最小值
if ( aa > arr [j]){
aa = arr [j]; //将较小的值赋值给Temp
index = j ; //获取较小值的角标
// System.out.println(aa) ;
}
}
//选出后面数字中的较小值时，如果比自身小，则调换位置
if (arr[i]>aa){
arr[index] = arr[i]; // 将arr[i]这个较大值赋值为arr[index],这里arr[index]充当一个中间量，此时arr[]为空
arr[i] =aa ; //然后将aa 赋值给已经是空值的arr[i] 实现两个数字的互换位置。
}
}
return arr; //返回arr 数组
}
public static void outArr (int [] arr){ //封装outArr 方法
for (int i = 0; i < arr.length ;i++ ){
System.out.print(arr[i]+" "); //打印 arr[i]这个数组
}
}
}
问题：
************************************************************************
为什么当 int aa=Integer.MAX_VALUE; 处在：
int index = 0 ;
处在：
for (int i =0;i < arr.length ;i++ ){ //遍历数组中的所有数字
上面时为什么是打印的结果是错误的。
*************************************************************************
冒泡排序
*****冒泡排序的话，该值会自动的跟下一位进行比较*****
所以 5，4，3，2，1 如果进行冒泡排序的话 只需要取到 arr[3]即可 ，arr[3]会自动的跟arr[4]进行比较。所以不需要取到arr[4]
举例：
使用大数下沉的方式 进行冒泡排序
class BubbleSort{
public static void main(String[] args) {
outArr(bubble(new int[]{ 3,6,8,2,1,5,9}));
}
public static int[] bubble (int [] arr) { //定义函数数组
//大数下沉的方式
for (int i = 0;i < arr.length - 1 ;i++ ){ //外层循环次数 为arr.length-1
for (int j = 0;j < arr.length - 1 - i ;j++ ){ //n内层循环次数为 arr.length-1-i
int temp= 0; //定义一个临时变量 用来接收数据
//数据的对调（因为是大数下沉的方式）
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr; //返回数组
}
public static void outArr(int [] arr){ //封装方法
for (int i=0 ;i<arr.length ;i++ ){
System.out.print(arr[i]+" ");
}
}
}
***************
for (int j = 0;j < arr.length - 2 - i ;j++ ){ //n内层循环次数为 arr.length-1-i
为什么-2 和 -1 结果相同
***************
折半查找
如果查找结果为10
1，3 ，5 ，7，8，10，11 进行折半的话 第一次折半的话为7，第二次进行折半的话为10（第二次从8开始）
折半查找 数据要有序
查找1-9数字中 6首次出现的位置。
class HalfFind{
public static void main(String[] args) {
System.out.println(find(new int []{1,2,3,4,5,6,7,8,9},6));
}
public static int find(int [] arr,int n){ //定义函数 *定义 一个int 型的数字
int a = 0 ;int b = arr.length ; int m = 0 ; //定义三个变量 【a b】角标 m （为中间量的值）
int mindex = 0; //中间量角标
//定义循环
while (a <= b){ //循环条件
mindex = (a + b) /2 ; //计算中间量的角标
m = arr[mindex]; //计算m的值
//判断m和
if ( m == n ){ //如果m 和查询值相等 注意是 “==”
return mindex;
}
//查询范围落在左边
else if(m > n){
b= mindex - 1;
}
//查询范围落在右边
else {
a = mindex + 1;
}
}
return - 1 ; //返回值
}
}
数组中的数组
---------------------
二维数组
格式1：
int [][] arr =new int [3][4]; //表示定义了一个名为arr的二维数组，该数组中有3个二维数组，每组4个元素
每一数组的名称分别为 arr[0],arr[1];arr[2];
如果给第一个数组的角标为1的 元素赋值的话写法为arr[0][1]= x;
格式2；
int[][] arr= new int[2][];
二维数组中有2个一维数组
每个一维数组都是默认初始化值null
可以对这个两个一维数组分别进行初始化
arr[0] = new int[3]; //第一个数组 有3个元素。
arr[1] = new int[1]; // 第二个数组 有1个元素。
打印倒置的二维数组
class MultiArray {
public static void main(String[] args) {
int [][] arr= new int[4][3]; //定义二维数组arr[4][3]
int a= 12; //定义一个数字从12开始
for (int i = 0;i<arr.length ;i++ ){ //定义外层函数 （有几个二维数组）
for (int j = 0;j<3 ;j++ ){ //定义内层函数（每个数组中有多少个元素）
arr [i][j] = a; //对第i行第j个元素赋值
a--; //自减1
}
}
outArr(arr); //调用
}
public static void outArr(int [][] arr){ //定义outArr 函数
for (int i = 0;i <arr.length ;i++ ){
for (int j=0 ;j< 3 ;j++ ){
System.out.print(arr[i][j]+"\t"); //打印arr[i][j]的数值
}
System.out.println();
}
}
}
/*
1 2 3 [0][0] [0][1] [0][2]
4 5 6 [1][0] [1][1] [1][2]
7 8 9 [2][0] [2][1] [2][2]
10 11 12 [3][0] [3][1] [3][2]
12 11 10 [3][2] [3][1] [3][0] [i][j] arr.length-1-i
9 8 7 [2][2] [2][1] [2][0] a--
6 5 4 [1][2] [1][1] [1][0]
3 2 1 [0][2] [0][1] [0][0]
*/标签：作业
原文地址：http://670597669.blog.51cto.com/10018785/1771307
