I'm writing a set of objects that should be able to alter fields in a Joda Time MutableDateTime instance.
Each object is applied in sequence to the buffer, and when all that set is applied, a complete valid MutableDateTime will be built.
Each instance have to be able to know which date time fields has already been set by other instances in the set.
I get stucked because I get following problems:
How to create the MutableDateTime instance with empty values in all
date time fields in order to use it as the initial value to build?
How could I know if some field of MutableDateTime has been set?
MutableDateTime internally keep track it's data in a long instance field initialized to number of milliseconds elapsed from start of era to now. It thus has all field already set to some value.
Do you know if MutableDateTime has some concept of an empty value?
Edit:
as I show in my response, I develop a solution using a manager class as Vladimir suggested.
You should create "Manager" class to remember fields which was already set. It should throw exception if user tries to retrieve instance of MutableDateTime before all fields was set.
And if you always set all fields for MutableDateTime then [1] is not important (values will be overwriten).
I finally changed my initial design, and I implemented it exactly as Vadim Ponomarev suggested. Since each field type in Joda buffer has a corresponding DateTimeFieldType instance, I use a private Set object to keep track of the fields present.
The code below show how I've done:
private final Set<DateTimeFieldType> fieldTypes = Sets.newHashSet();
/**
* Allow to set to or reset one of the DateTimeFieldType fields
* #param fieldType the DateTimeFieldType field to change
* #param value the value to set it
*/
public void changeField(DateTimeFieldType fieldType, boolean value) {
if (value)
fieldTypes.add(fieldType);
else
fieldTypes.remove(fieldType);
}
/**
* Check if one of the DateTimeFieldType is present in this set.
* #param fieldType The field type to check for presence.
* #return true if the DateTimeFieldType is present, otherwise false
*/
public boolean isFieldSet(DateTimeFieldType fieldType) {
return !fieldTypes.contains(fieldType);
}
I've also added some utility methods allowing to change all fields for the date and all fields for the time at once. This could be useful in client to code to easy a common operation on date field sets.
/**
* Allow to set the fields that build the time part
* of a date time
* <p/>
*
* #param value value to set the DateTime fields
*/
public void changeTimeFields(boolean value) {
changeField(DateTimeFieldType.hourOfDay(), value);
changeField(DateTimeFieldType.minuteOfHour(), value);
}
/**
* Allow to set the fields that build the date part
* of a date time
* <p/>
*
* #param value value to set the DateTime fields
*/
public void changeDateFields(boolean value) {
changeField(DateTimeFieldType.dayOfMonth(), value);
changeField(DateTimeFieldType.monthOfYear(), value);
changeField(DateTimeFieldType.yearOfEra(), value);
}
And finally, I also added some method to query if all date fields are set and if all time fields are set:
/**
* Allow to check if the DateTimeFieldType fields that build the
* date part of a datetime has been set in this instance.
* <p/>
*
* #return true if date part has yet to be applied to
* the instance, false otherwise
*/
public boolean isDateSet() {
return fieldTypes.contains(DateTimeFieldType.dayOfMonth()) &&
fieldTypes.contains(DateTimeFieldType.monthOfYear()) &&
fieldTypes.contains(DateTimeFieldType.yearOfEra());
}
/**
* Allow to check if the DateTimeFieldType fields that build the
* time part of a datetime has been set in this instance.
* <p/>
*
* #return true if time part has yet to be applied to
* the instance, false otherwise
*/
public boolean isTimeSet() {
return fieldTypes.contains(DateTimeFieldType.minuteOfHour()) &&
fieldTypes.contains(DateTimeFieldType.hourOfDay());
}
I finally made it a DateTimeFieldTypeSet class. I think it encapsulate well a common concept that is lacking in Joda classes. I hope it can be useful to some one else too.
Related
Each time you use String.format(), a new instance of java.util.Formatter is created that will be disposed afterwards.
Just because I was curious, I played around with that a bit to make the use of format() a little more efficient, by caching the Formatter object. Unfortunately, Formatter is not thread-safe, and any means of synchronisation would eat up any performance gain you can get from caching it.
Finally, I found the solution below:
import java.util.Formatter;
/*------------------------*\
====** Static Initialisations **===========================================
\*------------------------*/
/**
* The initial buffer size that is used by
* {#link #format(String, Object...)}
* and
* {#link #format(Locale, String, Object...)}
* (per thread): {#value}.
*/
public final static int FORMAT_INITIAL_BUFFERSIZE = 2048;
/**
* The cached
* {#link Formatter}
* instance.
*/
private static final ThreadLocal<Formatter> m_Formatter;
static
{
//---* The cached Formatter instance *---------------------------------
final Supplier<Formatter> initializer = () -> new Formatter( new StringBuilder( FORMAT_INITIAL_BUFFERSIZE ), Locale.getDefault( Locale.Category.FORMAT ) );
m_Formatter = ThreadLocal.<Formatter>withInitial( initializer );
}
/*---------*\
====** Methods **==========================================================
\*---------*/
/**
* Returns a formatted String using the specified
* {#link Locale},
* format String, and arguments.<br>
* <br>This method is meant as a replacement for the method
* {#link java.lang.String#format(String, Object...)};
* that implementation always uses a new instance of
* {#link Formatter}
* for each invocation. The implementation here uses a cached instance
* instead, and as {#code Formatter} is not inherently thread-safe, this
* cached instance is created and stored per thread, therefore no
* synchronisation is needed.<br>
* <br>The performance gain for this implementation is not that impressive
* when compared with that of
* {#link #format(String, Object...)},
* but still in the 10% range.
* {#code java.lang.String.format()}.
*
* #param locale The
* {#link Locale}
* that will be applied during formatting. If {#code locale} is
* {#code null} then no localisation is applied.
* #param format A format String with the syntax as described for the
* {#link Formatter}
* class.
* #param args The arguments referenced by the format specifiers in
* the {#code format} String. If there are more arguments than format
* specifiers, the extra arguments are ignored. The number of
* arguments is variable and may be zero. The maximum number of
* arguments is limited by the maximum dimension of a Java array as
* defined by <cite>The Java™ Virtual Machine
* Specification</cite>. The behaviour on a {#code null} argument
* depends on the conversion.
* #throws IllegalFormatException A format string contains an illegal
* syntax, a format specifier that is incompatible with the given
* arguments, insufficient arguments given the format string, or other
* illegal conditions occurred. For specification of all possible
* formatting errors, see the "Details" section of the
* {#code Formatter} class specification.
* #return A formatted String.
*
* #see java.util.Formatter
*/
#SuppressWarnings( "resource" )
public final static String format( final Locale locale, final String format, final Object... args ) throws IllegalFormatException
{
/*
* When this method StringUtils.format() is used inside an
* implementation of Formattable.formatTo() that in turn was called by
* this method already, the internal out buffer of the formatter
* contains already some text that has to be preserved.
*
* Therefore the current length of the out buffer is kept before new
* contents is added by the call to formatter.format(), and reset after
* the new formatted text was retrieved from that buffer.
*/
final var formatter = m_Formatter.get();
final var result = (StringBuilder) formatter.out();
final var currentPos = result.length();
formatter.format( locale, format, args );
final var retValue = result.substring( currentPos );
result.setLength( currentPos );
//---* Done *----------------------------------------------------------
return retValue;
} // format()
The cached Formatter instance is hold in an instance of java.lang.ThreadLocal, so each Thread has its own instance and no synchronisation is required.
So far it is working; extensive tests did not show any problems so far, and some (artificial) benchmarks show a performance gain of about 10% compared to the use of java.lang.String.format(); that gain is constant on any (class of) machine I ran the tests on.
An obvious disadvantage of this solution is that the memory footprint for each thread that uses my format() implementation is increased by around half a kB plus the size of the initial buffer (see the source).
But I can faintly remember some statements that using java.lang.ThreadLocal is evil, although I cannot remember any reason why … basically, you can boil it down to "there are rumours …".
Or not? Is there something that I missed about the use of java.util.ThreadLocal in the way I did?
Please do not discuss whether replacing String.format() with my solution might be useful or not: I just did it – as said – because I was curious whether it could made faster by caching the Formatter instance – nothing else.
Edit (based on some of the comments that have been added to the question):
That the Formatter instance will never be removed from the Thread is intended. But there is no need to keep the size of the associated StringBuilder at its current size when it was extended above the initial size.
There is an issue with ThreadLocal in the context of 'managed environments' (Application Servers and Web Servers) because there Threads are re-used, and therefore, the data stored in the ThreadLocal will never be garbage collected, as the ThreadLocal will never be released.
I'm not trying to format the date in YYYY-MM-DD or dd/MM/YYYY. I'm asking about the literal format of LocalDate.
I just started learning Java and I am using this IDE called BlueJ. and I want to create a test method.
The screenshot will show what I am trying to do
Now since from the constructor we know that it requires a int, LocalDate and a double. I've searched online and found that
https://www.javabrahman.com/java-8/java-8-working-with-localdate-localtime-localdatetime-tutorial-with-examples/
java.time.LocalDate: A LocalDate instance holds a date without a time
zone, in ISO-86011 calendar system. LocalDate has the default format
‘YYYY-MM-DD’ as in ‘2016-12-12’.
So I would put a normal number in 10001 for the testID and double would be something like 50.5
I also know that for it to register a string (if it was needed) I would need to enclose it within "string"
But I've tried all sorts of way to put in the date and I would be left with an error
2018-05-30,30-05-2018,30/05/2018 would give me
Error: incompatible types: Int cannot be converted to java.time.LocalDate
"30/05/2018" on the other hand would give me
Error: Incompatible types: java.lang.String cannot be converted to java.time.LocalDate
If I try 30.05.2018 it would say
Error: ';' expected
If I try '2018-05-30' it would say
Error: unclosed character literal
I ran out of ways to try it. So if you could tell me how I should put it in there, that would be great.
I just really need to know how BlueJ wants me to input it. Cause the resources for BlueJ is so sparse online.
Code:
import java.time.LocalDate;
import java.util.ArrayList;
/**
* Write a description of class TestPaper here.
*
* #author (your name)
* #version (a version number or a date)
*/
public class TestPaper
{
// instance variables - replace the example below with your own
private int testID;
private LocalDate testDate;
private double testMarks;
private ArrayList<MCQ> MCQDetails;
/**
* Constructor for objects of class TestPaper
*/
public TestPaper(int testID, LocalDate testDate, double testMarks)
{
this.testID = testID;
this.testDate = testDate;
this.testMarks = testMarks;
MCQDetails = new ArrayList<MCQ>() ;
}
/**
* Accessor Method getTestID to get the testID
*
* #return int value of the choice ID
*/
public int getTestID(){
return testID;
}
/**
* Mutator Method to set the testID
*
* #param int format of the testID to set
*/
public void setTestID(int testID){
this.testID = testID;
}
/**
* Accessor Method getTestMarks to get the Test Marks
*
* #return double value of the test marks
*/
public double getTestMarks(){
return testMarks;
}
/**
* Mutator Method to set the testMarks
*
* #param String format of the choice Description to be set
*/
public void setTestMarks(double testMarks){
this.testMarks = testMarks;
}
/**
* Accessor Method getTestDate to get the testDate
*
* #return LocalDate value of the testDate
*/
public LocalDate getTestDate(){
return testDate;
}
/**
* Mutator Method to set the testDate
*
* #param LocalDate format of the testDate to set
*/
public void setTestDate(LocalDate testDate){
this.testDate = testDate;
}
/**
* Method addMCQ will allow users to add a MCQ Object to the list of MCQ
*
* #param addMCQ a MCQ Object
* #return boolean will return true if it is successfully added or false if not
*/
public boolean addMCQ(MCQ MCQName)
{
return MCQDetails.add(MCQName);
}
/**
* Method removeMCQ to remove an MCQ object from the Arraylist
*
* #param MCQName A parameter of type MCQ
*/
public void removeMCQ(MCQ MCQName)
{
MCQDetails.remove(MCQName);
}
/**
* Method listMCQ to return a list of MCQ arraylist
*
* #return The return value of MCQDetails (MCQ Arraylist)
*/
public ArrayList<MCQ> listMCQ()
{
return MCQDetails;
}
public MCQ findMCQ(int MCQID)
{
for(MCQ m : MCQDetails)
{
if(m.getQuestionID() == MCQID)
{
return m;
}
}
return null;
}
Include package
As discussed in the comments, the solution is to add the code that creates the LocaDate, but bluej needs the fully qualified class name with the package prefix “java.time.”:
java.time.LocalDate.of(2018, 5, 30)
Not sure why it doesn't work with just LocalDate.of(...) (even with the class correclty imported), but at least this works.
Just another detail: a date has no format. Classes like LocalDate just holds values (in this case, it has year, month and day values), but a date itself has no format at all. The same date can be represented in many different formats: May 30th 2018, 2018-05-30, 30/05/18 are different formats, but all represent the same date. A date object just holds the values, and you can choose whatever format you want to represent it.
When you print a LocalDate, it implicity calls toString(), which by default chooses yyyy-MM-dd format, which is a ISO 8601 format, but as I said, that's just one of the many possible ways to format a date (although the value always stays the same). Telling that "a date has a format" is wrong and misleading.
Try converting the LocalDate in the call, such as:
TestPaper (2018-05-30, LocalDate.parse("2018/05/30"), 30/05/2018);
There are other static methods within LocalDate you can use. See here for more examples.
From your comment above, don't forget your import:
import java.time.LocalDate;
I'm not trying to format the date in YYYY-MM-DD or dd/MM/YYYY. I'm asking about the literal format of LocalDate.
I just started learning Java and I am using this IDE called BlueJ. and I want to create a test method.
The screenshot will show what I am trying to do
Now since from the constructor we know that it requires a int, LocalDate and a double. I've searched online and found that
https://www.javabrahman.com/java-8/java-8-working-with-localdate-localtime-localdatetime-tutorial-with-examples/
java.time.LocalDate: A LocalDate instance holds a date without a time
zone, in ISO-86011 calendar system. LocalDate has the default format
‘YYYY-MM-DD’ as in ‘2016-12-12’.
So I would put a normal number in 10001 for the testID and double would be something like 50.5
I also know that for it to register a string (if it was needed) I would need to enclose it within "string"
But I've tried all sorts of way to put in the date and I would be left with an error
2018-05-30,30-05-2018,30/05/2018 would give me
Error: incompatible types: Int cannot be converted to java.time.LocalDate
"30/05/2018" on the other hand would give me
Error: Incompatible types: java.lang.String cannot be converted to java.time.LocalDate
If I try 30.05.2018 it would say
Error: ';' expected
If I try '2018-05-30' it would say
Error: unclosed character literal
I ran out of ways to try it. So if you could tell me how I should put it in there, that would be great.
I just really need to know how BlueJ wants me to input it. Cause the resources for BlueJ is so sparse online.
Code:
import java.time.LocalDate;
import java.util.ArrayList;
/**
* Write a description of class TestPaper here.
*
* #author (your name)
* #version (a version number or a date)
*/
public class TestPaper
{
// instance variables - replace the example below with your own
private int testID;
private LocalDate testDate;
private double testMarks;
private ArrayList<MCQ> MCQDetails;
/**
* Constructor for objects of class TestPaper
*/
public TestPaper(int testID, LocalDate testDate, double testMarks)
{
this.testID = testID;
this.testDate = testDate;
this.testMarks = testMarks;
MCQDetails = new ArrayList<MCQ>() ;
}
/**
* Accessor Method getTestID to get the testID
*
* #return int value of the choice ID
*/
public int getTestID(){
return testID;
}
/**
* Mutator Method to set the testID
*
* #param int format of the testID to set
*/
public void setTestID(int testID){
this.testID = testID;
}
/**
* Accessor Method getTestMarks to get the Test Marks
*
* #return double value of the test marks
*/
public double getTestMarks(){
return testMarks;
}
/**
* Mutator Method to set the testMarks
*
* #param String format of the choice Description to be set
*/
public void setTestMarks(double testMarks){
this.testMarks = testMarks;
}
/**
* Accessor Method getTestDate to get the testDate
*
* #return LocalDate value of the testDate
*/
public LocalDate getTestDate(){
return testDate;
}
/**
* Mutator Method to set the testDate
*
* #param LocalDate format of the testDate to set
*/
public void setTestDate(LocalDate testDate){
this.testDate = testDate;
}
/**
* Method addMCQ will allow users to add a MCQ Object to the list of MCQ
*
* #param addMCQ a MCQ Object
* #return boolean will return true if it is successfully added or false if not
*/
public boolean addMCQ(MCQ MCQName)
{
return MCQDetails.add(MCQName);
}
/**
* Method removeMCQ to remove an MCQ object from the Arraylist
*
* #param MCQName A parameter of type MCQ
*/
public void removeMCQ(MCQ MCQName)
{
MCQDetails.remove(MCQName);
}
/**
* Method listMCQ to return a list of MCQ arraylist
*
* #return The return value of MCQDetails (MCQ Arraylist)
*/
public ArrayList<MCQ> listMCQ()
{
return MCQDetails;
}
public MCQ findMCQ(int MCQID)
{
for(MCQ m : MCQDetails)
{
if(m.getQuestionID() == MCQID)
{
return m;
}
}
return null;
}
Include package
As discussed in the comments, the solution is to add the code that creates the LocaDate, but bluej needs the fully qualified class name with the package prefix “java.time.”:
java.time.LocalDate.of(2018, 5, 30)
Not sure why it doesn't work with just LocalDate.of(...) (even with the class correclty imported), but at least this works.
Just another detail: a date has no format. Classes like LocalDate just holds values (in this case, it has year, month and day values), but a date itself has no format at all. The same date can be represented in many different formats: May 30th 2018, 2018-05-30, 30/05/18 are different formats, but all represent the same date. A date object just holds the values, and you can choose whatever format you want to represent it.
When you print a LocalDate, it implicity calls toString(), which by default chooses yyyy-MM-dd format, which is a ISO 8601 format, but as I said, that's just one of the many possible ways to format a date (although the value always stays the same). Telling that "a date has a format" is wrong and misleading.
Try converting the LocalDate in the call, such as:
TestPaper (2018-05-30, LocalDate.parse("2018/05/30"), 30/05/2018);
There are other static methods within LocalDate you can use. See here for more examples.
From your comment above, don't forget your import:
import java.time.LocalDate;
Say I have something like this:
public class MyClass {
private static MyClass sInstance;
/**
*
* #return The {#link MyClass} application instance.
*/
public static MyClass getInstance() {
return sInstance;
}
}
IntelliJ gives me this warning:
'#link' pointing to containing class is unnecessary
What's the proper/conventional way to write this piece of Javadoc?
How would you write it?
In the JDK, they use {#code}. That does not make a clickable link, but you are already looking at the page that would be linked anyway.
For example (from String.java):
/**
* Initializes a newly created {#code String} object so that it represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {#code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
*
* #param original
* A {#code String}
*/
You only get the warning because the link won't go anywhere. Just change it to {#code MyClass} to keep the formatting but without the link.
Here are some example getInstance() methods from the JDK.
java.text.Collator:
/**
* Gets the Collator for the current default locale.
* The default locale is determined by java.util.Locale.getDefault.
* #return the Collator for the default locale.(for example, en_US)
* #see java.util.Locale#getDefault
*/
public static synchronized Collator getInstance() {
java.text.NumberFormat:
/**
* Returns a general-purpose number format for the current default
* {#link java.util.Locale.Category#FORMAT FORMAT} locale.
* This is the same as calling
* {#link #getNumberInstance() getNumberInstance()}.
*
* #return the {#code NumberFormat} instance for general-purpose number
* formatting
*/
public final static NumberFormat getInstance() {
Why method firePropertyChange (String propertyName, Object oldValue, Object newValue) in class PropertyChangeSupport don't check that old and new value can be null at the same time?
PropertyChangeEvent javadoc may give some clue about it:
Null values may be provided for the old and the new values if their
true values are not known.
An event source may send a null object as the name to indicate that an
arbitrary set of if its properties have changed. In this case the old
and new values should also be null.
So it looks like having oldValue==null and newValue==null can have some special meaning when source==null as well. Because of this is may want to always propagate the change when both values are nulls even though they are the same.
I am not sure what do you mean, but here is actual code that is definitelly more clean than me trying to explain it :)
/**
* Reports a bound property update to listeners
* that have been registered to track updates of
* all properties or a property with the specified name.
* <p>
* No event is fired if old and new values are equal and non-null.
* <p>
* This is merely a convenience wrapper around the more general
* {#link #firePropertyChange(PropertyChangeEvent)} method.
*
* #param propertyName the programmatic name of the property that was changed
* #param oldValue the old value of the property
* #param newValue the new value of the property
*/
public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
if (oldValue == null || newValue == null || !oldValue.equals(newValue)) {
firePropertyChange(new PropertyChangeEvent(this.source, propertyName, oldValue, newValue));
}
}