Printing in Array in Ascending order

[Timothy Scott]

I'm having a hard time figuring out how to print this array in ascending order anytime I try to it says it can't find the variable what can I do to fix that and not have an infinite loop

import java.util.Random;
public class Project6
{
   public static void main (String [] args)
  {
   Hero();
    
  }
     
     public static void Hero ()
     {
       int k = 0;
       int count = 0;
       Random RNum = new Random ();
        int[] array = new int[1000];
        int[] nb = new int[1000];
        for(int i = 0; i < array.length; i++)
        {array[i] = RNum.nextInt(1000);
          nb[array[i]]++;
         System.out.println(array[i]);
         if (array[i] >= 500)
         count++;
                
         }
        int[] sorted = new int[1000];       
        for(int i = 0; i < 1000; i++) 
        {for(int j = 0; j < nb[i]; j++) 
          { sorted[k++] = i;
          }
        }
        System.out.println("The array had " + count + " elements over 500");
        
     }
          
}

[jittu goud]

i can compile your code with out any edit...but its printing in random order....
if you want to sort out your values you can use the java.util.SortedSet

i have edited and it prints the sorted collection above the 500

here it is

   import java.util.Random;  
   import java.util.*;
    public class Project6  
    {  

       public static void main (String [] args)  
      {  
       Hero();  
          
      }  
           
        public static void Hero ()  
        {  
          int k = 0;  
          int count = 0;  
          SortedSet set = new TreeSet();

          Random RNum = new Random ();  
           int[] array = new int[1000];  
           int[] nb = new int[1000];  
           for(int i = 0; i < array.length; i++)  
           {array[i] = RNum.nextInt(1000);  
             nb[array[i]]++;  
       
            set.add(array[i]);  
            if (array[i] >= 500)  
            count++;  
                     
            }  
       

   Iterator it = set.iterator();
    while (it.hasNext()) {
        // Get element
        Object element = it.next();
     System.out.println(element);
    }


 
           System.out.println("The array had "+count+" elements over 500");  
             
       }  
              
  }      

[Timothy Scott]

yes but it also has to print the original array. so thats why I can't use that

[Hunter McMillen]

Arrays.sort method sorts an array in ascending order. You can copy a reference of the array then sort one of the reference and print them simultaneously.


Example:

    
int[] arr1 = new int[3];
         int[] arr2 = new int[3];
      
         arr1[0] = 55;
         arr1[1] = 500;
         arr1[2] = -45;
      
			//deep copy
         for(int i =0; i < arr1.length; i++)
         {
            arr2[i] = arr1[i];
         }

         Arrays.sort(arr1);
      	System.out.println("Original\t\tSorted");
         for(int i =0; i < arr1.length; i++)
         {
            System.out.println(arr2[i] + "\t\t\t" + arr1[i]);
         }

Hunter.

[Rob Spoor]

Hunter McMillen wrote:

int[] arr1 = new int[3];
int[] arr2 = new int[3];
      
arr1[0] = 55;
arr1[1] = 500;
arr1[2] = -45;
      
//deep copy
for(int i =0; i < arr1.length; i++)
{
    arr2[i] = arr1[i];
}

Please don't do that. Use either clone() or System.arraycopy:

int[] arr1 = new int[3];
arr1[0] = 55;
arr1[1] = 500;
arr1[1] = -45;

int[] arr2 = arr1.clone(); // cast to int[] required before Java 5.0

int[] arr3 = new int[arr1.length];
System.arraycopy(arr1, 0, arr2, 0, arr1.length);

[Seetharaman Venkatasamy]

Thanks Rob .

[Campbell Ritchie]

Rob Prime wrote: . . . Use either clone() or System.arraycopy: . . .

As usual, Rob is right.

Remember the clone() method of an array returns a shallow clone, so it works best for an array with one [] pair and immutable objects. If you have an array with more than one pair of [] or which contains mutable objects, the individual elements are copied, not cloned, so a change in the 1st array will be reflected in the clone and vice versa.

[Hunter McMillen]

Right so if the change is reflected, if you used Arrays.sort on arr1 arr2 would be sorted also correct? doesnt he want to print the original and the sorted?

Hunter.

[Rob Spoor]

The array elements themselves will be the same, but the arrays are definitely decoupled - on a first level.

Consider the following:

int[] intArr1 = {1, 2, 3};
int[] intArr2 = intArr1.clone(); // or using System.arraycopy
intArr2[1] = 5;
// intArr1 is still {1, 2, 3}, intArr2 is now {1, 5, 3}

// BUT:
Date[] dateArr1 = {new Date(), new Date()}; // May 6th, May 6th
Date[] dateArr2 = dateArr1.clone(); // May 6th, May 6th
dateArr2[1] = new Date(500); // May 6th, something else
// dateArr1 is still May 6th, May 6th
dateArr2[0].setTime(0); // Jan 1st 1970, something else
// dateArr1[0] == dateArr2[0], sp dateArr1 is now Jan 1st 1970, May 6th

