1.定义一个函数,函数功能是动态提取int[]中元素的最大值。

2.定义一个函数,从数组中查询指定的元素首次出现的位置。

3.定义函数,完成冒泡排序,大数下沉。

4.折半查找。

5.阐述

6.定义一个函数,实现矩阵的转置.arr[i][j] == arr[j][i];//前提条件是正方的。

7.遍历三维组数,横向输出三维数组的每一个层。

8.定义一个类:Dog 有名称 color age cry();

9.阐述出来堆区,栈区,何时出现溢出,如何解决。

10.oop

---------------------------------------------------------------------

//1.定义一个函数,函数功能是动态提取int[]中元素的最大值。

class ArrayMaxDemo {

public static void main(String[] x) {

//System.out.println(Integer.MIN_VALUE);  //最小整数值 Integer.MIN_VALUE;

//System.out.println(getMax(new int[0])); //arr.length == 0,打出数组不存在和 -1


int[] arr = new int[] { 2, 8, 1, 3, 7 };

System.out.println("Max is : " + getMax(arr));

}


public static int getMax(int[] arr) {

if (arr == null || arr.length == 0) {

System.out.println("数组不存在!");

return -1;

}

int temp = Integer.MIN_VALUE;

for (int i = 0; i < arr.length; i++) {

if (temp < arr[i]) {//最小整数和数组里面的数比

temp = arr[i];

//return temp;最下面有了,不能写在这里,不然返回的就是第一个数值arr[0]的值了

}

//return temp;下面有了,不能写在这里,不然返回的就是第一个数值arr[0]的值了

}

return temp;//有返回值类型的,必须要有返回值

}

}

---------------------------------------------------------------------


//2.定义一个函数,从数组中查询指定的元素首次出现的位置。


class SearchArray {

public static void main(String[] args) {

int[] arr = new int[] { 1, 2, 3, 5, 4 };

int index = searchArray(3, arr);

}


public static int searchArray(int number, int[] array) {

if (array == null || array.length == 0) {//情况一

System.out.println("array is null or array lenth is 0!");

return -1;

}

int index = 1;//成立的情况,先初始化index值,

for (int i = 0; i < array.length; i++) {

if (array[i] == number) {//情况二

index = i;

System.out.println("Search " + number+ " succeed! the index is " + index);

return index;

}

}

System.out.println("can not searched" + number);//情况三

return -1;

//三种情况貌似有了return,也用不着else if了

}

}


---------------------------------------------------------------------

//3.定义函数,完成冒泡排序,大数下沉。

//数组升序冒泡排列

class BubbleSort {

public static void main(String[] xargs) {

int[] arr = sort(new int[] { 3, 1, 5, 9, 7 });

out(arr);

}


public static int[] sort(int[] array) {

for (int i = 0; i < array.length - 1; i++)

for (int j = 0; j < array.length - 1 - i; j++) {

int temp = 0;

if (array[j] > array[j + 1]) {

temp = array[j];

array[j] = array[j + 1];

array[j + 1] = temp;

}

}

return array;

}


public static void out(int[] array) {

for (int i = 0; i < array.length; i++) {

System.out.print(array[i] + "\t");

}

System.out.println();

}

}

---------------------------------------------------------------------

//4.折半查找。

/**

 * 折半查找/二分查找

 * 前提条件是要有顺序排序的数组

 */

class HalfFind {

public static void main(String[] args) {

int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };

int a = 0, b = arr.length - 1, m = 0;//a,b下标索引的最小和最大,m是如果找到对应数的索引值

int x = 5;

while (a <= b) {

m = (a + b) / 2;

if (arr[m] == x) {

System.out.println("Find it!,the index is " + m);//m的值是数组下标的索引值

break;

} else if (x < arr[m]) {////搜索范围落在左边

b = m - 1;

} else {//落在右边

a = m + 1;

}

}

}

}


//用方法体现

//class HalfFind

//{

//public static void main(String[] x){

//System.out.println(find(new int[]{1,2,3,4,6,7,8},9));

//}

//

////大数据下沉冒泡

//public static int find(int[] arr,int x){

//int a = 0 ,b = arr.length - 1, m = 0 ;

//int mindex = 0 ;

//while(a <= b){

//mindex = ( a + b) / 2 ;

//m = arr[mindex] ;

//

//if(m == x){

//return mindex ;

//}

////搜索范围落在左边

//else if(m > x){

//b = mindex - 1 ;

//}

////落在右边

//else{

//a = mindex + 1 ;

//}

//}

//return -1 ;

//

//}

//}

---------------------------------------------------------------------

//6.定义一个函数,实现矩阵的转置.arr[i][j] == arr[j][i];

//前提条件是正方的。

/**

 * 计算数组的转置

 */

class ArrayTransDemo {

public static void main(String[] args) {

int[][] arr = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, { 11, 12, 13, 14, 15 }, { 16, 17, 18, 19, 20 },{ 21, 22, 23, 24, 25 } };

out(arr);

System.out.println("-----原版正常遍历后的二位数组----------");

arr = trans(arr);

out(arr);

}


// 转置二位数组,其中1,7,13,19,25是不变的(arr[0][0],arr[1][1],arr[2][2],arr[3][3],arr[4][4]),转置的话是转一个三角形的范围,不是正方形,不然前面先转了,后面又变回去了

public static int[][] trans(int[][] arr) {

//转置的话是转一个三角形的范围,不是正方形,不然前面先转了,后面又变回去了,实际每行分别操作的是2-5,8-10,14-15,20------4行,最后一行不用操作

for (int i = 0; i < arr.length - 1; i++) {//外层,实际每行分别操作的是2-5,8-10,14-15,20------4行,arr.length - 1 最后一行(25那行)不用操作

for (int j = i ; j < arr[i].length; j++) {//比如1,不用操作,就直接j=i+1,操作2.  7不用操作,+1,就操作8

int temp = arr[i][j];//i和j相同转换没意义,上面就直接j=i+j,而不是int j = i,j < arr[i].length,不需要arr[i].length-1 ,这样最后一行不会变换

arr[i][j] = arr[j][i];

arr[j][i] = temp;

}

}

return arr;

}


//遍历二维数组

public static void out(int[][] arr) {

for (int i = 0; i < arr.length; i++) {//外层是行

for (int j = 0; j < arr[i].length; j++) {//里层打印列

System.out.print(arr[i][j] + "\t");

}

System.out.println();

}

}

}

---------------------------------------------------------------------

//7.遍历三维组数,横向输出三维数组的每一个层。没有5

/**

* 遍历三维组数,横向输出三维数组的每一个层

*/

class OutHorizontalDemo {

public static void main(String[] args) {//一个三阶魔方

int[][][] arrr = { { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } },

{ { 10, 11, 12 }, { 13, 14, 15 }, { 16, 17, 18 } },

{ { 19, 20, 21 }, { 22, 23, 24 }, { 25, 26, 27 } } };

outHor(arrr);

outThreeArray(arrr);

}


// 横向输出三维数组,

public static void outHor(int[][][] arr) {

// 循环行数,每个二维数组的长度

for (int i = 0; i < arr[0].length; i++) {

// 输出所有列

for (int j = 0; j < arr.length; j++) {

// 输出每个层上的第i行的元素.

for (int k = 0; k < arr[j][i].length; k++) {

System.out.print(arr[j][i][k] + "\t");

}

System.out.print(" | ");

}

System.out.println();

}

System.out.println("----------------------------------"+"\n"+"----------------------------------");

}



//正常输入一个三维数组

public static void outThreeArray(int[][][] arr){

for(int i = 0;i < 3;i++){

for(int j = 0;j < 3;j++){

for(int k=0;k < 3;k++){

System.out.print(arr[i][j][k]+"\t");

}

System.out.println();

}

System.out.println("---------------------");

}

}

}

---------------------------------------------------------------------

