treeset

TreeSet: Ability to sort elements according to a certain rule.There are two ways of sortingA: Natural SortB: Comparator sortFeatures of the TreeSet collection: sort and unique1 Public classTreesetdemo {2 Public Static voidMain (string[] args) {3 //To create a collection object4 //sort in natural order5treesetNewTreeset();6 7 //Create elements and add8 //20,18,23,22,17,24,19,18,249Ts.add (20);TenTs.add (18

= (Person) o; 53 54 int temp = this. age-p. age; 55 56 return temp = 0? This. name. compareTo (p. name): temp; 57 58 59} 60 61 62} 1 import java. util. comparator; 2 3 import cn. itcast. p1.bean. person; 4 5 public class ComparatorByName implements Comparator {// first by name, then by age 6 7 @ Override 8 public int compare (Object o1, Object o2) {9 Person p1 = (Person) o1; 10 Person p2 = (Person) o2; 11 12 int temp = p1.getName (). compareTo (p2.getName (); 13 14 return temp = 0? P1.getAge

Set class and sub-class:TreeSet ordered sub-class;HashSet unordered (hash) sub-classThe contents of the HashSet subclass are not sequential, and the individual elements are not duplicated (except for the object).set　　TreeSet Order:The TreeSet sub-class implements the Sortset subclass (sort) interface, TreeSet interfaces can be sorted.When you add a custom object

"To achieve a natural ordering, the object collection must implement the comparable interface and override the CompareTo () method The general requirements describe the "main conditions", such as: Sort by name length. Note the secondary conditions such as: the length of the same time, the name of the content, age and other conditions are equal, which determines whether to deposit TreeSet collection. PackageCn.itcast.day21.

PackageCn.itcast.day21.treeset2;ImportJava.util.Comparator;ImportJava.util.TreeSet;/** TreeSet Sort by the name length comparer of the custom object student * * Natural sort or comparator sort depending on, TreeSet construction method * Parameterless Construction: Natural sort * with parametric construction: comparator sort * * TreeSet The principle of the collec

First look at the following code Class worker implements comparable Public static void main (string [] ARGs) {What is the output result? The original intention of the code writer should be to set three workers in order by age. However, the result of the execution is 2, and then we can see that the tester 1 has no more than 2 and 3. Why? Check the source code and find that the add method of treeset is defined as follows: public boolean add(E param

elements in the set, but the performance is slightly inferior to hashset at insert time.TreeSet classTreeSet is the only implementation class for the SortedSet interface, and TreeSet ensures that the collection elements are in the sorted state. TreeSet supports two sorting methods, natural sorting and custom sorting, in which the natural sort is the default sorting method. The object that is added to the

The set interface is implemented by the collection of TreeSet ordered without duplicate objects. In fact, the bottom of it is the operation of TreeMap. In the default constructor, a TreeMap object is initialized.You might ask, TreeSet adds one element at a time, while TreeMap is adding key value. In fact, when put, the object is constructed as value, and the added element is the key, added to the TreeMap.OK

) {System.out.println (str); } }}Results:3 1023279 8884567 4873279TreeSet classTreeSet is the only implementation class for the SortedSet interface, and TreeSet ensures that the collection elements are in the sorted state. TreeSet supports two sorting methods, natural sorting and custom sorting, in which the natural sort is the default sorting method. The object that is added to the

[JavaSE] Collection framework (TreeSet), javasetreeset TreeSet: sorts the elements in the Set. By default, the elements are sorted by ascii table and the binary tree structure is used. The left cross is small, and the right cross is large. Store custom objects Define a class Student to implement the Comparable class so that the custom class has a comparison Define attribute age Define attribute name Implem

HashSet: A hash table stores information by using a mechanism called hashing, and the elements are not stored in a particular order;Linkedhashset: maintains a linked table of the collection in the order in which the elements are inserted, allowing iterations in the collection in the order in which they are inserted;TreeSet: Provides an implementation that uses a tree structure to store a set interface, where objects are stored in ascending order, and

set interface,Features: Unordered, non-repeatable Note: unordered in a collection does not refer to the natural order, but the order in which the elements are added is inconsistent with the order of the elements.------------------|HashSetThe implementation of the set interface features: There is no specific order, and no duplicate elements are allowed.------------------| TreeSet The implementation of the set interface, features: no specific order, no

Only the use of methods, non-source analysis.1 Public classTest {2 3 Public Static voidMain (string[] args) {4TreesetNewTreeset();5Treeset.add ("Se");6Treeset.add ("Ald");7Treeset.add ("Boo");8Treeset.add ("CC");9Iteratortreeset.iterator ();Ten while(Iterator.hasnext ()) { OneString string =(String) Iterator.next (); A System.out.println (string); - } - } the -}Output:AldBooCcSeWhen using the TreeSet collection, the element

/* Because it is a binary tree, the general search time complexity is O (lg (n )), Of course, this efficiency is not as efficient as hashmap. However, treemap is more powerful than hashmap, If no sorting is required, treemap is not used, If sorting is required, hashmap cannot be competent. Of course, it must use treemap. It can be used as a sub-map. Therefore, this is an applicable issue and cannot be compared. */ Import java. util .*; Class treesettest2 { Public static void main (string [] ARGs

ownPublicstatic {}}Generics are defined on the interfaceInterfaceinter{ }Wildcard characters:?Generic qualification:? extends E and? Super EMAPHashMap: The only principle of guaranteed keys is the same as HashSet, Hashcode (), Equals ()Treemap:treemap are sorted by key, and the only principle of guaranteed keys is the same as TreeSet, based onWhether the return value of compareTo () or compare () is 0, and 0 is considered a repeating keyThere are two

every data structure has a reason for its existence.Iv. TreeSetTreeSet is implemented using a tree structure (a red-black tree), and the elements in the collection are sorted, but the added, deleted, and included algorithm complexity is O (log (n)).For example, first we define a bird class. (A bird is a Mason's favorite animal)class bird{ int size; Public Bird (int s) { = s; } Public String toString () { return size + ""; }}Then add the bird cl

Objects in the treeset are sorted by size. Therefore, objects in the treeset must be comparable in size. ① The comparable interface can be inherited through objects in the treeset. ② Determine the object size through external referers According to the rules of the custom comparator, when the comparison objects are the same, they are considered to be the same elem

TreeSet When adding elements, the sorting and judging is equal according to the CompareTo method . If 0 is returned, the two objects are considered to be the same object in the same position. That is, TreeSet only adds CompareToReturns an object in the 0 object set.To avoid this situation, you need to write as follows @Override publicint Compare (CountryCode cc1, CountryCode cc2) { int cpr

Note: Only the implementation class is postedPackage Test3;Import Java.util.Comparator;Import Java.util.TreeSet;public class Test {public static void Main (string[] args) {Comparator com=new Comparator () {① Create an anonymous inner class for the Comparator interface@Overridepublic int Compare (object O1, Object O2) {② Rewrite Compare method, custom Sort methodif (O1 instanceof employee O2 instanceof Employee) {Employee e1= (employee) O1;Employee e2= (employee) O2;MyDate Birth1=e1.getbirthday

Method One: Let the class implement the comparable interface, and overwrite the CompareTo () method, add the custom class to TreeSet1 ImportJava.util.Scanner;2 ImportJava.util.TreeSet;3 //TreeSet Applications4 classMain {5 Public Static voidMain (string[] args) {6Scanner s =NewScanner (system.in);7TreesetNewTreeset();8 while(S.hasnextline ()) {9 intn =Integer.parseint (S.nextline ());Ten for(inti = 0; I ) { OneSt