12：xx在SimpleDateFormat.format（“ hh：mm：ss”）中显示为00：xx

25-02-26 12

在这篇文章中，我们将带领您了解12：xx在SimpleDateFormat.format的全貌，包括“hh：mm：ss”中显示为00：xx的相关情况。同时，我们还将为您介绍有关DateFormat类和

在这篇文章中，我们将带领您了解12：xx在SimpleDateFormat.format的全貌，包括“ hh：mm：ss”中显示为00：xx的相关情况。同时，我们还将为您介绍有关DateFormat 类和 SimpleDateFormat 类、DateFormatter不返回“ HH：mm：ss”的日期、DateTimeFormatter与SimpleDateFormat、DateTimeFormatter和SimpleDateFormat有什么区别？的知识，以帮助您更好地理解这个主题。

本文目录一览：

12：xx在SimpleDateFormat.format（“ hh：mm：ss”）中显示为00：xx
DateFormat 类和 SimpleDateFormat 类
DateFormatter不返回“ HH：mm：ss”的日期
DateTimeFormatter与SimpleDateFormat
DateTimeFormatter和SimpleDateFormat有什么区别？

12：xx在SimpleDateFormat.format（“ hh：mm：ss”）中显示为00：xx

在以下代码中使用SimpleDateFormatter.format时，startDateText
TextView中12:00和12:59之间的小时显示为00:00到00:59，而从13:00开始，它们正确显示为13：xx，14： xx直到23:59。

-—根据要求重构代码当dtold.parse（…）中的字符串为in时，示例的输出小时为00:00，当其为“ 13:00”时，则正确为“
13:00”

import java.text.SimpleDateFormat;import java.time.ZoneId;import java.time.ZonedDateTime;import java.util.Calendar;import java.util.Date;import java.util.TimeZone;// one class needs to have a main() methodpublic class HelloWorld{  // arguments are passed using the text field below this editor  public static void main(String[] args)  {        SimpleDateFormat dtnew = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");        SimpleDateFormat dtold = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");            try {            Calendar cal = Calendar.getInstance();            cal.setTime(dtold.parse("2017-03-12 12:33:33"));            cal.add(Calendar.SECOND, 10);            System.out.println(dtnew.format(cal.getTime()));        } catch (Exception e) {            throw new RuntimeException(e);        }  }}

答案1

小编典典

首先是几个像您这样的格式化程序，仅使用DateTimeFormatterfrom java.time，现代的Java日期和时间API：

private static DateTimeFormatter dtfOld = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");private static DateTimeFormatter dtfNew = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");

需要注意的两件事：（1）按照逻辑顺序声明格式化程序，即使用顺序。在问题中使用相反的顺序使我感到困惑，我不确定是否也使自己困惑。（2）在00到23之间的一天中的小时中dtfOld使用大写字母HH，在hh01到12的AM或PM中使用小时的小写字母（在这种情况下，相同的格式模式字母适用于SimpleDateFormat和DateTimeFormatter；但有所不同）。现在，其余的工作很无聊，只比您的代码简单：

    LocalDateTime parsed = LocalDateTime.parse("2017-03-12 12:33:33", dtfOld);    System.out.println(parsed);    LocalDateTime dateTime = parsed.plusSeconds(10);    System.out.println(dateTime);    System.out.println(dateTime.format(dtfNew));

输出为：

2017-03-12T12:33:332017-03-12T12:33:4312-03-2017 12:33:43

我推荐java.time。旧的日期和时间类，您使用的-
SimpleDateFormat，Calendar和Date-早已过时。不仅在这种情况下，现代类还允许使用更简单的代码，这很常见。我发现java.time工作起来通常好得多。

您的代码出了什么问题？

我已经给出了一个提示：小写hh表示从01到12的AM或PM中的小时数。当您不提供和解析AM / PM标记时，默认使用AM。而12:33:33
AM表示午夜后半小时多一点，并在24小时制上显示为00:33:33。

从13:00到23:59的时间？它们在AM中不存在。显然，SimpleDateFormat它不在乎，只是从01到11的时间进行推断，因此恰好为您提供了您期望的时间。有一个技巧可以告诉它不要；但我不想打扰，我宁愿完全不使用该类。

