TREEset java 二叉树_Java基础-TreeSet与Java自定义类型的排序

TreeSet与Java自定义类型的排序

演示TreeSet对String是可排序的

TreeSet无法对自定义类型进行排序

比较规则怎么写

自平衡二叉树结构

实现比较器接口

Collections工具类

演示TreeSet对String是可排序的

1.TreeMap集合底层实际上是一个TreeMap2.TreeMap集合底层是一个二叉树3.放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了4.TreeSet集合中的元素，无序不可重复，但是可以按照元素的大小顺序自动排序称为：可排序集合例如：编写程序从数据库中取出数据，在页面展示用户信息的时候按照生日升序或者降序，这个时候可以使用TreeSet集合，因为TreeSet集合放进去，拿出来就是有序的。

//创建一个TreeSet集合

TreeSet ts=new TreeSet<>();

//添加String

ts.add("zhangsan");

ts.add("lisi");

ts.add("wangwu");

ts.add("zhangsi");

ts.add("wangliu");

for(String s:ts){

//按照字典顺序排序

System.out.print(s+" ");

}

TreeSet ts2=new TreeSet<>();

ts2.add(100);

ts2.add(200);

ts2.add(900);

ts2.add(800);

ts2.add(600);

ts2.add(10);

for(Integer i:ts2){

//按照升序排序

System.out.print(i+" ");

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

TreeSet无法对自定义类型进行排序

TreeSet可以对自定义类型进行排序？以下程序中，对于Person类来说，无法排序，因为没有指定Person对象之间的比较规则。谁大谁小并没有说明。

public class TreeSetTest02 {

public static void main(String[] args) {

Person p1=new Person(50);

Person p2=new Person(10);

Person p3=new Person(20);

Person p4=new Person(60);

Person p5=new Person(40);

Person p6=new Person(30);

TreeSet persons=new TreeSet<>();

persons.add(p1);

persons.add(p2);

persons.add(p3);

persons.add(p4);

persons.add(p5);

persons.add(p6);

for(Person p:persons){

System.out.println(p);

}

}

}

class Person{

int age;

public Person(int age){

this.age=age;

}

@Override

public String toString() {

return "Person [age=" + age + "]";

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

Exception in thread "main" java.lang.ClassCastException: testCollection.Person cannot be cast to java.lang.Comparable1

出现这个错误的原因是Person类没有实现java.lang,Comparable接口

//放在TreeSet集合中的元素需要实现java.lang.Comparable接口//并且实现compareTo方法，equals可以不写

public class TreeSetTest04 {

public static void main(String[] args) {

Customer p1=new Customer(50);

Customer p2=new Customer(10);

Customer p3=new Customer(20);

Customer p4=new Customer(60);

Customer p5=new Customer(40);

Customer p6=new Customer(30);

TreeSet customers=new TreeSet<>();

customers.add(p1);

customers.add(p2);

customers.add(p3);

customers.add(p4);

customers.add(p5);

customers.add(p6);

for(Customer p:customers){

System.out.println(p);

}

}

}

//放在TreeSet集合中的元素需要实现java.lang.Comparable接口

//并且实现compareTo方法，equals可以不写

class Customer implements Comparable{

int age;

public Customer(int age){

this.age=age;

}

@Override

public String toString() {

return "Customer [age=" + age + "]";

}

//需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较。

//k.compareTo(t.key)

//拿着参数k和集合中的每个k进行比较，返回值可能是>0,<0,=0

//比较规则最终还是程序员实现的：例如按照年龄升序，或者按照年龄降序

@Override

public int compareTo(Customer c) { //c1.compareTo(c2)

// TODO Auto-generated method stub

//this是c1

//c是c2

//c1和c2进行比较的时候，就是this和c比较

// int age1=this.age;

// int age2=c.age;

// if(age1==age2){

// return 0;

// }else if(age1>age2){

// return 1;

// }else{

// return -1;

// }

return this.age-c.age; //>,

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

//需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较。//k.compareTo(t.key)//拿着参数k和集合中的每个k进行比较，返回值可能是>0,<0,=0//比较规则最终还是程序员实现的：例如按照年龄升序，或者按照年龄降序

比较规则怎么写

先按照年龄升序，如果年龄一样的再按照姓名升序

public class TreeSetTest05 {

public static void main(String[] args) {

TreeSet vips=new TreeSet<>();

vips.add(new Vip("zhangsi",20));

vips.add(new Vip("zhangsan",20));

vips.add(new Vip("king",18));

vips.add(new Vip("soft",17));

for(Vip vip:vips){

System.out.println(vip);

}

}

}

class Vip implements Comparable{

String name;

int age;

public Vip(String name,int age){

this.name=name;

this.age=age;

}

@Override

public String toString() {

return "Vip [name=" + name + ", age=" + age + "]";

}

//compareTo方法的返回值很重要：

//返回0表示相同，value会覆盖

//>0,会继续在右子树上找

//<0，会继续在左子树上找

@Override

public int compareTo(Vip v) {

if(this.age==v.age){

//年龄相同时，按照名字排序

//姓名是String类型，可以直接比，调用compareTo方法

return this.name.compareTo(v.name);

}else{

//年龄不一样

return this.age-v.age;

}

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

自平衡二叉树结构

1.自平衡二叉树，遵循左小右大的原则存放2.遍历二叉树的时候有三种方式前序遍历：根左右中序遍历：左根右后序遍历：左右根注意：前中后说的是根的位置3.TreeSet集合和TreeMap集合采用的是中序遍历方式，即左根右。他们是自平衡二叉树100 200 50 60 80 120 140 130 135 180 666

实现比较器接口

TreeSet集合中元素可排序的第二种方式，使用比较器的方式

public class TreeSetTest06 {

public static void main(String[] args) {

//创建TreeSet集合的时候，需要使用比较器

//TreeSet wuGuis=new TreeSet<>(); //这样不行，没有通过构造方法传递一个比较器进去

TreeSet wuGuis=new TreeSet<>(new WuguiComparator());

wuGuis.add(new Wugui(1000));

wuGuis.add(new Wugui(800));

wuGuis.add(new Wugui(900));

wuGuis.add(new Wugui(300));

wuGuis.add(new Wugui(60));

for(Wugui wugui:wuGuis){

System.out.println(wugui);

}

}

}

class Wugui{

int age;

public Wugui(int age) {

super();

this.age = age;

}

@Override

public String toString() {

return "Wugui [age=" + age + "]";

}

}

//单独再这里编写一个比较器

//比较器实现java.util.Comparator接口(Comparable是java.lang包下的)

class WuguiComparator implements Comparator{

public int compare(Wugui o1,Wugui o2){

//指定比较规则

//按照年龄排序

return o1.age-o2.age;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

我们可以使用匿名内部类的方式可以使用匿名内部类的方式(这个类没有名字，直接new接口)

TreeSet wuGuis=new TreeSet<>(new Comparator(){

public int compare(Wugui o1,Wugui o2){

//指定比较规则

//按照年龄排序

return o1.age-o2.age;

}

});1

2

3

4

5

6

7

8

最终的结论，放在TreeSet或者TreeMap集合key部分的元素要想做到排序，包括两种方式第一种：放在集合中的元素实现java.lang.Comparable接口第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象。Comparable和Comparator怎么选择呢？当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用comparator接口comparator接口的设计符合OCP原则。

Collections工具类

java.util.Collections集合工具类，方便集合的操作

public class CollectionsTest {

static class Wugui2 implements Comparable{

int age;

public Wugui2(int age) {

super();

this.age = age;

}

@Override

public String toString() {

return "Wugui2 [age=" + age + "]";

}

@Override

public int compareTo(Wugui2 o) {

// TODO Auto-generated method stub

return this.age-o.age;

}

}

public static void main(String[] args) {

//ArrayList集合不是线程安全的

List list=new ArrayList();

//变成线程安全的

Collections.synchronizedList(list);

//排序

list.add("abc");

list.add("abe");

list.add("abd");

list.add("abf");

list.add("abn");

list.add("abm");

Collections.sort(list);

for(String s:list){

System.out.println(s);

}

List wuguis=new ArrayList<>();

wuguis.add(new Wugui2(1000));

wuguis.add(new Wugui2(8000));

wuguis.add(new Wugui2(4000));

wuguis.add(new Wugui2(6000));

//注意：对list集合中元素排序，需要保证list集合中元素实现了Comparable接口

Collections.sort(wuguis);

for(Wugui2 wugui:wuguis){

System.out.println(wugui);

}

//对set集合怎么排序呢

Set set=new HashSet<>();

set.add("king");

set.add("kingsoft");

set.add("king2");

set.add("king1");

//将set集合转换成list集合

List myList=new ArrayList<>(set);

Collections.sort(myList);

for(String s:myList){

System.out.println(s);

}

//这种方式也可以排序

//Collections.sort(list集合，比较器对象)

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62