Java: Trouver la valeur la plus élevée dans un tableau

Pour quelque raison que ce code est en cours d'impression trois valeurs pour la valeur la plus élevée dans le tableau lorsque j'essaie d'imprimer un seul (qui est de 11,3). Quelqu'un peut-il m'expliquer pourquoi il fait cela?

Grâce.

import java.util.Scanner;

public class Slide24
{
    public static void main (String [] args)
    {
        Scanner in = new Scanner(System.in);

        double[] decMax = { -2.8, -8.8, 2.3, 7.9, 4.1, -1.4, 11.3, 10.4,
            8.9, 8.1, 5.8, 5.9, 7.8, 4.9, 5.7, -0.9, -0.4, 7.3, 8.3, 6.5, 9.2,
            3.5, 3, 1.1, 6.5, 5.1, -1.2, -5.1, 2, 5.2, 2.1};

        double total = 0, avgMax = 0;

        for (int counter = 0; counter < decMax.length; counter++)
        {
         total += decMax[counter];
        }

        avgMax = total / decMax.length;

        System.out.printf("%s %2.2f\n", "The average maximum temperature for December was: ", avgMax);

        //finds the highest value
        double max = decMax[0];

        for (int counter = 1; counter < decMax.length; counter++)
        {
         if (decMax[counter] > max)
         {
          max = decMax[counter];
          System.out.println("The highest maximum for the December is: " + max);
         }

        }        
    }
}

Les Collections.max(arrayList).toInt()

InformationsquelleAutor HelloWorld | 2009-11-27

35

C'est l'impression d'un nombre à chaque fois qu'il en trouve une qui est plus élevé que le courant max (qui arrive à se produire trois fois dans votre cas.) Déplacer l'impression à l'extérieur de la boucle for et vous devriez être bon.
```
for (int counter = 1; counter < decMax.length; counter++)
{
     if (decMax[counter] > max)
     {
      max = decMax[counter];
     }
}

System.out.println("The highest maximum for the December is: " + max);
```
InformationsquelleAutor Toji
23

Pour trouver le maximum (max) ou plus bas (min) à partir d'un tableau, cela pourrait vous donner la bonne direction. Voici un exemple de code pour obtenir la valeur la plus élevée à partir d'une primitive de tableau.

Méthode 1:
```
public int maxValue(int array[]){
  List<Integer> list = new ArrayList<Integer>();
  for (int i = 0; i < array.length; i++) {
    list.add(array[i]);
  }
 return Collections.max(list);
```
}

Pour obtenir la valeur la plus basse, vous pouvez utiliser
```
Collections.min(liste)
```
Méthode 2:
```
public int maxValue(int array[]){
  int max = Arrays.stream(array).max().getAsInt();
  return max;
}
```
Maintenant la ligne suivante devrait fonctionner.
```
Système.out.println("au maximum Le plus élevé pour le mois de décembre est:" + maxValue(decMax)); 
```
- Pour Java 8, la Méthode 2 est très pratique.
- Laquelle est la bonne performance sage?
- Ce sont aussi droit et de la bonne solution, mais pas le plus efficace. Accepté de répondre est la le plus efficace moyen de trouver plus d'élément dans le tableau.
InformationsquelleAutor sifho

Vous devez imprimer le max après vous ai scanné tous:

for (int counter = 1; counter < decMax.length; counter++)
{
    if (decMax[counter] > max)
    {
        max = decMax[counter];
        //not here: System.out.println("The highest maximum for the December is: " + max);
    }
}  
System.out.println("The highest maximum for the December is: " + max);

InformationsquelleAutor Michael Haren

Même comme suggéré par d'autres, le simple fait de mentionner le moyen le plus propre de le faire:

int max = decMax[0];
for(int i=1;i<decMax.length;i++)
    max = Math.max(decMax[i],max);
System.out.println("The Maximum value is : " + max);

InformationsquelleAutor Sahil Chhabra

4

Si vous cherchez le moyen le plus rapide et le plus simple pour effectuer diverses actions en ce qui concerne les tableaux, l'utilisation des Collections de la classe est très utile (documentation disponible à partir de https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html), des actions varie de trouver le maximum, le minimum, le tri, l'ordre inverse, etc.

Un moyen simple de trouver la valeur maximale de la matrice avec l'utilisation des Collections:
```
Double[] decMax = { -2.8, -8.8, 2.3, 7.9, 4.1, -1.4, 11.3, 10.4, 8.9, 8.1, 5.8, 5.9, 7.8, 4.9, 5.7, -0.9, -0.4, 7.3, 8.3, 6.5, 9.2, 3.5, 3.0, 1.1, 6.5, 5.1, -1.2, -5.1, 2.0, 5.2, 2.1};
List<Double> a = new ArrayList<Double>(Arrays.asList(decMax));
System.out.println("The highest maximum for the December is: " + Collections.max(a));
```
Si vous êtes intéressé à trouver la valeur minimale, semblable à trouver maximale:
```
System.out.println(Collections.min(a));
```
Le plus simple ligne pour trier la liste:
```
Collections.sort(a);
```
Ou l'utilisation des Tableaux de classe pour trier un tableau:
```
Arrays.sort(decMax);
```
Cependant, les Tableaux de la classe n'a pas une méthode qui fait référence à la valeur maximale directement, en faisant le tri et en se référant à la dernière, l'indice de la valeur maximale, cependant, gardez à l'esprit de tri par les 2 méthodes a une complexité de O(n log n).

InformationsquelleAutor christylam1
1

