java最大值函數

1. 用java語言編寫一個求兩個數最大的函數，在主函數輸入3個整數，用函數輸出最大值

importjava.util.Arrays;

publicclassT{
	publicstaticvoidmain(String[]args){
		System.out.println(T.sort(21,13,2));
	}
	
	publicstaticintsort(intn1,intn2,intn3){
		intarr[]={n1,n2,n3};
		
		//數組工具類，sort()方法是自動升序排序
		Arrays.sort(arr);
		
		returnarr[2];
	}
}
//控制台
21

2. 用java寫一個求2個整形數最大值的函數，調用該函數求7和9的最大值

public static void main(String[] args) {
System.out.println( getMax(7, 9));

}

public static int getMax(int a, int b) {
return a > b ? a : b;

}

3. Java作業 寫一個函數用於求出整數數組中的最大值

importjava.util.Arrays;
importjava.util.Random;

publicclassGetMaxTest{
publicstaticvoidmain(String[]args){
int[]is=newint[10];
Randomrandom=newRandom();
for(inti=0;i<is.length;i++){
is[i]=random.nextInt();
}
//Arrays.sort(is);
System.out.println("數組"+Arrays.toString(is)+" 最大值是:"
+getMaxnum(is));
}

publicstaticintgetMaxnum(int[]is){
intmax=0;
for(inti:is){
max=max>i?max:i;
}
returnmax;
}
}

4. java求數組的最大值和次大值 (求值函數只能調用一次，但是要返回倆個值)

參考代碼如下：

importjava.util.Arrays;

publicclassTestArray{
	publicstaticvoidmain(String[]args){
		int[]arr={7,2,1,3,5,6};
		
		TestArraytestArray=newTestArray();
		Stringresult=testArray.getMaxAndSecond(arr);
		System.out.println(result);
	}
	
	
	privateStringgetMaxAndSecond(int[]arr){
		//對數組排序（正序排列）
		Arrays.sort(arr);
		intlength=arr.length;
		if(length==0){
			return"";
		}elseif(length==1){
			returnarr[0]+"";
		}else{
			returnarr[length-1]+","+arr[length-2];
		}
	}
}

運行結果如下：

5. 用java編寫找最大值函數

你好，好多種辦法。我給你寫幾種經典的排序吧，最大值就在第一個（倒序）或者最後一個（從小到大）。
首先方便輸出，定義一個工具類
public class PrintUtil {
public static void print(int[] array){
for(int i=0;i<array.length;i++){
System.out.print(array[i] + " ");
}
System.out.println();
}
}
第一種：冒泡排序
public class BubblingSort {
/*
* 演算法思想->升序
* 1、比較相鄰兩項，若為逆序，則交換
* 2、每次比較的結果就是將最大項浮到數組尾
* 演算法分析：
* ------- 最壞情況 --------
* 比較次數：(n-1) + (n-2) + ... + 1 = n*(n-1)/2
* 交換次數：[(n-1) + (n-2) + ... + 1]*3 = 3*n*(n-1)/2
* 所以n元選擇排序需要的主要操作次數是：n*(n-1)/2+3*n*(n-1)/2=2*n*n-2*n
* 結論：O(n*n)階
* ------- 最好情況 --------
* 比較次數：n-1
* 交換次數：0
* 所以n元選擇排序需要的主要操作次數是：n-1
* 結論：O(n)階
*/
public void bubbingSort(int[] array){
int len = array.length ;
for(int i=len-1;i>0;i--){
boolean flag = false ;
for(int j=0;j<i;j++){
if(array[j]>array[j+1]){
int temp = array[j] ;
array[j] = array[j+1] ;
array[j+1] = temp ;
flag = true ;
}
}
if(!flag){
break ;
}
System.out.print("第" + (5-i) + "趟的排序結果為：" );
PrintUtil.print(array) ;
}
}
public static void main(String[] args) {
int[] array = {29,10,14,37,13} ;
// int[] array = {37,29,14,13,10} ; //最差情況
// int[] array = {10,13,14,29,37} ; //最好情況
BubblingSort ss = new BubblingSort();
ss.bubbingSort(array);
PrintUtil.print(array) ;
}
}
第二種：插入排序
public class InsertSort {
/*
* 演算法思想->升序
* 1、將一個數組的元素分成兩部分，前半部分為有序數組
* 2、每一次取後半部分的第一個元素，將該元素插入到有序數組中
* 演算法分析：
* ------- 最壞情況 --------
* 比較次數：1 + 2 + ... + (n-1) = n*(n-1)/2
* 移動次數：
* 內部循環：1 + 2 + ... + (n-1) = n*(n-1)/2
* 外部循環：2*(n-1) OR 2
* 所以n元選擇排序需要的主要操作次數是：n*(n-1)/2 + n*(n-1)/2 + 2*(n-1) = n*n+n-2
* 結論：O(n*n)階
*/
public void insertSort(int[] array){
for (int i = 1; i < array.length; i++) {
int temp = array[i] ;
for(int j= i-1; j >= 0; j--){
if(temp > array[j])
break ;
if(temp < array[j]){
array[j+1] = array[j] ;
if( j != 0 && temp > array[j-1]){
array[j] = temp ;
break ;
}
if(j == 0){
array[0] = temp ;
}
}
}
System.out.print("第" + i + "趟的排序結果為：" );
PrintUtil.print(array) ;
}
}
public static void main(String[] args) {
int[] array = {29,10,14,37,13} ;
InsertSort ss = new InsertSort();
ss.insertSort(array);
PrintUtil.print(array) ;
}
}
第三種：選擇排序
public class SelectSort {
/*
* 演算法思想->升序
* 1、找到最大的元素，與最後一個元素交換
* 2、除去最後一個元素外，在數組的剩餘項中查找最大項，並與倒數第二個元素交換
*
* 演算法分析：
* 比較次數：n*(n-1)/2
* 交換次數：3*(n-1)
* 所以n元選擇排序需要的主要操作次數是：n*(n-1)/2+3*(n-1)=n*n/2+5*n-3
* 結論：O(n*n)階
*/
public void selectSort(int[] array){
int len = array.length ; //記錄數組的長度
int scope = len ; //遍歷范圍
for(int i=0;i<len-1;i++){
int max = array[0] ; //數組的最大元素
int index = 0 ; //記錄最大元素的下標
for(int j=1;j<scope;j++){
if(max < array[j]){
max = array[j] ;
index = j ;
}
}
int temp = array[scope-1] ;
array[scope-1] = array[index] ;
array[index] = temp ;
System.out.print("第" + (i+1) + "趟的排序結果為：" );
PrintUtil.print(array) ;
scope -- ;
}
}

public static void main(String[] args) {
int[] array = {29,10,14,37,13} ;
SelectSort ss = new SelectSort();
ss.selectSort(array);
PrintUtil.print(array) ;
}
}
其餘的都比較復雜就不給你多寫了。
其實很簡單的演算法，就是遍歷這N個數，沒遇到一個大的值，就去賦給max，最後輸出max，但是這個沒什麼技術含量，所以在最後說明下。

