Javaheima10

Java

LinkedHashSet集合

实现类

有序,不重复,无索引
这里的有序是指保证存储和取出的元素顺序一致
原理:底层数据结构是依然哈希表,只是每个元素又额外的多了一个双链表的机制记录存储的顺序

TreeSet集合

不重复,无索引,可排序
可排序:按照元素的大小默认升序(有大到小)排序
TreeSet集合底层是基于红黑树的数据结构实现排序的,增删改查性能都较好
***注意:TreeSet集合是一定要排序的,可以将元素按照指定的规则进行排序

TreeSet集合默认的规则

对于数值类型:Integer,Double,官方默认按照大小进行升序排序.
对于字符串类型:默认按照首字符的编号升序排序
对于自定义类型如Student对象,TreeSet无法直接排序

*** 结论:想要使用TreeSet存储自定义类型,需要制定排序规则***

自定义排序规则

TreeSet集合存储对象的时候有两种方式可以设计自定义比较规则

方法一

让自定义的类(如学生类)实现Comparable接口里面的compareTo方法**来定制比较规则

public class Apple implements 	Comparable<Apple>{
    @Override
    public int compareTo(Apple o) {
        //从大到小排序,回去掉重量一样的苹果,不管其它元素是否相同
        //return  o.weight-this.weight;
        //从小到大排序,根据三目运算符,这样会保留重量一样的苹果
        return  o.weight-this.weight>=0 ? 1 : -1;
    }
}

方法二

TreeSet集合有参构造器,可以设置Comparator接口对应的比较对象,来定制规则

Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
//                return o1.getWeight() - o2.getWeight();
                //注意:浮点型建议直接使用Double.compare()方法进行比较
//                return Double.compare(o1.getPrice(),o2.getPrice());//升序
                return Double.compare(o2.getPrice(),o1.getPrice());//降序
            }
        });

简化写法

Set<Apple> apples = new TreeSet<>((o1, o2) -> Double.compare(o2.getPrice(),o1.getPrice()));

返回值规则
- 如果认为第一个元素大于第二个元素返回正整数即可
- 如果认为第一个元素小于第二个元素返回负整数即可
- 如果认为第一个等于第二个元素返回0即可,此时TreeSet集合只会保留一个元素,认为两者重复

注意:如果TreeSet集合存储的对象有实现比较规则,集合也自带比较器,默认使用集合自带的比较器排序

price 价格

weight 重量

buy 买

sell 卖

全部代码苹果类和实现类

package com.yu.Day0522Demo;

import java.util.TreeSet;

public class Apple implements Comparable<Apple>{
    private String name;
    private String color;
    private double price;//价格
    private int weight;//重量

    public Apple(String name, String color, double price, int weight) {
        this.name = name;
        this.color = color;
        this.price = price;
        this.weight = weight;
    }

    @Override
    public int compareTo(Apple o) {
        //从大到小排序,回去掉重量一样的苹果,不管其它元素是否相同
        //return  o.weight-this.weight;
        //从小到大排序,根据三目运算符,这样会保留重量一样的苹果
        return  o.weight-this.weight>=0 ? 1 : -1;
    }

    public Apple() {
    }

    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                ", weight=" + weight +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

package com.yu.Day0522Demo;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class SellApple {
    public static void main(String[] args) {
//        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
//            @Override
//            public int compare(Apple o1, Apple o2) {
////                return o1.getWeight() - o2.getWeight();
//                //注意:浮点型建议直接使用Double.compare()方法进行比较
////                return Double.compare(o1.getPrice(),o2.getPrice());//升序
//                return Double.compare(o2.getPrice(),o1.getPrice());//降序
//            }
//        });
        Set<Apple> apples = new TreeSet<>((o1, o2) -> Double.compare(o2.getPrice(),o1.getPrice()));
        apples.add(new Apple("红富士","红",9.9,500));
        apples.add(new Apple("红富士二代","红",9.9,500));
        apples.add(new Apple("冰糖心","黄",19.9,499));
        apples.add(new Apple("绿苹果","绿",29.9,450));
        System.out.println(apples);
    }
}

Collcetion体系的特点,使用场景总结

如果希望元素可以重复,又有索引,索引查询要快?
- 用ArrayList集合,基于数组的.(用的最多)
如果希望元素可以重复,又有索引,增删首位操作快?
- 用LinkedList集合,基于链表的.
如果希望增删改查都很快,但是元素不重复无序,无索引?
- 用HashSet集合,基于哈希表的
如果希望增删改查都有很快,但是元素不重复,有序,无索引?
- 用LinkedHashSet集合,基于哈希表和双链表
如果对对象进行排序
- 用TreeSet集合,基于红黑树.后续也可以使用List集合实现排序

可变参数

可变参数在形参中可以接收多个数据
可变参数的格式: 数据类型...参数名称

作用

传输参数非常灵活,方便.可以不传输参数,可以传输1个或者多个,也可以传输一个数组
可变参数在方法内部本质上就是一个数组

注意事项

1. 一个形参列表中可变参数只能有一个
2. 可变参数必须在形参列表的最后面

package com.yu.Day0522Demo;

public class changeparameter {
    public static void main(String[] args) {
        //二进制0b开头,八进制0开头,直接输入的是十进制,0x开头十六进制
        System.out.println(changeSum(0b11,011,11,0x11));
    }
    public static int changeSum(int...a){
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            sum+=a[i];
        }
        return sum;
    }
}

集合工具类Collections

java.utils.Collections:是集合工具类
**作用:Collections并不属于集合,是用来操作集合的工具类

Collections常用API

方法名称	说明
public static boolean addAll(Collection<? super T>c,T...elements)	给集合对象批量添加元素
public static void shuffle(List<?> list)	打乱List集合元素的顺序

package com.yu.Day0522Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo01 {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
//        names.add("yu");
//        names.add("xiao");
//        names.add("yu");
//        names.add("zhen");
//        names.add("shuai");
        //调用Collections方法,简化代码
        Collections.addAll(names,"yu","xiao","yu","zhen","shuai");
        System.out.println(names);
        //打乱List集合顺序
        Collections.shuffle(names);
        System.out.println(names);
    }
}

Collections 排序相关API

使用范围

排序方式一:

方法名称	说明
public static void sort(List list)	将集合中元素按照默认规则排序

注意:本方式不可以直接对自定义类型的List集合排序,除非自定义类型实现了比较规则Comparable接口

排序方式二

方法名称	说明
public static void sort(List list,Comparator<? super T> c)	将集合中元素按照指定规则排序

package com.yu.Day0522Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsSort {
    public static void main(String[] args) {
        List<Apple> apples = new ArrayList<>();
        apples.add(new Apple("冰糖心","黄",19.9,499));
        apples.add(new Apple("绿苹果","绿",29.9,450));
        apples.add(new Apple("红富士","红",9.9,500));
        apples.add(new Apple("红富士二代","红",9.9,500));
        System.out.println(apples);
//        //调用的是Comparable接口的compareTo方法
//        Collections.sort(apples);
//        System.out.println(apples);
        //根据价格排序
//        Collections.sort(apples, new Comparator<Apple>() {
//            @Override
//            public int compare(Apple o1, Apple o2) {
//                return Double.compare(o1.getPrice(), o2.getPrice()) ;
//            }
//        });
        //简化
        Collections.sort(apples,( o1,  o2) ->Double.compare(o1.getPrice(), o2.getPrice()));
        System.out.println(apples);
    }
}

posted on 2022-05-22 19:33 yulll 阅读(31) 评论(0) 收藏举报

刷新页面返回顶部