链接

Oracle教程：Date
Time解释如何使用java.time。

DateFormat 类和 SimpleDateFormat 类

1.DateFormat 类

花式显示时间和日期。

而且在本机 win10+eclipse 的环境下默认显示当前地区时间。

具体为什么暂时不用管，先记下这个怎么用哈哈哈！贼棒！

import java.text.DateFormat;
import java.util.Date;

public class XJBTEST {

public static void main(String[] args) {
  // TODO Auto-generated method stub
    DateFormat df1=null;
    DateFormat df2=null;
    df1 =DateFormat.getDateInstance();
    df2 =DateFormat.getDateTimeInstance();
    System.out.println("Date"+df1.format(new Date()));
    System.out.println("DateTime"+df2.format(new Date()));
}
}

1.SimpleDateFormat 类

花式完成日期的显示格式化。

import java.text.SimpleDateFormat;
import java.util.Date;

public class XJBTEST {

public static void main(String[] args) {
  // TODO Auto-generated method stub
    String Dataexample="2017-6-12 16:31:13";// 随便打个时间做模板
    String Dataorigin="yyyy-MM-dd HH:mm:ss";// 格式
    String Datanow="yyyy 年 MM 月 dd 日 HH 时 mm 分 ss 秒";// 目标格式
    SimpleDateFormat sdf1=new SimpleDateFormat (Dataorigin);// 实例化模板
    SimpleDateFormat sdf2=new SimpleDateFormat (Datanow);// 同上
    Date d=null;
    try
    {
    d=sdf1.parse(Dataexample);
    }
    catch(Exception e)
    {
    e.printStackTrace();
    }
    System.out.println (sdf2.format (d));// 打印日期为新格式
}
}

一开始老出现问题，结果发现是因为格式那一行的字母是不可以 XJB 用的，必须严格按照人家设置好的格式来弄。

这个是粘贴别人的，英文首字母，很好记。

DateFormatter不返回“ HH：mm：ss”的日期

这是代码摘录：