Une courte solution pour avoir la valeur max de la gamme:
```
double max = Arrays.stream(decMax).max(Double::compareTo).get();
```
- il ne fonctionne que de travail pour Android N & plus
InformationsquelleAutor freedev
1

Vous avez votre print() instruction dans le for() boucle, Il devrait être après, de sorte qu'il imprime seulement une fois. la façon dont il l'est actuellement, à chaque fois que le max des changements qu'il imprime une max.

InformationsquelleAutor twolfe18
1

Vous êtes juste de Comparer zéro de l'élément avec le reste des éléments de sorte qu'il imprime la valeur de la dernière plus grande valeur qu'il contiendra, dans votre cas, même problème qui se passe. Pour comparer chaque et tous les éléments que nous avons pour permuter les valeurs comme:
```
double max = decMax[0];
    for (int counter = 1; counter < decMax.length; counter++){
        if(max<decMax[i]){
            max=decMax[i]; //swapping
            decMax[i]=decMax[0];
        }
    }
    System.out.println("The max value is "+ max);
```
Espère que cela va vous aider à
- Cela a fonctionné pour moi
InformationsquelleAutor Ijhar Ansari

Vous pouvez utiliser une fonction qui accepte un tableau et trouve le max de valeur en elle. je l'ai fait générique, de sorte qu'il pourrait également accepter d'autres types de données

public static <T extends Comparable<T>> T findMax(T[] array){       
    T max = array[0];
    for(T data: array){
        if(data.compareTo(max)>0)
            max =data;                
    }
    return max;
}

InformationsquelleAutor Shimrod

Vous pouvez écrire comme cela.

import java.util.Scanner;
class   BigNoArray{

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter how many array element");
        int n=sc.nextInt();
        int[] ar= new int[n];
        System.out.println("enter "+n+" values");
        for(int i=0;i<ar.length;i++){
            ar[i]=sc.nextInt();
        }
        int fbig=ar[0];
        int sbig=ar[1];
        int tbig=ar[3];
            for(int i=1;i<ar.length;i++){
                if(fbig<ar[i]){
                    sbig=fbig;
                    fbig=ar[i];
                }
                else if(sbig<ar[i]&&ar[i]!=fbig){
                    sbig=ar[i];
                }
                else if(tbig<ar[i]&&ar[i]!=fbig){
                    tbig=ar[i];
                }
            }
        System.out.println("first big number is "+fbig);
        System.out.println("second big number is "+sbig);
        System.out.println("third big number is "+tbig);
    }
}

InformationsquelleAutor Vivek Shah

void FindMax()
{
    int lessonNum;

    System.out.print("Enter your lesson numbers : ");
    lessonNum = input.nextInt();
    int[] numbers = new int[lessonNum];
    for (int i = 0; i < numbers.length; i++)
    {
        System.out.print("Please enter " + (i + 1) + " number : ");
        numbers[i] = input.nextInt();
    }
    double max = numbers[0];
    for (int i = 1; i < numbers.length; i++)
    {
        if (numbers[i] > max)
        {
            max = numbers[i];
        }
    }
    System.out.println("Maximum number is : " + max);
}

InformationsquelleAutor Ahmad Fayazi

Façon la plus simple que j'ai trouvé, prend en charge toutes les versions d'android

Arrays.sort(series1Numbers);

int maxSeries = Integer.parseInt(String.valueOf(series1Numbers[series1Numbers.length-1]));

InformationsquelleAutor Amir De

Un moyen facile sans l'aide de collections

public void findHighestNoInArray() {
        int[] a = {1,2,6,8,9};
        int large = a[0];
            for(int num : a) {
                if(large < num) {
                    large = num;
                }
            }
            System.out.println("Large number is "+large+"");
        }

InformationsquelleAutor arunkumar sambu

Si vous ne voulez pas utiliser de java prédéfinis bibliothèques ci-dessous est la

façon la plus simple

   public class Test {

    public static void main(String[] args) {
        double[] decMax = { -2.8, -8.8, 2.3, 7.9, 4.1, -1.4, 11.3, 10.4,
            8.9, 8.1, 5.8, 5.9, 7.8, 4.9, 5.7, -0.9, -0.4, 7.3, 8.3, 6.5, 9.2,
            3.5, 3, 1.1, 6.5, 5.1, -1.2, -5.1, 2, 5.2, 2.1};

        double maxx = decMax[0];

        for (int i = 0; i < decMax.length; i++) {
            if (maxx < decMax[i]) {
                maxx = decMax[i];
            }
        }
        System.out.println(maxx);

    }
}

InformationsquelleAutor Java Strikers

import java.util.*;
class main9 //Find the smallest and 2lagest and  ascending and descending order of  elements in array//
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the array range");
        int no=sc.nextInt();
        System.out.println("Enter the array element");
        int a[]=new int[no];
        int i;
        for(i=0;i<no;i++)
        {
            a[i]=sc.nextInt();
        }
        Arrays.sort(a);
        int s=a[0];
        int l=a[a.length-1];
        int m=a[a.length-2];
        System.out.println("Smallest no is="+s);
        System.out.println("lagest 2 numbers are=");
        System.out.println(l);
        System.out.println(m);
        System.out.println("Array in ascending:");
        for(i=0;i<no;i++)
        {
            System.out.println(a[i]);
        }
        System.out.println("Array in descending:");
        for(i=a.length-1;i>=0;i--)
        {
            System.out.println(a[i]);
        }
    }
}

InformationsquelleAutor Gyana Ranjan Tripathy

Vous devez vous connecter pour publier un commentaire.

Méthode 1:

Méthode 2: