How to print year sign in DateTimeFormatter when the count of letters is four?

From DateTimeFormatter javadoc:

> If the count of letters is less than four (but not two), then the sign
> is only output for negative years as per SignStyle.NORMAL. Otherwise,
> the sign is output if the pad width is exceeded, as per
> SignStyle.EXCEEDS_PAD.

From what I understand, if the pad width is not exceeded and the count of letters is four, the minus sign (for negative years) should not be printed during formatting.

So I wrote such a snippet of code (figuring that I cannot use 'y' because then the year will always be positive):

    var negativeDate = LocalDate.now().minus(2021, ChronoUnit.YEARS);
    var formatter = DateTimeFormatter.ofPattern("ppppuuuu");
    var text = negativeDate.format(formatter);
    System.out.println("formatted string: " + text);

This code throws DateTimeException: "Cannot print as output of 5 characters exceeds pad width of 4".

So my question is basically how to see this last sentence from the javadoc work.

The Otherwise in the sentence you are asking about refers to the situation where the count of letters is 4 or greater. Confusingly the pad width here has nothing to do with pattern letter p for padding. It refers to the number of digits to be printed. It refers back to the first sentence of the paragraph, The count of letters determines the minimum field width below which padding is used.

So to see that work, use 4 or more pattern letters and use a year that takes a greater number of digits than the number of pattern letters. It works with both u, y and Y.

	DateTimeFormatter uuuu = DateTimeFormatter.ofPattern("uuuu");
	DateTimeFormatter yyyy = DateTimeFormatter.ofPattern("yyyy");
	DateTimeFormatter uppercaseYyyy = DateTimeFormatter.ofPattern("YYYY");
	
	LocalDate ld = LocalDate.of(12345, Month.OCTOBER, 23);
	
	System.out.println(ld.format(uuuu));
	System.out.println(ld.format(yyyy));
	System.out.println(ld.format(uppercaseYyyy));

Output:

> +12345
> +12345
> +12345

The minus sign is printed regardless of the number of characters to be printed. The documentation of SignStyle.EXCEEDS_PAD says:

> … A negative value will always output the '-' sign.

Documentation link: SignStyle.EXCEEDS_PAD

> If the count of letters is less than four (but not two), then the sign
> is only output for negative years as per SignStyle.NORMAL.

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;

public class Main {
	public static void main(String[] args) {
		var negativeDate = LocalDate.now().minus(2021, ChronoUnit.YEARS);
		var formatter1 = DateTimeFormatter.ofPattern("ppuu");
		var formatter2 = DateTimeFormatter.ofPattern("ppu");
		var text1 = negativeDate.format(formatter1);
		var text2 = negativeDate.format(formatter2);
		System.out.println("formatted string: year" + text1);
		System.out.println("formatted string: year" + text2);
	}
}

Output:

formatted string: year01
formatted string: year-1

I have used uu (count of letters as two) in formatter1 and therefore it does not show a negative sign. However, if the count of letters is is less than four, but not two, you need to provide enough padding e.g. for the year, -1, you need padding of at least 2 (i.e. pp), one for the - sign and one for 1. If you provide less number of padding, you will get DateTimeException and if you provide more than 2 padding, you will get space before -1.

Thus, in case of the format uuuu, you need a padding of at least 5 (i.e. ppppp) for a negative year, one for - and 4 for years (0001) i.e. you need to use DateTimeFormatter.ofPattern("pppppuuuu") to avoid DateTimeException.

This pattern "ppppuuuu" defines padWidth of 4 applied to the following format uuuu, which applies SignStyle.EXCEEDS_PAD (according to javadoc for DateTimeFormatBuilder).

That is, the - is always printed due to current SignStyle.

Thus, when the formatter tries to print a negative year, it uses 4 digits and a sign thus exceeding the available padWidth.

Similarly, the sign is always printed when using u or uuu patterns because SignStyle.NORMAL is applied in these cases.

So, the sign won't be printed only when uu format is used.

To avoid the exception for a negative number, the padding should exceed the number of digits, for example, "ppppu" or "pppppuuuu".

var onlyU = DateTimeFormatter.ofPattern("uuuu");
var padded = DateTimeFormatter.ofPattern("ppppu");
var padded5 = DateTimeFormatter.ofPattern("pppppuuuu");

for (LocalDate d = LocalDate.now().minus(2421, ChronoUnit.YEARS); d.getYear() < 2200; d = d.plus(400, ChronoUnit.YEARS)) {

    try {
        var uuuu  = d.format(onlyU);
        var ppppu = d.format(padded);
        var pppppuuuu = d.format(padded5);

        System.out.printf("formatted year=%5d\tuuuu=[%s] \tppppu=[%s]\tpppppuuuu=[%s]%n", d.getYear(), uuuu, ppppu, pppppuuuu);

    } catch (DateTimeException e) {
        System.out.println("error: " + e);  
    }
}

Output:

formatted year= -401	uuuu=[-0401] 	ppppu=[-401]	pppppuuuu=[-0401]
formatted year=   -1	uuuu=[-0001] 	ppppu=[  -1]	pppppuuuu=[-0001]
formatted year=  399	uuuu=[0399] 	ppppu=[ 399]	pppppuuuu=[ 0399]
formatted year=  799	uuuu=[0799] 	ppppu=[ 799]	pppppuuuu=[ 0799]
formatted year= 1199	uuuu=[1199] 	ppppu=[1199]	pppppuuuu=[ 1199]
formatted year= 1599	uuuu=[1599] 	ppppu=[1599]	pppppuuuu=[ 1599]
formatted year= 1999	uuuu=[1999] 	ppppu=[1999]	pppppuuuu=[ 1999]