func mapping(map: Map) {    time      <- (map["time"], TransformOf<Date, String>(fromJSON: {        let dateFormatter = DateFormatter()        dateFormatter.dateFormat = "HH:mm:ss"        //dateFormatter.timeZone = TimeZone(abbreviation: "EEST")        if let argument = $0 {            let date = dateFormatter.date(from: argument)            return dateFormatter.date(from: argument)        }        return nil        }}

$0是的字符串"22:12:00"。我输入“ let
date”以查看返回的内容，并且为零。我在这里查找格式代码：http : //waracle.net/iphone-
nsdateformatter-date-formatting-table/

代码应该实际工作。我究竟做错了什么？

编辑：添加了整个功能

EDIT2 ：我刚刚注意到它在iPhone 7 iOS 10.1模拟器上可以正常工作，但在iPod 10.1.1（2016）上返回nil。太奇怪了

答案1

小编典典

从技术问答QA1480 –
NSDateFormatter和Internet日期（强调）：

另一方面，如果您使用固定格式的日期，则应 首先将日期格式器的语言环境设置为适合您的固定格式的语言环境。 在大多数情况下，最佳选择的语言环境是“
en_US_POSIX”，该语言环境专门设计用于产生美式英语结果，无论用户和系统偏好如何。

这将防止根据用户的区域设置来解释日期：

let dateFormatter = DateFormatter()// Set the locale first ...dateFormatter.locale = Locale(identifier: "en_US_POSIX")// ... and then the date format:dateFormatter.dateFormat = "HH:mm:ss"// ...

DateTimeFormatter与SimpleDateFormat

日期格式化类：DateTimeFormatter与SimpleDateFormat

一、SimpleDateFormat类

SimpleDateFormat是用于以对语言环境敏感的方式格式化和解析日期的具体类。
SimpleDateFormat类的构造方法

NO	构造器	描述
1	SimpleDateFormat()	SimpleDateFormat使用默认FORMAT语言环境的默认模式和日期格式符号构造一个。
2	SimpleDateFormat(Stringpattern)	SimpleDateFormat使用给定的模式和默认FORMAT语言环境的默认日期格式符号构造一个。
3	SimpleDateFormat(Stringpattern,DateFormatSymbolsformatSymbols)	SimpleDateFormat使用给定的模式和日期格式符号构造一个。
4	SimpleDateFormat(Stringpattern,Localelocale)	SimpleDateFormat使用给定语言环境和给定语言环境的默认日期格式符号构造一个。

SimpleDateFormat为什么不是线程安全的？

SimpleDateFormat类的方法没有使用synchronized来给共享变量加锁。
SimpleDateFormat继承于DateFormat，下面我们看看我们用来格式化的format()方法的部分源码

DateFormat.java

    public final String format(Date date)
    {
        return format(date, new StringBuffer(),
                      DontCareFieldPosition.INSTANCE).toString();
    }

    public abstract StringBuffer format(Date date, StringBuffer toAppendTo,
                                        FieldPosition fieldPosition);

SimpleDateFormat.java

    @Override
    public StringBuffer format(Date date, StringBuffer toAppendTo,
                               FieldPosition pos)
    {
    //  如此轻易地使用内部变量，肯定不能线程安全
    //  线程都对pos进行写操作，必然会影响其他线程的读操作
        pos.beginIndex = pos.endIndex = 0;
        return format(date, toAppendTo, pos.getFieldDelegate());
    }

    private StringBuffer format(Date date, StringBuffer toAppendTo,
                                FieldDelegate delegate) {
        // Convert input date to time field list
       // 这里已经彻底毁坏线程的安全性
        calendar.setTime(date);

        boolean useDateFormatSymbols = useDateFormatSymbols();

        for (int i = 0; i < compiledPattern.length; ) {
            int tag = compiledPattern[i] >>> 8;
            int count = compiledPattern[i++] & 0xff;
            if (count == 255) {
                count = compiledPattern[i++] << 16;
                count |= compiledPattern[i++];
            }

            switch (tag) {
            case TAG_QUOTE_ASCII_CHAR:
                toAppendTo.append((char)count);
                break;

            case TAG_QUOTE_CHARS:
                toAppendTo.append(compiledPattern, i, count);
                i += count;
                break;

            default:
                subFormat(tag, count, delegate, toAppendTo, useDateFormatSymbols);
                break;
            }
        }
        return toAppendTo;
    }

看源码不用全部看，只需要看重点，不然你会很难受，很耗费时间。SimpleDateFormat类中的format方法的一段代码calendar.setTime(date);，从这我们可以看出来，如果我们把SimpleDateFormat定义成static成员变量，那么多个thread之间会共享这个SimpleDateFormat对象，所以Calendar对象也会被共享。那么当有线程A，B操作该方法时，A线程已经给Calendar对象setTime了，但是这时A线程让出了cpu被B线程抢占了，这时B线程在给Calendar对象setTime一个值，然后A线程获得cpu处理，这时A线程以为使用的是它给setTime的值，其实这里的值已经被B线程更改了。这里就会出现线程不安全，因为这里的处理对象都被两个或者更多的线程公用，就会出现线程不安全，所以我们在开发时，尽量使用内部变量，不共享的变量。 3. 实例

package www.com.lining.dateformate;

import java.text.SimpleDateFormat;
import java.util.Locale;

public class DateTimeFormateTest1 {

	private static SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy", Locale.US);
	private static String date[] = { "01-Jan-1999", "09-Jan-2000", "08-Jan-2001", "07-Jan-2002", "06-Jan-2003",
			"05-Jan-2004", "04-Jan-2005", "03-Jan-2006", "02-Jan-2007" };

	public static void main(String[] args) {
		for (int i = 0; i < date.length; i++) {
			final int temp = i;
			new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						while (true) {
							String str1 = date[temp];
							String str2 = sdf.format(sdf.parse(str1));
							System.out.println(Thread.currentThread().getName() + ", " + str1 + "," + str2);
							if (!str1.equals(str2)) {
								throw new RuntimeException(
										Thread.currentThread().getName() + ", Expected " + str1 + " but got " + str2);
							}
						}
					} catch (Exception e) {
						throw new RuntimeException("parse failed", e);
					}
				}
			}).start();
		}
	}
}

输出
一定要注意cpu的使用权都是需要去抢占的，所以就会出现多线程情况下，出现线程安全问题。

SimpleDateFormat线程不安全的解决方法

将SimpleDateFormat定义成局部变量，每次使用时在new 对象。但是每调用一次方法就会创建一个SimpleDateFormat对象，方法结束又要作为垃圾回收，很浪费资源。
加一把线程同步锁：synchronized(lock)

public class SyncDateFormatTest {
    private static SimpleDateFormat sdf = new SimpleDateFormat("dd-MMM-yyyy", Locale.US);
    private static String date[] = { "01-Jan-1999", "01-Jan-2000", "01-Jan-2001" };
 
    public static void main(String[] args) {
        for (int i = 0; i < date.length; i++) {
            final int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        while (true) {
                            synchronized (sdf) {
                                String str1 = date[temp];
                                Date date = sdf.parse(str1);
                                String str2 = sdf.format(date);
                                System.out.println(Thread.currentThread().getName() + ", " + str1 + "," + str2);
                                if(!str1.equals(str2)){
                                    throw new RuntimeException(Thread.currentThread().getName() 
                                            + ", Expected " + str1 + " but got " + str2);
                                }
                            }
                        }
                    } catch (Exception e) {
                        throw new RuntimeException("parse failed", e);
                    }
                }
            }).start();
        }
    }
}

缺点是：每次都要等该锁释放其他的线程才能使用，性能差。 3. 使用ThreadLocal类

直接继承与Object类，该类提供了线程局部变量，这些变量不同于他们的普通对应物，因为访问某个变量的每个线程都有自己的局部变量，它独立于变量的初始化副本。
每个线程都将拥有自己的SimpleDateFormat对象副本。

public class DateUtil {
 private static ThreadLocal<SimpleDateFormat> local = new ThreadLocal<SimpleDateFormat>();

 public static Date parse(String str) throws Exception {
     SimpleDateFormat sdf = local.get();
     if (sdf == null) {
         sdf = new SimpleDateFormat("dd-MMM-yyyy", Locale.US);
         local.set(sdf);
     }
     return sdf.parse(str);
 }
 
 public static String format(Date date) throws Exception {
     SimpleDateFormat sdf = local.get();
     if (sdf == null) {
         sdf = new SimpleDateFormat("dd-MMM-yyyy", Locale.US);
         local.set(sdf);
     }
     return sdf.format(date);
 }
}

public class ThreadLocalDateFormatTest {
 private static String date[] = { "01-Jan-1999", "01-Jan-2000", "01-Jan-2001" };

 public static void main(String[] args) {
     for (int i = 0; i < date.length; i++) {
         final int temp = i;
         new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     while (true) {
                         String str1 = date[temp];
                         Date date = DateUtil.parse(str1);
                         String str2 = DateUtil.format(date);
                         System.out.println(str1 + "," + str2);
                         if(!str1.equals(str2)){
                             throw new RuntimeException(Thread.currentThread().getName() 
                                     + ", Expected " + str1 + " but got " + str2);
                         }
                     }
                 } catch (Exception e) {
                     throw new RuntimeException("parse failed", e);
                 }
             }
         }).start();
     }
 }
 }

这样每个线程都有自己的副本对象SimpleDateFormat，所以每次不同的线程调用的都是自己的副本对象，不会改变其他线程的对象的。

二、DateTimeFormatter类

jdk1.8中新增了 LocalDate 与 LocalDateTime等类来解决日期处理方法，同时引入了一个新的类DateTimeFormatter来解决日期格式化问题。
LocalDateTime,DateTimeFormatter两个类都没有线程问题，只要你自己不把它们创建为共享变量就没有线程问题。
可以使用Instant代替 Date，LocalDateTime代替 Calendar，DateTimeFormatter 代替 SimpleDateFormat。

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy MM dd");
LocalDate date = LocalDate.parse("2017 06 17", formatter);
System.out.println(formatter.format(date));

DateTimeFormatter.ofPattern(pattern)的实现

 public static DateTimeFormatter ofPattern(String pattern) {
        return new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter();
    }

public final class DateTimeFormatterBuilder extends Object