6. 用JAVA程序寫一個函數求數組里最大值 寫一個函數求數組里最小值

public int getMax(int[] args){
int max = 0;
//設定一個數，用於存放最大值
for(int i=0;i<args.length;i++){
//依次將max與數組中的每個元素比較，將較大的值賦予max

max = max > args[i] ? max : args[i];

}

//返回獲得的最大值

return max;
}

7. java語言中最大怎麼表示

Java API 中有幾個最大值函數，他們是：public static double max(double a, double b)，public static int max(int a, int b),還有其他的，只是返回值類型不同而已。
舉個例子說明：double d=Math.max(2, 6);
System.out.println(d);
則d的值等於6.0，這就是java中最大函數的表示。

8. java取數組中的最大值

先假設第一個數是最大的，設成max的值，然後拿它依次和後面的數去比，如果遇到比它大的，那就把max的值換成這個較大數，直到遍歷完了，max的值就是數組中的最大值嘍。

9. Java求最大值的三種方法

普通方法：
public class Max {
public static void main(String[] args) {

double[] myList = {1.9, 2.9, 3.4, 3.5,10,11,15,100,-1,-4.5}; //定義一維數組
double num = myList[0]; //0為第一個數組下標
for (int i = 0; i < myList.length; i++) { //開始循環一維數組
if (myList[i] > num) { //循環判斷數組元素
num = myList[i]; } //賦值給num，然後再次循環
}
System.out.println("最大值為" + num); //跳出循環，輸出結果 }
}
三元運算符：
public class Max {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5,10,11,15,1,-1,-4.2}; //定義一維數組
double num = myList[0]; //0為第一個數組下標
for (int i = 0; i < myList.length; i++){ //開始循環一維數組

num=(myList[i] < num?num: myList[i]); //三元運算符，詳情看註解
}
System.out.println("最大值為" + num); //跳出循環，輸出結果
}}
一般函數/方法：
public class Max {
double[] myList = {1.9, 2.9, 3.4, 100,3.5,10,11,12,13,-1};
double num = myList[0];
void getValue(){ //創建一般方法
for (int i = 0; i < myList.length; i++) {

num=(myList[i] < num?num: myList[i]);//三元運算符
}
System.out.println("最大值為" + num);
}
public static void main(String args[]){

Max max=new Max(); //創建對象

max.getValue(); //通過對象調用一般方法
}
}
三種求最大值的方法

10. java用函數輸出abcd中的最大值

/**
	*獲取指定的參數列表中的最大值
	*@paramargs
	*@return
	*/
	publicintgetMax(int...args){
		intmax=Integer.MIN_VALUE;//int類型的最小值
		for(inti=0;i<args.length;i++){
			if(args[i]>max){
				max=args[i];
				if(max==Integer.MAX_VALUE){
					break;//假如是int；類型的最大值，則不用繼續比較後面的值了，直接跳出循環
				}
			}
		}
		returnmax;
	}
	//調用該方法時，直接把你要比較的四個值寫到方法括弧中去，以逗號隔開