Java 按开始和结束时间筛选带有日期的ArrayList

我正在实现一个简单的ListView，其中数据源是一个包含名称、开始日期和结束日期的ArrayList。在iOS中，我会使用一个简单的NSPredicate来过滤数组，但在Android和Java中，我不知道应该使用什么。欢迎任何建议。

您可以使用Date.before和Date.after方法。这些选项允许您筛选日期列表（针对特定范围内的日期（例如一月））：

a。使用带有开始日期和结束日期的Java8筛选器

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.stream.Collectors;

public class FilterStartAndEndDate {

    private SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
    private Collection<Date> dateList = null;
    private Date start = null;
    private Date end = null;

    private FilterStartAndEndDate() throws ParseException {
        dateList = new ArrayList<Date>() {{
            add(sdf.parse("01/01/2016"));
            add(sdf.parse("02/01/2016"));
            add(sdf.parse("03/02/2016"));
            add(sdf.parse("04/01/2016"));
            add(sdf.parse("05/01/2016"));
        }};

        start = sdf.parse("31/12/2015");
        end = sdf.parse("01/02/2016");
    }

    /**
     * Filter dates with Lambda
     *
     * @throws ParseException
     */
    private void getDatesBetweenStartAndFinishWithFilter() throws ParseException {
        dateList.stream()
                .filter(dates -> dates.after(start) && dates.before(end))
                .collect(Collectors.toList())
                .forEach(januaryDate->System.out.println(januaryDate));
    }

    /**
     * Filter dates with Iterator
     *
     * @throws ParseException
     */
    private void getDatesBetweenStartAndFinish() throws ParseException {
        Collection<Date> datesInJanuaryList = new ArrayList<>();

        for (Date eachDate : dateList) {
            if (eachDate.after(start) && eachDate.before(end)) {
                datesInJanuaryList.add(eachDate);
            }
        }

        for (Date eachDate : datesInJanuaryList) {
            System.out.println(eachDate);
        }
    }


    public static void main(String[] args) throws Exception {
        FilterStartAndEndDate datesInJanuary = new FilterStartAndEndDate();
        datesInJanuary.getDatesBetweenStartAndFinish();
        datesInJanuary.getDatesBetweenStartAndFinishWithFilter();
    }
}

b。使用Java循环/迭代器检查开始和结束日期

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.stream.Collectors;

public class FilterStartAndEndDate {

    private SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
    private Collection<Date> dateList = null;
    private Date start = null;
    private Date end = null;

    private FilterStartAndEndDate() throws ParseException {
        dateList = new ArrayList<Date>() {{
            add(sdf.parse("01/01/2016"));
            add(sdf.parse("02/01/2016"));
            add(sdf.parse("03/02/2016"));
            add(sdf.parse("04/01/2016"));
            add(sdf.parse("05/01/2016"));
        }};

        start = sdf.parse("31/12/2015");
        end = sdf.parse("01/02/2016");
    }

    /**
     * Filter dates with Lambda
     *
     * @throws ParseException
     */
    private void getDatesBetweenStartAndFinishWithFilter() throws ParseException {
        dateList.stream()
                .filter(dates -> dates.after(start) && dates.before(end))
                .collect(Collectors.toList())
                .forEach(januaryDate->System.out.println(januaryDate));
    }

    /**
     * Filter dates with Iterator
     *
     * @throws ParseException
     */
    private void getDatesBetweenStartAndFinish() throws ParseException {
        Collection<Date> datesInJanuaryList = new ArrayList<>();

        for (Date eachDate : dateList) {
            if (eachDate.after(start) && eachDate.before(end)) {
                datesInJanuaryList.add(eachDate);
            }
        }

        for (Date eachDate : datesInJanuaryList) {
            System.out.println(eachDate);
        }
    }


    public static void main(String[] args) throws Exception {
        FilterStartAndEndDate datesInJanuary = new FilterStartAndEndDate();
        datesInJanuary.getDatesBetweenStartAndFinish();
        datesInJanuary.getDatesBetweenStartAndFinishWithFilter();
    }
}

import java.text.ParseException；
导入java.text.simpleDataFormat；
导入java.util.ArrayList；
导入java.util.Collection；
导入java.util.Date；
导入java.util.stream.collector；
公共类筛选器开始和结束日期{
私有SimpleDataFormat sdf=新SimpleDataFormat（“dd/MM/yyyy”）；
私有收集日期列表=null；
私有日期开始=null；
私有日期结束=null；
私有筛选器StartAndEndDate（）引发ParseException{
dateList=newArrayList（）{{
添加（sdf.parse（“01/01/2016”）；
添加（sdf.parse（“2016年1月2日”）；
添加（sdf.parse（“2016年2月3日”）；
添加（sdf.parse（“2016年1月4日”）；
添加（sdf.parse（“05/01/2016”）；
}};
start=sdf.parse（“2015年12月31日”）；
end=sdf.parse（“01/02/2016”）；
}
/**
*用Lambda过滤日期
*
*@ParseException
*/
private void GetDatesBetween StartAndFinishWithFilter（）引发ParseException{
dateList.stream（）
.filter（日期->开始日期之后和结束日期之前）
.collect（收集器.toList（））
.forEach（一月一日->系统输出.println（一月一日））；
}
/**
*用迭代器过滤日期
*
*@ParseException
*/
private void GetDatesBetween StartAndFinish（）引发ParseException异常{
收集日期一月列表=新的ArrayList（）；
for（日期：日期列表）{
if（每个日期之后（开始）和每个日期之前（结束））{
日期1月1日添加（每个日期）；
}
}
日期（每个日期：datesInJanuaryList）{
系统输出打印LN（每个日期）；
}
}
公共静态void main（字符串[]args）引发异常{
FilterStartAndEndDate sinJanuary=新的FilterStartAndEndDate（）；
datesInJanuary.GetDatesBeween StartAndFinish（）；
datesInJanuary.GetDatesBeween Start and FinishWithFilter（）；
}
}

