Java: recherche de la valeur la plus élevée dans un tableau
Pour une raison quelconque, ce code imprime trois valeurs pour la valeur la plus élevée du tableau lorsque j'essaie d'en imprimer une seule (qui est 11.3). Quelqu'un peut-il m'expliquer s'il vous plaît pourquoi il fait cela?
Merci.
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);
}
}
}
}
Il imprime un nombre chaque fois qu'il en trouve un supérieur au maximum actuel (ce qui se produit trois fois dans votre cas.) Déplacez l'impression en dehors 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);
Pour rechercher la valeur la plus élevée (max) ou la plus basse (min) d'un tableau, vous pouvez vous orienter dans la bonne direction. Voici un exemple de code permettant d'obtenir la valeur la plus élevée d'un tableau primitif.
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
public int maxValue(int array[]){
int max = Arrays.stream(array).max().getAsInt();
return max;
}
Maintenant, la ligne suivante devrait fonctionner.
System.out.println ("Le maximum le plus élevé en décembre est:" + maxValue (decMax)); Vous devez imprimer le maximum après vous les avez tous numérisés:
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);
Comme suggéré par d'autres, mentionnant simplement la manière la 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);
Si vous recherchez le moyen le plus simple et le plus rapide d'effectuer diverses actions concernant les tableaux, l'utilisation de la classe Collections est extrêmement utile (documentation disponible à l'adresse https://docs.Oracle.com/javase/7/docs/. api/Java/util/Collections.html ), les actions vont de la recherche du maximum, du minimum au tri, de l'ordre inverse, etc.
Un moyen simple de trouver la valeur maximale du tableau avec l'utilisation de 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é par la recherche de la valeur minimale, similaire à la recherche de la valeur maximale:
System.out.println(Collections.min(a));
La ligne la plus simple pour trier la liste:
Collections.sort(a);
Ou encore, l'utilisation de la classe Arrays pour trier un tableau:
Arrays.sort(decMax);
Cependant, la classe Arrays n'a pas de méthode qui se réfère directement à la valeur maximale, elle est triée et le dernier indice est la valeur maximale, mais gardez à l'esprit que le tri effectué selon les méthodes ci-dessus a une complexité de 0 .
Vous avez votre instruction print () dans la boucle for(), elle devrait être après pour ne s'imprimer qu'une seule fois Dans l’état actuel des choses, chaque fois que le maximum change, il imprime une max.
Vous pouvez utiliser une fonction qui accepte un tableau et y trouve la valeur maximale. je l'ai fait générique afin qu'il puisse é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;
}
Le moyen le 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]));
Vous ne faites que comparer l’élément zeroth avec le reste des éléments pour qu’il affiche la dernière valeur la plus grande qu’il contiendra. Dans votre cas, le même problème se produit. Pour comparer chaque élément, nous devons échanger les valeurs telles que:
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);
J'espère que ceci vous aidera
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);
}
Vous pouvez écrire comme ça.
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);
}
}
Une solution plus courte pour avoir la valeur maximale de array:
double max = Arrays.stream(decMax).max(Double::compareTo).get();
Si vous ne souhaitez utiliser aucune bibliothèque prédéfinie Java, vous trouverez ci-dessous la
manière 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);
}
}
Un moyen facile sans utiliser les 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+"");
}