感谢大家对IT十八掌大数据的支持，今天的作业如下
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(getMax(new int[0]));
int[] arr = new int[] { 5, 7, 1, 3, 9 };
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;
}
}
2.定义一个函数，从数组中查询指定的元素首次出现的位置。
答：
class SearchArray {
public static void main(String[] args) {
int[] arr = new int[] { 1, 2, 3, 4, 5 };
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;
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;
}
}
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;
int x = 5;
while (a <= b) {
m = (a + b) / 2;
if (arr[m] == x) {
System.out.println("Find it!,the index is " + m);
break;
} else if (x < arr[m]) {
b = m - 1;
} else {
a = m + 1;
}
}
}
}
5.定义一个函数，实现矩阵的转置.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);
}
// 转置
public static int[][] trans(int[][] arr) {
//
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr[i].length; j++) {
int temp = arr[i][j];
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();
}
}
}
6.遍历三维组数，横向输出三维数组的每一个层。
答：
/**
* 遍历三维组数，横向输出三维数组的每一个层
*/
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);
}
// 横向输出三维数组
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();
}
}
}
7.定义一个类:Dog 有名称 color age cry();
答：
class DogDemo {
public static void main(String[] args) {
Dog job = new Dog("Job", 2);
System.out.println("Name:" + job.getName() + " Age:" + job.getage());
job.setName("lala");
job.setAge(3);
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;
}
}
8.阐述
答：
1) 获取数组的最大值,解决方法:遍历整个数组,通过if条件判断比较出最大值
2) 查询数组中某个值,解决方法:遍历整个数组,if条件判断,查找到这个值时,跳出循环
3) 冒泡排序:将最小/最大的数,依次沉到数组的最后完成排序.
外层循环需要进行array.length-1次,内层循环需要比较array.length-i-1次.
4) 二分查找法:要求有序数组,通过比较中间值和查找值,确定查找值所在位置(中间值的左或右),进行多次循环查找找到值的真正所在.
5) 矩阵转置问题:涉及矩阵初始化,赋值操作,转置操作注意只需对左下正三角的值进行对位交换array[i][j]=array[j][i].
6) 三位数组:抽象为魔方,分为层,每层的每行,每层的每行的每列.通过循环控制,可以横向以及纵向打印每层.具体参见代码.
7)面相对象:涉及面相对象类的定义,对象的生成,构造函数,修饰符,javabean技巧,对封装的理解.
9.阐述出来堆区，栈区，何时出现溢出，如何解决。
答：
堆区:保存对象以及成员变量栈区:保存方法以及局部变量
溢出条件:产生过多或者占用内存很大的对象函数递归调用自身可能出现栈区溢出
如何解决:1.尽可能不产生不必要的对象或成员变量1.递归操作要小心
2.设置JAVA虚拟机堆大小(java -Xms<size>) 2.采用非递归手段
10.oop
答：
面相对象:是相对面向过程而言的一种编程方式,将问题简单化.
类:是对象的抽象.
对象:是类的具体实现.
实例:就是对象.
成员变量:对象的属性变量.
成员函数:对象的方法.
public:用于修饰成员变量或者成员函数,表示公有,供其他类调用.
private:用于修饰成员变量或者成员函数,表示私有,用于封装,提高数据安全性,可通过set,get方法进行属性的改变,获取
构造函数:用于初始化对象.函数没有返回值.
this:是对象的成员变量,指向当前的对象,用于类中方法引用当前对象.
static:静态的,修饰成员变量,同类对象所共有,类也可以引用静态成员,静态方法只能访问静态成员.