So after clone() or System.arraycopy, both arrays have the exact same contents - that includes references to the exact same objects. If you overwrite a reference (like on line 9) that only changes one array. If you change an element of one array (like on line 11), you change the object to which both arrays are referencing, and therefore the contents of both arrays change. Not the references inside the array, but the objects these references refer to.

[Campbell Ritchie]

No, that is not what I meant at all.

The clone of an array which contains mutable elements, ie mutable objects (which includes arrays, as in a [][] array), contains references to the original objects. If you sort the clone, the original array remains unchanged, but if you change the state of any elements, that element is in both arrays, and you can see the change from both references. Here's some code I thought up out of my head, and executed

/**
 * This class represents a phone number consisting of a code
 * not starting with 0 and a number also not starting with 0.
 * The fact that nobody reading has ever seen a phone number in that format
 * is neither here nor there ;-)
 */
public class PhoneNumber implements Comparable<PhoneNumber>
{
   private int number;
   private int code;

/**
 * @throws IllegalArgumentException if you pass a 0 or negative argument
 */
   public PhoneNumber(int code, int number)
   {
      if (code <= 0 || number <= 0)
         throw new IllegalArgumentException("Number and code must be greater than 0");
      this.code = code;
      this.number = number;
   }//end constructor

/**
 * @throws NumberFormatException if you don't pass the right String
 * @throws IllegalArgumentException if you pass a 0 or negative argument
 */
   public PhoneNumber(String codeText, String numberText)
   {
      this(Integer.parseInt(codeText), Integer.parseInt(numberText));
   }//end constructor

   public void setCode(int newCode)
   {
      if (newCode <= 0)
         throw new IllegalArgumentException("Number and code must be greater than 0");
       code = newCode;
   }//end setCode

   public void setNumber(int newNumber)
   {
      if (newNumber <= 0)
         throw new IllegalArgumentException("Number and code must be greater than 0");
       number = newNumber;
   }//end setNumber

   @Override public String toString()
   {
       return String.format("Phone number: (%d) %d", code, number);
   }//end to String

   @Override public int hashCode()
    {
        return code * 31 + number;
    }//end hash code

   @Override public boolean equals(Object other)
   {
       return other == this ||
                  other != null &&
                  getClass() == other.getClass() &&
                  ((PhoneNumber)other).number == number &&
                  ((PhoneNumber)other).code == code;
    }//end equals

/**
 * Compares on the basis that different codes take precedence over different
 * numbers. So (123) 456 < (234) 456 and (123) 456 > (123) 345.
 * Since the constructor only allows positive values there is no risk of overflow
 */
    public int compareTo(PhoneNumber other)
    {
        return code == other.code ? number - other.number : code - other.code;
    }//end compareTo
}//end class

import java.util.Arrays;
import java.util.Random;

public class PhoneBook
{
   /**
    * @param args Requires an even number of arguments, positive ints, to use as successive
    * codes and numbers
    *@throws Any number of Exceptions if you don't fulfil the above ;-)
    */
   public static void main(String[] args)
   {
       new PhoneBook(args).go();
   }//end main

   private Random rnd;
   private PhoneNumber[] numbers;

   public PhoneBook(String[] args)
   {
       rnd = new Random();
       numbers = new PhoneNumber[args.length / 2];
       for (int i = 0; i < args.length; i += 2)
           numbers[i / 2] = new PhoneNumber(args[i], args[i + 1]);
   }//end constructor

   private static void printNumbers(PhoneNumber[] nums, String message)
   {
       System.out.printf("%s%n*************************************************%n", message);
       for (PhoneNumber n : nums)
            System.out.println(n);
       System.out.printf("%n*************************************************%n");
   }//end print numbers

   public void go()
   {
       printNumbers(numbers, "Array before sorting");
       PhoneNumber[] copies = numbers.clone();
       printNumbers(copies, "Array copy before sorting");
       Arrays.sort(copies);
       printNumbers(copies, "Array copy after sorting");
       printNumbers(numbers, "Original array not sorted");
/*
 * Randomly change some of the objects, only in the copy array
 */
       for (int i = 0; i < copies.length - 1; i++)
       {
           PhoneNumber p = copies[rnd.nextInt(copies.length)];
           int iii = 1 + rnd.nextInt(10000);
           if (rnd.nextInt(2) == 1)
              p.setCode(iii);
           else
              p.setNumber(iii);
       }//end for
       printNumbers(copies, "Array copy after random changes");
       printNumbers(numbers, "Original array not touched: see whether there are any changes");
    }//end go
}//end class

[Campbell@localhost java]$ java PhoneBook 123 456 789 234 567 890 321 654 987 147 258 369 741 852 963 753 123 456 123 567
Array before sorting
*************************************************
Phone number: (123) 456
Phone number: (789) 234
Phone number: (567) 890
Phone number: (321) 654
Phone number: (987) 147
Phone number: (258) 369
Phone number: (741) 852
Phone number: (963) 753
Phone number: (123) 456
Phone number: (123) 567

*************************************************
Array copy before sorting
*************************************************

And if you want to know what happens next, you will have to run it yourself