TimeFormatterBuilder()：用于创建日期时间格式化程序的生成器。
TimeFormatterBuilder().appendPattern(pattern):将指定模式定义的元素追加到构建器，返回TimeFormatterBuilder对象。
toFormatter()：通过DateTimeFormatter使用默认语言环境创建来完成此构建器，获取DateTimeFormatter对象。
模式基于字母和符号的简单序列。模式用于使用ofPattern(String)和ofPattern(String, Locale)方法创建格式化程序。例如， "d MMM uuuu"将2011-12-03的格式设置为“ 2011年12月3日”。从模式创建的格式化程序可以根据需要多次使用，它是不可变的并且是线程安全的。例如：

LocalDate日期= LocalDate.now（）;
DateTimeFormatter formatter = DateTimeFormatter.ofPattern（“ yyyy MM dd”）;
字符串文本= date.format（formatter）;
LocalDate parsedDate = LocalDate.parse（text，formatter）;

其中的LocalDate和LocalDateTime都可以去查看jdk1.8往上的版本api去学习。

DateTimeFormatter和SimpleDateFormat有什么区别？

DateTimeFormatter和SimpleDateFormat都是用于日期时间格式化和解析的类，但它们有以下几个区别：

1.线程安全性：

DateTimeFormatter 是线程安全的，可以在多线程环境下共享和重用。
SimpleDateFormat 不是线程安全的，不建议在多线程环境中共享和重用，除非使用适当的同步措施。

2.API 设计：

DateTimeFormatter 是 Java 8 中引入的，并遵循了新的日期时间 API 的设计原则，提供了一致且易于使用的方法，支持更多的日期时间模式符号和灵活的格式化选项。
SimpleDateFormat 是早期的 Java 日期时间 API（java.util.Date) 中的类，使用较老的设计风格，并且其 API 比较有限。

3.底层实现：

DateTimeFormatter 使用基于解析器和格式化器的模型，底层使用 java.time.format.DateTimeFormatterBuilder 类来构建格式化模式。
SimpleDateFormat 使用基于模式字符串的方式进行格式化和解析，底层使用 java.text.SimpleDateFormat 类。

以下是使用DateTimeFormatter和SimpleDateFormat的代码示例：

使用DateTimeFormatter示例代码：

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class DateTimeFormatterExample {

    public static void main(String[] args) {

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 格式化日期时间
        LocalDateTime now = LocalDateTime.now();
        String formattedDateTime = formatter.format(now);
        System.out.println("格式化后的日期时间：" + formattedDateTime);

        // 解析日期时间
        String dateTimeString = "2023-07-03 12:30:45";
        LocalDateTime parsedDateTime = LocalDateTime.parse(dateTimeString, formatter);
        System.out.println("解析后的日期时间：" + parsedDateTime);
    }

}

打印结果:

格式化后的日期时间：2023-07-03 15:34:58
解析后的日期时间：2023-07-03T12:30:45

使用SimpleDateFormat示例代码：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatExample {

    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        // 格式化日期时间
        Date now = new Date();
        String formattedDateTime = sdf.format(now);
        System.out.println("格式化后的日期时间：" + formattedDateTime);

        // 解析日期时间
        String dateTimeString = "2023-07-03 12:30:45";
        try {
            Date parsedDateTime = sdf.parse(dateTimeString);
            System.out.println("解析后的日期时间：" + parsedDateTime);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

打印结果：

格式化后的日期时间：2023-07-03 15:38:33
解析后的日期时间：Mon Jul 03 12:30:45 CST 2023

在这个示例中，我们分别使用了DateTimeFormatter和SimpleDateFormat来格式化和解析日期时间。它们的用法非常相似，但是需要注意的是，DateTimeFormatter是线程安全的，可以在多线程环境下共享和重用；而SimpleDateFormat不是线程安全的，不建议在多线程环境中共享和重用。

今天关于12：xx在SimpleDateFormat.format和“ hh：mm：ss”中显示为00：xx的分享就到这里，希望大家有所收获，若想了解更多关于DateFormat 类和 SimpleDateFormat 类、DateFormatter不返回“ HH：mm：ss”的日期、DateTimeFormatter与SimpleDateFormat、DateTimeFormatter和SimpleDateFormat有什么区别？等相关知识，可以在本站进行查询。

本文标签：