java 打印三维数组_Java基础第三天_数组
1.定義一個函數，函數功能是動態提取int[]中元素的最大值。
2.定義一個函數，從數組中查詢指定的元素首次出現的位置。
3.定義函數，完成冒泡排序，大數下沉。
4.折半查找。
5.闡述
6.定義一個函數，實現矩陣的轉置.arr[i][j] == arr[j][i];//前提條件是正方的。
7.遍歷三維組數，橫向輸出三維數組的每一個層。
8.定義一個類:Dog 有名稱 color age cry();
9.闡述出來堆區，棧區，何時出現溢出，如何解決。
10.oop
---------------------------------------------------
解答：獲取數組中最大值
class ArrayMax {
public static void main(String[] args){
System.out.println(arraymax(new int[]{1,2,3,6,33,76,23}));
}
public static int arraymax(int[] arr){
if(arr ==null){
System.out.println("數組不存在");
return -1;
}
int temp =arr[0];
for(int i=0;i
if(temp
temp=arr[i];
}
}
return temp;
}
}
2.從數組中查詢指定的元素首次出現的位置
class SearchArray{
public static void main(String[] args){
//System.out.println("第一次位置是第"+(searchArray(5,new int[]{1,2,4,5,7,8})+1)+"個數");
searchArray(5,new int[] {1,2,4,5,7,8});
}
public static void searchArray(int num,int[] arr){
// int a=-1;
for(int i=0;i
if(arr[i]==num){
System.out.println("這個數第一次位置是第"+(i+1)+"個數");
}
}
}
}
3.定義函數，完成冒泡排序，大數下沉。
/*
冒泡排序，大數下沉
*/
class BubbleSort{
public static void main(String[] args){
//outArray(getSort(new int[]{9,5,4,5,1,7}));
outArray(getSort(new int[]{55,8,7,9,3,1,4,11,15,6,50,45,33,30}));
}
//定義一個冒泡排序方法
public static int[] getSort(int[] arr){
//外層循環決定排序幾次
for(int i=0;i
//內層循環決定大數下沉走幾步
for(int j=0;j
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
}
//定義一個輸出數組的方法
public static void outArray(int[] arr){
for(int i=0;i
System.out.print(arr[i]+" ");
}
}
}
4.折半查找。
class BinarySelect{
public static void main(String[] args){
System.out.println(getValue(new int[]{1,2,3,4,5,6,7,8},6));
}
public static int getValue(int[] arr,int x){
int a=0;
int b=arr.length-1;
int m=0;
//int minindex=0;
while(a<=b){
int minindex=(a+b)/2;
m=arr[minindex];
if(m==x){
return minindex;
}
else if(m>x){
b=minindex-1;
}
else {
a=minindex+1;
}
}
return -1;
}
}
5.闡述
答：
1) 獲取數組的最大值,解決方法:遍歷整個數組,通過if條件判斷比較出最大值
2) 查詢數組中某個值,解決方法:遍歷整個數組,if條件判斷,查找到這個值時,跳出循環
3) 冒泡排序:將最小/最大的數,依次沉到數組的最后完成排序.
外層循環需要進行array.length-1次,內層循環需要比較array.length-i-1次.
選擇排序： 先循環選出最小(最大)值，找出下標，本輪循環完跟第一數交換，繼續從第二個數開始循環，找到最小或者最大值，本輪循環完跟第二個數交換，以此類推。。
冒泡排序：第一個數跟第二個數比較大數下沉，以此類推 直到最大數下沉，然后在進行比較第二輪，第二大數下沉。。。
4) 二分查找法:要求有序數組,通過比較中間值和查找值,確定查找值所在位置(中間值的左或右),進行多次循環查找找到值的真正所在.
折半查詢：找到中間位置數比較這個數跟要查詢數大小，判斷這個數在中間位置數的哪邊，然后再取出那邊中間數繼續比較找出中間數，直到找出查詢數(條件是兩邊數相等)。
5) 矩陣轉置問題:涉及矩陣初始化,賦值操作,轉置操作注意只需對左下正三角的值進行對位交換array[i][j]=array[j][i].行列式轉置
6) 三位數組:抽象為魔方,分為層,每層的每行,每層的每行的每列.通過循環控制,可以橫向以及縱向打印每層.具體參見代碼.
7)面相對象:oriented object program 面向對象編程 一切皆對象
涉及面相對象類的定義,對象的生成,構造函數,修飾符,javabean技巧,對封裝的理解.
6.定義一個函數，實現矩陣的轉置.arr[i][j] == arr[j][i];//前提條件是正方的。
//轉置數組
class ArrayTransDemo{
public static void main(String[] args){
transDemo(new int[][] {{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}});
}
public static void transDemo(int[][] arr){
for(int i=0;i
for(int j=i+1;j
int a=arr[i][j];
arr[i][j]=arr[j][i];
arr[j][i]=a;
}
}
//輸出數組
for(int i=0;i
for(int j=0;j
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
7.遍歷三維組數，橫向輸出三維數組的每一個層
/*
*遍歷三維組數，橫向輸出三維數組的每一個層
*/
class MagicArray{
public static void main(String[] args){
int[][][] arry=new int[][][]{{{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}}};
magicCube1(arry);
}
//縱向輸出三維數組
public static void magicCube(int[][][] arr){
for( int i=0; i
for( int j=0; j
for( int k=0; k
System.out.print(arr[i][j][k] +" ");
}
System.out.println();
}
System.out.println("------------------------------");
}
}
//橫向輸出三維數組方法
public static void magicCube1(int[][][] arr){
for( int i=0; i
for( int j=0; j
for( int k=0; k
System.out.print(arr[j][i][k] +" ");
}
System.out.print("\t"+"|"+"\t");
}
System.out.println();
}
}
}
8.定義一個類:Dog 有名稱 color age cry();
class DogDemo{
public static void main(String[] args){
Dog d=new Dog();
d.cry();
//new Dog().cry();
System.out.println(d.getName());
d.setName("hetao");
//System.out.println(d.name);
System.out.println(d.getName());
}
}
class Dog{
private String color="black";
private int age=3;
private String name="xiaobai";
//構造方法
public ?void Dog(String name){
//name="n";
this.name=name;
}
public void setName(String name){
this.name=name;
//name="n";
}
public String getName(){
return this.name;
}
//屬性私有化 不能用靜態方法調用
public ? void cry(){
System.out.println(name +" "+ age+" "+"wawa");
}
}
9.闡述出來堆區，棧區，何時出現溢出，如何解決。
答：
堆區:保存對象以及成員變量
棧區:保存方法以及局部變量
溢出條件:產生過多或者占用內存很大的對象函數遞歸調用自身可能出現棧區溢出
如何解決:1.盡可能不產生不必要的對象或成員變量1.遞歸操作要小心
2.設置JAVA虛擬機堆大小(java -Xms) 2.采用非遞歸手段
棧空間不足：java -Xss ? stacksize
堆空間不足：java -Xms
舉例：
堆溢出 byte[][] arr = new byte[1024 * 1024][1024 * 5];
棧溢出：
while(true){
out();
}
}
catch(Exception e){
System.out.println(count);
}
10.oop
答：
面相對象:是相對面向過程而言的一種編程方式,將問題簡單化.
類:是對象的抽象.
對象:是類的具體實現.
實例:就是對象.
成員變量:對象的屬性變量.
成員函數:對象的方法.
public:用于修飾成員變量或者成員函數,表示公有,供其他類調用.
private:用于修飾成員變量或者成員函數,表示私有,用于封裝,提高數據安全性,可通過set,get方法進行屬性的改變,獲取
構造函數:用于初始化對象.函數沒有返回值.
this:是對象的成員變量,指向當前的對象,用于類中方法引用當前對象.
static:靜態的,修飾成員變量,同類對象所共有,類也可以引用靜態成員,靜態方法只能訪問靜態成員.
面向對象是相對面向過程而言，將功能封裝進對象，強調具備了功能的對象。
類是對象的抽象，對象跟實例概念差不多
面向對象的特征：
1.封裝
把屬性都隱藏，提供set() get()方法
private ：
用于修飾成員變量和成員函數
被私有化成員只在本類中有效
對外提供set get方法
2.繼承
3.多態
類的屬性也叫成員變量
類的方法也叫成員函數
成員變量：
定義在類中，隨著對象的建立而建立，存在于對象所在的堆內存中，成員變量有默認初始化。
局部變量：
定義在局部范圍內，存在于棧內存，作用范圍結束，變量空間釋放，沒有默認初始化
構造函數
--------------------------
給對象進行初始化 可以有多個構造函數 重載
1.沒有返回值 連void也不能有
2.函數名和類名相同
3.用構造函數創建對象 默認的構造函數時calssname
匿名對象
-----------------------------------
匿名對象是對象的簡化形式
匿名對象使用情況:
1.當對對象方法僅進行一次調用的時候
2.匿名對象可以作為實際參數進行傳遞
Car car=new Car();
outCarColor(Car c);
匿名： outCarColor(new Car());
或者 ?new Car().run;
this :是關鍵字 對象內部指向內部的一個指針
static 靜態
用于修飾 成員變量和成員函數
修飾的成員：隨著類的加載而加載 ?優于對象存在 被所有對象所共享 ?可以直接被類名調用
靜態方法只能訪問靜態成員 ?靜態方法中不可以寫this super關鍵字 主函數是靜態的
總結
以上是生活随笔為你收集整理的java 打印三维数组_Java基础第三天_数组的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： MATLAB 输出当前时间
- 下一篇： 目标检测发展路程(一)——Two sta