Confusion on assigning arrays to object

I have a text file with various pieces of information, but it boils down to NAME/DESCRIPTION/WEBSITE and then repeat in that order til the file is done. I am suppose to take the file and sort the data after combining the three datas into a object. I am confused on what that means exactly and how to do it.
This is a quote from my professor explaining what to do but I can't wrap my head around how to do it.
"You can design and implement a user-defined object that consists of the three property values that you must combine as a single unit. Once you create the user-defined object, you can instantiate an array of that user-defined object. Once the instantiate the array of the user-defined object, you can load the array with instances of the associated values. After that, you can use the appropriate sorting algorithms to sort the instances of the objects in the array"

Here is the code I created so far.

public class Main {
public static void main(String[] args) {
Junk Stuff = new Junk();
}
public static class Junk {
String[] list = new String[59]; //array of all the data
String[] Names = new String[20];
String[] Desc = new String[20];
String[] Websites = new String[20];
int i = 0;
{
File file = new File("Tutorials.txt"); //calls file to be opened
Scanner sc = null; // scans file
try {
sc = new Scanner(file);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
sc.hasNextLine(); //sets while loop that while scanner is on next line of file, prints it
for (i = 0; i <= list.length; i++) //loop to iterate thru array name = sc.nextLine();
try {
Names[i] = sc.nextLine();
Desc[i] = sc.nextLine();
Websites[i] = sc.nextLine();
} catch (NoSuchElementException e) {
}
}
public String[] getNames() {
return Names.clone();
}
public String[] getDesc() {
return Desc.clone();
}
public String[] getSites() {
return Websites.clone();
}
}
}

I think what your professor is trying to get you to do is to think in terms of OOP (object-oriented programming) and address what's known as comparators (means to compare 2 objects).

First of all, let's address the object part. You are reading data that is made up of 3 items. You call that a Tuple (see this great definition) aka a set of values that have meaning together.

Let's define an object class to store that data. We could call it Data or maybe Entity or even Website (note that I am using Java's first capital letter convention). Whatever you do, keep it away from the class that will eventually run it (your Main).

So as an example I got this:

package eu.webfarmr;
import java.net.URL;
/**
* Illustrate comparators
* @author djob
*
*/
public class Website {
private String name;
private String description;
private URL website;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public URL getWebsite() {
return website;
}
public void setWebsite(URL website) {
this.website = website;
}
}

You can now use another class or maybe even a main method in that class (if you're lazy) to create arrays or lists of that object:

public static void main(String[] args) throws MalformedURLException {
List<Website> websites = new ArrayList<Website>();
Website a = new Website();
a.setName("Let's cook");
a.setDescription("Some fascinating website");
a.setWebsite(new URL("https://www.delscookingtwist.com"));
Website b = new Website();
b.setName("XACML stuff");
b.setDescription("My personal blog");
b.setWebsite(new URL("https://www.webfarmr.eu"));
websites.add(a);
websites.add(b);
}

But what your professor really wants you to do is sort that list or array of objects. While sorting numbers is straightforward (and built-in), it's not straightforward to rank custom objects. What matters most? The title? The description? The URL? What if some of these values are equal?

This is where comparators kick in. You need to get your class to implement Comparable<T>. That means your class needs to implement the following additional method

@Override
public int compareTo(Website o) {
if (o == null) return 1;
// If the names are different then return whichever is the string order
// Consider using lower-case comparison
if (this.getName().compareTo(o.getName())!=0) {
return this.getName().compareTo(o.getName());
} else {
if (this.getWebsite().toString().compareTo(o.getWebsite().toString())!=0) {
return this.getWebsite().toString().compareTo(o.getWebsite().toString());
} else {
return (this.getDescription().compareTo(o.getDescription()));
}
}
}

This is just an example of course, you can change the logic. Here's the Javadoc on compareTo():

> int eu.webfarmr.Website.compareTo(Website o)
>
>
> @Override
>
>
> Compares this object with the specified object for order. Returns
> anegative integer, zero, or a positive integer as this object is
> lessthan, equal to, or greater than the specified object.
>
> The implementor must ensure sgn(x.compareTo(y)) ==-sgn(y.compareTo(x))
> for all x and y. (Thisimplies that x.compareTo(y) must throw an
> exception iff y.compareTo(x) throws an exception.)
>
> The implementor must also ensure that the relation is transitive:
> (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.
>
> Finally, the implementor must ensure that x.compareTo(y)==0implies
> that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), forall z.
>
> It is strongly recommended, but not strictly required that
> (x.compareTo(y)==0) == (x.equals(y)). Generally speaking, anyclass
> that implements the Comparable interface and violatesthis condition
> should clearly indicate this fact. The recommendedlanguage is "Note:
> this class has a natural ordering that isinconsistent with equals."
>
> In the foregoing description, the notation sgn(expression) designates
> the mathematical signum function, which is defined to return one of
> -1, 0, or 1 according to whether the value of expression is negative, zero or positive.

Note that there are many other ways to compare. See this site for more.

First Define a class 'User' with three string property :name, description and website.
Now create a list with datatype User and then read lines from the file and create new User object and add into list.
Than sort this based on given property.

Collections.sort(userList,(u1,u2)->u1.name.compareTo(u2.name));