示例代码过滤器的日期为1月份，使用Lambda过滤器和Java迭代器。两者都使用Date before和after方法。

定义一个类 包含名称、开始日期和结束日期

定义一个类来保存事件名称、开始日期和停止日期

LocalDate

将现代java.time类用于日期时间值。该类表示一个仅限日期的值，不包含一天中的时间和时区。切勿使用

Date

、

Calendar

、

SimpleDateFormat

或其他可怕的旧日期时间类

class Event {
    String name;
    LocalDate start, stop;

    // Constructor
    public Event ( String name , LocalDate start , LocalDate stop ) {
        this.name = name;
        this.start = start;
        this.stop = stop;
    }

}

添加一个方法，将传递的

LocalDate

与开始日期和停止日期进行比较，如果包含在日期范围内，则返回true。通常最好使用半开放式方法进行比较，其中开始是包含的，而结束是独占的

建立这些事件的列表

List< Event > events = new ArrayList<>();
events.add( new Event( "alpha" , LocalDate.of( 2018 , Month.JANUARY , 23 ) , LocalDate.of( 2018 , Month.JANUARY , 28 ) ) );
events.add( new Event( "beta" , LocalDate.of( 2018 , Month.FEBRUARY , 23 ) , LocalDate.of( 2018 , Month.FEBRUARY , 28 ) ) );
events.add( new Event( "gamma" , LocalDate.of( 2018 , Month.MARCH , 23 ) , LocalDate.of( 2018 , Month.MARCH , 28 ) ) );

跑步的时候

[事件{name='beta'|开始=2018-02-23 |停止=2018-02-28}]

LocalDateRange

如果您想获得更多乐趣，请在项目中添加三个额外的库（如下所述）。使用其

LocalDateRange

类将停止-开始日期对显式表示为日期范围。该类已经包含了一个

contains

方法，因此无需编写自己的方法

package com.basilbourque.example;

import org.threeten.extra.LocalDateRange;

import java.time.LocalDate;
import java.time.Month;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class ListFilterExample {

    public static void main ( String[] args ) {
        ListFilterExample app = new ListFilterExample();
        app.doIt();
    }

    private void doIt () {
        List< Event > events = new ArrayList<>();
        events.add( new Event( "alpha" , LocalDate.of( 2018 , Month.JANUARY , 23 ) , LocalDate.of( 2018 , Month.JANUARY , 28 ) ) );
        events.add( new Event( "beta" , LocalDate.of( 2018 , Month.FEBRUARY , 23 ) , LocalDate.of( 2018 , Month.FEBRUARY , 28 ) ) );
        events.add( new Event( "gamma" , LocalDate.of( 2018 , Month.MARCH , 23 ) , LocalDate.of( 2018 , Month.MARCH , 28 ) ) );

        LocalDate target = LocalDate.of( 2018 , Month.FEBRUARY , 25 );
        // Lambda syntax, instead of for-each loop.
        List< Event > hits = events.stream().filter( event -> event.contains( target ) ).collect( Collectors.toList() );
        System.out.println( hits );
    }

    class Event {
        String name;
        LocalDateRange dateRange;

        public boolean contains ( LocalDate localDate ) {
            // Regarding the beginning date, a short way of saying2 "is equal to or is later than" is "is not before".
            boolean x = this.dateRange.contains( localDate );
            return x;
        }

        // Constructor
        public Event ( String name , LocalDate start , LocalDate stop ) {
            this.name = name;
            this.dateRange = LocalDateRange.of( start , stop );
        }

        @Override
        public String toString () {
            return "Event{ " +
                   "name='" + name + '\'' +
                   "| dateRange=" + dateRange +
                   " }";
        }
    }
}

