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;
	}
	//调用该方法时，直接把你要比较的四个值写到方法括号中去，以逗号隔开