阐述

1) 获取数组的最大值,解决方法:遍历整个数组,通过if条件判断比较出最大值

2) 查询数组中某个值,解决方法:遍历整个数组,if条件判断,查找到这个值时,跳出循环

3) 冒泡排序:将最小/最大的数,依次沉到数组的最后完成排序.

外层循环需要进行array.length-1次,内层循环需要比较array.length-i-1次.

4) 二分查找法:要求有序数组,通过比较中间值和查找值,确定查找值所在位置(中间值的左或右),进行多次循环查找找到值的真正所在.

5) 矩阵转置问题:涉及矩阵初始化,赋值操作,转置操作注意只需对左下正三角的值进行对位交换array[i][j]=array[j][i].

6) 三位数组:抽象为魔方,分为层,每层的每行,每层的每行的每列.通过循环控制,可以横向以及纵向打印每层.具体参见代码.

7)面相对象:涉及面相对象类的定义,对象的生成,构造函数,修饰符,javabean技巧,对封装的理解.

1) 获取数组的最大值,解决方法:遍历整个数组,通过if条件判断比较出最大值

2) 查询数组中某个值,解决方法:遍历整个数组,if条件判断,查找到这个值时,跳出循环

3) 冒泡排序:将最小/最大的数,依次沉到数组的最后完成排序.

外层循环需要进行array.length-1次,内层循环需要比较array.length-i-1次.

4) 二分查找法:要求有序数组,通过比较中间值和查找值,确定查找值所在位置(中间值的左或右),进行多次循环查找找到值的真正所在.

5) 矩阵转置问题:涉及矩阵初始化,赋值操作,转置操作注意只需对左下正三角的值进行对位交换array[i][j]=array[j][i].

6) 三位数组:抽象为魔方,分为层,每层的每行,每层的每行的每列.通过循环控制,可以横向以及纵向打印每层.具体参见代码.

7)面相对象:涉及面相对象类的定义,对象的生成,构造函数,修饰符,javabean技巧,对封装的理解.

---------------------------------------------------------------------

/*//8.定义一个类:Dog 有名称 color age cry();*/


class DogDemo {

public static void main(String[] args) {

Dog job = new Dog("Jobboer", 7);

System.out.println("Name:" + job.getName() + " Age:" + job.getage());

job.setName("lala");

job.setAge(9);

System.out.println("Name:" + job.getName() + " Age:" + job.getage());

}

}


class Dog {

private String name;

private int age;


public void cry() {

System.out.println("wangwang~!");

}


public Dog(String name, int age) {

this.name = name;

this.age = age;

}


public void setName(String name) {

this.name = name;

}


public void setAge(int age) {

this.age = age;

}


public String getName() {

return this.name;

}


public int getage() {

return this.age;

}

}

---------------------------------------------------------------------

9.阐述出来堆区,栈区,何时出现溢出,如何解决。

 

堆区:保存对象以及成员变量栈区:保存方法以及局部变量

溢出条件:产生过多或者占用内存很大的对象函数递归调用自身可能出现栈区溢出

如何解决:1.尽可能不产生不必要的对象或成员变量1.递归操作要小心

2.设置JAVA虚拟机堆大小(java -Xms<size>) 2.采用非递归手段

---------------------------------------------------------------------


10.oop

面相对象:是相对面向过程而言的一种编程方式,将问题简单化.

类:是对象的抽象.

对象:是类的具体实现.

实例:就是对象.

成员变量:对象的属性变量.

成员函数:对象的方法.

public:用于修饰成员变量或者成员函数,表示公有,供其他类调用.

private:用于修饰成员变量或者成员函数,表示私有,用于封装,提高数据安全性,可通过set,get方法进行属性的改变,获取

构造函数:用于初始化对象.函数没有返回值.

this:是对象的成员变量,指向当前的对象,用于类中方法引用当前对象.

static:静态的,修饰成员变量,同类对象所共有,类也可以引用静态成员,静态方法只能访问静态成员.