package com.basilbourque.example；
导入org.threeten.extra.LocalDateRange；
导入java.time.LocalDate；
导入java.time.Month；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.stream.collector；
公共类ListFilterExample{
公共静态void main（字符串[]args）{
ListFilterExample应用程序=新建ListFilterExample（）；
app.doIt（）；
}
私有无效doIt（）{
Listevents=newarraylist（）；
添加事件（新事件（“alpha”，LocalDate.of（2018年1月23日），LocalDate.of（2018年1月28日））；
添加事件（新事件（“beta”，LocalDate.of（2018年2月23日），LocalDate.of（2018年2月28日））；
添加事件（新事件（“gamma”，LocalDate.of（2018年3月23日），LocalDate.of（2018年3月28日））；
LocalDate目标=LocalDate.of（2018年2月25日）；
//Lambda语法，而不是for each循环。
Listhits=events.stream（）.filter（Event->Event.contains（target））.collect（Collectors.toList（））；
系统输出打印项次（点击次数）；
}
班级活动{
字符串名；
LocalDateRange日期范围；
公共布尔包含（LocalDate LocalDate）{
//关于开始日期，简短的说法是“等于或晚于”is“is not before”。
布尔x=this.dateRange.contains（localDate）；
返回x；
}
//建造师
公共事件（字符串名称、LocalDate开始、LocalDate停止）{
this.name=名称；
this.dateRange=LocalDateRange.of（开始、停止）；
}
@凌驾
公共字符串toString（）{
返回“事件{”+
“name=”+name+“\”+
“| dateRange=“+dateRange+
" }";
}
}
}

[事件{name='beta'| dateRange=2018-02-23/2018-02-28}]

---

关于java.time 该框架内置于Java8及更高版本中。这些类取代了麻烦的旧日期时间类，例如，

LocalDate target = LocalDate.of( 2018 , Month.FEBRUARY , 25 );
List< Event > hits = 
    events
    .stream()
    .filter( event -> event.contains( target ) )
    .collect( Collectors.toList() )
;

package com.basilbourque.example;

import java.time.LocalDate;
import java.time.Month;
import java.util.ArrayList;
import java.util.List;

public class ListFilterExample {

    public static void main ( String[] args ) {
        ListFilterExample app = new ListFilterExample();
        app.doIt();
    }

    private void doIt () {
        List< Event > events = new ArrayList<>();
        events.add( new Event( "alpha" , LocalDate.of( 2018 , Month.JANUARY , 23 ) , LocalDate.of( 2018 , Month.JANUARY , 28 ) ) );
        events.add( new Event( "beta" , LocalDate.of( 2018 , Month.FEBRUARY , 23 ) , LocalDate.of( 2018 , Month.FEBRUARY , 28 ) ) );
        events.add( new Event( "gamma" , LocalDate.of( 2018 , Month.MARCH , 23 ) , LocalDate.of( 2018 , Month.MARCH , 28 ) ) );

        LocalDate target = LocalDate.of( 2018 , Month.FEBRUARY , 25 );
        List< Event > hits = new ArrayList<>( events.size() );
        for ( Event event : events ) {
            if ( event.contains( target ) ) {
                hits.add( event );
            }
        }
        System.out.println( hits );
    }

    class Event {
        String name;
        LocalDate start, stop;

        public boolean contains ( LocalDate localDate ) {
            // Regarding the beginning date, a short way of saying2 "is equal to or is later than" is "is not before".
            boolean x = ( ! localDate.isBefore( this.start ) ) && localDate.isBefore( this.stop );
            return x;
        }

        // Constructor
        public Event ( String name , LocalDate start , LocalDate stop ) {
            this.name = name;
            this.start = start;
            this.stop = stop;
        }

        @Override
        public String toString () {
            return "Event{ " +
                   "name='" + name + '\'' +
                   "| start=" + start +
                   "| stop=" + stop +
                   " }";
        }
    }
}

package com.basilbourque.example;

import org.threeten.extra.LocalDateRange;

import java.time.LocalDate;
import java.time.Month;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class ListFilterExample {

    public static void main ( String[] args ) {
        ListFilterExample app = new ListFilterExample();
        app.doIt();
    }

    private void doIt () {
        List< Event > events = new ArrayList<>();
        events.add( new Event( "alpha" , LocalDate.of( 2018 , Month.JANUARY , 23 ) , LocalDate.of( 2018 , Month.JANUARY , 28 ) ) );
        events.add( new Event( "beta" , LocalDate.of( 2018 , Month.FEBRUARY , 23 ) , LocalDate.of( 2018 , Month.FEBRUARY , 28 ) ) );
        events.add( new Event( "gamma" , LocalDate.of( 2018 , Month.MARCH , 23 ) , LocalDate.of( 2018 , Month.MARCH , 28 ) ) );

        LocalDate target = LocalDate.of( 2018 , Month.FEBRUARY , 25 );
        // Lambda syntax, instead of for-each loop.
        List< Event > hits = events.stream().filter( event -> event.contains( target ) ).collect( Collectors.toList() );
        System.out.println( hits );
    }

    class Event {
        String name;
        LocalDateRange dateRange;

        public boolean contains ( LocalDate localDate ) {
            // Regarding the beginning date, a short way of saying2 "is equal to or is later than" is "is not before".
            boolean x = this.dateRange.contains( localDate );
            return x;
        }

        // Constructor
        public Event ( String name , LocalDate start , LocalDate stop ) {
            this.name = name;
            this.dateRange = LocalDateRange.of( start , stop );
        }

        @Override
        public String toString () {
            return "Event{ " +
                   "name='" + name + '\'' +
                   "| dateRange=" + dateRange +
                   " }";
        }
    }
}